1#[cfg(span_locations)]
2use crate::location::LineColumn;
3use crate::parse::{self, Cursor};
4use crate::rcvec::{RcVec, RcVecBuilder, RcVecIntoIter, RcVecMut};
5use crate::{Delimiter, Spacing, TokenTree};
6#[cfg(all(span_locations, not(fuzzing)))]
7use alloc::collections::BTreeMap;
8#[cfg(all(span_locations, not(fuzzing)))]
9use core::cell::RefCell;
10#[cfg(span_locations)]
11use core::cmp;
12use core::fmt::{self, Debug, Display, Write};
13use core::mem::ManuallyDrop;
14use core::ops::RangeBounds;
15use core::ptr;
16use core::str::FromStr;
17use std::path::PathBuf;
18
19/// Force use of proc-macro2's fallback implementation of the API for now, even
20/// if the compiler's implementation is available.
21pub fn force() {
22 #[cfg(wrap_proc_macro)]
23 crate::detection::force_fallback();
24}
25
26/// Resume using the compiler's implementation of the proc macro API if it is
27/// available.
28pub fn unforce() {
29 #[cfg(wrap_proc_macro)]
30 crate::detection::unforce_fallback();
31}
32
33#[derive(Clone)]
34pub(crate) struct TokenStream {
35 inner: RcVec<TokenTree>,
36}
37
38#[derive(Debug)]
39pub(crate) struct LexError {
40 pub(crate) span: Span,
41}
42
43impl LexError {
44 pub(crate) fn span(&self) -> Span {
45 self.span
46 }
47
48 fn call_site() -> Self {
49 LexError {
50 span: Span::call_site(),
51 }
52 }
53}
54
55impl TokenStream {
56 pub fn new() -> Self {
57 TokenStream {
58 inner: RcVecBuilder::new().build(),
59 }
60 }
61
62 pub fn is_empty(&self) -> bool {
63 self.inner.len() == 0
64 }
65
66 fn take_inner(self) -> RcVecBuilder<TokenTree> {
67 let nodrop = ManuallyDrop::new(self);
68 unsafe { ptr::read(&nodrop.inner) }.make_owned()
69 }
70}
71
72fn push_token_from_proc_macro(mut vec: RcVecMut<TokenTree>, token: TokenTree) {
73 // https://github.com/dtolnay/proc-macro2/issues/235
74 match token {
75 TokenTree::Literal(crate::Literal {
76 #[cfg(wrap_proc_macro)]
77 inner: crate::imp::Literal::Fallback(literal),
78 #[cfg(not(wrap_proc_macro))]
79 inner: literal,
80 ..
81 }) if literal.repr.starts_with('-') => {
82 push_negative_literal(vec, literal);
83 }
84 _ => vec.push(token),
85 }
86
87 #[cold]
88 fn push_negative_literal(mut vec: RcVecMut<TokenTree>, mut literal: Literal) {
89 literal.repr.remove(0);
90 let mut punct = crate::Punct::new('-', Spacing::Alone);
91 punct.set_span(crate::Span::_new_fallback(literal.span));
92 vec.push(TokenTree::Punct(punct));
93 vec.push(TokenTree::Literal(crate::Literal::_new_fallback(literal)));
94 }
95}
96
97// Nonrecursive to prevent stack overflow.
98impl Drop for TokenStream {
99 fn drop(&mut self) {
100 let mut inner = match self.inner.get_mut() {
101 Some(inner) => inner,
102 None => return,
103 };
104 while let Some(token) = inner.pop() {
105 let group = match token {
106 TokenTree::Group(group) => group.inner,
107 _ => continue,
108 };
109 #[cfg(wrap_proc_macro)]
110 let group = match group {
111 crate::imp::Group::Fallback(group) => group,
112 crate::imp::Group::Compiler(_) => continue,
113 };
114 inner.extend(group.stream.take_inner());
115 }
116 }
117}
118
119pub(crate) struct TokenStreamBuilder {
120 inner: RcVecBuilder<TokenTree>,
121}
122
123impl TokenStreamBuilder {
124 pub fn new() -> Self {
125 TokenStreamBuilder {
126 inner: RcVecBuilder::new(),
127 }
128 }
129
130 pub fn with_capacity(cap: usize) -> Self {
131 TokenStreamBuilder {
132 inner: RcVecBuilder::with_capacity(cap),
133 }
134 }
135
136 pub fn push_token_from_parser(&mut self, tt: TokenTree) {
137 self.inner.push(tt);
138 }
139
140 pub fn build(self) -> TokenStream {
141 TokenStream {
142 inner: self.inner.build(),
143 }
144 }
145}
146
147#[cfg(span_locations)]
148fn get_cursor(src: &str) -> Cursor {
149 #[cfg(fuzzing)]
150 return Cursor { rest: src, off: 1 };
151
152 // Create a dummy file & add it to the source map
153 #[cfg(not(fuzzing))]
154 SOURCE_MAP.with(|cm| {
155 let mut cm = cm.borrow_mut();
156 let span = cm.add_file(src);
157 Cursor {
158 rest: src,
159 off: span.lo,
160 }
161 })
162}
163
164#[cfg(not(span_locations))]
165fn get_cursor(src: &str) -> Cursor {
166 Cursor { rest: src }
167}
168
169impl FromStr for TokenStream {
170 type Err = LexError;
171
172 fn from_str(src: &str) -> Result<TokenStream, LexError> {
173 // Create a dummy file & add it to the source map
174 let mut cursor = get_cursor(src);
175
176 // Strip a byte order mark if present
177 const BYTE_ORDER_MARK: &str = "\u{feff}";
178 if cursor.starts_with(BYTE_ORDER_MARK) {
179 cursor = cursor.advance(BYTE_ORDER_MARK.len());
180 }
181
182 parse::token_stream(cursor)
183 }
184}
185
186impl Display for LexError {
187 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
188 f.write_str("cannot parse string into token stream")
189 }
190}
191
192impl Display for TokenStream {
193 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
194 let mut joint = false;
195 for (i, tt) in self.inner.iter().enumerate() {
196 if i != 0 && !joint {
197 write!(f, " ")?;
198 }
199 joint = false;
200 match tt {
201 TokenTree::Group(tt) => Display::fmt(tt, f),
202 TokenTree::Ident(tt) => Display::fmt(tt, f),
203 TokenTree::Punct(tt) => {
204 joint = tt.spacing() == Spacing::Joint;
205 Display::fmt(tt, f)
206 }
207 TokenTree::Literal(tt) => Display::fmt(tt, f),
208 }?;
209 }
210
211 Ok(())
212 }
213}
214
215impl Debug for TokenStream {
216 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
217 f.write_str("TokenStream ")?;
218 f.debug_list().entries(self.clone()).finish()
219 }
220}
221
222#[cfg(feature = "proc-macro")]
223impl From<proc_macro::TokenStream> for TokenStream {
224 fn from(inner: proc_macro::TokenStream) -> Self {
225 inner
226 .to_string()
227 .parse()
228 .expect("compiler token stream parse failed")
229 }
230}
231
232#[cfg(feature = "proc-macro")]
233impl From<TokenStream> for proc_macro::TokenStream {
234 fn from(inner: TokenStream) -> Self {
235 inner
236 .to_string()
237 .parse()
238 .expect("failed to parse to compiler tokens")
239 }
240}
241
242impl From<TokenTree> for TokenStream {
243 fn from(tree: TokenTree) -> Self {
244 let mut stream = RcVecBuilder::new();
245 push_token_from_proc_macro(stream.as_mut(), tree);
246 TokenStream {
247 inner: stream.build(),
248 }
249 }
250}
251
252impl FromIterator<TokenTree> for TokenStream {
253 fn from_iter<I: IntoIterator<Item = TokenTree>>(tokens: I) -> Self {
254 let mut stream = TokenStream::new();
255 stream.extend(tokens);
256 stream
257 }
258}
259
260impl FromIterator<TokenStream> for TokenStream {
261 fn from_iter<I: IntoIterator<Item = TokenStream>>(streams: I) -> Self {
262 let mut v = RcVecBuilder::new();
263
264 for stream in streams {
265 v.extend(stream.take_inner());
266 }
267
268 TokenStream { inner: v.build() }
269 }
270}
271
272impl Extend<TokenTree> for TokenStream {
273 fn extend<I: IntoIterator<Item = TokenTree>>(&mut self, tokens: I) {
274 let mut vec = self.inner.make_mut();
275 tokens
276 .into_iter()
277 .for_each(|token| push_token_from_proc_macro(vec.as_mut(), token));
278 }
279}
280
281impl Extend<TokenStream> for TokenStream {
282 fn extend<I: IntoIterator<Item = TokenStream>>(&mut self, streams: I) {
283 self.inner.make_mut().extend(streams.into_iter().flatten());
284 }
285}
286
287pub(crate) type TokenTreeIter = RcVecIntoIter<TokenTree>;
288
289impl IntoIterator for TokenStream {
290 type Item = TokenTree;
291 type IntoIter = TokenTreeIter;
292
293 fn into_iter(self) -> TokenTreeIter {
294 self.take_inner().into_iter()
295 }
296}
297
298#[derive(Clone, PartialEq, Eq)]
299pub(crate) struct SourceFile {
300 path: PathBuf,
301}
302
303impl SourceFile {
304 /// Get the path to this source file as a string.
305 pub fn path(&self) -> PathBuf {
306 self.path.clone()
307 }
308
309 pub fn is_real(&self) -> bool {
310 false
311 }
312}
313
314impl Debug for SourceFile {
315 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
316 f.debug_struct("SourceFile")
317 .field("path", &self.path())
318 .field("is_real", &self.is_real())
319 .finish()
320 }
321}
322
323#[cfg(all(span_locations, not(fuzzing)))]
324thread_local! {
325 static SOURCE_MAP: RefCell<SourceMap> = RefCell::new(SourceMap {
326 // Start with a single dummy file which all call_site() and def_site()
327 // spans reference.
328 files: vec![FileInfo {
329 source_text: String::new(),
330 span: Span { lo: 0, hi: 0 },
331 lines: vec![0],
332 char_index_to_byte_offset: BTreeMap::new(),
333 }],
334 });
335}
336
337#[cfg(all(span_locations, not(fuzzing)))]
338struct FileInfo {
339 source_text: String,
340 span: Span,
341 lines: Vec<usize>,
342 char_index_to_byte_offset: BTreeMap<usize, usize>,
343}
344
345#[cfg(all(span_locations, not(fuzzing)))]
346impl FileInfo {
347 fn offset_line_column(&self, offset: usize) -> LineColumn {
348 assert!(self.span_within(Span {
349 lo: offset as u32,
350 hi: offset as u32,
351 }));
352 let offset = offset - self.span.lo as usize;
353 match self.lines.binary_search(&offset) {
354 Ok(found) => LineColumn {
355 line: found + 1,
356 column: 0,
357 },
358 Err(idx) => LineColumn {
359 line: idx,
360 column: offset - self.lines[idx - 1],
361 },
362 }
363 }
364
365 fn span_within(&self, span: Span) -> bool {
366 span.lo >= self.span.lo && span.hi <= self.span.hi
367 }
368
369 fn source_text(&mut self, span: Span) -> String {
370 let lo_char = (span.lo - self.span.lo) as usize;
371
372 // Look up offset of the largest already-computed char index that is
373 // less than or equal to the current requested one. We resume counting
374 // chars from that point.
375 let (&last_char_index, &last_byte_offset) = self
376 .char_index_to_byte_offset
377 .range(..=lo_char)
378 .next_back()
379 .unwrap_or((&0, &0));
380
381 let lo_byte = if last_char_index == lo_char {
382 last_byte_offset
383 } else {
384 let total_byte_offset = match self.source_text[last_byte_offset..]
385 .char_indices()
386 .nth(lo_char - last_char_index)
387 {
388 Some((additional_offset, _ch)) => last_byte_offset + additional_offset,
389 None => self.source_text.len(),
390 };
391 self.char_index_to_byte_offset
392 .insert(lo_char, total_byte_offset);
393 total_byte_offset
394 };
395
396 let trunc_lo = &self.source_text[lo_byte..];
397 let char_len = (span.hi - span.lo) as usize;
398 let source_text = match trunc_lo.char_indices().nth(char_len) {
399 Some((offset, _ch)) => &trunc_lo[..offset],
400 None => trunc_lo,
401 };
402 source_text.to_owned()
403 }
404}
405
406/// Computes the offsets of each line in the given source string
407/// and the total number of characters
408#[cfg(all(span_locations, not(fuzzing)))]
409fn lines_offsets(s: &str) -> (usize, Vec<usize>) {
410 let mut lines = vec![0];
411 let mut total = 0;
412
413 for ch in s.chars() {
414 total += 1;
415 if ch == '\n' {
416 lines.push(total);
417 }
418 }
419
420 (total, lines)
421}
422
423#[cfg(all(span_locations, not(fuzzing)))]
424struct SourceMap {
425 files: Vec<FileInfo>,
426}
427
428#[cfg(all(span_locations, not(fuzzing)))]
429impl SourceMap {
430 fn next_start_pos(&self) -> u32 {
431 // Add 1 so there's always space between files.
432 //
433 // We'll always have at least 1 file, as we initialize our files list
434 // with a dummy file.
435 self.files.last().unwrap().span.hi + 1
436 }
437
438 fn add_file(&mut self, src: &str) -> Span {
439 let (len, lines) = lines_offsets(src);
440 let lo = self.next_start_pos();
441 let span = Span {
442 lo,
443 hi: lo + (len as u32),
444 };
445
446 self.files.push(FileInfo {
447 source_text: src.to_owned(),
448 span,
449 lines,
450 // Populated lazily by source_text().
451 char_index_to_byte_offset: BTreeMap::new(),
452 });
453
454 span
455 }
456
457 #[cfg(procmacro2_semver_exempt)]
458 fn filepath(&self, span: Span) -> PathBuf {
459 for (i, file) in self.files.iter().enumerate() {
460 if file.span_within(span) {
461 return PathBuf::from(if i == 0 {
462 "<unspecified>".to_owned()
463 } else {
464 format!("<parsed string {}>", i)
465 });
466 }
467 }
468 unreachable!("Invalid span with no related FileInfo!");
469 }
470
471 fn fileinfo(&self, span: Span) -> &FileInfo {
472 for file in &self.files {
473 if file.span_within(span) {
474 return file;
475 }
476 }
477 unreachable!("Invalid span with no related FileInfo!");
478 }
479
480 fn fileinfo_mut(&mut self, span: Span) -> &mut FileInfo {
481 for file in &mut self.files {
482 if file.span_within(span) {
483 return file;
484 }
485 }
486 unreachable!("Invalid span with no related FileInfo!");
487 }
488}
489
490#[derive(Clone, Copy, PartialEq, Eq)]
491pub(crate) struct Span {
492 #[cfg(span_locations)]
493 pub(crate) lo: u32,
494 #[cfg(span_locations)]
495 pub(crate) hi: u32,
496}
497
498impl Span {
499 #[cfg(not(span_locations))]
500 pub fn call_site() -> Self {
501 Span {}
502 }
503
504 #[cfg(span_locations)]
505 pub fn call_site() -> Self {
506 Span { lo: 0, hi: 0 }
507 }
508
509 pub fn mixed_site() -> Self {
510 Span::call_site()
511 }
512
513 #[cfg(procmacro2_semver_exempt)]
514 pub fn def_site() -> Self {
515 Span::call_site()
516 }
517
518 pub fn resolved_at(&self, _other: Span) -> Span {
519 // Stable spans consist only of line/column information, so
520 // `resolved_at` and `located_at` only select which span the
521 // caller wants line/column information from.
522 *self
523 }
524
525 pub fn located_at(&self, other: Span) -> Span {
526 other
527 }
528
529 #[cfg(procmacro2_semver_exempt)]
530 pub fn source_file(&self) -> SourceFile {
531 #[cfg(fuzzing)]
532 return SourceFile {
533 path: PathBuf::from("<unspecified>"),
534 };
535
536 #[cfg(not(fuzzing))]
537 SOURCE_MAP.with(|cm| {
538 let cm = cm.borrow();
539 let path = cm.filepath(*self);
540 SourceFile { path }
541 })
542 }
543
544 #[cfg(span_locations)]
545 pub fn start(&self) -> LineColumn {
546 #[cfg(fuzzing)]
547 return LineColumn { line: 0, column: 0 };
548
549 #[cfg(not(fuzzing))]
550 SOURCE_MAP.with(|cm| {
551 let cm = cm.borrow();
552 let fi = cm.fileinfo(*self);
553 fi.offset_line_column(self.lo as usize)
554 })
555 }
556
557 #[cfg(span_locations)]
558 pub fn end(&self) -> LineColumn {
559 #[cfg(fuzzing)]
560 return LineColumn { line: 0, column: 0 };
561
562 #[cfg(not(fuzzing))]
563 SOURCE_MAP.with(|cm| {
564 let cm = cm.borrow();
565 let fi = cm.fileinfo(*self);
566 fi.offset_line_column(self.hi as usize)
567 })
568 }
569
570 #[cfg(not(span_locations))]
571 pub fn join(&self, _other: Span) -> Option<Span> {
572 Some(Span {})
573 }
574
575 #[cfg(span_locations)]
576 pub fn join(&self, other: Span) -> Option<Span> {
577 #[cfg(fuzzing)]
578 return {
579 let _ = other;
580 None
581 };
582
583 #[cfg(not(fuzzing))]
584 SOURCE_MAP.with(|cm| {
585 let cm = cm.borrow();
586 // If `other` is not within the same FileInfo as us, return None.
587 if !cm.fileinfo(*self).span_within(other) {
588 return None;
589 }
590 Some(Span {
591 lo: cmp::min(self.lo, other.lo),
592 hi: cmp::max(self.hi, other.hi),
593 })
594 })
595 }
596
597 #[cfg(not(span_locations))]
598 pub fn source_text(&self) -> Option<String> {
599 None
600 }
601
602 #[cfg(span_locations)]
603 pub fn source_text(&self) -> Option<String> {
604 #[cfg(fuzzing)]
605 return None;
606
607 #[cfg(not(fuzzing))]
608 {
609 if self.is_call_site() {
610 None
611 } else {
612 Some(SOURCE_MAP.with(|cm| cm.borrow_mut().fileinfo_mut(*self).source_text(*self)))
613 }
614 }
615 }
616
617 #[cfg(not(span_locations))]
618 pub(crate) fn first_byte(self) -> Self {
619 self
620 }
621
622 #[cfg(span_locations)]
623 pub(crate) fn first_byte(self) -> Self {
624 Span {
625 lo: self.lo,
626 hi: cmp::min(self.lo.saturating_add(1), self.hi),
627 }
628 }
629
630 #[cfg(not(span_locations))]
631 pub(crate) fn last_byte(self) -> Self {
632 self
633 }
634
635 #[cfg(span_locations)]
636 pub(crate) fn last_byte(self) -> Self {
637 Span {
638 lo: cmp::max(self.hi.saturating_sub(1), self.lo),
639 hi: self.hi,
640 }
641 }
642
643 #[cfg(span_locations)]
644 fn is_call_site(&self) -> bool {
645 self.lo == 0 && self.hi == 0
646 }
647}
648
649impl Debug for Span {
650 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
651 #[cfg(span_locations)]
652 return write!(f, "bytes({}..{})", self.lo, self.hi);
653
654 #[cfg(not(span_locations))]
655 write!(f, "Span")
656 }
657}
658
659pub(crate) fn debug_span_field_if_nontrivial(debug: &mut fmt::DebugStruct, span: Span) {
660 #[cfg(span_locations)]
661 {
662 if span.is_call_site() {
663 return;
664 }
665 }
666
667 if cfg!(span_locations) {
668 debug.field("span", &span);
669 }
670}
671
672#[derive(Clone)]
673pub(crate) struct Group {
674 delimiter: Delimiter,
675 stream: TokenStream,
676 span: Span,
677}
678
679impl Group {
680 pub fn new(delimiter: Delimiter, stream: TokenStream) -> Self {
681 Group {
682 delimiter,
683 stream,
684 span: Span::call_site(),
685 }
686 }
687
688 pub fn delimiter(&self) -> Delimiter {
689 self.delimiter
690 }
691
692 pub fn stream(&self) -> TokenStream {
693 self.stream.clone()
694 }
695
696 pub fn span(&self) -> Span {
697 self.span
698 }
699
700 pub fn span_open(&self) -> Span {
701 self.span.first_byte()
702 }
703
704 pub fn span_close(&self) -> Span {
705 self.span.last_byte()
706 }
707
708 pub fn set_span(&mut self, span: Span) {
709 self.span = span;
710 }
711}
712
713impl Display for Group {
714 // We attempt to match libproc_macro's formatting.
715 // Empty parens: ()
716 // Nonempty parens: (...)
717 // Empty brackets: []
718 // Nonempty brackets: [...]
719 // Empty braces: { }
720 // Nonempty braces: { ... }
721 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
722 let (open, close) = match self.delimiter {
723 Delimiter::Parenthesis => ("(", ")"),
724 Delimiter::Brace => ("{ ", "}"),
725 Delimiter::Bracket => ("[", "]"),
726 Delimiter::None => ("", ""),
727 };
728
729 f.write_str(open)?;
730 Display::fmt(&self.stream, f)?;
731 if self.delimiter == Delimiter::Brace && !self.stream.inner.is_empty() {
732 f.write_str(" ")?;
733 }
734 f.write_str(close)?;
735
736 Ok(())
737 }
738}
739
740impl Debug for Group {
741 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
742 let mut debug = fmt.debug_struct("Group");
743 debug.field("delimiter", &self.delimiter);
744 debug.field("stream", &self.stream);
745 debug_span_field_if_nontrivial(&mut debug, self.span);
746 debug.finish()
747 }
748}
749
750#[derive(Clone)]
751pub(crate) struct Ident {
752 sym: String,
753 span: Span,
754 raw: bool,
755}
756
757impl Ident {
758 #[track_caller]
759 pub fn new_checked(string: &str, span: Span) -> Self {
760 validate_ident(string);
761 Ident::new_unchecked(string, span)
762 }
763
764 pub fn new_unchecked(string: &str, span: Span) -> Self {
765 Ident {
766 sym: string.to_owned(),
767 span,
768 raw: false,
769 }
770 }
771
772 #[track_caller]
773 pub fn new_raw_checked(string: &str, span: Span) -> Self {
774 validate_ident_raw(string);
775 Ident::new_raw_unchecked(string, span)
776 }
777
778 pub fn new_raw_unchecked(string: &str, span: Span) -> Self {
779 Ident {
780 sym: string.to_owned(),
781 span,
782 raw: true,
783 }
784 }
785
786 pub fn span(&self) -> Span {
787 self.span
788 }
789
790 pub fn set_span(&mut self, span: Span) {
791 self.span = span;
792 }
793}
794
795pub(crate) fn is_ident_start(c: char) -> bool {
796 c == '_' || unicode_ident::is_xid_start(c)
797}
798
799pub(crate) fn is_ident_continue(c: char) -> bool {
800 unicode_ident::is_xid_continue(c)
801}
802
803#[track_caller]
804fn validate_ident(string: &str) {
805 if string.is_empty() {
806 panic!("Ident is not allowed to be empty; use Option<Ident>");
807 }
808
809 if string.bytes().all(|digit| b'0' <= digit && digit <= b'9') {
810 panic!("Ident cannot be a number; use Literal instead");
811 }
812
813 fn ident_ok(string: &str) -> bool {
814 let mut chars = string.chars();
815 let first = chars.next().unwrap();
816 if !is_ident_start(first) {
817 return false;
818 }
819 for ch in chars {
820 if !is_ident_continue(ch) {
821 return false;
822 }
823 }
824 true
825 }
826
827 if !ident_ok(string) {
828 panic!("{:?} is not a valid Ident", string);
829 }
830}
831
832#[track_caller]
833fn validate_ident_raw(string: &str) {
834 validate_ident(string);
835
836 match string {
837 "_" | "super" | "self" | "Self" | "crate" => {
838 panic!("`r#{}` cannot be a raw identifier", string);
839 }
840 _ => {}
841 }
842}
843
844impl PartialEq for Ident {
845 fn eq(&self, other: &Ident) -> bool {
846 self.sym == other.sym && self.raw == other.raw
847 }
848}
849
850impl<T> PartialEq<T> for Ident
851where
852 T: ?Sized + AsRef<str>,
853{
854 fn eq(&self, other: &T) -> bool {
855 let other = other.as_ref();
856 if self.raw {
857 other.starts_with("r#") && self.sym == other[2..]
858 } else {
859 self.sym == other
860 }
861 }
862}
863
864impl Display for Ident {
865 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
866 if self.raw {
867 f.write_str("r#")?;
868 }
869 Display::fmt(&self.sym, f)
870 }
871}
872
873#[allow(clippy::missing_fields_in_debug)]
874impl Debug for Ident {
875 // Ident(proc_macro), Ident(r#union)
876 #[cfg(not(span_locations))]
877 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
878 let mut debug = f.debug_tuple("Ident");
879 debug.field(&format_args!("{}", self));
880 debug.finish()
881 }
882
883 // Ident {
884 // sym: proc_macro,
885 // span: bytes(128..138)
886 // }
887 #[cfg(span_locations)]
888 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
889 let mut debug = f.debug_struct("Ident");
890 debug.field("sym", &format_args!("{}", self));
891 debug_span_field_if_nontrivial(&mut debug, self.span);
892 debug.finish()
893 }
894}
895
896#[derive(Clone)]
897pub(crate) struct Literal {
898 repr: String,
899 span: Span,
900}
901
902macro_rules! suffixed_numbers {
903 ($($name:ident => $kind:ident,)*) => ($(
904 pub fn $name(n: $kind) -> Literal {
905 Literal::_new(format!(concat!("{}", stringify!($kind)), n))
906 }
907 )*)
908}
909
910macro_rules! unsuffixed_numbers {
911 ($($name:ident => $kind:ident,)*) => ($(
912 pub fn $name(n: $kind) -> Literal {
913 Literal::_new(n.to_string())
914 }
915 )*)
916}
917
918impl Literal {
919 pub(crate) fn _new(repr: String) -> Self {
920 Literal {
921 repr,
922 span: Span::call_site(),
923 }
924 }
925
926 pub(crate) unsafe fn from_str_unchecked(repr: &str) -> Self {
927 Literal::_new(repr.to_owned())
928 }
929
930 suffixed_numbers! {
931 u8_suffixed => u8,
932 u16_suffixed => u16,
933 u32_suffixed => u32,
934 u64_suffixed => u64,
935 u128_suffixed => u128,
936 usize_suffixed => usize,
937 i8_suffixed => i8,
938 i16_suffixed => i16,
939 i32_suffixed => i32,
940 i64_suffixed => i64,
941 i128_suffixed => i128,
942 isize_suffixed => isize,
943
944 f32_suffixed => f32,
945 f64_suffixed => f64,
946 }
947
948 unsuffixed_numbers! {
949 u8_unsuffixed => u8,
950 u16_unsuffixed => u16,
951 u32_unsuffixed => u32,
952 u64_unsuffixed => u64,
953 u128_unsuffixed => u128,
954 usize_unsuffixed => usize,
955 i8_unsuffixed => i8,
956 i16_unsuffixed => i16,
957 i32_unsuffixed => i32,
958 i64_unsuffixed => i64,
959 i128_unsuffixed => i128,
960 isize_unsuffixed => isize,
961 }
962
963 pub fn f32_unsuffixed(f: f32) -> Literal {
964 let mut s = f.to_string();
965 if !s.contains('.') {
966 s.push_str(".0");
967 }
968 Literal::_new(s)
969 }
970
971 pub fn f64_unsuffixed(f: f64) -> Literal {
972 let mut s = f.to_string();
973 if !s.contains('.') {
974 s.push_str(".0");
975 }
976 Literal::_new(s)
977 }
978
979 pub fn string(t: &str) -> Literal {
980 let mut repr = String::with_capacity(t.len() + 2);
981 repr.push('"');
982 let mut chars = t.chars();
983 while let Some(ch) = chars.next() {
984 if ch == '\0' {
985 repr.push_str(
986 if chars
987 .as_str()
988 .starts_with(|next| '0' <= next && next <= '7')
989 {
990 // circumvent clippy::octal_escapes lint
991 "\\x00"
992 } else {
993 "\\0"
994 },
995 );
996 } else if ch == '\'' {
997 // escape_debug turns this into "\'" which is unnecessary.
998 repr.push(ch);
999 } else {
1000 repr.extend(ch.escape_debug());
1001 }
1002 }
1003 repr.push('"');
1004 Literal::_new(repr)
1005 }
1006
1007 pub fn character(t: char) -> Literal {
1008 let mut repr = String::new();
1009 repr.push('\'');
1010 if t == '"' {
1011 // escape_debug turns this into '\"' which is unnecessary.
1012 repr.push(t);
1013 } else {
1014 repr.extend(t.escape_debug());
1015 }
1016 repr.push('\'');
1017 Literal::_new(repr)
1018 }
1019
1020 pub fn byte_string(bytes: &[u8]) -> Literal {
1021 let mut escaped = "b\"".to_string();
1022 let mut bytes = bytes.iter();
1023 while let Some(&b) = bytes.next() {
1024 #[allow(clippy::match_overlapping_arm)]
1025 match b {
1026 b'\0' => escaped.push_str(match bytes.as_slice().first() {
1027 // circumvent clippy::octal_escapes lint
1028 Some(b'0'..=b'7') => r"\x00",
1029 _ => r"\0",
1030 }),
1031 b'\t' => escaped.push_str(r"\t"),
1032 b'\n' => escaped.push_str(r"\n"),
1033 b'\r' => escaped.push_str(r"\r"),
1034 b'"' => escaped.push_str("\\\""),
1035 b'\\' => escaped.push_str("\\\\"),
1036 b'\x20'..=b'\x7E' => escaped.push(b as char),
1037 _ => {
1038 let _ = write!(escaped, "\\x{:02X}", b);
1039 }
1040 }
1041 }
1042 escaped.push('"');
1043 Literal::_new(escaped)
1044 }
1045
1046 pub fn span(&self) -> Span {
1047 self.span
1048 }
1049
1050 pub fn set_span(&mut self, span: Span) {
1051 self.span = span;
1052 }
1053
1054 pub fn subspan<R: RangeBounds<usize>>(&self, range: R) -> Option<Span> {
1055 #[cfg(not(span_locations))]
1056 {
1057 let _ = range;
1058 None
1059 }
1060
1061 #[cfg(span_locations)]
1062 {
1063 use core::ops::Bound;
1064
1065 let lo = match range.start_bound() {
1066 Bound::Included(start) => {
1067 let start = u32::try_from(*start).ok()?;
1068 self.span.lo.checked_add(start)?
1069 }
1070 Bound::Excluded(start) => {
1071 let start = u32::try_from(*start).ok()?;
1072 self.span.lo.checked_add(start)?.checked_add(1)?
1073 }
1074 Bound::Unbounded => self.span.lo,
1075 };
1076 let hi = match range.end_bound() {
1077 Bound::Included(end) => {
1078 let end = u32::try_from(*end).ok()?;
1079 self.span.lo.checked_add(end)?.checked_add(1)?
1080 }
1081 Bound::Excluded(end) => {
1082 let end = u32::try_from(*end).ok()?;
1083 self.span.lo.checked_add(end)?
1084 }
1085 Bound::Unbounded => self.span.hi,
1086 };
1087 if lo <= hi && hi <= self.span.hi {
1088 Some(Span { lo, hi })
1089 } else {
1090 None
1091 }
1092 }
1093 }
1094}
1095
1096impl FromStr for Literal {
1097 type Err = LexError;
1098
1099 fn from_str(repr: &str) -> Result<Self, Self::Err> {
1100 let mut cursor = get_cursor(repr);
1101 #[cfg(span_locations)]
1102 let lo = cursor.off;
1103
1104 let negative = cursor.starts_with_char('-');
1105 if negative {
1106 cursor = cursor.advance(1);
1107 if !cursor.starts_with_fn(|ch| ch.is_ascii_digit()) {
1108 return Err(LexError::call_site());
1109 }
1110 }
1111
1112 if let Ok((rest, mut literal)) = parse::literal(cursor) {
1113 if rest.is_empty() {
1114 if negative {
1115 literal.repr.insert(0, '-');
1116 }
1117 literal.span = Span {
1118 #[cfg(span_locations)]
1119 lo,
1120 #[cfg(span_locations)]
1121 hi: rest.off,
1122 };
1123 return Ok(literal);
1124 }
1125 }
1126 Err(LexError::call_site())
1127 }
1128}
1129
1130impl Display for Literal {
1131 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1132 Display::fmt(&self.repr, f)
1133 }
1134}
1135
1136impl Debug for Literal {
1137 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
1138 let mut debug = fmt.debug_struct("Literal");
1139 debug.field("lit", &format_args!("{}", self.repr));
1140 debug_span_field_if_nontrivial(&mut debug, self.span);
1141 debug.finish()
1142 }
1143}
1144