syn/
lit.rs

Help
1#[cfg(feature = "parsing")]
2use crate::lookahead;
3#[cfg(feature = "parsing")]
4use crate::parse::{Parse, Parser};
5use crate::{Error, Result};
6use proc_macro2::{Ident, Literal, Span};
7#[cfg(feature = "parsing")]
8use proc_macro2::{TokenStream, TokenTree};
9use std::ffi::{CStr, CString};
10use std::fmt::{self, Display};
11#[cfg(feature = "extra-traits")]
12use std::hash::{Hash, Hasher};
13use std::str::{self, FromStr};
14
15ast_enum_of_structs! {
16    /// A Rust literal such as a string or integer or boolean.
17    ///
18    /// # Syntax tree enum
19    ///
20    /// This type is a [syntax tree enum].
21    ///
22    /// [syntax tree enum]: crate::expr::Expr#syntax-tree-enums
23    #[non_exhaustive]
24    pub enum Lit {
25        /// A UTF-8 string literal: `"foo"`.
26        Str(LitStr),
27
28        /// A byte string literal: `b"foo"`.
29        ByteStr(LitByteStr),
30
31        /// A nul-terminated C-string literal: `c"foo"`.
32        CStr(LitCStr),
33
34        /// A byte literal: `b'f'`.
35        Byte(LitByte),
36
37        /// A character literal: `'a'`.
38        Char(LitChar),
39
40        /// An integer literal: `1` or `1u16`.
41        Int(LitInt),
42
43        /// A floating point literal: `1f64` or `1.0e10f64`.
44        ///
45        /// Must be finite. May not be infinite or NaN.
46        Float(LitFloat),
47
48        /// A boolean literal: `true` or `false`.
49        Bool(LitBool),
50
51        /// A raw token literal not interpreted by Syn.
52        Verbatim(Literal),
53    }
54}
55
56ast_struct! {
57    /// A UTF-8 string literal: `"foo"`.
58    pub struct LitStr {
59        repr: Box<LitRepr>,
60    }
61}
62
63ast_struct! {
64    /// A byte string literal: `b"foo"`.
65    pub struct LitByteStr {
66        repr: Box<LitRepr>,
67    }
68}
69
70ast_struct! {
71    /// A nul-terminated C-string literal: `c"foo"`.
72    pub struct LitCStr {
73        repr: Box<LitRepr>,
74    }
75}
76
77ast_struct! {
78    /// A byte literal: `b'f'`.
79    pub struct LitByte {
80        repr: Box<LitRepr>,
81    }
82}
83
84ast_struct! {
85    /// A character literal: `'a'`.
86    pub struct LitChar {
87        repr: Box<LitRepr>,
88    }
89}
90
91struct LitRepr {
92    token: Literal,
93    suffix: Box<str>,
94}
95
96ast_struct! {
97    /// An integer literal: `1` or `1u16`.
98    pub struct LitInt {
99        repr: Box<LitIntRepr>,
100    }
101}
102
103struct LitIntRepr {
104    token: Literal,
105    digits: Box<str>,
106    suffix: Box<str>,
107}
108
109ast_struct! {
110    /// A floating point literal: `1f64` or `1.0e10f64`.
111    ///
112    /// Must be finite. May not be infinite or NaN.
113    pub struct LitFloat {
114        repr: Box<LitFloatRepr>,
115    }
116}
117
118struct LitFloatRepr {
119    token: Literal,
120    digits: Box<str>,
121    suffix: Box<str>,
122}
123
124ast_struct! {
125    /// A boolean literal: `true` or `false`.
126    pub struct LitBool {
127        pub value: bool,
128        pub span: Span,
129    }
130}
131
132impl LitStr {
133    pub fn new(value: &str, span: Span) -> Self {
134        let mut token = Literal::string(value);
135        token.set_span(span);
136        LitStr {
137            repr: Box::new(LitRepr {
138                token,
139                suffix: Box::<str>::default(),
140            }),
141        }
142    }
143
144    pub fn value(&self) -> String {
145        let repr = self.repr.token.to_string();
146        let (value, _suffix) = value::parse_lit_str(&repr);
147        String::from(value)
148    }
149
150    /// Parse a syntax tree node from the content of this string literal.
151    ///
152    /// All spans in the syntax tree will point to the span of this `LitStr`.
153    ///
154    /// # Example
155    ///
156    /// ```
157    /// use syn::{Attribute, Error, Expr, Lit, Meta, Path, Result};
158    ///
159    /// // Parses the path from an attribute that looks like:
160    /// //
161    /// //     #[path = "a::b::c"]
162    /// //
163    /// // or returns `None` if the input is some other attribute.
164    /// fn get_path(attr: &Attribute) -> Result<Option<Path>> {
165    ///     if !attr.path().is_ident("path") {
166    ///         return Ok(None);
167    ///     }
168    ///
169    ///     if let Meta::NameValue(meta) = &attr.meta {
170    ///         if let Expr::Lit(expr) = &meta.value {
171    ///             if let Lit::Str(lit_str) = &expr.lit {
172    ///                 return lit_str.parse().map(Some);
173    ///             }
174    ///         }
175    ///     }
176    ///
177    ///     let message = "expected #[path = \"...\"]";
178    ///     Err(Error::new_spanned(attr, message))
179    /// }
180    /// ```
181    #[cfg(feature = "parsing")]
182    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
183    pub fn parse<T: Parse>(&self) -> Result<T> {
184        self.parse_with(T::parse)
185    }
186
187    /// Invoke parser on the content of this string literal.
188    ///
189    /// All spans in the syntax tree will point to the span of this `LitStr`.
190    ///
191    /// # Example
192    ///
193    /// ```
194    /// # use proc_macro2::Span;
195    /// # use syn::{LitStr, Result};
196    /// #
197    /// # fn main() -> Result<()> {
198    /// #     let lit_str = LitStr::new("a::b::c", Span::call_site());
199    /// #
200    /// #     const IGNORE: &str = stringify! {
201    /// let lit_str: LitStr = /* ... */;
202    /// #     };
203    ///
204    /// // Parse a string literal like "a::b::c" into a Path, not allowing
205    /// // generic arguments on any of the path segments.
206    /// let basic_path = lit_str.parse_with(syn::Path::parse_mod_style)?;
207    /// #
208    /// #     Ok(())
209    /// # }
210    /// ```
211    #[cfg(feature = "parsing")]
212    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
213    pub fn parse_with<F: Parser>(&self, parser: F) -> Result<F::Output> {
214        use proc_macro2::Group;
215
216        // Token stream with every span replaced by the given one.
217        fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
218            stream
219                .into_iter()
220                .map(|token| respan_token_tree(token, span))
221                .collect()
222        }
223
224        // Token tree with every span replaced by the given one.
225        fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree {
226            match &mut token {
227                TokenTree::Group(g) => {
228                    let stream = respan_token_stream(g.stream(), span);
229                    *g = Group::new(g.delimiter(), stream);
230                    g.set_span(span);
231                }
232                other => other.set_span(span),
233            }
234            token
235        }
236
237        // Parse string literal into a token stream with every span equal to the
238        // original literal's span.
239        let span = self.span();
240        let mut tokens = TokenStream::from_str(&self.value())?;
241        tokens = respan_token_stream(tokens, span);
242
243        let result = crate::parse::parse_scoped(parser, span, tokens)?;
244
245        let suffix = self.suffix();
246        if !suffix.is_empty() {
247            return Err(Error::new(
248                self.span(),
249                format!("unexpected suffix `{}` on string literal", suffix),
250            ));
251        }
252
253        Ok(result)
254    }
255
256    pub fn span(&self) -> Span {
257        self.repr.token.span()
258    }
259
260    pub fn set_span(&mut self, span: Span) {
261        self.repr.token.set_span(span);
262    }
263
264    pub fn suffix(&self) -> &str {
265        &self.repr.suffix
266    }
267
268    pub fn token(&self) -> Literal {
269        self.repr.token.clone()
270    }
271}
272
273impl LitByteStr {
274    pub fn new(value: &[u8], span: Span) -> Self {
275        let mut token = Literal::byte_string(value);
276        token.set_span(span);
277        LitByteStr {
278            repr: Box::new(LitRepr {
279                token,
280                suffix: Box::<str>::default(),
281            }),
282        }
283    }
284
285    pub fn value(&self) -> Vec<u8> {
286        let repr = self.repr.token.to_string();
287        let (value, _suffix) = value::parse_lit_byte_str(&repr);
288        value
289    }
290
291    pub fn span(&self) -> Span {
292        self.repr.token.span()
293    }
294
295    pub fn set_span(&mut self, span: Span) {
296        self.repr.token.set_span(span);
297    }
298
299    pub fn suffix(&self) -> &str {
300        &self.repr.suffix
301    }
302
303    pub fn token(&self) -> Literal {
304        self.repr.token.clone()
305    }
306}
307
308impl LitCStr {
309    pub fn new(value: &CStr, span: Span) -> Self {
310        let mut token = Literal::c_string(value);
311        token.set_span(span);
312        LitCStr {
313            repr: Box::new(LitRepr {
314                token,
315                suffix: Box::<str>::default(),
316            }),
317        }
318    }
319
320    pub fn value(&self) -> CString {
321        let repr = self.repr.token.to_string();
322        let (value, _suffix) = value::parse_lit_c_str(&repr);
323        value
324    }
325
326    pub fn span(&self) -> Span {
327        self.repr.token.span()
328    }
329
330    pub fn set_span(&mut self, span: Span) {
331        self.repr.token.set_span(span);
332    }
333
334    pub fn suffix(&self) -> &str {
335        &self.repr.suffix
336    }
337
338    pub fn token(&self) -> Literal {
339        self.repr.token.clone()
340    }
341}
342
343impl LitByte {
344    pub fn new(value: u8, span: Span) -> Self {
345        let mut token = Literal::u8_suffixed(value);
346        token.set_span(span);
347        LitByte {
348            repr: Box::new(LitRepr {
349                token,
350                suffix: Box::<str>::default(),
351            }),
352        }
353    }
354
355    pub fn value(&self) -> u8 {
356        let repr = self.repr.token.to_string();
357        let (value, _suffix) = value::parse_lit_byte(&repr);
358        value
359    }
360
361    pub fn span(&self) -> Span {
362        self.repr.token.span()
363    }
364
365    pub fn set_span(&mut self, span: Span) {
366        self.repr.token.set_span(span);
367    }
368
369    pub fn suffix(&self) -> &str {
370        &self.repr.suffix
371    }
372
373    pub fn token(&self) -> Literal {
374        self.repr.token.clone()
375    }
376}
377
378impl LitChar {
379    pub fn new(value: char, span: Span) -> Self {
380        let mut token = Literal::character(value);
381        token.set_span(span);
382        LitChar {
383            repr: Box::new(LitRepr {
384                token,
385                suffix: Box::<str>::default(),
386            }),
387        }
388    }
389
390    pub fn value(&self) -> char {
391        let repr = self.repr.token.to_string();
392        let (value, _suffix) = value::parse_lit_char(&repr);
393        value
394    }
395
396    pub fn span(&self) -> Span {
397        self.repr.token.span()
398    }
399
400    pub fn set_span(&mut self, span: Span) {
401        self.repr.token.set_span(span);
402    }
403
404    pub fn suffix(&self) -> &str {
405        &self.repr.suffix
406    }
407
408    pub fn token(&self) -> Literal {
409        self.repr.token.clone()
410    }
411}
412
413impl LitInt {
414    pub fn new(repr: &str, span: Span) -> Self {
415        let (digits, suffix) = match value::parse_lit_int(repr) {
416            Some(parse) => parse,
417            None => panic!("not an integer literal: `{}`", repr),
418        };
419
420        let mut token: Literal = repr.parse().unwrap();
421        token.set_span(span);
422        LitInt {
423            repr: Box::new(LitIntRepr {
424                token,
425                digits,
426                suffix,
427            }),
428        }
429    }
430
431    pub fn base10_digits(&self) -> &str {
432        &self.repr.digits
433    }
434
435    /// Parses the literal into a selected number type.
436    ///
437    /// This is equivalent to `lit.base10_digits().parse()` except that the
438    /// resulting errors will be correctly spanned to point to the literal token
439    /// in the macro input.
440    ///
441    /// ```
442    /// use syn::LitInt;
443    /// use syn::parse::{Parse, ParseStream, Result};
444    ///
445    /// struct Port {
446    ///     value: u16,
447    /// }
448    ///
449    /// impl Parse for Port {
450    ///     fn parse(input: ParseStream) -> Result<Self> {
451    ///         let lit: LitInt = input.parse()?;
452    ///         let value = lit.base10_parse::<u16>()?;
453    ///         Ok(Port { value })
454    ///     }
455    /// }
456    /// ```
457    pub fn base10_parse<N>(&self) -> Result<N>
458    where
459        N: FromStr,
460        N::Err: Display,
461    {
462        self.base10_digits()
463            .parse()
464            .map_err(|err| Error::new(self.span(), err))
465    }
466
467    pub fn suffix(&self) -> &str {
468        &self.repr.suffix
469    }
470
471    pub fn span(&self) -> Span {
472        self.repr.token.span()
473    }
474
475    pub fn set_span(&mut self, span: Span) {
476        self.repr.token.set_span(span);
477    }
478
479    pub fn token(&self) -> Literal {
480        self.repr.token.clone()
481    }
482}
483
484impl From<Literal> for LitInt {
485    fn from(token: Literal) -> Self {
486        let repr = token.to_string();
487        if let Some((digits, suffix)) = value::parse_lit_int(&repr) {
488            LitInt {
489                repr: Box::new(LitIntRepr {
490                    token,
491                    digits,
492                    suffix,
493                }),
494            }
495        } else {
496            panic!("not an integer literal: `{}`", repr);
497        }
498    }
499}
500
501impl Display for LitInt {
502    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
503        self.repr.token.fmt(formatter)
504    }
505}
506
507impl LitFloat {
508    pub fn new(repr: &str, span: Span) -> Self {
509        let (digits, suffix) = match value::parse_lit_float(repr) {
510            Some(parse) => parse,
511            None => panic!("not a float literal: `{}`", repr),
512        };
513
514        let mut token: Literal = repr.parse().unwrap();
515        token.set_span(span);
516        LitFloat {
517            repr: Box::new(LitFloatRepr {
518                token,
519                digits,
520                suffix,
521            }),
522        }
523    }
524
525    pub fn base10_digits(&self) -> &str {
526        &self.repr.digits
527    }
528
529    pub fn base10_parse<N>(&self) -> Result<N>
530    where
531        N: FromStr,
532        N::Err: Display,
533    {
534        self.base10_digits()
535            .parse()
536            .map_err(|err| Error::new(self.span(), err))
537    }
538
539    pub fn suffix(&self) -> &str {
540        &self.repr.suffix
541    }
542
543    pub fn span(&self) -> Span {
544        self.repr.token.span()
545    }
546
547    pub fn set_span(&mut self, span: Span) {
548        self.repr.token.set_span(span);
549    }
550
551    pub fn token(&self) -> Literal {
552        self.repr.token.clone()
553    }
554}
555
556impl From<Literal> for LitFloat {
557    fn from(token: Literal) -> Self {
558        let repr = token.to_string();
559        if let Some((digits, suffix)) = value::parse_lit_float(&repr) {
560            LitFloat {
561                repr: Box::new(LitFloatRepr {
562                    token,
563                    digits,
564                    suffix,
565                }),
566            }
567        } else {
568            panic!("not a float literal: `{}`", repr);
569        }
570    }
571}
572
573impl Display for LitFloat {
574    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
575        self.repr.token.fmt(formatter)
576    }
577}
578
579impl LitBool {
580    pub fn new(value: bool, span: Span) -> Self {
581        LitBool { value, span }
582    }
583
584    pub fn value(&self) -> bool {
585        self.value
586    }
587
588    pub fn span(&self) -> Span {
589        self.span
590    }
591
592    pub fn set_span(&mut self, span: Span) {
593        self.span = span;
594    }
595
596    pub fn token(&self) -> Ident {
597        let s = if self.value { "true" } else { "false" };
598        Ident::new(s, self.span)
599    }
600}
601
602#[cfg(feature = "extra-traits")]
603mod debug_impls {
604    use crate::lit::{LitBool, LitByte, LitByteStr, LitCStr, LitChar, LitFloat, LitInt, LitStr};
605    use std::fmt::{self, Debug};
606
607    #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
608    impl Debug for LitStr {
609        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
610            self.debug(formatter, "LitStr")
611        }
612    }
613
614    impl LitStr {
615        pub(crate) fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
616            formatter
617                .debug_struct(name)
618                .field("token", &format_args!("{}", self.repr.token))
619                .finish()
620        }
621    }
622
623    #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
624    impl Debug for LitByteStr {
625        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
626            self.debug(formatter, "LitByteStr")
627        }
628    }
629
630    impl LitByteStr {
631        pub(crate) fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
632            formatter
633                .debug_struct(name)
634                .field("token", &format_args!("{}", self.repr.token))
635                .finish()
636        }
637    }
638
639    #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
640    impl Debug for LitCStr {
641        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
642            self.debug(formatter, "LitCStr")
643        }
644    }
645
646    impl LitCStr {
647        pub(crate) fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
648            formatter
649                .debug_struct(name)
650                .field("token", &format_args!("{}", self.repr.token))
651                .finish()
652        }
653    }
654
655    #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
656    impl Debug for LitByte {
657        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
658            self.debug(formatter, "LitByte")
659        }
660    }
661
662    impl LitByte {
663        pub(crate) fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
664            formatter
665                .debug_struct(name)
666                .field("token", &format_args!("{}", self.repr.token))
667                .finish()
668        }
669    }
670
671    #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
672    impl Debug for LitChar {
673        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
674            self.debug(formatter, "LitChar")
675        }
676    }
677
678    impl LitChar {
679        pub(crate) fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
680            formatter
681                .debug_struct(name)
682                .field("token", &format_args!("{}", self.repr.token))
683                .finish()
684        }
685    }
686
687    #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
688    impl Debug for LitInt {
689        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
690            self.debug(formatter, "LitInt")
691        }
692    }
693
694    impl LitInt {
695        pub(crate) fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
696            formatter
697                .debug_struct(name)
698                .field("token", &format_args!("{}", self.repr.token))
699                .finish()
700        }
701    }
702
703    #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
704    impl Debug for LitFloat {
705        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
706            self.debug(formatter, "LitFloat")
707        }
708    }
709
710    impl LitFloat {
711        pub(crate) fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
712            formatter
713                .debug_struct(name)
714                .field("token", &format_args!("{}", self.repr.token))
715                .finish()
716        }
717    }
718
719    #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
720    impl Debug for LitBool {
721        fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
722            self.debug(formatter, "LitBool")
723        }
724    }
725
726    impl LitBool {
727        pub(crate) fn debug(&self, formatter: &mut fmt::Formatter, name: &str) -> fmt::Result {
728            formatter
729                .debug_struct(name)
730                .field("value", &self.value)
731                .finish()
732        }
733    }
734}
735
736#[cfg(feature = "clone-impls")]
737#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
738impl Clone for LitRepr {
739    fn clone(&self) -> Self {
740        LitRepr {
741            token: self.token.clone(),
742            suffix: self.suffix.clone(),
743        }
744    }
745}
746
747#[cfg(feature = "clone-impls")]
748#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
749impl Clone for LitIntRepr {
750    fn clone(&self) -> Self {
751        LitIntRepr {
752            token: self.token.clone(),
753            digits: self.digits.clone(),
754            suffix: self.suffix.clone(),
755        }
756    }
757}
758
759#[cfg(feature = "clone-impls")]
760#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
761impl Clone for LitFloatRepr {
762    fn clone(&self) -> Self {
763        LitFloatRepr {
764            token: self.token.clone(),
765            digits: self.digits.clone(),
766            suffix: self.suffix.clone(),
767        }
768    }
769}
770
771macro_rules! lit_extra_traits {
772    ($ty:ident) => {
773        #[cfg(feature = "clone-impls")]
774        #[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
775        impl Clone for $ty {
776            fn clone(&self) -> Self {
777                $ty {
778                    repr: self.repr.clone(),
779                }
780            }
781        }
782
783        #[cfg(feature = "extra-traits")]
784        #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
785        impl PartialEq for $ty {
786            fn eq(&self, other: &Self) -> bool {
787                self.repr.token.to_string() == other.repr.token.to_string()
788            }
789        }
790
791        #[cfg(feature = "extra-traits")]
792        #[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
793        impl Hash for $ty {
794            fn hash<H>(&self, state: &mut H)
795            where
796                H: Hasher,
797            {
798                self.repr.token.to_string().hash(state);
799            }
800        }
801
802        #[cfg(feature = "parsing")]
803        pub_if_not_doc! {
804            #[doc(hidden)]
805            #[allow(non_snake_case)]
806            pub fn $ty(marker: lookahead::TokenMarker) -> $ty {
807                match marker {}
808            }
809        }
810    };
811}
812
813lit_extra_traits!(LitStr);
814lit_extra_traits!(LitByteStr);
815lit_extra_traits!(LitCStr);
816lit_extra_traits!(LitByte);
817lit_extra_traits!(LitChar);
818lit_extra_traits!(LitInt);
819lit_extra_traits!(LitFloat);
820
821#[cfg(feature = "parsing")]
822pub_if_not_doc! {
823    #[doc(hidden)]
824    #[allow(non_snake_case)]
825    pub fn LitBool(marker: lookahead::TokenMarker) -> LitBool {
826        match marker {}
827    }
828}
829
830/// The style of a string literal, either plain quoted or a raw string like
831/// `r##"data"##`.
832#[doc(hidden)] // https://github.com/dtolnay/syn/issues/1566
833pub enum StrStyle {
834    /// An ordinary string like `"data"`.
835    Cooked,
836    /// A raw string like `r##"data"##`.
837    ///
838    /// The unsigned integer is the number of `#` symbols used.
839    Raw(usize),
840}
841
842#[cfg(feature = "parsing")]
843pub_if_not_doc! {
844    #[doc(hidden)]
845    #[allow(non_snake_case)]
846    pub fn Lit(marker: lookahead::TokenMarker) -> Lit {
847        match marker {}
848    }
849}
850
851#[cfg(feature = "parsing")]
852pub(crate) mod parsing {
853    use crate::buffer::Cursor;
854    use crate::error::Result;
855    use crate::lit::{
856        value, Lit, LitBool, LitByte, LitByteStr, LitCStr, LitChar, LitFloat, LitFloatRepr, LitInt,
857        LitIntRepr, LitStr,
858    };
859    use crate::parse::{Parse, ParseStream, Unexpected};
860    use crate::token::{self, Token};
861    use proc_macro2::{Literal, Punct, Span};
862    use std::cell::Cell;
863    use std::rc::Rc;
864
865    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
866    impl Parse for Lit {
867        fn parse(input: ParseStream) -> Result<Self> {
868            input.step(|cursor| {
869                if let Some((lit, rest)) = cursor.literal() {
870                    return Ok((Lit::new(lit), rest));
871                }
872
873                if let Some((ident, rest)) = cursor.ident() {
874                    let value = ident == "true";
875                    if value || ident == "false" {
876                        let lit_bool = LitBool {
877                            value,
878                            span: ident.span(),
879                        };
880                        return Ok((Lit::Bool(lit_bool), rest));
881                    }
882                }
883
884                if let Some((punct, rest)) = cursor.punct() {
885                    if punct.as_char() == '-' {
886                        if let Some((lit, rest)) = parse_negative_lit(punct, rest) {
887                            return Ok((lit, rest));
888                        }
889                    }
890                }
891
892                Err(cursor.error("expected literal"))
893            })
894        }
895    }
896
897    fn parse_negative_lit(neg: Punct, cursor: Cursor) -> Option<(Lit, Cursor)> {
898        let (lit, rest) = cursor.literal()?;
899
900        let mut span = neg.span();
901        span = span.join(lit.span()).unwrap_or(span);
902
903        let mut repr = lit.to_string();
904        repr.insert(0, '-');
905
906        if let Some((digits, suffix)) = value::parse_lit_int(&repr) {
907            let mut token: Literal = repr.parse().unwrap();
908            token.set_span(span);
909            return Some((
910                Lit::Int(LitInt {
911                    repr: Box::new(LitIntRepr {
912                        token,
913                        digits,
914                        suffix,
915                    }),
916                }),
917                rest,
918            ));
919        }
920
921        let (digits, suffix) = value::parse_lit_float(&repr)?;
922        let mut token: Literal = repr.parse().unwrap();
923        token.set_span(span);
924        Some((
925            Lit::Float(LitFloat {
926                repr: Box::new(LitFloatRepr {
927                    token,
928                    digits,
929                    suffix,
930                }),
931            }),
932            rest,
933        ))
934    }
935
936    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
937    impl Parse for LitStr {
938        fn parse(input: ParseStream) -> Result<Self> {
939            let head = input.fork();
940            match input.parse() {
941                Ok(Lit::Str(lit)) => Ok(lit),
942                _ => Err(head.error("expected string literal")),
943            }
944        }
945    }
946
947    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
948    impl Parse for LitByteStr {
949        fn parse(input: ParseStream) -> Result<Self> {
950            let head = input.fork();
951            match input.parse() {
952                Ok(Lit::ByteStr(lit)) => Ok(lit),
953                _ => Err(head.error("expected byte string literal")),
954            }
955        }
956    }
957
958    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
959    impl Parse for LitCStr {
960        fn parse(input: ParseStream) -> Result<Self> {
961            let head = input.fork();
962            match input.parse() {
963                Ok(Lit::CStr(lit)) => Ok(lit),
964                _ => Err(head.error("expected C string literal")),
965            }
966        }
967    }
968
969    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
970    impl Parse for LitByte {
971        fn parse(input: ParseStream) -> Result<Self> {
972            let head = input.fork();
973            match input.parse() {
974                Ok(Lit::Byte(lit)) => Ok(lit),
975                _ => Err(head.error("expected byte literal")),
976            }
977        }
978    }
979
980    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
981    impl Parse for LitChar {
982        fn parse(input: ParseStream) -> Result<Self> {
983            let head = input.fork();
984            match input.parse() {
985                Ok(Lit::Char(lit)) => Ok(lit),
986                _ => Err(head.error("expected character literal")),
987            }
988        }
989    }
990
991    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
992    impl Parse for LitInt {
993        fn parse(input: ParseStream) -> Result<Self> {
994            let head = input.fork();
995            match input.parse() {
996                Ok(Lit::Int(lit)) => Ok(lit),
997                _ => Err(head.error("expected integer literal")),
998            }
999        }
1000    }
1001
1002    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
1003    impl Parse for LitFloat {
1004        fn parse(input: ParseStream) -> Result<Self> {
1005            let head = input.fork();
1006            match input.parse() {
1007                Ok(Lit::Float(lit)) => Ok(lit),
1008                _ => Err(head.error("expected floating point literal")),
1009            }
1010        }
1011    }
1012
1013    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
1014    impl Parse for LitBool {
1015        fn parse(input: ParseStream) -> Result<Self> {
1016            let head = input.fork();
1017            match input.parse() {
1018                Ok(Lit::Bool(lit)) => Ok(lit),
1019                _ => Err(head.error("expected boolean literal")),
1020            }
1021        }
1022    }
1023
1024    fn peek_impl(cursor: Cursor, peek: fn(ParseStream) -> bool) -> bool {
1025        let scope = Span::call_site();
1026        let unexpected = Rc::new(Cell::new(Unexpected::None));
1027        let buffer = crate::parse::new_parse_buffer(scope, cursor, unexpected);
1028        peek(&buffer)
1029    }
1030
1031    macro_rules! impl_token {
1032        ($display:literal $name:ty) => {
1033            impl Token for $name {
1034                fn peek(cursor: Cursor) -> bool {
1035                    fn peek(input: ParseStream) -> bool {
1036                        <$name as Parse>::parse(input).is_ok()
1037                    }
1038                    peek_impl(cursor, peek)
1039                }
1040
1041                fn display() -> &'static str {
1042                    $display
1043                }
1044            }
1045
1046            impl token::private::Sealed for $name {}
1047        };
1048    }
1049
1050    impl_token!("literal" Lit);
1051    impl_token!("string literal" LitStr);
1052    impl_token!("byte string literal" LitByteStr);
1053    impl_token!("C-string literal" LitCStr);
1054    impl_token!("byte literal" LitByte);
1055    impl_token!("character literal" LitChar);
1056    impl_token!("integer literal" LitInt);
1057    impl_token!("floating point literal" LitFloat);
1058    impl_token!("boolean literal" LitBool);
1059}
1060
1061#[cfg(feature = "printing")]
1062mod printing {
1063    use crate::lit::{LitBool, LitByte, LitByteStr, LitCStr, LitChar, LitFloat, LitInt, LitStr};
1064    use proc_macro2::TokenStream;
1065    use quote::{ToTokens, TokenStreamExt};
1066
1067    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1068    impl ToTokens for LitStr {
1069        fn to_tokens(&self, tokens: &mut TokenStream) {
1070            self.repr.token.to_tokens(tokens);
1071        }
1072    }
1073
1074    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1075    impl ToTokens for LitByteStr {
1076        fn to_tokens(&self, tokens: &mut TokenStream) {
1077            self.repr.token.to_tokens(tokens);
1078        }
1079    }
1080
1081    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1082    impl ToTokens for LitCStr {
1083        fn to_tokens(&self, tokens: &mut TokenStream) {
1084            self.repr.token.to_tokens(tokens);
1085        }
1086    }
1087
1088    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1089    impl ToTokens for LitByte {
1090        fn to_tokens(&self, tokens: &mut TokenStream) {
1091            self.repr.token.to_tokens(tokens);
1092        }
1093    }
1094
1095    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1096    impl ToTokens for LitChar {
1097        fn to_tokens(&self, tokens: &mut TokenStream) {
1098            self.repr.token.to_tokens(tokens);
1099        }
1100    }
1101
1102    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1103    impl ToTokens for LitInt {
1104        fn to_tokens(&self, tokens: &mut TokenStream) {
1105            self.repr.token.to_tokens(tokens);
1106        }
1107    }
1108
1109    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1110    impl ToTokens for LitFloat {
1111        fn to_tokens(&self, tokens: &mut TokenStream) {
1112            self.repr.token.to_tokens(tokens);
1113        }
1114    }
1115
1116    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1117    impl ToTokens for LitBool {
1118        fn to_tokens(&self, tokens: &mut TokenStream) {
1119            tokens.append(self.token());
1120        }
1121    }
1122}
1123
1124mod value {
1125    use crate::bigint::BigInt;
1126    use crate::lit::{
1127        Lit, LitBool, LitByte, LitByteStr, LitCStr, LitChar, LitFloat, LitFloatRepr, LitInt,
1128        LitIntRepr, LitRepr, LitStr,
1129    };
1130    use proc_macro2::{Literal, Span};
1131    use std::ascii;
1132    use std::char;
1133    use std::ffi::CString;
1134    use std::ops::{Index, RangeFrom};
1135
1136    impl Lit {
1137        /// Interpret a Syn literal from a proc-macro2 literal.
1138        pub fn new(token: Literal) -> Self {
1139            let repr = token.to_string();
1140
1141            match byte(&repr, 0) {
1142                // "...", r"...", r#"..."#
1143                b'"' | b'r' => {
1144                    let (_, suffix) = parse_lit_str(&repr);
1145                    return Lit::Str(LitStr {
1146                        repr: Box::new(LitRepr { token, suffix }),
1147                    });
1148                }
1149                b'b' => match byte(&repr, 1) {
1150                    // b"...", br"...", br#"...#"
1151                    b'"' | b'r' => {
1152                        let (_, suffix) = parse_lit_byte_str(&repr);
1153                        return Lit::ByteStr(LitByteStr {
1154                            repr: Box::new(LitRepr { token, suffix }),
1155                        });
1156                    }
1157                    // b'...'
1158                    b'\'' => {
1159                        let (_, suffix) = parse_lit_byte(&repr);
1160                        return Lit::Byte(LitByte {
1161                            repr: Box::new(LitRepr { token, suffix }),
1162                        });
1163                    }
1164                    _ => {}
1165                },
1166                // c"...", cr"...", cr#"..."#
1167                b'c' => {
1168                    let (_, suffix) = parse_lit_c_str(&repr);
1169                    return Lit::CStr(LitCStr {
1170                        repr: Box::new(LitRepr { token, suffix }),
1171                    });
1172                }
1173                // '...'
1174                b'\'' => {
1175                    let (_, suffix) = parse_lit_char(&repr);
1176                    return Lit::Char(LitChar {
1177                        repr: Box::new(LitRepr { token, suffix }),
1178                    });
1179                }
1180                b'0'..=b'9' | b'-' => {
1181                    // 0, 123, 0xFF, 0o77, 0b11
1182                    if let Some((digits, suffix)) = parse_lit_int(&repr) {
1183                        return Lit::Int(LitInt {
1184                            repr: Box::new(LitIntRepr {
1185                                token,
1186                                digits,
1187                                suffix,
1188                            }),
1189                        });
1190                    }
1191                    // 1.0, 1e-1, 1e+1
1192                    if let Some((digits, suffix)) = parse_lit_float(&repr) {
1193                        return Lit::Float(LitFloat {
1194                            repr: Box::new(LitFloatRepr {
1195                                token,
1196                                digits,
1197                                suffix,
1198                            }),
1199                        });
1200                    }
1201                }
1202                // true, false
1203                b't' | b'f' => {
1204                    if repr == "true" || repr == "false" {
1205                        return Lit::Bool(LitBool {
1206                            value: repr == "true",
1207                            span: token.span(),
1208                        });
1209                    }
1210                }
1211                b'(' if repr == "(/*ERROR*/)" => return Lit::Verbatim(token),
1212                _ => {}
1213            }
1214
1215            panic!("unrecognized literal: `{}`", repr);
1216        }
1217
1218        pub fn suffix(&self) -> &str {
1219            match self {
1220                Lit::Str(lit) => lit.suffix(),
1221                Lit::ByteStr(lit) => lit.suffix(),
1222                Lit::CStr(lit) => lit.suffix(),
1223                Lit::Byte(lit) => lit.suffix(),
1224                Lit::Char(lit) => lit.suffix(),
1225                Lit::Int(lit) => lit.suffix(),
1226                Lit::Float(lit) => lit.suffix(),
1227                Lit::Bool(_) | Lit::Verbatim(_) => "",
1228            }
1229        }
1230
1231        pub fn span(&self) -> Span {
1232            match self {
1233                Lit::Str(lit) => lit.span(),
1234                Lit::ByteStr(lit) => lit.span(),
1235                Lit::CStr(lit) => lit.span(),
1236                Lit::Byte(lit) => lit.span(),
1237                Lit::Char(lit) => lit.span(),
1238                Lit::Int(lit) => lit.span(),
1239                Lit::Float(lit) => lit.span(),
1240                Lit::Bool(lit) => lit.span,
1241                Lit::Verbatim(lit) => lit.span(),
1242            }
1243        }
1244
1245        pub fn set_span(&mut self, span: Span) {
1246            match self {
1247                Lit::Str(lit) => lit.set_span(span),
1248                Lit::ByteStr(lit) => lit.set_span(span),
1249                Lit::CStr(lit) => lit.set_span(span),
1250                Lit::Byte(lit) => lit.set_span(span),
1251                Lit::Char(lit) => lit.set_span(span),
1252                Lit::Int(lit) => lit.set_span(span),
1253                Lit::Float(lit) => lit.set_span(span),
1254                Lit::Bool(lit) => lit.span = span,
1255                Lit::Verbatim(lit) => lit.set_span(span),
1256            }
1257        }
1258    }
1259
1260    /// Get the byte at offset idx, or a default of `b'\0'` if we're looking
1261    /// past the end of the input buffer.
1262    pub(crate) fn byte<S: AsRef<[u8]> + ?Sized>(s: &S, idx: usize) -> u8 {
1263        let s = s.as_ref();
1264        if idx < s.len() {
1265            s[idx]
1266        } else {
1267            0
1268        }
1269    }
1270
1271    fn next_chr(s: &str) -> char {
1272        s.chars().next().unwrap_or('\0')
1273    }
1274
1275    // Returns (content, suffix).
1276    pub(crate) fn parse_lit_str(s: &str) -> (Box<str>, Box<str>) {
1277        match byte(s, 0) {
1278            b'"' => parse_lit_str_cooked(s),
1279            b'r' => parse_lit_str_raw(s),
1280            _ => unreachable!(),
1281        }
1282    }
1283
1284    fn parse_lit_str_cooked(mut s: &str) -> (Box<str>, Box<str>) {
1285        assert_eq!(byte(s, 0), b'"');
1286        s = &s[1..];
1287
1288        let mut content = String::new();
1289        'outer: loop {
1290            let ch = match byte(s, 0) {
1291                b'"' => break,
1292                b'\\' => {
1293                    let b = byte(s, 1);
1294                    s = &s[2..];
1295                    match b {
1296                        b'x' => {
1297                            let (byte, rest) = backslash_x(s);
1298                            s = rest;
1299                            assert!(byte <= 0x7F, "invalid \\x byte in string literal");
1300                            char::from_u32(u32::from(byte)).unwrap()
1301                        }
1302                        b'u' => {
1303                            let (ch, rest) = backslash_u(s);
1304                            s = rest;
1305                            ch
1306                        }
1307                        b'n' => '\n',
1308                        b'r' => '\r',
1309                        b't' => '\t',
1310                        b'\\' => '\\',
1311                        b'0' => '\0',
1312                        b'\'' => '\'',
1313                        b'"' => '"',
1314                        b'\r' | b'\n' => loop {
1315                            let b = byte(s, 0);
1316                            match b {
1317                                b' ' | b'\t' | b'\n' | b'\r' => s = &s[1..],
1318                                _ => continue 'outer,
1319                            }
1320                        },
1321                        b => panic!(
1322                            "unexpected byte '{}' after \\ character in string literal",
1323                            ascii::escape_default(b),
1324                        ),
1325                    }
1326                }
1327                b'\r' => {
1328                    assert_eq!(byte(s, 1), b'\n', "bare CR not allowed in string");
1329                    s = &s[2..];
1330                    '\n'
1331                }
1332                _ => {
1333                    let ch = next_chr(s);
1334                    s = &s[ch.len_utf8()..];
1335                    ch
1336                }
1337            };
1338            content.push(ch);
1339        }
1340
1341        assert!(s.starts_with('"'));
1342        let content = content.into_boxed_str();
1343        let suffix = s[1..].to_owned().into_boxed_str();
1344        (content, suffix)
1345    }
1346
1347    fn parse_lit_str_raw(mut s: &str) -> (Box<str>, Box<str>) {
1348        assert_eq!(byte(s, 0), b'r');
1349        s = &s[1..];
1350
1351        let mut pounds = 0;
1352        while byte(s, pounds) == b'#' {
1353            pounds += 1;
1354        }
1355        assert_eq!(byte(s, pounds), b'"');
1356        let close = s.rfind('"').unwrap();
1357        for end in s[close + 1..close + 1 + pounds].bytes() {
1358            assert_eq!(end, b'#');
1359        }
1360
1361        let content = s[pounds + 1..close].to_owned().into_boxed_str();
1362        let suffix = s[close + 1 + pounds..].to_owned().into_boxed_str();
1363        (content, suffix)
1364    }
1365
1366    // Returns (content, suffix).
1367    pub(crate) fn parse_lit_byte_str(s: &str) -> (Vec<u8>, Box<str>) {
1368        assert_eq!(byte(s, 0), b'b');
1369        match byte(s, 1) {
1370            b'"' => parse_lit_byte_str_cooked(s),
1371            b'r' => parse_lit_byte_str_raw(s),
1372            _ => unreachable!(),
1373        }
1374    }
1375
1376    fn parse_lit_byte_str_cooked(mut s: &str) -> (Vec<u8>, Box<str>) {
1377        assert_eq!(byte(s, 0), b'b');
1378        assert_eq!(byte(s, 1), b'"');
1379        s = &s[2..];
1380
1381        // We're going to want to have slices which don't respect codepoint boundaries.
1382        let mut v = s.as_bytes();
1383
1384        let mut out = Vec::new();
1385        'outer: loop {
1386            let byte = match byte(v, 0) {
1387                b'"' => break,
1388                b'\\' => {
1389                    let b = byte(v, 1);
1390                    v = &v[2..];
1391                    match b {
1392                        b'x' => {
1393                            let (b, rest) = backslash_x(v);
1394                            v = rest;
1395                            b
1396                        }
1397                        b'n' => b'\n',
1398                        b'r' => b'\r',
1399                        b't' => b'\t',
1400                        b'\\' => b'\\',
1401                        b'0' => b'\0',
1402                        b'\'' => b'\'',
1403                        b'"' => b'"',
1404                        b'\r' | b'\n' => loop {
1405                            let byte = byte(v, 0);
1406                            if matches!(byte, b' ' | b'\t' | b'\n' | b'\r') {
1407                                v = &v[1..];
1408                            } else {
1409                                continue 'outer;
1410                            }
1411                        },
1412                        b => panic!(
1413                            "unexpected byte '{}' after \\ character in byte-string literal",
1414                            ascii::escape_default(b),
1415                        ),
1416                    }
1417                }
1418                b'\r' => {
1419                    assert_eq!(byte(v, 1), b'\n', "bare CR not allowed in string");
1420                    v = &v[2..];
1421                    b'\n'
1422                }
1423                b => {
1424                    v = &v[1..];
1425                    b
1426                }
1427            };
1428            out.push(byte);
1429        }
1430
1431        assert_eq!(byte(v, 0), b'"');
1432        let suffix = s[s.len() - v.len() + 1..].to_owned().into_boxed_str();
1433        (out, suffix)
1434    }
1435
1436    fn parse_lit_byte_str_raw(s: &str) -> (Vec<u8>, Box<str>) {
1437        assert_eq!(byte(s, 0), b'b');
1438        let (value, suffix) = parse_lit_str_raw(&s[1..]);
1439        (String::from(value).into_bytes(), suffix)
1440    }
1441
1442    // Returns (content, suffix).
1443    pub(crate) fn parse_lit_c_str(s: &str) -> (CString, Box<str>) {
1444        assert_eq!(byte(s, 0), b'c');
1445        match byte(s, 1) {
1446            b'"' => parse_lit_c_str_cooked(s),
1447            b'r' => parse_lit_c_str_raw(s),
1448            _ => unreachable!(),
1449        }
1450    }
1451
1452    fn parse_lit_c_str_cooked(mut s: &str) -> (CString, Box<str>) {
1453        assert_eq!(byte(s, 0), b'c');
1454        assert_eq!(byte(s, 1), b'"');
1455        s = &s[2..];
1456
1457        // We're going to want to have slices which don't respect codepoint boundaries.
1458        let mut v = s.as_bytes();
1459
1460        let mut out = Vec::new();
1461        'outer: loop {
1462            let byte = match byte(v, 0) {
1463                b'"' => break,
1464                b'\\' => {
1465                    let b = byte(v, 1);
1466                    v = &v[2..];
1467                    match b {
1468                        b'x' => {
1469                            let (b, rest) = backslash_x(v);
1470                            assert!(b != 0, "\\x00 is not allowed in C-string literal");
1471                            v = rest;
1472                            b
1473                        }
1474                        b'u' => {
1475                            let (ch, rest) = backslash_u(v);
1476                            assert!(ch != '\0', "\\u{{0}} is not allowed in C-string literal");
1477                            v = rest;
1478                            out.extend_from_slice(ch.encode_utf8(&mut [0u8; 4]).as_bytes());
1479                            continue 'outer;
1480                        }
1481                        b'n' => b'\n',
1482                        b'r' => b'\r',
1483                        b't' => b'\t',
1484                        b'\\' => b'\\',
1485                        b'\'' => b'\'',
1486                        b'"' => b'"',
1487                        b'\r' | b'\n' => loop {
1488                            let byte = byte(v, 0);
1489                            if matches!(byte, b' ' | b'\t' | b'\n' | b'\r') {
1490                                v = &v[1..];
1491                            } else {
1492                                continue 'outer;
1493                            }
1494                        },
1495                        b => panic!(
1496                            "unexpected byte '{}' after \\ character in byte literal",
1497                            ascii::escape_default(b),
1498                        ),
1499                    }
1500                }
1501                b'\r' => {
1502                    assert_eq!(byte(v, 1), b'\n', "bare CR not allowed in string");
1503                    v = &v[2..];
1504                    b'\n'
1505                }
1506                b => {
1507                    v = &v[1..];
1508                    b
1509                }
1510            };
1511            out.push(byte);
1512        }
1513
1514        assert_eq!(byte(v, 0), b'"');
1515        let suffix = s[s.len() - v.len() + 1..].to_owned().into_boxed_str();
1516        (CString::new(out).unwrap(), suffix)
1517    }
1518
1519    fn parse_lit_c_str_raw(s: &str) -> (CString, Box<str>) {
1520        assert_eq!(byte(s, 0), b'c');
1521        let (value, suffix) = parse_lit_str_raw(&s[1..]);
1522        (CString::new(String::from(value)).unwrap(), suffix)
1523    }
1524
1525    // Returns (value, suffix).
1526    pub(crate) fn parse_lit_byte(s: &str) -> (u8, Box<str>) {
1527        assert_eq!(byte(s, 0), b'b');
1528        assert_eq!(byte(s, 1), b'\'');
1529
1530        // We're going to want to have slices which don't respect codepoint boundaries.
1531        let mut v = &s.as_bytes()[2..];
1532
1533        let b = match byte(v, 0) {
1534            b'\\' => {
1535                let b = byte(v, 1);
1536                v = &v[2..];
1537                match b {
1538                    b'x' => {
1539                        let (b, rest) = backslash_x(v);
1540                        v = rest;
1541                        b
1542                    }
1543                    b'n' => b'\n',
1544                    b'r' => b'\r',
1545                    b't' => b'\t',
1546                    b'\\' => b'\\',
1547                    b'0' => b'\0',
1548                    b'\'' => b'\'',
1549                    b'"' => b'"',
1550                    b => panic!(
1551                        "unexpected byte '{}' after \\ character in byte literal",
1552                        ascii::escape_default(b),
1553                    ),
1554                }
1555            }
1556            b => {
1557                v = &v[1..];
1558                b
1559            }
1560        };
1561
1562        assert_eq!(byte(v, 0), b'\'');
1563        let suffix = s[s.len() - v.len() + 1..].to_owned().into_boxed_str();
1564        (b, suffix)
1565    }
1566
1567    // Returns (value, suffix).
1568    pub(crate) fn parse_lit_char(mut s: &str) -> (char, Box<str>) {
1569        assert_eq!(byte(s, 0), b'\'');
1570        s = &s[1..];
1571
1572        let ch = match byte(s, 0) {
1573            b'\\' => {
1574                let b = byte(s, 1);
1575                s = &s[2..];
1576                match b {
1577                    b'x' => {
1578                        let (byte, rest) = backslash_x(s);
1579                        s = rest;
1580                        assert!(byte <= 0x7F, "invalid \\x byte in character literal");
1581                        char::from_u32(u32::from(byte)).unwrap()
1582                    }
1583                    b'u' => {
1584                        let (ch, rest) = backslash_u(s);
1585                        s = rest;
1586                        ch
1587                    }
1588                    b'n' => '\n',
1589                    b'r' => '\r',
1590                    b't' => '\t',
1591                    b'\\' => '\\',
1592                    b'0' => '\0',
1593                    b'\'' => '\'',
1594                    b'"' => '"',
1595                    b => panic!(
1596                        "unexpected byte '{}' after \\ character in character literal",
1597                        ascii::escape_default(b),
1598                    ),
1599                }
1600            }
1601            _ => {
1602                let ch = next_chr(s);
1603                s = &s[ch.len_utf8()..];
1604                ch
1605            }
1606        };
1607        assert_eq!(byte(s, 0), b'\'');
1608        let suffix = s[1..].to_owned().into_boxed_str();
1609        (ch, suffix)
1610    }
1611
1612    fn backslash_x<S>(s: &S) -> (u8, &S)
1613    where
1614        S: Index<RangeFrom<usize>, Output = S> + AsRef<[u8]> + ?Sized,
1615    {
1616        let mut ch = 0;
1617        let b0 = byte(s, 0);
1618        let b1 = byte(s, 1);
1619        ch += 0x10
1620            * match b0 {
1621                b'0'..=b'9' => b0 - b'0',
1622                b'a'..=b'f' => 10 + (b0 - b'a'),
1623                b'A'..=b'F' => 10 + (b0 - b'A'),
1624                _ => panic!("unexpected non-hex character after \\x"),
1625            };
1626        ch += match b1 {
1627            b'0'..=b'9' => b1 - b'0',
1628            b'a'..=b'f' => 10 + (b1 - b'a'),
1629            b'A'..=b'F' => 10 + (b1 - b'A'),
1630            _ => panic!("unexpected non-hex character after \\x"),
1631        };
1632        (ch, &s[2..])
1633    }
1634
1635    fn backslash_u<S>(mut s: &S) -> (char, &S)
1636    where
1637        S: Index<RangeFrom<usize>, Output = S> + AsRef<[u8]> + ?Sized,
1638    {
1639        if byte(s, 0) != b'{' {
1640            panic!("{}", "expected { after \\u");
1641        }
1642        s = &s[1..];
1643
1644        let mut ch = 0;
1645        let mut digits = 0;
1646        loop {
1647            let b = byte(s, 0);
1648            let digit = match b {
1649                b'0'..=b'9' => b - b'0',
1650                b'a'..=b'f' => 10 + b - b'a',
1651                b'A'..=b'F' => 10 + b - b'A',
1652                b'_' if digits > 0 => {
1653                    s = &s[1..];
1654                    continue;
1655                }
1656                b'}' if digits == 0 => panic!("invalid empty unicode escape"),
1657                b'}' => break,
1658                _ => panic!("unexpected non-hex character after \\u"),
1659            };
1660            if digits == 6 {
1661                panic!("overlong unicode escape (must have at most 6 hex digits)");
1662            }
1663            ch *= 0x10;
1664            ch += u32::from(digit);
1665            digits += 1;
1666            s = &s[1..];
1667        }
1668        assert!(byte(s, 0) == b'}');
1669        s = &s[1..];
1670
1671        if let Some(ch) = char::from_u32(ch) {
1672            (ch, s)
1673        } else {
1674            panic!("character code {:x} is not a valid unicode character", ch);
1675        }
1676    }
1677
1678    // Returns base 10 digits and suffix.
1679    pub(crate) fn parse_lit_int(mut s: &str) -> Option<(Box<str>, Box<str>)> {
1680        let negative = byte(s, 0) == b'-';
1681        if negative {
1682            s = &s[1..];
1683        }
1684
1685        let base = match (byte(s, 0), byte(s, 1)) {
1686            (b'0', b'x') => {
1687                s = &s[2..];
1688                16
1689            }
1690            (b'0', b'o') => {
1691                s = &s[2..];
1692                8
1693            }
1694            (b'0', b'b') => {
1695                s = &s[2..];
1696                2
1697            }
1698            (b'0'..=b'9', _) => 10,
1699            _ => return None,
1700        };
1701
1702        let mut value = BigInt::new();
1703        let mut has_digit = false;
1704        'outer: loop {
1705            let b = byte(s, 0);
1706            let digit = match b {
1707                b'0'..=b'9' => b - b'0',
1708                b'a'..=b'f' if base > 10 => b - b'a' + 10,
1709                b'A'..=b'F' if base > 10 => b - b'A' + 10,
1710                b'_' => {
1711                    s = &s[1..];
1712                    continue;
1713                }
1714                // If looking at a floating point literal, we don't want to
1715                // consider it an integer.
1716                b'.' if base == 10 => return None,
1717                b'e' | b'E' if base == 10 => {
1718                    let mut has_exp = false;
1719                    for (i, b) in s[1..].bytes().enumerate() {
1720                        match b {
1721                            b'_' => {}
1722                            b'-' | b'+' => return None,
1723                            b'0'..=b'9' => has_exp = true,
1724                            _ => {
1725                                let suffix = &s[1 + i..];
1726                                if has_exp && crate::ident::xid_ok(suffix) {
1727                                    return None;
1728                                } else {
1729                                    break 'outer;
1730                                }
1731                            }
1732                        }
1733                    }
1734                    if has_exp {
1735                        return None;
1736                    } else {
1737                        break;
1738                    }
1739                }
1740                _ => break,
1741            };
1742
1743            if digit >= base {
1744                return None;
1745            }
1746
1747            has_digit = true;
1748            value *= base;
1749            value += digit;
1750            s = &s[1..];
1751        }
1752
1753        if !has_digit {
1754            return None;
1755        }
1756
1757        let suffix = s;
1758        if suffix.is_empty() || crate::ident::xid_ok(suffix) {
1759            let mut repr = value.to_string();
1760            if negative {
1761                repr.insert(0, '-');
1762            }
1763            Some((repr.into_boxed_str(), suffix.to_owned().into_boxed_str()))
1764        } else {
1765            None
1766        }
1767    }
1768
1769    // Returns base 10 digits and suffix.
1770    pub(crate) fn parse_lit_float(input: &str) -> Option<(Box<str>, Box<str>)> {
1771        // Rust's floating point literals are very similar to the ones parsed by
1772        // the standard library, except that rust's literals can contain
1773        // ignorable underscores. Let's remove those underscores.
1774
1775        let mut bytes = input.to_owned().into_bytes();
1776
1777        let start = (*bytes.first()? == b'-') as usize;
1778        match bytes.get(start)? {
1779            b'0'..=b'9' => {}
1780            _ => return None,
1781        }
1782
1783        let mut read = start;
1784        let mut write = start;
1785        let mut has_dot = false;
1786        let mut has_e = false;
1787        let mut has_sign = false;
1788        let mut has_exponent = false;
1789        while read < bytes.len() {
1790            match bytes[read] {
1791                b'_' => {
1792                    // Don't increase write
1793                    read += 1;
1794                    continue;
1795                }
1796                b'0'..=b'9' => {
1797                    if has_e {
1798                        has_exponent = true;
1799                    }
1800                    bytes[write] = bytes[read];
1801                }
1802                b'.' => {
1803                    if has_e || has_dot {
1804                        return None;
1805                    }
1806                    has_dot = true;
1807                    bytes[write] = b'.';
1808                }
1809                b'e' | b'E' => {
1810                    match bytes[read + 1..]
1811                        .iter()
1812                        .find(|b| **b != b'_')
1813                        .unwrap_or(&b'\0')
1814                    {
1815                        b'-' | b'+' | b'0'..=b'9' => {}
1816                        _ => break,
1817                    }
1818                    if has_e {
1819                        if has_exponent {
1820                            break;
1821                        } else {
1822                            return None;
1823                        }
1824                    }
1825                    has_e = true;
1826                    bytes[write] = b'e';
1827                }
1828                b'-' | b'+' => {
1829                    if has_sign || has_exponent || !has_e {
1830                        return None;
1831                    }
1832                    has_sign = true;
1833                    if bytes[read] == b'-' {
1834                        bytes[write] = bytes[read];
1835                    } else {
1836                        // Omit '+'
1837                        read += 1;
1838                        continue;
1839                    }
1840                }
1841                _ => break,
1842            }
1843            read += 1;
1844            write += 1;
1845        }
1846
1847        if has_e && !has_exponent {
1848            return None;
1849        }
1850
1851        let mut digits = String::from_utf8(bytes).unwrap();
1852        let suffix = digits.split_off(read);
1853        digits.truncate(write);
1854        if suffix.is_empty() || crate::ident::xid_ok(&suffix) {
1855            Some((digits.into_boxed_str(), suffix.into_boxed_str()))
1856        } else {
1857            None
1858        }
1859    }
1860}
syn/lit.rs

syn/
lit.rs
