1#![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
47pub 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
68pub 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 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 fn get_source_range(self, cx: &impl HasSession) -> Option<SourceFileRange> {
108 get_source_range(cx.sess().source_map(), self.into_range())
109 }
110
111 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 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 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 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 fn with_leading_whitespace(self, cx: &impl HasSession) -> Range<BytePos> {
161 with_leading_whitespace(cx.sess().source_map(), self.into_range())
162 }
163
164 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
171pub struct SourceText(SourceFileRange);
173impl SourceText {
174 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 pub fn as_str(&self) -> &str {
185 self.0.as_str().unwrap()
186 }
187
188 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 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 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
353pub 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 format!("{{ {code} }}")
374 }
375}
376
377pub 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
399fn 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
416pub 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
428pub 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
437pub 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
451pub 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
479pub 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 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
516pub 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
537pub 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
572pub fn snippet_opt(sess: &impl HasSession, span: Span) -> Option<String> {
574 sess.sess().source_map().span_to_snippet(span).ok()
575}
576
577pub 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
617pub 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
644pub 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 if *applicability != Applicability::Unspecified {
675 *applicability = Applicability::MaybeIncorrect;
676 }
677 (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
689pub 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
721pub 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
742pub 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
752pub 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 &snip[(nhash + 2)..(snip.len() - 1 - nhash)]
775 } else {
776 &snip[1..(snip.len() - 1)]
778 };
779
780 let hint = format!(
781 "'{}'",
782 match ch {
783 "'" => "\\'",
784 r"\" => "\\\\",
785 "\\\"" => "\"", _ => 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}