rustc: Tweak Literal APIs of proc_macro

This commit tweaks the public api of the `proc_macro::Literal` structure to
solve #48889, an issue about negative integers and their representation in
`proc_macro` tokens. Currently the compiler assumes that all integer tokens are
*positive* integers rather than embedding a negative sign. The negative sign is
a separate token from the integer itself.

Currently there's a function like:

    impl Literal {
        pub fn i32(i: i32) -> Literal;
    }

but unfortunately this doesn't work for negative integers. When called with
negative integers weird errors end up getting thrown later during the parsing
process.

This function tweaks the definitions to instead use:

    impl Literal {
        pub fn i32(i: u32) -> Literal;
    }

This construction makes it more clear that negative arguments are not supported.
This additionally allows literals like `-128i8` where `128`, the positive
integer part of this literal, isn't representable in `i8`. By taking an unsigned
number in each constructor we can allow constructing the minimum literal for
each signed type as well.

The final tweak of this commit is to panic in `Literal::{f32, f64}` if the input
number is negative. This is similar to how infinite/nan literals are handled
today (they panic) and constructing a literal should be possible by negating a
float and then separately passing in a literal.

Closes #48889

Author: alexcrichton

src/libproc_macro/lib.rs

@@ -471,24 +471,37 @@ impl fmt::Display for Literal {
 }
 
 macro_rules! int_literals {
-    ($($int_kind:ident),*) => {$(
+    ($($int_kind:ident => $signed:ident,)*) => {$(
         /// Integer literal.
         #[unstable(feature = "proc_macro", issue = "38356")]
-        pub fn $int_kind(n: $int_kind) -> Literal {
-            Literal::typed_integer(n as i128, stringify!($int_kind))
+        pub fn $int_kind(n: $signed) -> Literal {
+            Literal::typed_integer(n as u128, stringify!($int_kind))
+        }
+
+        /// Integer literal.
+        #[unstable(feature = "proc_macro", issue = "38356")]
+        pub fn $signed(n: $signed) -> Literal {
+            Literal::typed_integer(n as u128, stringify!($signed))
         }
     )*}
 }
 
 impl Literal {
     /// Integer literal
     #[unstable(feature = "proc_macro", issue = "38356")]
-    pub fn integer(n: i128) -> Literal {
+    pub fn integer(n: u128) -> Literal {
         Literal(token::Literal(token::Lit::Integer(Symbol::intern(&n.to_string())), None))
     }
 
-    int_literals!(u8, i8, u16, i16, u32, i32, u64, i64, usize, isize);
-    fn typed_integer(n: i128, kind: &'static str) -> Literal {
+    int_literals!(
+        i8 => u8,
+        i16 => u16,
+        i32 => u32,
+        i64 => u64,
+        isize => usize,
+    );
+
+    fn typed_integer(n: u128, kind: &'static str) -> Literal {
         Literal(token::Literal(token::Lit::Integer(Symbol::intern(&n.to_string())),
                                Some(Symbol::intern(kind))))
     }
@@ -499,6 +512,9 @@ impl Literal {
         if !n.is_finite() {
             panic!("Invalid float literal {}", n);
         }
+        if n.is_sign_negative() {
+            panic!("float literal cannot be negative {}", n);
+        }
         Literal(token::Literal(token::Lit::Float(Symbol::intern(&n.to_string())), None))
     }
 
@@ -508,6 +524,9 @@ impl Literal {
         if !n.is_finite() {
             panic!("Invalid f32 literal {}", n);
         }
+        if n.is_sign_negative() {
+            panic!("f32 literal cannot be negative {}", n);
+        }
         Literal(token::Literal(token::Lit::Float(Symbol::intern(&n.to_string())),
                                Some(Symbol::intern("f32"))))
     }
@@ -518,6 +537,9 @@ impl Literal {
         if !n.is_finite() {
             panic!("Invalid f64 literal {}", n);
         }
+        if n.is_sign_negative() {
+            panic!("f64 literal cannot be negative {}", n);
+        }
         Literal(token::Literal(token::Lit::Float(Symbol::intern(&n.to_string())),
                                Some(Symbol::intern("f64"))))
     }

src/libproc_macro/quote.rs

@@ -156,7 +156,7 @@ impl<'a> Quote for &'a str {
 
 impl Quote for usize {
     fn quote(self) -> TokenStream {
-        TokenNode::Literal(Literal::integer(self as i128)).into()
+        TokenNode::Literal(Literal::integer(self as u128)).into()
     }
 }