Set up LexError to support tracking a Span

Author: dtolnay

src/fallback.rs

@@ -35,7 +35,15 @@ pub(crate) struct TokenStream {
 }
 
 #[derive(Debug)]
-pub(crate) struct LexError;
+pub(crate) struct LexError {}
+
+impl LexError {
+    // Codepaths that will need a meaningful span attached as part of
+    // https://github.com/alexcrichton/proc-macro2/issues/178
+    pub(crate) fn todo() -> Self {
+        LexError {}
+    }
+}
 
 impl TokenStream {
     pub fn new() -> TokenStream {

src/parse.rs

@@ -168,7 +168,7 @@ pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
         let first = match input.bytes().next() {
             Some(first) => first,
             None if stack.is_empty() => return Ok(TokenStream { inner: trees }),
-            None => return Err(LexError),
+            None => return Err(LexError::todo()),
         };
 
         if let Some(open_delimiter) = match first {
@@ -190,12 +190,12 @@ pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
             _ => None,
         } {
             input = input.advance(1);
-            let frame = stack.pop().ok_or(LexError)?;
+            let frame = stack.pop().ok_or_else(LexError::todo)?;
             #[cfg(span_locations)]
             let (lo, frame) = frame;
             let (open_delimiter, outer) = frame;
             if open_delimiter != close_delimiter {
-                return Err(LexError);
+                return Err(LexError::todo());
             }
             let mut g = Group::new(open_delimiter, TokenStream { inner: trees });
             g.set_span(Span {
@@ -209,7 +209,7 @@ pub(crate) fn token_stream(mut input: Cursor) -> Result<TokenStream, LexError> {
         } else {
             let (rest, mut tt) = match leaf_token(input) {
                 Ok((rest, tt)) => (rest, tt),
-                Err(Reject) => return Err(LexError),
+                Err(Reject) => return Err(LexError::todo()),
             };
             tt.set_span(crate::Span::_new_stable(Span {
                 #[cfg(span_locations)]

src/wrapper.rs

@@ -107,8 +107,8 @@ impl FromStr for TokenStream {
 
 // Work around https://github.com/rust-lang/rust/issues/58736.
 fn proc_macro_parse(src: &str) -> Result<proc_macro::TokenStream, LexError> {
-    panic::catch_unwind(|| src.parse().map_err(LexError::Compiler))
-        .unwrap_or(Err(LexError::Fallback(fallback::LexError)))
+    let result = panic::catch_unwind(|| src.parse().map_err(LexError::Compiler));
+    result.unwrap_or_else(|_| Err(LexError::Fallback(fallback::LexError::todo())))
 }
 
 impl Display for TokenStream {
@@ -270,7 +270,7 @@ impl Display for LexError {
             #[cfg(lexerror_display)]
             LexError::Compiler(e) => Display::fmt(e, f),
             #[cfg(not(lexerror_display))]
-            LexError::Compiler(_e) => Display::fmt(&fallback::LexError, f),
+            LexError::Compiler(_e) => Display::fmt(&fallback::LexError::todo(), f),
             LexError::Fallback(e) => Display::fmt(e, f),
         }
     }