lit.rs

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