Merge pull request dtolnay#683 from dtolnay/lit

Switch to base10_digits() as the main numeric literal accessor

codegen/src/debug.rs

@@ -251,8 +251,14 @@ fn expand_impl_body(defs: &Definitions, node: &Node, name: &str) -> TokenStream
             }
         }
         Data::Private => {
-            quote! {
-                write!(formatter, "{:?}", _val.value())
+            if node.ident == "LitInt" || node.ident == "LitFloat" {
+                quote! {
+                    write!(formatter, "{}", _val)
+                }
+            } else {
+                quote! {
+                    write!(formatter, "{:?}", _val.value())
+                }
             }
         }
     }

src/bigint.rs

@@ -0,0 +1,69 @@
+use std::ops::{AddAssign, MulAssign};
+
+// For implementing base10_digits() accessor on LitInt.
+pub struct BigInt {
+    digits: Vec<u8>,
+}
+
+impl BigInt {
+    pub fn new() -> Self {
+        BigInt {
+            digits: Vec::new(),
+        }
+    }
+
+    pub fn to_string(&self) -> String {
+        let mut repr = String::with_capacity(self.digits.len());
+
+        let mut has_nonzero = false;
+        for digit in self.digits.iter().rev() {
+            has_nonzero |= *digit != 0;
+            if has_nonzero {
+                repr.push((*digit + b'0') as char);
+            }
+        }
+
+        if repr.is_empty() {
+            repr.push('0');
+        }
+
+        repr
+    }
+
+    fn reserve_two_digits(&mut self) {
+        let len = self.digits.len();
+        let desired = len
+            + !self.digits.ends_with(&[0, 0]) as usize
+            + !self.digits.ends_with(&[0]) as usize;
+        self.digits.resize(desired, 0);
+    }
+}
+
+impl AddAssign<u8> for BigInt {
+    // Assumes increment <16.
+    fn add_assign(&mut self, mut increment: u8) {
+        self.reserve_two_digits();
+
+        let mut i = 0;
+        while increment > 0 {
+            let sum = self.digits[i] + increment;
+            self.digits[i] = sum % 10;
+            increment = sum / 10;
+            i += 1;
+        }
+    }
+}
+
+impl MulAssign<u8> for BigInt {
+    // Assumes base <=16.
+    fn mul_assign(&mut self, base: u8) {
+        self.reserve_two_digits();
+
+        let mut carry = 0;
+        for digit in &mut self.digits {
+            let prod = *digit * base + carry;
+            *digit = prod % 10;
+            carry = prod / 10;
+        }
+    }
+}

src/expr.rs

@@ -2968,9 +2968,12 @@ pub mod parsing {
     impl Parse for Index {
         fn parse(input: ParseStream) -> Result<Self> {
             let lit: LitInt = input.parse()?;
-            if let IntSuffix::None = lit.suffix() {
+            if lit.suffix().is_empty() {
                 Ok(Index {
-                    index: lit.value() as u32,
+                    index: lit
+                        .base10_digits()
+                        .parse()
+                        .map_err(|err| Error::new(lit.span(), err))?,
                     span: lit.span(),
                 })
             } else {

src/ident.rs

@@ -6,6 +6,7 @@ use crate::lookahead;
 use crate::parse::{Parse, ParseStream, Result};
 #[cfg(feature = "parsing")]
 use crate::token::Token;
+use unicode_xid::UnicodeXID;
 
 pub use proc_macro2::Ident;
 
@@ -84,3 +85,17 @@ impl From<Token![_]> for Ident {
         Ident::new("_", token.span)
     }
 }
+
+pub fn xid_ok(symbol: &str) -> bool {
+    let mut chars = symbol.chars();
+    let first = chars.next().unwrap();
+    if !(UnicodeXID::is_xid_start(first) || first == '_') {
+        return false;
+    }
+    for ch in chars {
+        if !UnicodeXID::is_xid_continue(ch) {
+            return false;
+        }
+    }
+    true
+}

src/lib.rs

@@ -309,6 +309,9 @@ pub use crate::attr::{
     AttrStyle, Attribute, AttributeArgs, Meta, MetaList, MetaNameValue, NestedMeta,
 };
 
+#[cfg(any(feature = "full", feature = "derive"))]
+mod bigint;
+
 #[cfg(any(feature = "full", feature = "derive"))]
 mod data;
 #[cfg(any(feature = "full", feature = "derive"))]
@@ -372,8 +375,7 @@ pub use crate::lifetime::Lifetime;
 mod lit;
 #[cfg(any(feature = "full", feature = "derive"))]
 pub use crate::lit::{
-    FloatSuffix, IntSuffix, Lit, LitBool, LitByte, LitByteStr, LitChar, LitFloat, LitInt, LitStr,
-    StrStyle,
+    Lit, LitBool, LitByte, LitByteStr, LitChar, LitFloat, LitInt, LitStr, StrStyle,
 };
 
 #[cfg(any(feature = "full", feature = "derive"))]

src/lifetime.rs

@@ -3,7 +3,6 @@ use std::fmt::{self, Display};
 use std::hash::{Hash, Hasher};
 
 use proc_macro2::{Ident, Span};
-use unicode_xid::UnicodeXID;
 
 #[cfg(feature = "parsing")]
 use crate::lookahead;
@@ -55,21 +54,7 @@ impl Lifetime {
             panic!("lifetime name must not be empty");
         }
 
-        fn xid_ok(symbol: &str) -> bool {
-            let mut chars = symbol.chars();
-            let first = chars.next().unwrap();
-            if !(UnicodeXID::is_xid_start(first) || first == '_') {
-                return false;
-            }
-            for ch in chars {
-                if !UnicodeXID::is_xid_continue(ch) {
-                    return false;
-                }
-            }
-            true
-        }
-
-        if !xid_ok(&symbol[1..]) {
+        if !crate::ident::xid_ok(&symbol[1..]) {
             panic!("{:?} is not a valid lifetime name", symbol);
         }