clippy_utils/
source.rs

1//! Utils for extracting, inspecting or transforming source code
2
3#![allow(clippy::module_name_repetitions)]
4
5use std::sync::Arc;
6
7use rustc_ast::{LitKind, StrStyle};
8use rustc_errors::Applicability;
9use rustc_hir::{BlockCheckMode, Expr, ExprKind, UnsafeSource};
10use rustc_lexer::{LiteralKind, TokenKind, tokenize};
11use rustc_lint::{EarlyContext, LateContext};
12use rustc_middle::ty::TyCtxt;
13use rustc_session::Session;
14use rustc_span::source_map::{SourceMap, original_sp};
15use rustc_span::{
16    BytePos, DUMMY_SP, FileNameDisplayPreference, Pos, RelativeBytePos, SourceFile, SourceFileAndLine, Span, SpanData,
17    SyntaxContext, hygiene,
18};
19use std::borrow::Cow;
20use std::fmt;
21use std::ops::{Deref, Index, Range};
22
23pub trait HasSession {
24    fn sess(&self) -> &Session;
25}
26impl HasSession for Session {
27    fn sess(&self) -> &Session {
28        self
29    }
30}
31impl HasSession for TyCtxt<'_> {
32    fn sess(&self) -> &Session {
33        self.sess
34    }
35}
36impl HasSession for EarlyContext<'_> {
37    fn sess(&self) -> &Session {
38        ::rustc_lint::LintContext::sess(self)
39    }
40}
41impl HasSession for LateContext<'_> {
42    fn sess(&self) -> &Session {
43        self.tcx.sess()
44    }
45}
46
47/// Conversion of a value into the range portion of a `Span`.
48pub trait SpanRange: Sized {
49    fn into_range(self) -> Range<BytePos>;
50}
51impl SpanRange for Span {
52    fn into_range(self) -> Range<BytePos> {
53        let data = self.data();
54        data.lo..data.hi
55    }
56}
57impl SpanRange for SpanData {
58    fn into_range(self) -> Range<BytePos> {
59        self.lo..self.hi
60    }
61}
62impl SpanRange for Range<BytePos> {
63    fn into_range(self) -> Range<BytePos> {
64        self
65    }
66}
67
68/// Conversion of a value into a `Span`
69pub trait IntoSpan: Sized {
70    fn into_span(self) -> Span;
71    fn with_ctxt(self, ctxt: SyntaxContext) -> Span;
72}
73impl IntoSpan for Span {
74    fn into_span(self) -> Span {
75        self
76    }
77    fn with_ctxt(self, ctxt: SyntaxContext) -> Span {
78        self.with_ctxt(ctxt)
79    }
80}
81impl IntoSpan for SpanData {
82    fn into_span(self) -> Span {
83        self.span()
84    }
85    fn with_ctxt(self, ctxt: SyntaxContext) -> Span {
86        Span::new(self.lo, self.hi, ctxt, self.parent)
87    }
88}
89impl IntoSpan for Range<BytePos> {
90    fn into_span(self) -> Span {
91        Span::with_root_ctxt(self.start, self.end)
92    }
93    fn with_ctxt(self, ctxt: SyntaxContext) -> Span {
94        Span::new(self.start, self.end, ctxt, None)
95    }
96}
97
98pub trait SpanRangeExt: SpanRange {
99    /// Attempts to get a handle to the source text. Returns `None` if either the span is malformed,
100    /// or the source text is not accessible.
101    fn get_source_text(self, cx: &impl HasSession) -> Option<SourceText> {
102        get_source_range(cx.sess().source_map(), self.into_range()).and_then(SourceText::new)
103    }
104
105    /// Gets the source file, and range in the file, of the given span. Returns `None` if the span
106    /// extends through multiple files, or is malformed.
107    fn get_source_range(self, cx: &impl HasSession) -> Option<SourceFileRange> {
108        get_source_range(cx.sess().source_map(), self.into_range())
109    }
110
111    /// Calls the given function with the source text referenced and returns the value. Returns
112    /// `None` if the source text cannot be retrieved.
113    fn with_source_text<T>(self, cx: &impl HasSession, f: impl for<'a> FnOnce(&'a str) -> T) -> Option<T> {
114        with_source_text(cx.sess().source_map(), self.into_range(), f)
115    }
116
117    /// Checks if the referenced source text satisfies the given predicate. Returns `false` if the
118    /// source text cannot be retrieved.
119    fn check_source_text(self, cx: &impl HasSession, pred: impl for<'a> FnOnce(&'a str) -> bool) -> bool {
120        self.with_source_text(cx, pred).unwrap_or(false)
121    }
122
123    /// Calls the given function with the both the text of the source file and the referenced range,
124    /// and returns the value. Returns `None` if the source text cannot be retrieved.
125    fn with_source_text_and_range<T>(
126        self,
127        cx: &impl HasSession,
128        f: impl for<'a> FnOnce(&'a str, Range<usize>) -> T,
129    ) -> Option<T> {
130        with_source_text_and_range(cx.sess().source_map(), self.into_range(), f)
131    }
132
133    /// Calls the given function with the both the text of the source file and the referenced range,
134    /// and creates a new span with the returned range. Returns `None` if the source text cannot be
135    /// retrieved, or no result is returned.
136    ///
137    /// The new range must reside within the same source file.
138    fn map_range(
139        self,
140        cx: &impl HasSession,
141        f: impl for<'a> FnOnce(&'a SourceFile, &'a str, Range<usize>) -> Option<Range<usize>>,
142    ) -> Option<Range<BytePos>> {
143        map_range(cx.sess().source_map(), self.into_range(), f)
144    }
145
146    #[allow(rustdoc::invalid_rust_codeblocks, reason = "The codeblock is intentionally broken")]
147    /// Extends the range to include all preceding whitespace characters.
148    ///
149    /// The range will not be expanded if it would cross a line boundary, the line the range would
150    /// be extended to ends with a line comment and the text after the range contains a
151    /// non-whitespace character on the same line. e.g.
152    ///
153    /// ```ignore
154    /// ( // Some comment
155    /// foo)
156    /// ```
157    ///
158    /// When the range points to `foo`, suggesting to remove the range after it's been extended will
159    /// cause the `)` to be placed inside the line comment as `( // Some comment)`.
160    fn with_leading_whitespace(self, cx: &impl HasSession) -> Range<BytePos> {
161        with_leading_whitespace(cx.sess().source_map(), self.into_range())
162    }
163
164    /// Trims the leading whitespace from the range.
165    fn trim_start(self, cx: &impl HasSession) -> Range<BytePos> {
166        trim_start(cx.sess().source_map(), self.into_range())
167    }
168}
169impl<T: SpanRange> SpanRangeExt for T {}
170
171/// Handle to a range of text in a source file.
172pub struct SourceText(SourceFileRange);
173impl SourceText {
174    /// Takes ownership of the source file handle if the source text is accessible.
175    pub fn new(text: SourceFileRange) -> Option<Self> {
176        if text.as_str().is_some() {
177            Some(Self(text))
178        } else {
179            None
180        }
181    }
182
183    /// Gets the source text.
184    pub fn as_str(&self) -> &str {
185        self.0.as_str().unwrap()
186    }
187
188    /// Converts this into an owned string.
189    pub fn to_owned(&self) -> String {
190        self.as_str().to_owned()
191    }
192}
193impl Deref for SourceText {
194    type Target = str;
195    fn deref(&self) -> &Self::Target {
196        self.as_str()
197    }
198}
199impl AsRef<str> for SourceText {
200    fn as_ref(&self) -> &str {
201        self.as_str()
202    }
203}
204impl<T> Index<T> for SourceText
205where
206    str: Index<T>,
207{
208    type Output = <str as Index<T>>::Output;
209    fn index(&self, idx: T) -> &Self::Output {
210        &self.as_str()[idx]
211    }
212}
213impl fmt::Display for SourceText {
214    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
215        self.as_str().fmt(f)
216    }
217}
218
219fn get_source_range(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRange> {
220    let start = sm.lookup_byte_offset(sp.start);
221    let end = sm.lookup_byte_offset(sp.end);
222    if !Arc::ptr_eq(&start.sf, &end.sf) || start.pos > end.pos {
223        return None;
224    }
225    sm.ensure_source_file_source_present(&start.sf);
226    let range = start.pos.to_usize()..end.pos.to_usize();
227    Some(SourceFileRange { sf: start.sf, range })
228}
229
230fn with_source_text<T>(sm: &SourceMap, sp: Range<BytePos>, f: impl for<'a> FnOnce(&'a str) -> T) -> Option<T> {
231    if let Some(src) = get_source_range(sm, sp)
232        && let Some(src) = src.as_str()
233    {
234        Some(f(src))
235    } else {
236        None
237    }
238}
239
240fn with_source_text_and_range<T>(
241    sm: &SourceMap,
242    sp: Range<BytePos>,
243    f: impl for<'a> FnOnce(&'a str, Range<usize>) -> T,
244) -> Option<T> {
245    if let Some(src) = get_source_range(sm, sp)
246        && let Some(text) = &src.sf.src
247    {
248        Some(f(text, src.range))
249    } else {
250        None
251    }
252}
253
254#[expect(clippy::cast_possible_truncation)]
255fn map_range(
256    sm: &SourceMap,
257    sp: Range<BytePos>,
258    f: impl for<'a> FnOnce(&'a SourceFile, &'a str, Range<usize>) -> Option<Range<usize>>,
259) -> Option<Range<BytePos>> {
260    if let Some(src) = get_source_range(sm, sp.clone())
261        && let Some(text) = &src.sf.src
262        && let Some(range) = f(&src.sf, text, src.range.clone())
263    {
264        debug_assert!(
265            range.start <= text.len() && range.end <= text.len(),
266            "Range `{range:?}` is outside the source file (file `{}`, length `{}`)",
267            src.sf.name.display(FileNameDisplayPreference::Local),
268            text.len(),
269        );
270        debug_assert!(range.start <= range.end, "Range `{range:?}` has overlapping bounds");
271        let dstart = (range.start as u32).wrapping_sub(src.range.start as u32);
272        let dend = (range.end as u32).wrapping_sub(src.range.start as u32);
273        Some(BytePos(sp.start.0.wrapping_add(dstart))..BytePos(sp.start.0.wrapping_add(dend)))
274    } else {
275        None
276    }
277}
278
279fn ends_with_line_comment_or_broken(text: &str) -> bool {
280    let Some(last) = tokenize(text).last() else {
281        return false;
282    };
283    match last.kind {
284        // Will give the wrong result on text like `" // "` where the first quote ends a string
285        // started earlier. The only workaround is to lex the whole file which we don't really want
286        // to do.
287        TokenKind::LineComment { .. } | TokenKind::BlockComment { terminated: false, .. } => true,
288        TokenKind::Literal { kind, .. } => matches!(
289            kind,
290            LiteralKind::Byte { terminated: false }
291                | LiteralKind::ByteStr { terminated: false }
292                | LiteralKind::CStr { terminated: false }
293                | LiteralKind::Char { terminated: false }
294                | LiteralKind::RawByteStr { n_hashes: None }
295                | LiteralKind::RawCStr { n_hashes: None }
296                | LiteralKind::RawStr { n_hashes: None }
297        ),
298        _ => false,
299    }
300}
301
302fn with_leading_whitespace_inner(lines: &[RelativeBytePos], src: &str, range: Range<usize>) -> Option<usize> {
303    debug_assert!(lines.is_empty() || lines[0].to_u32() == 0);
304
305    let start = src.get(..range.start)?.trim_end();
306    let next_line = lines.partition_point(|&pos| pos.to_usize() <= start.len());
307    if let Some(line_end) = lines.get(next_line)
308        && line_end.to_usize() <= range.start
309        && let prev_start = lines.get(next_line - 1).map_or(0, |&x| x.to_usize())
310        && ends_with_line_comment_or_broken(&start[prev_start..])
311        && let next_line = lines.partition_point(|&pos| pos.to_usize() < range.end)
312        && let next_start = lines.get(next_line).map_or(src.len(), |&x| x.to_usize())
313        && tokenize(src.get(range.end..next_start)?).any(|t| !matches!(t.kind, TokenKind::Whitespace))
314    {
315        Some(range.start)
316    } else {
317        Some(start.len())
318    }
319}
320
321fn with_leading_whitespace(sm: &SourceMap, sp: Range<BytePos>) -> Range<BytePos> {
322    map_range(sm, sp.clone(), |sf, src, range| {
323        Some(with_leading_whitespace_inner(sf.lines(), src, range.clone())?..range.end)
324    })
325    .unwrap_or(sp)
326}
327
328fn trim_start(sm: &SourceMap, sp: Range<BytePos>) -> Range<BytePos> {
329    map_range(sm, sp.clone(), |_, src, range| {
330        let src = src.get(range.clone())?;
331        Some(range.start + (src.len() - src.trim_start().len())..range.end)
332    })
333    .unwrap_or(sp)
334}
335
336pub struct SourceFileRange {
337    pub sf: Arc<SourceFile>,
338    pub range: Range<usize>,
339}
340impl SourceFileRange {
341    /// Attempts to get the text from the source file. This can fail if the source text isn't
342    /// loaded.
343    pub fn as_str(&self) -> Option<&str> {
344        self.sf
345            .src
346            .as_ref()
347            .map(|src| src.as_str())
348            .or_else(|| self.sf.external_src.get().and_then(|src| src.get_source()))
349            .and_then(|x| x.get(self.range.clone()))
350    }
351}
352
353/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block` with no label.
354pub fn expr_block(
355    sess: &impl HasSession,
356    expr: &Expr<'_>,
357    outer: SyntaxContext,
358    default: &str,
359    indent_relative_to: Option<Span>,
360    app: &mut Applicability,
361) -> String {
362    let (code, from_macro) = snippet_block_with_context(sess, expr.span, outer, default, indent_relative_to, app);
363    if !from_macro
364        && let ExprKind::Block(block, None) = expr.kind
365        && block.rules != BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
366    {
367        code
368    } else {
369        // FIXME: add extra indent for the unsafe blocks:
370        //     original code:   unsafe { ... }
371        //     result code:     { unsafe { ... } }
372        //     desired code:    {\n  unsafe { ... }\n}
373        format!("{{ {code} }}")
374    }
375}
376
377/// Returns a new Span that extends the original Span to the first non-whitespace char of the first
378/// line.
379///
380/// ```rust,ignore
381///     let x = ();
382/// //          ^^
383/// // will be converted to
384///     let x = ();
385/// //  ^^^^^^^^^^
386/// ```
387pub fn first_line_of_span(sess: &impl HasSession, span: Span) -> Span {
388    first_char_in_first_line(sess, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
389}
390
391fn first_char_in_first_line(sess: &impl HasSession, span: Span) -> Option<BytePos> {
392    let line_span = line_span(sess, span);
393    snippet_opt(sess, line_span).and_then(|snip| {
394        snip.find(|c: char| !c.is_whitespace())
395            .map(|pos| line_span.lo() + BytePos::from_usize(pos))
396    })
397}
398
399/// Extends the span to the beginning of the spans line, incl. whitespaces.
400///
401/// ```no_run
402///        let x = ();
403/// //             ^^
404/// // will be converted to
405///        let x = ();
406/// // ^^^^^^^^^^^^^^
407/// ```
408fn line_span(sess: &impl HasSession, span: Span) -> Span {
409    let span = original_sp(span, DUMMY_SP);
410    let SourceFileAndLine { sf, line } = sess.sess().source_map().lookup_line(span.lo()).unwrap();
411    let line_start = sf.lines()[line];
412    let line_start = sf.absolute_position(line_start);
413    span.with_lo(line_start)
414}
415
416/// Returns the indentation of the line of a span
417///
418/// ```rust,ignore
419/// let x = ();
420/// //      ^^ -- will return 0
421///     let x = ();
422/// //          ^^ -- will return 4
423/// ```
424pub fn indent_of(sess: &impl HasSession, span: Span) -> Option<usize> {
425    snippet_opt(sess, line_span(sess, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
426}
427
428/// Gets a snippet of the indentation of the line of a span
429pub fn snippet_indent(sess: &impl HasSession, span: Span) -> Option<String> {
430    snippet_opt(sess, line_span(sess, span)).map(|mut s| {
431        let len = s.len() - s.trim_start().len();
432        s.truncate(len);
433        s
434    })
435}
436
437// If the snippet is empty, it's an attribute that was inserted during macro
438// expansion and we want to ignore those, because they could come from external
439// sources that the user has no control over.
440// For some reason these attributes don't have any expansion info on them, so
441// we have to check it this way until there is a better way.
442pub fn is_present_in_source(sess: &impl HasSession, span: Span) -> bool {
443    if let Some(snippet) = snippet_opt(sess, span)
444        && snippet.is_empty()
445    {
446        return false;
447    }
448    true
449}
450
451/// Returns the position just before rarrow
452///
453/// ```rust,ignore
454/// fn into(self) -> () {}
455///              ^
456/// // in case of unformatted code
457/// fn into2(self)-> () {}
458///               ^
459/// fn into3(self)   -> () {}
460///               ^
461/// ```
462pub fn position_before_rarrow(s: &str) -> Option<usize> {
463    s.rfind("->").map(|rpos| {
464        let mut rpos = rpos;
465        let chars: Vec<char> = s.chars().collect();
466        while rpos > 1 {
467            if let Some(c) = chars.get(rpos - 1)
468                && c.is_whitespace()
469            {
470                rpos -= 1;
471                continue;
472            }
473            break;
474        }
475        rpos
476    })
477}
478
479/// Reindent a multiline string with possibility of ignoring the first line.
480pub fn reindent_multiline(s: &str, ignore_first: bool, indent: Option<usize>) -> String {
481    let s_space = reindent_multiline_inner(s, ignore_first, indent, ' ');
482    let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
483    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ')
484}
485
486fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>, ch: char) -> String {
487    let x = s
488        .lines()
489        .skip(usize::from(ignore_first))
490        .filter_map(|l| {
491            if l.is_empty() {
492                None
493            } else {
494                // ignore empty lines
495                Some(l.char_indices().find(|&(_, x)| x != ch).unwrap_or((l.len(), ch)).0)
496            }
497        })
498        .min()
499        .unwrap_or(0);
500    let indent = indent.unwrap_or(0);
501    s.lines()
502        .enumerate()
503        .map(|(i, l)| {
504            if (ignore_first && i == 0) || l.is_empty() {
505                l.to_owned()
506            } else if x > indent {
507                l.split_at(x - indent).1.to_owned()
508            } else {
509                " ".repeat(indent - x) + l
510            }
511        })
512        .collect::<Vec<String>>()
513        .join("\n")
514}
515
516/// Converts a span to a code snippet if available, otherwise returns the default.
517///
518/// This is useful if you want to provide suggestions for your lint or more generally, if you want
519/// to convert a given `Span` to a `str`. To create suggestions consider using
520/// [`snippet_with_applicability`] to ensure that the applicability stays correct.
521///
522/// # Example
523/// ```rust,ignore
524/// // Given two spans one for `value` and one for the `init` expression.
525/// let value = Vec::new();
526/// //  ^^^^^   ^^^^^^^^^^
527/// //  span1   span2
528///
529/// // The snipped call would return the corresponding code snippet
530/// snippet(cx, span1, "..") // -> "value"
531/// snippet(cx, span2, "..") // -> "Vec::new()"
532/// ```
533pub fn snippet<'a>(sess: &impl HasSession, span: Span, default: &'a str) -> Cow<'a, str> {
534    snippet_opt(sess, span).map_or_else(|| Cow::Borrowed(default), From::from)
535}
536
537/// Same as [`snippet`], but it adapts the applicability level by following rules:
538///
539/// - Applicability level `Unspecified` will never be changed.
540/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
541/// - If the default value is used and the applicability level is `MachineApplicable`, change it to
542///   `HasPlaceholders`
543pub fn snippet_with_applicability<'a>(
544    sess: &impl HasSession,
545    span: Span,
546    default: &'a str,
547    applicability: &mut Applicability,
548) -> Cow<'a, str> {
549    snippet_with_applicability_sess(sess.sess(), span, default, applicability)
550}
551
552fn snippet_with_applicability_sess<'a>(
553    sess: &Session,
554    span: Span,
555    default: &'a str,
556    applicability: &mut Applicability,
557) -> Cow<'a, str> {
558    if *applicability != Applicability::Unspecified && span.from_expansion() {
559        *applicability = Applicability::MaybeIncorrect;
560    }
561    snippet_opt(sess, span).map_or_else(
562        || {
563            if *applicability == Applicability::MachineApplicable {
564                *applicability = Applicability::HasPlaceholders;
565            }
566            Cow::Borrowed(default)
567        },
568        From::from,
569    )
570}
571
572/// Converts a span to a code snippet. Returns `None` if not available.
573pub fn snippet_opt(sess: &impl HasSession, span: Span) -> Option<String> {
574    sess.sess().source_map().span_to_snippet(span).ok()
575}
576
577/// Converts a span (from a block) to a code snippet if available, otherwise use default.
578///
579/// This trims the code of indentation, except for the first line. Use it for blocks or block-like
580/// things which need to be printed as such.
581///
582/// The `indent_relative_to` arg can be used, to provide a span, where the indentation of the
583/// resulting snippet of the given span.
584///
585/// # Example
586///
587/// ```rust,ignore
588/// snippet_block(cx, block.span, "..", None)
589/// // where, `block` is the block of the if expr
590///     if x {
591///         y;
592///     }
593/// // will return the snippet
594/// {
595///     y;
596/// }
597/// ```
598///
599/// ```rust,ignore
600/// snippet_block(cx, block.span, "..", Some(if_expr.span))
601/// // where, `block` is the block of the if expr
602///     if x {
603///         y;
604///     }
605/// // will return the snippet
606/// {
607///         y;
608///     } // aligned with `if`
609/// ```
610/// Note that the first line of the snippet always has 0 indentation.
611pub fn snippet_block(sess: &impl HasSession, span: Span, default: &str, indent_relative_to: Option<Span>) -> String {
612    let snip = snippet(sess, span, default);
613    let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
614    reindent_multiline(&snip, true, indent)
615}
616
617/// Same as `snippet_block`, but adapts the applicability level by the rules of
618/// `snippet_with_applicability`.
619pub fn snippet_block_with_applicability(
620    sess: &impl HasSession,
621    span: Span,
622    default: &str,
623    indent_relative_to: Option<Span>,
624    applicability: &mut Applicability,
625) -> String {
626    let snip = snippet_with_applicability(sess, span, default, applicability);
627    let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
628    reindent_multiline(&snip, true, indent)
629}
630
631pub fn snippet_block_with_context(
632    sess: &impl HasSession,
633    span: Span,
634    outer: SyntaxContext,
635    default: &str,
636    indent_relative_to: Option<Span>,
637    app: &mut Applicability,
638) -> (String, bool) {
639    let (snip, from_macro) = snippet_with_context(sess, span, outer, default, app);
640    let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
641    (reindent_multiline(&snip, true, indent), from_macro)
642}
643
644/// Same as `snippet_with_applicability`, but first walks the span up to the given context.
645///
646/// This will result in the macro call, rather than the expansion, if the span is from a child
647/// context. If the span is not from a child context, it will be used directly instead.
648///
649/// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR node
650/// would result in `box []`. If given the context of the address of expression, this function will
651/// correctly get a snippet of `vec![]`.
652///
653/// This will also return whether or not the snippet is a macro call.
654pub fn snippet_with_context<'a>(
655    sess: &impl HasSession,
656    span: Span,
657    outer: SyntaxContext,
658    default: &'a str,
659    applicability: &mut Applicability,
660) -> (Cow<'a, str>, bool) {
661    snippet_with_context_sess(sess.sess(), span, outer, default, applicability)
662}
663
664fn snippet_with_context_sess<'a>(
665    sess: &Session,
666    span: Span,
667    outer: SyntaxContext,
668    default: &'a str,
669    applicability: &mut Applicability,
670) -> (Cow<'a, str>, bool) {
671    let (span, is_macro_call) = walk_span_to_context(span, outer).map_or_else(
672        || {
673            // The span is from a macro argument, and the outer context is the macro using the argument
674            if *applicability != Applicability::Unspecified {
675                *applicability = Applicability::MaybeIncorrect;
676            }
677            // TODO: get the argument span.
678            (span, false)
679        },
680        |outer_span| (outer_span, span.ctxt() != outer),
681    );
682
683    (
684        snippet_with_applicability_sess(sess, span, default, applicability),
685        is_macro_call,
686    )
687}
688
689/// Walks the span up to the target context, thereby returning the macro call site if the span is
690/// inside a macro expansion, or the original span if it is not.
691///
692/// Note this will return `None` in the case of the span being in a macro expansion, but the target
693/// context is from expanding a macro argument.
694///
695/// Given the following
696///
697/// ```rust,ignore
698/// macro_rules! m { ($e:expr) => { f($e) }; }
699/// g(m!(0))
700/// ```
701///
702/// If called with a span of the call to `f` and a context of the call to `g` this will return a
703/// span containing `m!(0)`. However, if called with a span of the literal `0` this will give a span
704/// containing `0` as the context is the same as the outer context.
705///
706/// This will traverse through multiple macro calls. Given the following:
707///
708/// ```rust,ignore
709/// macro_rules! m { ($e:expr) => { n!($e, 0) }; }
710/// macro_rules! n { ($e:expr, $f:expr) => { f($e, $f) }; }
711/// g(m!(0))
712/// ```
713///
714/// If called with a span of the call to `f` and a context of the call to `g` this will return a
715/// span containing `m!(0)`.
716pub fn walk_span_to_context(span: Span, outer: SyntaxContext) -> Option<Span> {
717    let outer_span = hygiene::walk_chain(span, outer);
718    (outer_span.ctxt() == outer).then_some(outer_span)
719}
720
721/// Trims the whitespace from the start and the end of the span.
722pub fn trim_span(sm: &SourceMap, span: Span) -> Span {
723    let data = span.data();
724    let sf: &_ = &sm.lookup_source_file(data.lo);
725    let Some(src) = sf.src.as_deref() else {
726        return span;
727    };
728    let Some(snip) = &src.get((data.lo - sf.start_pos).to_usize()..(data.hi - sf.start_pos).to_usize()) else {
729        return span;
730    };
731    let trim_start = snip.len() - snip.trim_start().len();
732    let trim_end = snip.len() - snip.trim_end().len();
733    SpanData {
734        lo: data.lo + BytePos::from_usize(trim_start),
735        hi: data.hi - BytePos::from_usize(trim_end),
736        ctxt: data.ctxt,
737        parent: data.parent,
738    }
739    .span()
740}
741
742/// Expand a span to include a preceding comma
743/// ```rust,ignore
744/// writeln!(o, "")   ->   writeln!(o, "")
745///             ^^                   ^^^^
746/// ```
747pub fn expand_past_previous_comma(sess: &impl HasSession, span: Span) -> Span {
748    let extended = sess.sess().source_map().span_extend_to_prev_char(span, ',', true);
749    extended.with_lo(extended.lo() - BytePos(1))
750}
751
752/// Converts `expr` to a `char` literal if it's a `str` literal containing a single
753/// character (or a single byte with `ascii_only`)
754pub fn str_literal_to_char_literal(
755    sess: &impl HasSession,
756    expr: &Expr<'_>,
757    applicability: &mut Applicability,
758    ascii_only: bool,
759) -> Option<String> {
760    if let ExprKind::Lit(lit) = &expr.kind
761        && let LitKind::Str(r, style) = lit.node
762        && let string = r.as_str()
763        && let len = if ascii_only {
764            string.len()
765        } else {
766            string.chars().count()
767        }
768        && len == 1
769    {
770        let snip = snippet_with_applicability(sess, expr.span, string, applicability);
771        let ch = if let StrStyle::Raw(nhash) = style {
772            let nhash = nhash as usize;
773            // for raw string: r##"a"##
774            &snip[(nhash + 2)..(snip.len() - 1 - nhash)]
775        } else {
776            // for regular string: "a"
777            &snip[1..(snip.len() - 1)]
778        };
779
780        let hint = format!(
781            "'{}'",
782            match ch {
783                "'" => "\\'",
784                r"\" => "\\\\",
785                "\\\"" => "\"", // no need to escape `"` in `'"'`
786                _ => ch,
787            }
788        );
789
790        Some(hint)
791    } else {
792        None
793    }
794}
795
796#[cfg(test)]
797mod test {
798    use super::reindent_multiline;
799
800    #[test]
801    fn test_reindent_multiline_single_line() {
802        assert_eq!("", reindent_multiline("", false, None));
803        assert_eq!("...", reindent_multiline("...", false, None));
804        assert_eq!("...", reindent_multiline("    ...", false, None));
805        assert_eq!("...", reindent_multiline("\t...", false, None));
806        assert_eq!("...", reindent_multiline("\t\t...", false, None));
807    }
808
809    #[test]
810    #[rustfmt::skip]
811    fn test_reindent_multiline_block() {
812        assert_eq!("\
813    if x {
814        y
815    } else {
816        z
817    }", reindent_multiline("    if x {
818            y
819        } else {
820            z
821        }", false, None));
822        assert_eq!("\
823    if x {
824    \ty
825    } else {
826    \tz
827    }", reindent_multiline("    if x {
828        \ty
829        } else {
830        \tz
831        }", false, None));
832    }
833
834    #[test]
835    #[rustfmt::skip]
836    fn test_reindent_multiline_empty_line() {
837        assert_eq!("\
838    if x {
839        y
840
841    } else {
842        z
843    }", reindent_multiline("    if x {
844            y
845
846        } else {
847            z
848        }", false, None));
849    }
850
851    #[test]
852    #[rustfmt::skip]
853    fn test_reindent_multiline_lines_deeper() {
854        assert_eq!("\
855        if x {
856            y
857        } else {
858            z
859        }", reindent_multiline("\
860    if x {
861        y
862    } else {
863        z
864    }", true, Some(8)));
865    }
866}