Split parse_items from parse_mod for proc_macro.

Author: m-ou-se

compiler/rustc_expand/src/proc_macro.rs

@@ -8,7 +8,6 @@ use rustc_ast::tokenstream::{CanSynthesizeMissingTokens, TokenStream, TokenTree}
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::ErrorReported;
 use rustc_parse::nt_to_tokenstream;
-use rustc_parse::parser::ForceCollect;
 use rustc_span::{Span, DUMMY_SP};
 
 const EXEC_STRATEGY: pm::bridge::server::SameThread = pm::bridge::server::SameThread;
@@ -114,37 +113,22 @@ impl MultiItemModifier for ProcMacroDerive {
         let error_count_before = ecx.sess.parse_sess.span_diagnostic.err_count();
         let mut parser =
             rustc_parse::stream_to_parser(&ecx.sess.parse_sess, stream, Some("proc-macro derive"));
-        let mut items = vec![];
 
-        loop {
-            match parser.parse_item(ForceCollect::No) {
-                Ok(None) => break,
-                Ok(Some(item)) => {
-                    if is_stmt {
-                        items.push(Annotatable::Stmt(P(ecx.stmt_item(span, item))));
-                    } else {
-                        items.push(Annotatable::Item(item));
-                    }
-                }
-                Err(mut err) => {
-                    err.emit();
-                    break;
+        let items = parser
+            .parse_items(&token::Eof)
+            .unwrap_or_else(|mut e| {
+                e.emit();
+                Vec::new()
+            })
+            .into_iter()
+            .map(|item| {
+                if is_stmt {
+                    Annotatable::Stmt(P(ecx.stmt_item(span, item)))
+                } else {
+                    Annotatable::Item(item)
                 }
-            }
-        }
-
-        // check if the entire stream was parsed
-        if parser.token != token::Eof {
-            ecx.struct_span_err(
-                parser.token.span,
-                &format!(
-                    "expected item, found {}",
-                    rustc_parse::parser::token_descr(&parser.token)
-                ),
-            )
-            .span_label(parser.token.span, "expected item")
-            .emit();
-        }
+            })
+            .collect();
 
         // fail if there have been errors emitted
         if ecx.sess.parse_sess.span_diagnostic.err_count() > error_count_before {

compiler/rustc_parse/src/parser/item.rs

@@ -54,7 +54,11 @@ impl<'a> Parser<'a> {
     ) -> PResult<'a, (Vec<Attribute>, Vec<P<Item>>, Span)> {
         let lo = self.token.span;
         let attrs = self.parse_inner_attributes()?;
+        let items = self.parse_items(term)?;
+        Ok((attrs, items, lo.to(self.prev_token.span)))
+    }
 
+    pub fn parse_items(&mut self, term: &TokenKind) -> PResult<'a, Vec<P<Item>>> {
         let mut items = vec![];
         while let Some(item) = self.parse_item(ForceCollect::No)? {
             items.push(item);
@@ -71,7 +75,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        Ok((attrs, items, lo.to(self.prev_token.span)))
+        Ok(items)
     }
 }
 

compiler/rustc_parse/src/parser/mod.rs

@@ -394,7 +394,7 @@ fn token_descr_opt(token: &Token) -> Option<&'static str> {
     })
 }
 
-pub fn token_descr(token: &Token) -> String {
+pub(super) fn token_descr(token: &Token) -> String {
     let token_str = pprust::token_to_string(token);
     match token_descr_opt(token) {
         Some(prefix) => format!("{} `{}`", prefix, token_str),