cleanup: Refactor parser method `finish_parsing_statement` -> `parse_full_stmt`.

diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 7b09a44b814ffd5244d6f0361d18829eea679be4..50ac99efc0089dfee88191ef6612448a30bdacca 100644 (file)
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -118,18 +118,12 @@ fn make_trait_items(self: Box<ParserAnyMacro<'a>>)
 
     fn make_stmts(self: Box<ParserAnyMacro<'a>>)
                  -> Option<SmallVector<ast::Stmt>> {
-        let parse_stmt = |parser: &mut Parser<'a>| -> ::parse::PResult<'a, _> {
-            Ok(match parser.parse_stmt()? {
-                Some(stmt) => Some(parser.finish_parsing_statement(stmt)?),
-                None => None,
-            })
-        };
         let mut ret = SmallVector::zero();
         loop {
             let mut parser = self.parser.borrow_mut();
             match parser.token {
                 token::Eof => break,
-                _ => match parse_stmt(&mut parser) {
+                _ => match parser.parse_full_stmt() {
                     Ok(maybe_stmt) => match maybe_stmt {
                         Some(stmt) => ret.push(stmt),
                         None => (),

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 454320337edcb97801805255ad7f4709895db329..5617d223e8c461aa950bd8cc209bc87b72cc944a 100644 (file)
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -4044,8 +4044,8 @@ fn parse_block_tail(&mut self, lo: BytePos, s: BlockCheckMode) -> PResult<'a, P<
         let mut stmts = vec![];
 
         while !self.eat(&token::CloseDelim(token::Brace)) {
-            if let Some(stmt) = self.parse_stmt_() {
-                stmts.push(self.finish_parsing_statement(stmt)?);
+            if let Some(stmt) = self.parse_full_stmt()? {
+                stmts.push(stmt);
             } else if self.token == token::Eof {
                 break;
             } else {
@@ -4062,9 +4062,14 @@ fn parse_block_tail(&mut self, lo: BytePos, s: BlockCheckMode) -> PResult<'a, P<
         }))
     }
 
-    /// Finish parsing expressions that start with macros and handle trailing semicolons
-    /// (or the lack thereof) -- c.f. `parse_stmt`.
-    pub fn finish_parsing_statement(&mut self, mut stmt: Stmt) -> PResult<'a, Stmt> {
+    /// Parse a statement, including the trailing semicolon.
+    /// This parses expression statements that begin with macros correctly (c.f. `parse_stmt`).
+    pub fn parse_full_stmt(&mut self) -> PResult<'a, Option<Stmt>> {
+        let mut stmt = match self.parse_stmt_() {
+            Some(stmt) => stmt,
+            None => return Ok(None),
+        };
+
         if let StmtKind::Mac(mac) = stmt.node {
             if mac.1 != MacStmtStyle::NoBraces ||
                self.token == token::Semi || self.token == token::Eof {
@@ -4078,7 +4083,8 @@ pub fn finish_parsing_statement(&mut self, mut stmt: Stmt) -> PResult<'a, Stmt>
             }
         }
 
-        self.handle_trailing_semicolon(stmt)
+        stmt = self.handle_trailing_semicolon(stmt)?;
+        Ok(Some(stmt))
     }
 
     fn handle_trailing_semicolon(&mut self, mut stmt: Stmt) -> PResult<'a, Stmt> {