Merge pull request #478 from dtolnay/fromstr

Spell out types in FromStr conversions

Author: dtolnay

src/fallback.rs

@@ -226,19 +226,14 @@ impl Debug for TokenStream {
 #[cfg(feature = "proc-macro")]
 impl From<proc_macro::TokenStream> for TokenStream {
     fn from(inner: proc_macro::TokenStream) -> Self {
-        inner
-            .to_string()
-            .parse()
-            .expect("compiler token stream parse failed")
+        TokenStream::from_str(&inner.to_string()).expect("compiler token stream parse failed")
     }
 }
 
 #[cfg(feature = "proc-macro")]
 impl From<TokenStream> for proc_macro::TokenStream {
     fn from(inner: TokenStream) -> Self {
-        inner
-            .to_string()
-            .parse()
+        proc_macro::TokenStream::from_str(&inner.to_string())
             .expect("failed to parse to compiler tokens")
     }
 }

src/lib.rs

@@ -245,7 +245,7 @@ impl FromStr for TokenStream {
     type Err = LexError;
 
     fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        let e = src.parse().map_err(|e| LexError {
+        let e = imp::TokenStream::from_str(src).map_err(|e| LexError {
             inner: e,
             _marker: MARKER,
         })?;
@@ -1307,10 +1307,12 @@ impl FromStr for Literal {
     type Err = LexError;
 
     fn from_str(repr: &str) -> Result<Self, LexError> {
-        repr.parse().map(Literal::_new).map_err(|inner| LexError {
-            inner,
-            _marker: MARKER,
-        })
+        imp::Literal::from_str(repr)
+            .map(Literal::_new)
+            .map_err(|inner| LexError {
+                inner,
+                _marker: MARKER,
+            })
     }
 }
 

src/wrapper.rs

@@ -117,14 +117,15 @@ impl FromStr for TokenStream {
                 proc_macro_parse(src)?,
             )))
         } else {
-            Ok(TokenStream::Fallback(src.parse()?))
+            Ok(TokenStream::Fallback(fallback::TokenStream::from_str(src)?))
         }
     }
 }
 
 // Work around https://github.com/rust-lang/rust/issues/58736.
 fn proc_macro_parse(src: &str) -> Result<proc_macro::TokenStream, LexError> {
-    let result = panic::catch_unwind(|| src.parse().map_err(LexError::Compiler));
+    let result =
+        panic::catch_unwind(|| proc_macro::TokenStream::from_str(src).map_err(LexError::Compiler));
     result.unwrap_or_else(|_| Err(LexError::CompilerPanic))
 }
 
@@ -147,7 +148,9 @@ impl From<TokenStream> for proc_macro::TokenStream {
     fn from(inner: TokenStream) -> Self {
         match inner {
             TokenStream::Compiler(inner) => inner.into_token_stream(),
-            TokenStream::Fallback(inner) => inner.to_string().parse().unwrap(),
+            TokenStream::Fallback(inner) => {
+                proc_macro::TokenStream::from_str(&inner.to_string()).unwrap()
+            }
         }
     }
 }
@@ -897,7 +900,7 @@ impl Literal {
                 #[cfg(no_literal_byte_character)]
                 {
                     let fallback = fallback::Literal::byte_character(byte);
-                    fallback.repr.parse::<proc_macro::Literal>().unwrap()
+                    proc_macro::Literal::from_str(&fallback.repr).unwrap()
                 }
             })
         } else {
@@ -924,7 +927,7 @@ impl Literal {
                 #[cfg(no_literal_c_string)]
                 {
                     let fallback = fallback::Literal::c_string(string);
-                    fallback.repr.parse::<proc_macro::Literal>().unwrap()
+                    proc_macro::Literal::from_str(&fallback.repr).unwrap()
                 }
             })
         } else {