Even more fixes for handling of macros (#16443)

*[View all
comments](https://triagebot.infra.rust-lang.org/gh-comments/rust-lang/rust-clippy/pull/16443)*

Continuation rust-lang/rust-clippy#16337

Even more fixes for handling macros

changelog: [`manual_rotate`] fix wrongly unmangled macros
changelog: [`map_with_unused_argument_over_ranges`] fix wrongly
unmangled macros
changelog: [`needless_bool`] fix wrongly unmangled macros
changelog: [`manual_is_power_of_two`] fix wrongly unmangled macros
changelog: [`manual_div_ceil`] fix wrongly unmangled macros
changelog: [`implicit_saturating_sub`] fix wrongly unmangled macros
changelog: [`range_minus_one`] fix wrongly unmangled macros
changelog: [`range_plus_one`] fix wrongly unmangled macros
changelog: [`manual_swap`] fix wrongly unmangled macros
changelog: [`let_and_return`] fix wrongly unmangled macros

Author: ada4a

clippy_lints/src/implicit_saturating_sub.rs

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::{Sugg, make_binop};
 use clippy_utils::{
     SpanlessEq, eq_expr_value, higher, is_in_const_context, is_integer_literal, is_integer_literal_untyped,
@@ -246,33 +246,35 @@ fn check_subtraction(
             // This part of the condition is voluntarily split from the one before to ensure that
             // if `snippet_opt` fails, it won't try the next conditions.
             if !is_in_const_context(cx) || msrv.meets(cx, msrvs::SATURATING_SUB_CONST) {
-                let mut applicability = Applicability::MachineApplicable;
-                let big_expr_sugg = (if is_integer_literal_untyped(big_expr) {
-                    let get_snippet = |span: Span| {
-                        let snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
-                        let big_expr_ty = cx.typeck_results().expr_ty(big_expr);
-                        Cow::Owned(format!("{snippet}_{big_expr_ty}"))
-                    };
-                    Sugg::hir_from_snippet(cx, big_expr, get_snippet)
-                } else {
-                    Sugg::hir_with_applicability(cx, big_expr, "..", &mut applicability)
-                })
-                .maybe_paren();
-                let little_expr_sugg = Sugg::hir_with_applicability(cx, little_expr, "..", &mut applicability);
-
-                let sugg = format!(
-                    "{}{big_expr_sugg}.saturating_sub({little_expr_sugg}){}",
-                    if is_composited { "{ " } else { "" },
-                    if is_composited { " }" } else { "" }
-                );
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
                     IMPLICIT_SATURATING_SUB,
                     expr_span,
                     "manual arithmetic check found",
-                    "replace it with",
-                    sugg,
-                    applicability,
+                    |diag| {
+                        let mut applicability = Applicability::MachineApplicable;
+                        let expr_span_ctxt = expr_span.ctxt();
+                        let big_expr_sugg = (if is_integer_literal_untyped(big_expr) {
+                            let get_snippet = |span: Span| {
+                                let (snippet, _) =
+                                    snippet_with_context(cx, span, expr_span_ctxt, "..", &mut applicability);
+                                let big_expr_ty = cx.typeck_results().expr_ty(big_expr);
+                                Cow::Owned(format!("{snippet}_{big_expr_ty}"))
+                            };
+                            Sugg::hir_from_snippet(cx, big_expr, get_snippet)
+                        } else {
+                            Sugg::hir_with_context(cx, big_expr, expr_span_ctxt, "..", &mut applicability)
+                        })
+                        .maybe_paren();
+                        let little_expr_sugg =
+                            Sugg::hir_with_context(cx, little_expr, expr_span_ctxt, "..", &mut applicability);
+                        let sugg = format!(
+                            "{}{big_expr_sugg}.saturating_sub({little_expr_sugg}){}",
+                            if is_composited { "{ " } else { "" },
+                            if is_composited { " }" } else { "" }
+                        );
+                        diag.span_suggestion(expr_span, "replace it with", sugg, applicability);
+                    },
                 );
             }
         } else if eq_expr_value(cx, left, little_expr)

clippy_lints/src/manual_is_power_of_two.rs

@@ -51,7 +51,7 @@ impl ManualIsPowerOfTwo {
         }
 
         let mut applicability = Applicability::MachineApplicable;
-        let snippet = Sugg::hir_with_applicability(cx, receiver, "_", &mut applicability);
+        let snippet = Sugg::hir_with_context(cx, receiver, expr.span.ctxt(), "_", &mut applicability);
 
         span_lint_and_sugg(
             cx,

clippy_lints/src/manual_rotate.rs

@@ -1,7 +1,7 @@
 use std::fmt::Display;
 
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -116,17 +116,23 @@ impl LateLintPass<'_> for ManualRotate {
                 }
             };
 
-            let mut applicability = Applicability::MachineApplicable;
-            let expr_sugg = sugg::Sugg::hir_with_applicability(cx, l_expr, "_", &mut applicability).maybe_paren();
-            let amount = sugg::Sugg::hir_with_applicability(cx, amount, "_", &mut applicability);
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 MANUAL_ROTATE,
                 expr.span,
                 "there is no need to manually implement bit rotation",
-                "this expression can be rewritten as",
-                format!("{expr_sugg}.{shift_function}({amount})"),
-                Applicability::MachineApplicable,
+                |diag| {
+                    let mut applicability = Applicability::MachineApplicable;
+                    let expr_sugg = sugg::Sugg::hir_with_context(cx, l_expr, expr.span.ctxt(), "_", &mut applicability)
+                        .maybe_paren();
+                    let amount = sugg::Sugg::hir_with_context(cx, amount, expr.span.ctxt(), "_", &mut applicability);
+                    diag.span_suggestion(
+                        expr.span,
+                        "this expression can be rewritten as",
+                        format!("{expr_sugg}.{shift_function}({amount})"),
+                        applicability,
+                    );
+                },
             );
         }
     }

clippy_lints/src/methods/map_with_unused_argument_over_ranges.rs

@@ -1,7 +1,7 @@
 use crate::methods::MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{eager_or_lazy, higher, std_or_core, usage};
 use rustc_ast::LitKind;
@@ -10,12 +10,13 @@ use rustc_data_structures::packed::Pu128;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Closure, Expr, ExprKind};
 use rustc_lint::LateContext;
-use rustc_span::Span;
+use rustc_span::{Span, SyntaxContext};
 
 fn extract_count_with_applicability(
     cx: &LateContext<'_>,
     range: higher::Range<'_>,
     applicability: &mut Applicability,
+    ctxt: SyntaxContext,
 ) -> Option<String> {
     let start = range.start?;
     let end = range.end?;
@@ -40,7 +41,7 @@ fn extract_count_with_applicability(
             };
             return Some(format!("{count}"));
         }
-        let end_snippet = Sugg::hir_with_applicability(cx, end, "...", applicability)
+        let end_snippet = Sugg::hir_with_context(cx, end, ctxt, "...", applicability)
             .maybe_paren()
             .into_string();
         if lower_bound == 0 {
@@ -74,52 +75,43 @@ pub(super) fn check(
             value: body_expr,
         } = body_hir
         && !usage::BindingUsageFinder::are_params_used(cx, body_hir)
-        && let Some(count) = extract_count_with_applicability(cx, range, &mut applicability)
+        && let ctxt = ex.span.ctxt()
+        && let Some(count) = extract_count_with_applicability(cx, range, &mut applicability, ctxt)
         && let Some(exec_context) = std_or_core(cx)
     {
-        let method_to_use_name;
-        let new_span;
-        let use_take;
-
-        if eager_or_lazy::switch_to_eager_eval(cx, body_expr) {
+        let (method_to_use_name, new_span, use_take) = if eager_or_lazy::switch_to_eager_eval(cx, body_expr) {
             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}"));
-                use_take = false;
+                let (body_snippet, _) = snippet_with_context(cx, body_expr.span, ctxt, "..", &mut applicability);
+                ("repeat_n", (arg.span, format!("{body_snippet}, {count}")), false)
             } else {
-                method_to_use_name = "repeat";
-                let body_snippet = snippet_with_applicability(cx, body_expr.span, "..", &mut applicability);
-                new_span = (arg.span, body_snippet.to_string());
-                use_take = true;
+                let (body_snippet, _) = snippet_with_context(cx, body_expr.span, ctxt, "..", &mut applicability);
+                ("repeat", (arg.span, body_snippet.to_string()), true)
             }
         } else if msrv.meets(cx, msrvs::REPEAT_WITH) {
-            method_to_use_name = "repeat_with";
-            new_span = (param.span, String::new());
-            use_take = true;
+            ("repeat_with", (param.span, String::new()), true)
         } else {
             return;
-        }
-
-        // We need to provide nonempty parts to diag.multipart_suggestion so we
-        // collate all our parts here and then remove those that are empty.
-        let mut parts = vec![
-            (
-                ex.span.with_hi(method_name_span.hi()),
-                format!("{exec_context}::iter::{method_to_use_name}"),
-            ),
-            new_span,
-        ];
-        if use_take {
-            parts.push((ex.span.shrink_to_hi(), format!(".take({count})")));
-        }
+        };
 
         span_lint_and_then(
             cx,
             MAP_WITH_UNUSED_ARGUMENT_OVER_RANGES,
             ex.span,
             "map of a closure that does not depend on its parameter over a range",
             |diag| {
+                // We need to provide nonempty parts to diag.multipart_suggestion so we
+                // collate all our parts here and then remove those that are empty.
+                let mut parts = vec![
+                    (
+                        ex.span.with_hi(method_name_span.hi()),
+                        format!("{exec_context}::iter::{method_to_use_name}"),
+                    ),
+                    new_span,
+                ];
+                if use_take {
+                    parts.push((ex.span.shrink_to_hi(), format!(".take({count})")));
+                }
+
                 diag.multipart_suggestion(
                     if use_take {
                         format!("remove the explicit range and use `{method_to_use_name}` and `take`")

clippy_lints/src/needless_bool.rs

@@ -112,7 +112,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBool {
         {
             let reduce = |ret, not| {
                 let mut applicability = Applicability::MachineApplicable;
-                let snip = Sugg::hir_with_applicability(cx, cond, "<predicate>", &mut applicability);
+                let snip = Sugg::hir_with_context(cx, cond, e.span.ctxt(), "<predicate>", &mut applicability);
                 let mut snip = if not { !snip } else { snip };
 
                 if ret {

clippy_lints/src/operators/manual_div_ceil.rs

@@ -148,7 +148,8 @@ fn build_suggestion(
     rhs: &Expr<'_>,
     applicability: &mut Applicability,
 ) {
-    let dividend_sugg = Sugg::hir_with_applicability(cx, lhs, "..", applicability).maybe_paren();
+    let ctxt = expr.span.ctxt();
+    let dividend_sugg = Sugg::hir_with_context(cx, lhs, ctxt, "..", applicability).maybe_paren();
     let rhs_ty = cx.typeck_results().expr_ty(rhs);
     let type_suffix = if cx.typeck_results().expr_ty(lhs).is_numeric()
         && matches!(
@@ -186,7 +187,7 @@ fn build_suggestion(
     };
 
     // Dereference the RHS if it is a reference type
-    let divisor_snippet = match Sugg::hir_with_context(cx, rhs, expr.span.ctxt(), "_", applicability) {
+    let divisor_snippet = match Sugg::hir_with_context(cx, rhs, ctxt, "_", applicability) {
         sugg if rhs_ty.is_ref() => sugg.deref(),
         sugg => sugg,
     };

clippy_lints/src/operators/needless_bitwise_bool.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::snippet_with_context;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -24,12 +24,12 @@ pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, op: BinOpKind, lhs: &Exp
             e.span,
             "use of bitwise operator instead of lazy operator between booleans",
             |diag| {
-                if let Some(lhs_snip) = lhs.span.get_source_text(cx)
-                    && let Some(rhs_snip) = rhs.span.get_source_text(cx)
-                {
-                    let sugg = format!("{lhs_snip} {op_str} {rhs_snip}");
-                    diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
-                }
+                let mut applicability = Applicability::MachineApplicable;
+                let expr_span_ctxt = e.span.ctxt();
+                let (lhs_snip, _) = snippet_with_context(cx, lhs.span, expr_span_ctxt, "..", &mut applicability);
+                let (rhs_snip, _) = snippet_with_context(cx, rhs.span, expr_span_ctxt, "..", &mut applicability);
+
+                diag.span_suggestion(e.span, "try", format!("{lhs_snip} {op_str} {rhs_snip}"), applicability);
             },
         );
     }

clippy_lints/src/ranges.rs

@@ -518,11 +518,11 @@ fn check_range_switch<'tcx>(
         span_lint_and_then(cx, lint, span, msg, |diag| {
             let mut app = Applicability::MachineApplicable;
             let start = start.map_or(String::new(), |x| {
-                Sugg::hir_with_applicability(cx, x, "<x>", &mut app)
+                Sugg::hir_with_context(cx, x, span.ctxt(), "<x>", &mut app)
                     .maybe_paren()
                     .to_string()
             });
-            let end = Sugg::hir_with_applicability(cx, y, "<y>", &mut app).maybe_paren();
+            let end = Sugg::hir_with_context(cx, y, span.ctxt(), "<y>", &mut app).maybe_paren();
             match span.with_source_text(cx, |src| src.starts_with('(') && src.ends_with(')')) {
                 Some(true) => {
                     diag.span_suggestion(span, "use", format!("({start}{operator}{end})"), app);

clippy_lints/src/returns/let_and_return.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::res::MaybeResPath;
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{binary_expr_needs_parentheses, fn_def_id, span_contains_non_whitespace};
@@ -38,30 +38,29 @@ pub(super) fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>)
             |err| {
                 err.span_label(local.span, "unnecessary `let` binding");
 
-                if let Some(src) = initexpr.span.get_source_text(cx) {
-                    let sugg = if binary_expr_needs_parentheses(initexpr) {
-                        if has_enclosing_paren(&src) {
-                            src.to_owned()
-                        } else {
-                            format!("({src})")
-                        }
-                    } else if !cx.typeck_results().expr_adjustments(retexpr).is_empty() {
-                        if has_enclosing_paren(&src) {
-                            format!("{src} as _")
-                        } else {
-                            format!("({src}) as _")
-                        }
+                let mut app = Applicability::MachineApplicable;
+                let (src, _) = snippet_with_context(cx, initexpr.span, local.span.ctxt(), "..", &mut app);
+
+                let sugg = if binary_expr_needs_parentheses(initexpr) {
+                    if has_enclosing_paren(&src) {
+                        src.to_string()
+                    } else {
+                        format!("({src})")
+                    }
+                } else if !cx.typeck_results().expr_adjustments(retexpr).is_empty() {
+                    if has_enclosing_paren(&src) {
+                        format!("{src} as _")
                     } else {
-                        src.to_owned()
-                    };
-                    err.multipart_suggestion(
-                        "return the expression directly",
-                        vec![(local.span, String::new()), (retexpr.span, sugg)],
-                        Applicability::MachineApplicable,
-                    );
+                        format!("({src}) as _")
+                    }
                 } else {
-                    err.span_help(initexpr.span, "this expression can be directly returned");
-                }
+                    src.to_string()
+                };
+                err.multipart_suggestion(
+                    "return the expression directly",
+                    vec![(local.span, String::new()), (retexpr.span, sugg)],
+                    app,
+                );
             },
         );
     }

clippy_lints/src/swap.rs

@@ -112,7 +112,7 @@ fn generate_swap_warning<'tcx>(
                 || ty.is_diag_item(cx, sym::Vec)
                 || ty.is_diag_item(cx, sym::VecDeque)
             {
-                let slice = Sugg::hir_with_applicability(cx, lhs1, "<slice>", &mut applicability);
+                let slice = Sugg::hir_with_context(cx, lhs1, ctxt, "<slice>", &mut applicability);
 
                 span_lint_and_sugg(
                     cx,