diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index 39b2391c98ec..7fb8e51377a2 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -1,16 +1,22 @@
 use super::FOR_KV_MAP;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::res::MaybeDef;
-use clippy_utils::source::snippet;
+use clippy_utils::source::{snippet_with_applicability, walk_span_to_context};
 use clippy_utils::{pat_is_wild, sugg};
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
-use rustc_span::sym;
+use rustc_span::{Span, sym};
 
 /// Checks for the `FOR_KV_MAP` lint.
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx Expr<'_>, body: &'tcx Expr<'_>) {
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    pat: &'tcx Pat<'_>,
+    arg: &'tcx Expr<'_>,
+    body: &'tcx Expr<'_>,
+    span: Span,
+) {
     let pat_span = pat.span;
 
     if let PatKind::Tuple(pat, _) = pat.kind
@@ -34,21 +40,25 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
             _ => arg,
         };
 
-        if matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap)) {
+        if matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap))
+            && let Some(arg_span) = walk_span_to_context(arg_span, span.ctxt())
+        {
             span_lint_and_then(
                 cx,
                 FOR_KV_MAP,
                 arg_span,
                 format!("you seem to want to iterate on a map's {kind}s"),
                 |diag| {
-                    let map = sugg::Sugg::hir(cx, arg, "map");
+                    let mut applicability = Applicability::MachineApplicable;
+                    let map = sugg::Sugg::hir_with_context(cx, arg, span.ctxt(), "map", &mut applicability);
+                    let pat = snippet_with_applicability(cx, new_pat_span, kind, &mut applicability);
                     diag.multipart_suggestion(
                         "use the corresponding method",
                         vec![
-                            (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
+                            (pat_span, pat.to_string()),
                             (arg_span, format!("{}.{kind}s{mutbl}()", map.maybe_paren())),
                         ],
-                        Applicability::MachineApplicable,
+                        applicability,
                     );
                 },
             );
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index ddc783069385..83574cab6b67 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -943,7 +943,7 @@ impl Loops {
             explicit_counter_loop::check(cx, pat, arg, body, expr, label);
         }
         self.check_for_loop_arg(cx, pat, arg);
-        for_kv_map::check(cx, pat, arg, body);
+        for_kv_map::check(cx, pat, arg, body, span);
         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);
diff --git a/clippy_lints/src/matches/manual_ok_err.rs b/clippy_lints/src/matches/manual_ok_err.rs
index c35c3d1f62e6..1fc8bb9acce2 100644
--- a/clippy_lints/src/matches/manual_ok_err.rs
+++ b/clippy_lints/src/matches/manual_ok_err.rs
@@ -135,7 +135,7 @@ fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, is_ok
     } else {
         Applicability::MachineApplicable
     };
-    let scrut = Sugg::hir_with_applicability(cx, scrutinee, "..", &mut app).maybe_paren();
+    let scrut = Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_paren();
 
     let scrutinee_ty = cx.typeck_results().expr_ty(scrutinee);
     let (_, _, mutability) = peel_and_count_ty_refs(scrutinee_ty);
diff --git a/clippy_lints/src/matches/match_as_ref.rs b/clippy_lints/src/matches/match_as_ref.rs
index 795355f25f9e..12fe44ef2f13 100644
--- a/clippy_lints/src/matches/match_as_ref.rs
+++ b/clippy_lints/src/matches/match_as_ref.rs
@@ -46,6 +46,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
         let cast = if input_ty == output_ty { "" } else { ".map(|x| x as _)" };
 
         let mut applicability = Applicability::MachineApplicable;
+        let ctxt = expr.span.ctxt();
         span_lint_and_then(
             cx,
             MATCH_AS_REF,
@@ -59,7 +60,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                         "use `Option::as_ref()`",
                         format!(
                             "{}.as_ref(){cast}",
-                            Sugg::hir_with_applicability(cx, ex, "_", &mut applicability).maybe_paren(),
+                            Sugg::hir_with_context(cx, ex, ctxt, "_", &mut applicability).maybe_paren(),
                         ),
                         applicability,
                     );
@@ -69,7 +70,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
                         format!("use `Option::{method}()` directly"),
                         format!(
                             "{}.{method}(){cast}",
-                            Sugg::hir_with_applicability(cx, ex, "_", &mut applicability).maybe_paren(),
+                            Sugg::hir_with_context(cx, ex, ctxt, "_", &mut applicability).maybe_paren(),
                         ),
                         applicability,
                     );
diff --git a/clippy_lints/src/matches/match_bool.rs b/clippy_lints/src/matches/match_bool.rs
index dc3457aa7a46..3e76231b6ef1 100644
--- a/clippy_lints/src/matches/match_bool.rs
+++ b/clippy_lints/src/matches/match_bool.rs
@@ -25,8 +25,9 @@ pub(crate) fn check(cx: &LateContext<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>]
             "`match` on a boolean expression",
             move |diag| {
                 let mut app = Applicability::MachineApplicable;
+                let ctxt = expr.span.ctxt();
                 let test_sugg = if let PatKind::Expr(arm_bool) = arms[0].pat.kind {
-                    let test = Sugg::hir_with_applicability(cx, scrutinee, "_", &mut app);
+                    let test = Sugg::hir_with_context(cx, scrutinee, ctxt, "_", &mut app);
                     if let PatExprKind::Lit { lit, .. } = arm_bool.kind {
                         match &lit.node {
                             LitKind::Bool(true) => Some(test),
@@ -36,7 +37,7 @@ pub(crate) fn check(cx: &LateContext<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>]
                         .map(|test| {
                             if let Some(guard) = &arms[0]
                                 .guard
-                                .map(|g| Sugg::hir_with_applicability(cx, g, "_", &mut app))
+                                .map(|g| Sugg::hir_with_context(cx, g, ctxt, "_", &mut app))
                             {
                                 test.and(guard)
                             } else {
diff --git a/clippy_lints/src/matches/redundant_pattern_match.rs b/clippy_lints/src/matches/redundant_pattern_match.rs
index 897e7da5a967..bf0c0c4aec3c 100644
--- a/clippy_lints/src/matches/redundant_pattern_match.rs
+++ b/clippy_lints/src/matches/redundant_pattern_match.rs
@@ -267,13 +267,14 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
     if let Ok(arms) = arms.try_into() // TODO: use `slice::as_array` once stabilized
         && let Some((good_method, maybe_guard)) = found_good_method(cx, arms)
     {
-        let span = is_expn_of(expr.span, sym::matches).unwrap_or(expr.span.to(op.span));
+        let expr_span = is_expn_of(expr.span, sym::matches).unwrap_or(expr.span);
+
         let result_expr = match &op.kind {
             ExprKind::AddrOf(_, _, borrowed) => borrowed,
             _ => op,
         };
         let mut app = Applicability::MachineApplicable;
-        let receiver_sugg = Sugg::hir_with_applicability(cx, result_expr, "_", &mut app).maybe_paren();
+        let receiver_sugg = Sugg::hir_with_context(cx, result_expr, expr_span.ctxt(), "_", &mut app).maybe_paren();
         let mut sugg = format!("{receiver_sugg}.{good_method}");
 
         if let Some(guard) = maybe_guard {
@@ -296,14 +297,14 @@ pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, op
                 return;
             }
 
-            let guard = Sugg::hir(cx, guard, "..");
+            let guard = Sugg::hir_with_context(cx, guard, expr_span.ctxt(), "..", &mut app);
             let _ = write!(sugg, " && {}", guard.maybe_paren());
         }
 
         span_lint_and_sugg(
             cx,
             REDUNDANT_PATTERN_MATCHING,
-            span,
+            expr_span,
             format!("redundant pattern matching, consider using `{good_method}`"),
             "try",
             sugg,
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index 16db8663941e..366bfaed73d4 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -2,7 +2,7 @@ use super::ITER_KV_MAP;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::MaybeDef;
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::{pat_is_wild, sym};
 use rustc_hir::{Body, Expr, ExprKind, PatKind};
 use rustc_lint::LateContext;
@@ -58,6 +58,8 @@ pub(super) fn check<'tcx>(
                 applicability,
             );
         } else {
+            let (body_snippet, _) =
+                snippet_with_context(cx, body_expr.span, expr.span.ctxt(), "..", &mut applicability);
             span_lint_and_sugg(
                 cx,
                 ITER_KV_MAP,
@@ -65,9 +67,8 @@ pub(super) fn check<'tcx>(
                 format!("iterating on a map's {replacement_kind}s"),
                 "try",
                 format!(
-                    "{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{}{bound_ident}| {})",
+                    "{recv_snippet}.{into_prefix}{replacement_kind}s().map(|{}{bound_ident}| {body_snippet})",
                     annotation.prefix_str(),
-                    snippet_with_applicability(cx, body_expr.span, "/* body */", &mut applicability)
                 ),
                 applicability,
             );
diff --git a/clippy_lints/src/methods/unnecessary_fold.rs b/clippy_lints/src/methods/unnecessary_fold.rs
index 7802763ef74a..c3f031edff2e 100644
--- a/clippy_lints/src/methods/unnecessary_fold.rs
+++ b/clippy_lints/src/methods/unnecessary_fold.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::res::{MaybeDef, MaybeQPath, MaybeResPath, MaybeTypeckRes};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::{DefinedTy, ExprUseNode, expr_use_ctxt, peel_blocks, strip_pat_refs};
 use rustc_ast::ast;
 use rustc_data_structures::packed::Pu128;
@@ -124,11 +124,12 @@ fn check_fold_with_op(
                 let mut applicability = replacement.default_applicability();
                 let turbofish =
                     replacement.maybe_turbofish(cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs());
+                let (r_snippet, _) =
+                    snippet_with_context(cx, right_expr.span, expr.span.ctxt(), "EXPR", &mut applicability);
                 let sugg = if replacement.has_args {
                     format!(
-                        "{method}{turbofish}(|{second_arg_ident}| {r})",
+                        "{method}{turbofish}(|{second_arg_ident}| {r_snippet})",
                         method = replacement.method_name,
-                        r = snippet_with_applicability(cx, right_expr.span, "EXPR", &mut applicability),
                     )
                 } else {
                     format!("{method}{turbofish}()", method = replacement.method_name)
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 2fef8404f824..ad44d65b4d66 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -143,7 +143,7 @@ fn check_expr<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, ty_ascription: &T
                 && new.ident.name == sym::new
             {
                 let mut applicability = Applicability::MaybeIncorrect;
-                let arg = Sugg::hir_with_applicability(cx, arg, "_", &mut applicability);
+                let arg = Sugg::hir_with_context(cx, arg, expr.span.ctxt(), "_", &mut applicability);
                 let mut suggs = vec![(expr.span, format!("std::sync::atomic::{atomic_name}::new({arg})"))];
                 match ty_ascription {
                     TypeAscriptionKind::Required(ty_ascription) => {
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index 59d31f782bc3..e5fb3c0fa431 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -5,7 +5,7 @@ use clippy_config::types::MatchLintBehaviour;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::{MaybeDef, MaybeQPath, MaybeResPath};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_copy};
 use clippy_utils::usage::local_used_after_expr;
@@ -147,7 +147,8 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         && !span_contains_cfg(cx, els.span)
     {
         let mut applicability = Applicability::MaybeIncorrect;
-        let init_expr_str = Sugg::hir_with_applicability(cx, init_expr, "..", &mut applicability).maybe_paren();
+        let init_expr_str =
+            Sugg::hir_with_context(cx, init_expr, stmt.span.ctxt(), "..", &mut applicability).maybe_paren();
         // Take care when binding is `ref`
         let sugg = if let PatKind::Binding(
             BindingMode(ByRef::Yes(_, ref_mutability), binding_mutability),
@@ -295,7 +296,7 @@ fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Ex
         && (is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block))
     {
         let mut applicability = Applicability::MachineApplicable;
-        let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
+        let receiver_str = snippet_with_context(cx, caller.span, expr.span.ctxt(), "..", &mut applicability).0;
         let by_ref = !cx.type_is_copy_modulo_regions(caller_ty)
             && !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
         let sugg = if let Some(else_inner) = r#else {
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 1d0efa46a14c..c0be724bcdee 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::res::{MaybeDef, MaybeQPath};
-use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::source::{snippet, snippet_with_applicability, snippet_with_context};
 use clippy_utils::{
     SpanlessEq, get_expr_use_or_unification_node, get_parent_expr, is_lint_allowed, method_calls, peel_blocks, sym,
 };
@@ -273,6 +273,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
             let string_expression = &expressions[0].0;
 
             let snippet_app = snippet_with_applicability(cx, string_expression.span, "..", &mut applicability);
+            let (right_snip, _) = snippet_with_context(cx, right.span, e.span.ctxt(), "..", &mut applicability);
 
             span_lint_and_sugg(
                 cx,
@@ -280,7 +281,7 @@ impl<'tcx> LateLintPass<'tcx> for StringLitAsBytes {
                 e.span,
                 "calling a slice of `as_bytes()` with `from_utf8` should be not necessary",
                 "try",
-                format!("Some(&{snippet_app}[{}])", snippet(cx, right.span, "..")),
+                format!("Some(&{snippet_app}[{right_snip}])"),
                 applicability,
             );
         }
@@ -404,7 +405,8 @@ impl<'tcx> LateLintPass<'tcx> for StrToString {
                 "`to_string()` called on a `&str`",
                 |diag| {
                     let mut applicability = Applicability::MachineApplicable;
-                    let snippet = snippet_with_applicability(cx, self_arg.span, "..", &mut applicability);
+                    let (snippet, _) =
+                        snippet_with_context(cx, self_arg.span, expr.span.ctxt(), "..", &mut applicability);
                     diag.span_suggestion(expr.span, "try", format!("{snippet}.to_owned()"), applicability);
                 },
             );
diff --git a/tests/ui/for_kv_map.fixed b/tests/ui/for_kv_map.fixed
index 2a68b7443fbf..6ec4cb01ffd1 100644
--- a/tests/ui/for_kv_map.fixed
+++ b/tests/ui/for_kv_map.fixed
@@ -69,3 +69,20 @@ fn main() {
         let _v = v;
     }
 }
+
+fn wrongly_unmangled_macros() {
+    use std::collections::HashMap;
+
+    macro_rules! test_map {
+        ($val:expr) => {
+            &*$val
+        };
+    }
+
+    let m: HashMap<u64, u64> = HashMap::new();
+    let wrapped = Rc::new(m);
+    for v in test_map!(wrapped).values() {
+        //~^ for_kv_map
+        let _v = v;
+    }
+}
diff --git a/tests/ui/for_kv_map.rs b/tests/ui/for_kv_map.rs
index 485a97815e3c..19e907ff10a6 100644
--- a/tests/ui/for_kv_map.rs
+++ b/tests/ui/for_kv_map.rs
@@ -69,3 +69,20 @@ fn main() {
         let _v = v;
     }
 }
+
+fn wrongly_unmangled_macros() {
+    use std::collections::HashMap;
+
+    macro_rules! test_map {
+        ($val:expr) => {
+            &*$val
+        };
+    }
+
+    let m: HashMap<u64, u64> = HashMap::new();
+    let wrapped = Rc::new(m);
+    for (_, v) in test_map!(wrapped) {
+        //~^ for_kv_map
+        let _v = v;
+    }
+}
diff --git a/tests/ui/for_kv_map.stderr b/tests/ui/for_kv_map.stderr
index 0bd474a10682..5436592f2ab6 100644
--- a/tests/ui/for_kv_map.stderr
+++ b/tests/ui/for_kv_map.stderr
@@ -72,5 +72,17 @@ LL -     'label: for (k, _value) in rm {
 LL +     'label: for k in rm.keys() {
    |
 
-error: aborting due to 6 previous errors
+error: you seem to want to iterate on a map's values
+  --> tests/ui/for_kv_map.rs:84:19
+   |
+LL |     for (_, v) in test_map!(wrapped) {
+   |                   ^^^^^^^^^^^^^^^^^^
+   |
+help: use the corresponding method
+   |
+LL -     for (_, v) in test_map!(wrapped) {
+LL +     for v in test_map!(wrapped).values() {
+   |
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/iter_kv_map.fixed b/tests/ui/iter_kv_map.fixed
index b18dda358877..189d76bc9431 100644
--- a/tests/ui/iter_kv_map.fixed
+++ b/tests/ui/iter_kv_map.fixed
@@ -189,3 +189,9 @@ fn issue14595() {
     let _ = map.as_ref().values().copied().collect::<Vec<_>>();
     //~^ iter_kv_map
 }
+
+fn issue16340() {
+    let hm: HashMap<&str, &str> = HashMap::new();
+    let _ = hm.keys().map(|key| vec![key]);
+    //~^ iter_kv_map
+}
diff --git a/tests/ui/iter_kv_map.rs b/tests/ui/iter_kv_map.rs
index 729e4e8a266c..cfc303447004 100644
--- a/tests/ui/iter_kv_map.rs
+++ b/tests/ui/iter_kv_map.rs
@@ -193,3 +193,9 @@ fn issue14595() {
     let _ = map.as_ref().iter().map(|(_, v)| v).copied().collect::<Vec<_>>();
     //~^ iter_kv_map
 }
+
+fn issue16340() {
+    let hm: HashMap<&str, &str> = HashMap::new();
+    let _ = hm.iter().map(|(key, _)| vec![key]);
+    //~^ iter_kv_map
+}
diff --git a/tests/ui/iter_kv_map.stderr b/tests/ui/iter_kv_map.stderr
index 8f73541f5033..866e69ea1922 100644
--- a/tests/ui/iter_kv_map.stderr
+++ b/tests/ui/iter_kv_map.stderr
@@ -269,5 +269,11 @@ error: iterating on a map's values
 LL |     let _ = map.as_ref().iter().map(|(_, v)| v).copied().collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.as_ref().values()`
 
-error: aborting due to 39 previous errors
+error: iterating on a map's keys
+  --> tests/ui/iter_kv_map.rs:199:13
+   |
+LL |     let _ = hm.iter().map(|(key, _)| vec![key]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hm.keys().map(|key| vec![key])`
+
+error: aborting due to 40 previous errors
 
diff --git a/tests/ui/manual_ok_err.fixed b/tests/ui/manual_ok_err.fixed
index 9b70ce0df43a..e22f91a0155f 100644
--- a/tests/ui/manual_ok_err.fixed
+++ b/tests/ui/manual_ok_err.fixed
@@ -127,3 +127,13 @@ mod issue15051 {
         result_with_ref_mut(x).as_mut().ok()
     }
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Ok::<i32, ()>($val)
+        };
+    }
+
+    let _ = test_expr!(42).ok();
+}
diff --git a/tests/ui/manual_ok_err.rs b/tests/ui/manual_ok_err.rs
index dee904638245..c1355f0d4096 100644
--- a/tests/ui/manual_ok_err.rs
+++ b/tests/ui/manual_ok_err.rs
@@ -177,3 +177,17 @@ mod issue15051 {
         }
     }
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Ok::<i32, ()>($val)
+        };
+    }
+
+    let _ = match test_expr!(42) {
+        //~^ manual_ok_err
+        Ok(v) => Some(v),
+        Err(_) => None,
+    };
+}
diff --git a/tests/ui/manual_ok_err.stderr b/tests/ui/manual_ok_err.stderr
index 448fbffc0509..0c2ed368eb97 100644
--- a/tests/ui/manual_ok_err.stderr
+++ b/tests/ui/manual_ok_err.stderr
@@ -141,5 +141,16 @@ LL | |             Err(_) => None,
 LL | |         }
    | |_________^ help: replace with: `result_with_ref_mut(x).as_mut().ok()`
 
-error: aborting due to 12 previous errors
+error: manual implementation of `ok`
+  --> tests/ui/manual_ok_err.rs:188:13
+   |
+LL |       let _ = match test_expr!(42) {
+   |  _____________^
+LL | |
+LL | |         Ok(v) => Some(v),
+LL | |         Err(_) => None,
+LL | |     };
+   | |_____^ help: replace with: `test_expr!(42).ok()`
+
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/match_as_ref.fixed b/tests/ui/match_as_ref.fixed
index 09a6ed169390..b1b8ffb885f5 100644
--- a/tests/ui/match_as_ref.fixed
+++ b/tests/ui/match_as_ref.fixed
@@ -90,3 +90,13 @@ fn issue15932() {
 
     let _: Option<&dyn std::fmt::Debug> = Some(0).as_ref().map(|x| x as _);
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Some($val)
+        };
+    }
+
+    let _: Option<&u32> = test_expr!(42).as_ref();
+}
diff --git a/tests/ui/match_as_ref.rs b/tests/ui/match_as_ref.rs
index 347b6d186887..3113167957d4 100644
--- a/tests/ui/match_as_ref.rs
+++ b/tests/ui/match_as_ref.rs
@@ -114,3 +114,17 @@ fn issue15932() {
         Some(ref mut v) => Some(v),
     };
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Some($val)
+        };
+    }
+
+    let _: Option<&u32> = match test_expr!(42) {
+        //~^ match_as_ref
+        None => None,
+        Some(ref v) => Some(v),
+    };
+}
diff --git a/tests/ui/match_as_ref.stderr b/tests/ui/match_as_ref.stderr
index df06e358f296..3eab499fe409 100644
--- a/tests/ui/match_as_ref.stderr
+++ b/tests/ui/match_as_ref.stderr
@@ -127,5 +127,26 @@ LL -     };
 LL +     let _: Option<&dyn std::fmt::Debug> = Some(0).as_ref().map(|x| x as _);
    |
 
-error: aborting due to 6 previous errors
+error: manual implementation of `Option::as_ref`
+  --> tests/ui/match_as_ref.rs:125:27
+   |
+LL |       let _: Option<&u32> = match test_expr!(42) {
+   |  ___________________________^
+LL | |
+LL | |         None => None,
+LL | |         Some(ref v) => Some(v),
+LL | |     };
+   | |_____^
+   |
+help: use `Option::as_ref()` directly
+   |
+LL -     let _: Option<&u32> = match test_expr!(42) {
+LL -
+LL -         None => None,
+LL -         Some(ref v) => Some(v),
+LL -     };
+LL +     let _: Option<&u32> = test_expr!(42).as_ref();
+   |
+
+error: aborting due to 7 previous errors
 
diff --git a/tests/ui/match_bool.fixed b/tests/ui/match_bool.fixed
index 876ae935afde..3d5d0a0d532c 100644
--- a/tests/ui/match_bool.fixed
+++ b/tests/ui/match_bool.fixed
@@ -74,4 +74,15 @@ fn issue15351() {
     }
 }
 
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            ($val + 1) > 0
+        };
+    }
+
+    let x = 5;
+    if test_expr!(x) { 1 } else { 0 };
+}
+
 fn main() {}
diff --git a/tests/ui/match_bool.rs b/tests/ui/match_bool.rs
index a134ad8346e2..4db0aedf3260 100644
--- a/tests/ui/match_bool.rs
+++ b/tests/ui/match_bool.rs
@@ -126,4 +126,19 @@ fn issue15351() {
     }
 }
 
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            ($val + 1) > 0
+        };
+    }
+
+    let x = 5;
+    match test_expr!(x) {
+        //~^ match_bool
+        true => 1,
+        false => 0,
+    };
+}
+
 fn main() {}
diff --git a/tests/ui/match_bool.stderr b/tests/ui/match_bool.stderr
index c05742e56339..223acd17aead 100644
--- a/tests/ui/match_bool.stderr
+++ b/tests/ui/match_bool.stderr
@@ -183,5 +183,15 @@ LL +         break 'a;
 LL +     } }
    |
 
-error: aborting due to 13 previous errors
+error: `match` on a boolean expression
+  --> tests/ui/match_bool.rs:137:5
+   |
+LL | /     match test_expr!(x) {
+LL | |
+LL | |         true => 1,
+LL | |         false => 0,
+LL | |     };
+   | |_____^ help: consider using an `if`/`else` expression: `if test_expr!(x) { 1 } else { 0 }`
+
+error: aborting due to 14 previous errors
 
diff --git a/tests/ui/mutex_atomic.fixed b/tests/ui/mutex_atomic.fixed
index e4218726019f..dc05d8a2c61f 100644
--- a/tests/ui/mutex_atomic.fixed
+++ b/tests/ui/mutex_atomic.fixed
@@ -65,3 +65,15 @@ fn issue13378() {
     let (funky_mtx) = std::sync::atomic::AtomicU64::new(0);
     //~^ mutex_integer
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            ($val > 0 && true)
+        };
+    }
+
+    let _ = std::sync::atomic::AtomicBool::new(test_expr!(1));
+    //~^ mutex_atomic
+    // The suggestion should preserve the macro call: `AtomicBool::new(test_expr!(true))`
+}
diff --git a/tests/ui/mutex_atomic.rs b/tests/ui/mutex_atomic.rs
index 95f2b135903f..33745f8fc5e1 100644
--- a/tests/ui/mutex_atomic.rs
+++ b/tests/ui/mutex_atomic.rs
@@ -65,3 +65,15 @@ fn issue13378() {
     let (funky_mtx): Mutex<u64> = Mutex::new(0);
     //~^ mutex_integer
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            ($val > 0 && true)
+        };
+    }
+
+    let _ = Mutex::new(test_expr!(1));
+    //~^ mutex_atomic
+    // The suggestion should preserve the macro call: `AtomicBool::new(test_expr!(true))`
+}
diff --git a/tests/ui/mutex_atomic.stderr b/tests/ui/mutex_atomic.stderr
index 0afc6d541dea..56d94035583c 100644
--- a/tests/ui/mutex_atomic.stderr
+++ b/tests/ui/mutex_atomic.stderr
@@ -130,5 +130,13 @@ LL -     let (funky_mtx): Mutex<u64> = Mutex::new(0);
 LL +     let (funky_mtx) = std::sync::atomic::AtomicU64::new(0);
    |
 
-error: aborting due to 14 previous errors
+error: using a `Mutex` where an atomic would do
+  --> tests/ui/mutex_atomic.rs:76:13
+   |
+LL |     let _ = Mutex::new(test_expr!(1));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::sync::atomic::AtomicBool::new(test_expr!(1))`
+   |
+   = help: if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
+
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/question_mark.fixed b/tests/ui/question_mark.fixed
index 2c5ee0245038..b8072932c4ea 100644
--- a/tests/ui/question_mark.fixed
+++ b/tests/ui/question_mark.fixed
@@ -1,5 +1,5 @@
 #![feature(try_blocks)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::no_effect)]
 
 use std::sync::MutexGuard;
 
@@ -500,3 +500,18 @@ mod issue14894 {
         Ok(())
     }
 }
+
+fn wrongly_unmangled_macros() -> Option<i32> {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Some($val)
+        };
+    }
+
+    let x = test_expr!(42)?;
+    //~^^^ question_mark
+    Some(x);
+
+    test_expr!(42)?;
+    test_expr!(42)
+}
diff --git a/tests/ui/question_mark.rs b/tests/ui/question_mark.rs
index b9ff9d1565b2..b320dcd4b0bc 100644
--- a/tests/ui/question_mark.rs
+++ b/tests/ui/question_mark.rs
@@ -1,5 +1,5 @@
 #![feature(try_blocks)]
-#![allow(clippy::unnecessary_wraps)]
+#![allow(clippy::unnecessary_wraps, clippy::no_effect)]
 
 use std::sync::MutexGuard;
 
@@ -615,3 +615,23 @@ mod issue14894 {
         Ok(())
     }
 }
+
+fn wrongly_unmangled_macros() -> Option<i32> {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Some($val)
+        };
+    }
+
+    let Some(x) = test_expr!(42) else {
+        return None;
+    };
+    //~^^^ question_mark
+    Some(x);
+
+    if test_expr!(42).is_none() {
+        //~^ question_mark
+        return None;
+    }
+    test_expr!(42)
+}
diff --git a/tests/ui/question_mark.stderr b/tests/ui/question_mark.stderr
index 9b2896328e66..d645c8830adc 100644
--- a/tests/ui/question_mark.stderr
+++ b/tests/ui/question_mark.stderr
@@ -333,5 +333,22 @@ LL | |             return Err(reason);
 LL | |         }
    | |_________^ help: replace it with: `result?;`
 
-error: aborting due to 35 previous errors
+error: this `let...else` may be rewritten with the `?` operator
+  --> tests/ui/question_mark.rs:626:5
+   |
+LL | /     let Some(x) = test_expr!(42) else {
+LL | |         return None;
+LL | |     };
+   | |______^ help: replace it with: `let x = test_expr!(42)?;`
+
+error: this block may be rewritten with the `?` operator
+  --> tests/ui/question_mark.rs:632:5
+   |
+LL | /     if test_expr!(42).is_none() {
+LL | |
+LL | |         return None;
+LL | |     }
+   | |_____^ help: replace it with: `test_expr!(42)?;`
+
+error: aborting due to 37 previous errors
 
diff --git a/tests/ui/redundant_pattern_matching_result.fixed b/tests/ui/redundant_pattern_matching_result.fixed
index 261d82fc35c8..8754d71aa629 100644
--- a/tests/ui/redundant_pattern_matching_result.fixed
+++ b/tests/ui/redundant_pattern_matching_result.fixed
@@ -165,3 +165,23 @@ fn issue10803() {
     // Don't lint
     let _ = matches!(x, Err(16));
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Ok::<i32, i32>($val)
+        };
+    }
+
+    let _ = test_expr!(42).is_ok();
+
+    macro_rules! test_guard {
+        ($val:expr) => {
+            ($val + 1) > 0
+        };
+    }
+
+    let x: Result<i32, ()> = Ok(42);
+    let _ = x.is_ok() && test_guard!(42);
+    //~^ redundant_pattern_matching
+}
diff --git a/tests/ui/redundant_pattern_matching_result.rs b/tests/ui/redundant_pattern_matching_result.rs
index 6cae4cc4b6b0..b83b02588fb6 100644
--- a/tests/ui/redundant_pattern_matching_result.rs
+++ b/tests/ui/redundant_pattern_matching_result.rs
@@ -205,3 +205,27 @@ fn issue10803() {
     // Don't lint
     let _ = matches!(x, Err(16));
 }
+
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($val:expr) => {
+            Ok::<i32, i32>($val)
+        };
+    }
+
+    let _ = match test_expr!(42) {
+        //~^ redundant_pattern_matching
+        Ok(_) => true,
+        Err(_) => false,
+    };
+
+    macro_rules! test_guard {
+        ($val:expr) => {
+            ($val + 1) > 0
+        };
+    }
+
+    let x: Result<i32, ()> = Ok(42);
+    let _ = matches!(x, Ok(_) if test_guard!(42));
+    //~^ redundant_pattern_matching
+}
diff --git a/tests/ui/redundant_pattern_matching_result.stderr b/tests/ui/redundant_pattern_matching_result.stderr
index 7e7d27d07a7f..dda203b753c3 100644
--- a/tests/ui/redundant_pattern_matching_result.stderr
+++ b/tests/ui/redundant_pattern_matching_result.stderr
@@ -209,5 +209,22 @@ error: redundant pattern matching, consider using `is_err()`
 LL |     let _ = matches!(x, Err(_));
    |             ^^^^^^^^^^^^^^^^^^^ help: try: `x.is_err()`
 
-error: aborting due to 28 previous errors
+error: redundant pattern matching, consider using `is_ok()`
+  --> tests/ui/redundant_pattern_matching_result.rs:216:13
+   |
+LL |       let _ = match test_expr!(42) {
+   |  _____________^
+LL | |
+LL | |         Ok(_) => true,
+LL | |         Err(_) => false,
+LL | |     };
+   | |_____^ help: try: `test_expr!(42).is_ok()`
+
+error: redundant pattern matching, consider using `is_ok()`
+  --> tests/ui/redundant_pattern_matching_result.rs:229:13
+   |
+LL |     let _ = matches!(x, Ok(_) if test_guard!(42));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_ok() && test_guard!(42)`
+
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/str_to_string.fixed b/tests/ui/str_to_string.fixed
index 2941c4dbd33d..8713c4f9bc86 100644
--- a/tests/ui/str_to_string.fixed
+++ b/tests/ui/str_to_string.fixed
@@ -8,3 +8,17 @@ fn main() {
     msg.to_owned();
     //~^ str_to_string
 }
+
+fn issue16271(key: &[u8]) {
+    macro_rules! t {
+        ($e:expr) => {
+            match $e {
+                Ok(e) => e,
+                Err(e) => panic!("{} failed with {}", stringify!($e), e),
+            }
+        };
+    }
+
+    let _value = t!(str::from_utf8(key)).to_owned();
+    //~^ str_to_string
+}
diff --git a/tests/ui/str_to_string.rs b/tests/ui/str_to_string.rs
index 4c4d2bb18062..b81759e1037b 100644
--- a/tests/ui/str_to_string.rs
+++ b/tests/ui/str_to_string.rs
@@ -8,3 +8,17 @@ fn main() {
     msg.to_string();
     //~^ str_to_string
 }
+
+fn issue16271(key: &[u8]) {
+    macro_rules! t {
+        ($e:expr) => {
+            match $e {
+                Ok(e) => e,
+                Err(e) => panic!("{} failed with {}", stringify!($e), e),
+            }
+        };
+    }
+
+    let _value = t!(str::from_utf8(key)).to_string();
+    //~^ str_to_string
+}
diff --git a/tests/ui/str_to_string.stderr b/tests/ui/str_to_string.stderr
index cb7b6b48843a..c0a38c8ebe46 100644
--- a/tests/ui/str_to_string.stderr
+++ b/tests/ui/str_to_string.stderr
@@ -13,5 +13,11 @@ error: `to_string()` called on a `&str`
 LL |     msg.to_string();
    |     ^^^^^^^^^^^^^^^ help: try: `msg.to_owned()`
 
-error: aborting due to 2 previous errors
+error: `to_string()` called on a `&str`
+  --> tests/ui/str_to_string.rs:22:18
+   |
+LL |     let _value = t!(str::from_utf8(key)).to_string();
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t!(str::from_utf8(key)).to_owned()`
+
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/string_from_utf8_as_bytes.fixed b/tests/ui/string_from_utf8_as_bytes.fixed
index 193217114d88..98fa3a4fcf70 100644
--- a/tests/ui/string_from_utf8_as_bytes.fixed
+++ b/tests/ui/string_from_utf8_as_bytes.fixed
@@ -1,6 +1,16 @@
 #![warn(clippy::string_from_utf8_as_bytes)]
 
+macro_rules! test_range {
+    ($start:expr, $end:expr) => {
+        $start..$end
+    };
+}
+
 fn main() {
     let _ = Some(&"Hello World!"[6..11]);
     //~^ string_from_utf8_as_bytes
+
+    let s = "Hello World!";
+    let _ = Some(&s[test_range!(6, 11)]);
+    //~^ string_from_utf8_as_bytes
 }
diff --git a/tests/ui/string_from_utf8_as_bytes.rs b/tests/ui/string_from_utf8_as_bytes.rs
index 49beb19ee40f..6354d5376ad6 100644
--- a/tests/ui/string_from_utf8_as_bytes.rs
+++ b/tests/ui/string_from_utf8_as_bytes.rs
@@ -1,6 +1,16 @@
 #![warn(clippy::string_from_utf8_as_bytes)]
 
+macro_rules! test_range {
+    ($start:expr, $end:expr) => {
+        $start..$end
+    };
+}
+
 fn main() {
     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
     //~^ string_from_utf8_as_bytes
+
+    let s = "Hello World!";
+    let _ = std::str::from_utf8(&s.as_bytes()[test_range!(6, 11)]);
+    //~^ string_from_utf8_as_bytes
 }
diff --git a/tests/ui/string_from_utf8_as_bytes.stderr b/tests/ui/string_from_utf8_as_bytes.stderr
index 99c8d8ae4eab..bba9ec0caf19 100644
--- a/tests/ui/string_from_utf8_as_bytes.stderr
+++ b/tests/ui/string_from_utf8_as_bytes.stderr
@@ -1,5 +1,5 @@
 error: calling a slice of `as_bytes()` with `from_utf8` should be not necessary
-  --> tests/ui/string_from_utf8_as_bytes.rs:4:13
+  --> tests/ui/string_from_utf8_as_bytes.rs:10:13
    |
 LL |     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(&"Hello World!"[6..11])`
@@ -7,5 +7,11 @@ LL |     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
    = note: `-D clippy::string-from-utf8-as-bytes` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::string_from_utf8_as_bytes)]`
 
-error: aborting due to 1 previous error
+error: calling a slice of `as_bytes()` with `from_utf8` should be not necessary
+  --> tests/ui/string_from_utf8_as_bytes.rs:14:13
+   |
+LL |     let _ = std::str::from_utf8(&s.as_bytes()[test_range!(6, 11)]);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(&s[test_range!(6, 11)])`
+
+error: aborting due to 2 previous errors
 
diff --git a/tests/ui/unnecessary_fold.fixed b/tests/ui/unnecessary_fold.fixed
index c3eeafbc39cd..d51359349cb9 100644
--- a/tests/ui/unnecessary_fold.fixed
+++ b/tests/ui/unnecessary_fold.fixed
@@ -178,4 +178,15 @@ fn issue10000() {
     }
 }
 
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($e:expr) => {
+            ($e + 1) > 2
+        };
+    }
+
+    let _ = (0..3).any(|x| test_expr!(x));
+    //~^ unnecessary_fold
+}
+
 fn main() {}
diff --git a/tests/ui/unnecessary_fold.rs b/tests/ui/unnecessary_fold.rs
index 6ab41a942625..c6eb7157ab12 100644
--- a/tests/ui/unnecessary_fold.rs
+++ b/tests/ui/unnecessary_fold.rs
@@ -178,4 +178,15 @@ fn issue10000() {
     }
 }
 
+fn wrongly_unmangled_macros() {
+    macro_rules! test_expr {
+        ($e:expr) => {
+            ($e + 1) > 2
+        };
+    }
+
+    let _ = (0..3).fold(false, |acc: bool, x| acc || test_expr!(x));
+    //~^ unnecessary_fold
+}
+
 fn main() {}
diff --git a/tests/ui/unnecessary_fold.stderr b/tests/ui/unnecessary_fold.stderr
index 025a2bd0048b..560427a681a9 100644
--- a/tests/ui/unnecessary_fold.stderr
+++ b/tests/ui/unnecessary_fold.stderr
@@ -203,5 +203,13 @@ error: this `.fold` can be written more succinctly using another method
 LL |         (0..3).fold(1, |acc, x| acc * x)
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
-error: aborting due to 32 previous errors
+error: this `.fold` can be written more succinctly using another method
+  --> tests/ui/unnecessary_fold.rs:188:20
+   |
+LL |     let _ = (0..3).fold(false, |acc: bool, x| acc || test_expr!(x));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| test_expr!(x))`
+   |
+   = note: the `any` method is short circuiting and may change the program semantics if the iterator has side effects
+
+error: aborting due to 33 previous errors