Start replacing snippet_with_context with get_source_text_at_ctxt

clippy_lints/src/assertions_on_result_states.rs

@@ -1,10 +1,9 @@
-use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::diagnostics::{applicability_for_ctxt, span_lint_and_then};
 use clippy_utils::macros::{PanicExpn, find_assert_args, root_macro_call_first_node};
-use clippy_utils::source::snippet_with_context;
+use clippy_utils::source::SpanExt;
 use clippy_utils::ty::{has_debug_impl, is_copy, is_type_diagnostic_item};
 use clippy_utils::usage::local_used_after_expr;
 use clippy_utils::{path_res, sym};
-use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::{Expr, ExprKind, Node};
 use rustc_lint::{LateContext, LateLintPass};
@@ -76,10 +75,11 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                 },
                 _ => return,
             };
+            let ctxt = condition.span.ctxt();
+            let Some(recv) = recv.span.get_source_text_at_ctxt(cx, ctxt) else {
+                return;
+            };
             span_lint_and_then(cx, ASSERTIONS_ON_RESULT_STATES, macro_call.span, message, |diag| {
-                let mut app = Applicability::MachineApplicable;
-                let recv = snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0;
-
                 // `assert!` doesn't return anything, but `Result::unwrap(_err)` does, so we might need to add a
                 // semicolon to the suggestion to avoid leaking the type
                 let sugg = match cx.tcx.parent_hir_node(e.hir_id) {
@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                     // this is the last-resort option, because it's rather verbose
                     _ => format!("{{ {recv}.{replacement}(); }}"),
                 };
-                diag.span_suggestion(macro_call.span, "replace with", sugg, app);
+                diag.span_suggestion(macro_call.span, "replace with", sugg, applicability_for_ctxt(ctxt));
             });
         }
     }

clippy_lints/src/attrs/non_minimal_cfg.rs

@@ -1,6 +1,6 @@
 use super::{Attribute, NON_MINIMAL_CFG};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::SpanExt;
 use rustc_ast::{MetaItemInner, MetaItemKind};
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;

clippy_lints/src/attrs/unnecessary_clippy_cfg.rs

@@ -1,6 +1,6 @@
 use super::{Attribute, UNNECESSARY_CLIPPY_CFG};
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::SpanExt;
 use itertools::Itertools;
 use rustc_ast::AttrStyle;
 use rustc_errors::Applicability;

clippy_lints/src/attrs/useless_attribute.rs

@@ -1,7 +1,7 @@
 use super::USELESS_ATTRIBUTE;
 use super::utils::{is_lint_level, is_word, namespace_and_lint};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::{SpanRangeExt, first_line_of_span};
+use clippy_utils::source::{SpanExt, first_line_of_span};
 use clippy_utils::sym;
 use rustc_ast::{Attribute, Item, ItemKind};
 use rustc_errors::Applicability;

clippy_lints/src/bool_to_int_with_if.rs

@@ -1,5 +1,4 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::HasSession;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{higher, is_else_clause, is_in_const_context, span_contains_comment};
 use rustc_ast::LitKind;
@@ -59,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
             && !is_in_const_context(cx)
         {
             let ty = cx.typeck_results().expr_ty(then);
-            let mut applicability = if span_contains_comment(cx.sess().source_map(), expr.span) {
+            let mut applicability = if span_contains_comment(cx, expr.span) {
                 Applicability::MaybeIncorrect
             } else {
                 Applicability::MachineApplicable

clippy_lints/src/booleans.rs

@@ -2,7 +2,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::higher::has_let_expr;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::SpanExt;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{eq_expr_value, sym};

clippy_lints/src/borrow_deref_ref.rs

@@ -1,6 +1,6 @@
 use crate::reference::DEREF_ADDROF;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::SpanExt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{get_parent_expr, is_expr_temporary_value, is_from_proc_macro, is_lint_allowed, is_mutable};
 use rustc_errors::Applicability;

clippy_lints/src/casts/as_ptr_cast_mut.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::SpanExt;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;

clippy_lints/src/casts/borrow_as_ptr.rs

@@ -1,6 +1,6 @@
-use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{applicability_for_ctxt, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::msrvs::Msrv;
-use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
+use clippy_utils::source::SpanExt;
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::{get_parent_expr, is_expr_temporary_value, is_from_proc_macro, is_lint_allowed, msrvs, std_or_core};
 use rustc_errors::Applicability;
@@ -21,18 +21,21 @@ pub(super) fn check<'tcx>(
     if let TyKind::Ptr(target) = cast_to.kind
         && !matches!(target.ty.kind, TyKind::TraitObject(..))
         && let ExprKind::AddrOf(BorrowKind::Ref, mutability, e) = cast_expr.kind
+        && let ctxt = expr.span.ctxt()
+        && cast_expr.span.ctxt() == ctxt
         && !is_lint_allowed(cx, BORROW_AS_PTR, expr.hir_id)
         // Fix #9884
         && !is_expr_temporary_value(cx, e)
         && !is_from_proc_macro(cx, expr)
+        && let Some(snip) = e.span.get_source_text_at_ctxt(cx, ctxt)
     {
-        let mut app = Applicability::MachineApplicable;
-        let snip = snippet_with_context(cx, e.span, cast_expr.span.ctxt(), "..", &mut app).0;
-
         let (suggestion, span) = if msrv.meets(cx, msrvs::RAW_REF_OP) {
             // Make sure that the span to be replaced doesn't include parentheses, that could break the
             // suggestion.
-            let span = if has_enclosing_paren(snippet_with_applicability(cx, expr.span, "", &mut app)) {
+            let Some(src) = expr.span.get_source_text(cx) else {
+                return false;
+            };
+            let span = if has_enclosing_paren(&*src) {
                 expr.span
                     .with_lo(expr.span.lo() + BytePos(1))
                     .with_hi(expr.span.hi() - BytePos(1))
@@ -51,7 +54,15 @@ pub(super) fn check<'tcx>(
             (format!("{std_or_core}::ptr::{macro_name}!({snip})"), expr.span)
         };
 
-        span_lint_and_sugg(cx, BORROW_AS_PTR, span, "borrow as raw pointer", "try", suggestion, app);
+        span_lint_and_sugg(
+            cx,
+            BORROW_AS_PTR,
+            span,
+            "borrow as raw pointer",
+            "try",
+            suggestion,
+            applicability_for_ctxt(ctxt),
+        );
         return true;
     }
     false

clippy_lints/src/casts/cast_lossless.rs

@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_in_const_context;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::SpanExt;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_errors::Applicability;

clippy_lints/src/casts/manual_dangling_ptr.rs

@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::SpanExt;
 use clippy_utils::{expr_or_init, is_path_diagnostic_item, std_or_core, sym};
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;

clippy_lints/src/casts/unnecessary_cast.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::NumericLiteral;
-use clippy_utils::source::{SpanRangeExt, snippet_opt};
+use clippy_utils::source::{SpanExt, snippet_opt};
 use clippy_utils::visitors::{Visitable, for_each_expr_without_closures};
 use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, is_ty_alias, path_to_local};
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
@@ -167,7 +167,7 @@ pub(super) fn check<'tcx>(
                 sym::assert_ne_macro,
                 sym::debug_assert_ne_macro,
             ];
-            matches!(expr.span.ctxt().outer_expn_data().macro_def_id, Some(def_id) if 
+            matches!(expr.span.ctxt().outer_expn_data().macro_def_id, Some(def_id) if
                 cx.tcx.get_diagnostic_name(def_id).is_some_and(|sym| ALLOWED_MACROS.contains(&sym)))
         }
 

clippy_lints/src/casts/zero_ptr.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::SpanExt;
 use clippy_utils::{is_in_const_context, is_integer_literal, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability, Ty, TyKind};

clippy_lints/src/cognitive_complexity.rs

@@ -1,6 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::source::{IntoSpan, SpanRangeExt};
+use clippy_utils::source::SpanExt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{LimitStack, get_async_fn_body, is_async_fn, sym};
@@ -110,14 +110,15 @@ impl CognitiveComplexity {
                 FnKind::ItemFn(ident, _, _) | FnKind::Method(ident, _) => ident.span,
                 FnKind::Closure => {
                     let header_span = body_span.with_hi(decl.output.span().lo());
-                    if let Some(range) = header_span.map_range(cx, |_, src, range| {
-                        let mut idxs = src.get(range.clone())?.match_indices('|');
-                        Some(range.start + idxs.next()?.0..range.start + idxs.next()?.0 + 1)
-                    }) {
-                        range.with_ctxt(header_span.ctxt())
-                    } else {
+                    let Some(s) = header_span.map_range(cx, |range| {
+                        range.edit_range(|src, range| {
+                            let mut idxs = src.get(range.clone())?.match_indices('|');
+                            Some(range.start + idxs.next()?.0..range.start + idxs.next()?.0 + 1)
+                        })
+                    }) else {
                         return;
-                    }
+                    };
+                    s
                 },
             };
 

clippy_lints/src/collapsible_if.rs

@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::{IntoSpan as _, SpanRangeExt, snippet, snippet_block_with_applicability};
+use clippy_utils::source::{SourceFileRange, SpanExt, snippet, snippet_block_with_applicability};
 use clippy_utils::{span_contains_non_whitespace, tokenize_with_text};
 use rustc_ast::BinOpKind;
 use rustc_errors::Applicability;
@@ -113,15 +113,15 @@ impl CollapsibleIf {
                             span_extract_keyword(cx.tcx.sess.source_map(), up_to_else, "else")
                         && let Some(else_if_keyword_span) =
                             span_extract_keyword(cx.tcx.sess.source_map(), else_before_if, "if")
+                        && let Some(else_keyword_span) =
+                            else_keyword_span.map_range(cx, SourceFileRange::add_leading_whitespace)
+                        && let Some(else_open_bracket) = else_block
+                            .span
+                            .map_range(cx, |range| range.set_to_prefix('{')?.add_leading_whitespace())
+                        && let Some(else_closing_bracket) = else_block
+                            .span
+                            .map_range(cx, |range| range.set_to_suffix('}')?.add_leading_whitespace())
                     {
-                        let else_keyword_span = else_keyword_span.with_leading_whitespace(cx).into_span();
-                        let else_open_bracket = else_block.span.split_at(1).0.with_leading_whitespace(cx).into_span();
-                        let else_closing_bracket = {
-                            let end = else_block.span.shrink_to_hi();
-                            end.with_lo(end.lo() - BytePos(1))
-                                .with_leading_whitespace(cx)
-                                .into_span()
-                        };
                         let sugg = vec![
                             // Remove the outer else block `else`
                             (else_keyword_span, String::new()),
@@ -171,20 +171,19 @@ impl CollapsibleIf {
             && self.eligible_condition(cx, check_inner)
             && expr.span.eq_ctxt(inner.span)
             && !block_starts_with_significant_tokens(cx, then, inner, self.lint_commented_code)
+            && let Some(then_open_bracket) = then
+                .span
+                .map_range(cx, |range| range.set_to_prefix('{')?.add_leading_whitespace())
+            && let Some(then_closing_bracket) = then
+                .span
+                .map_range(cx, |range| range.set_to_suffix('}')?.add_leading_whitespace())
         {
             span_lint_and_then(
                 cx,
                 COLLAPSIBLE_IF,
                 expr.span,
                 "this `if` statement can be collapsed",
                 |diag| {
-                    let then_open_bracket = then.span.split_at(1).0.with_leading_whitespace(cx).into_span();
-                    let then_closing_bracket = {
-                        let end = then.span.shrink_to_hi();
-                        end.with_lo(end.lo() - BytePos(1))
-                            .with_leading_whitespace(cx)
-                            .into_span()
-                    };
                     let (paren_start, inner_if_span, paren_end) = peel_parens(cx.tcx.sess.source_map(), inner.span);
                     let inner_if = inner_if_span.split_at(2).0;
                     let mut sugg = vec![

clippy_lints/src/copies.rs

@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_note, span_lint_and_then};
 use clippy_utils::higher::has_let_expr;
-use clippy_utils::source::{IntoSpan, SpanRangeExt, first_line_of_span, indent_of, reindent_multiline, snippet};
+use clippy_utils::source::{SpanExt, first_line_of_span, indent_of, reindent_multiline, snippet};
 use clippy_utils::ty::{InteriorMut, needs_ordered_drop};
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{
@@ -239,21 +239,23 @@ fn lint_branches_sharing_code<'tcx>(
         let suggestion = reindent_multiline(&suggestion, true, cond_indent);
         (replace_span, suggestion)
     });
-    let end_suggestion = res.end_span(last_block, sm).map(|span| {
+    let end_suggestion = res.end_span(last_block, sm).and_then(|span| {
         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(&suggestion, true, indent);
 
-        let span = span.with_hi(last_block.span.hi());
         // Improve formatting if the inner block has indentation (i.e. normal Rust formatting)
-        let span = span
-            .map_range(cx, |_, src, range| {
-                (range.start > 4 && src.get(range.start - 4..range.start)? == "    ")
-                    .then_some(range.start - 4..range.end)
+        let span = span.map_range(cx, |range| {
+            range.set_end_if_after(last_block.span.hi())?.edit_range(|src, range| {
+                if src.get(..range.start)?.ends_with("    ") {
+                    Some(range.start - 4..range.end)
+                } else {
+                    Some(range)
+                }
             })
-            .map_or(span, |range| range.with_ctxt(span.ctxt()));
-        (span, suggestion.clone())
+        })?;
+        Some((span, suggestion))
     });
 
     let (span, msg, end_span) = match (&start_suggestion, &end_suggestion) {

clippy_lints/src/default_constructed_unit_structs.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_ty_alias;
-use clippy_utils::source::SpanRangeExt as _;
+use clippy_utils::source::SpanExt as _;
 use hir::ExprKind;
 use hir::def::Res;
 use rustc_errors::Applicability;
@@ -75,7 +75,7 @@ impl LateLintPass<'_> for DefaultConstructedUnitStructs {
             && !base.is_suggestable_infer_ty()
         {
             let mut removals = vec![(expr.span.with_lo(qpath.qself_span().hi()), String::new())];
-            if expr.span.with_source_text(cx, |s| s.starts_with('<')) == Some(true) {
+            if expr.span.check_source_text(cx, |s| s.starts_with('<')) {
                 // Remove `<`, '>` has already been removed by the existing removal expression.
                 removals.push((expr.span.with_hi(qpath.qself_span().lo()), String::new()));
             }