From 6189e6cdba6d12ab65baafd95c5f8a6e0cc37937 Mon Sep 17 00:00:00 2001 From: Jeffrey Seyfried Date: Sat, 2 Jul 2016 09:01:21 +0000 Subject: Clean up statement parsing without changing the semantics of `parse_stmt`. --- src/libsyntax/ext/expand.rs | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) (limited to 'src/libsyntax/ext') diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index b2b63d0dbb4..220e0a753c3 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -444,14 +444,7 @@ fn expand_stmt(stmt: Stmt, fld: &mut MacroExpander) -> SmallVector { // semicolon to the final statement produced by expansion. if style == MacStmtStyle::Semicolon { if let Some(stmt) = fully_expanded.pop() { - fully_expanded.push(Stmt { - id: stmt.id, - node: match stmt.node { - StmtKind::Expr(expr) => StmtKind::Semi(expr), - _ => stmt.node /* might already have a semi */ - }, - span: stmt.span, - }); + fully_expanded.push(stmt.add_trailing_semicolon()); } } -- cgit 1.4.1-3-g733a5 From 57c56dd7e04bcd25ed578f27e65ec2379299f44b Mon Sep 17 00:00:00 2001 From: Jeffrey Seyfried Date: Sat, 2 Jul 2016 09:32:23 +0000 Subject: Parse macro-expanded statements like ordinary statements. --- src/libsyntax/ext/tt/macro_rules.rs | 8 +++++++- src/libsyntax/parse/parser.rs | 4 ++-- 2 files changed, 9 insertions(+), 3 deletions(-) (limited to 'src/libsyntax/ext') diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 84572b84963..7b09a44b814 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -118,12 +118,18 @@ impl<'a> MacResult for ParserAnyMacro<'a> { fn make_stmts(self: Box>) -> Option> { + 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 parser.parse_stmt() { + _ => match parse_stmt(&mut parser) { 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 0dd8c199827..b2cbe252344 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -4064,7 +4064,7 @@ impl<'a> Parser<'a> { /// Finish parsing expressions that start with macros and handle trailing semicolons /// (or the lack thereof) -- c.f. `parse_stmt`. - fn finish_parsing_statement(&mut self, mut stmt: Stmt) -> PResult<'a, Stmt> { + pub fn finish_parsing_statement(&mut self, mut stmt: Stmt) -> PResult<'a, Stmt> { if let StmtKind::Mac(mac) = stmt.node { if mac.1 != MacStmtStyle::NoBraces || self.token == token::Semi { stmt.node = StmtKind::Mac(mac); @@ -4082,7 +4082,7 @@ impl<'a> Parser<'a> { fn handle_trailing_semicolon(&mut self, mut stmt: Stmt) -> PResult<'a, Stmt> { match stmt.node { - StmtKind::Expr(ref expr) => { + StmtKind::Expr(ref expr) if self.token != token::Eof => { // expression without semicolon if classify::expr_requires_semi_to_be_stmt(expr) { // Just check for errors and recover; do not eat semicolon yet. -- cgit 1.4.1-3-g733a5 From c1b850d3041e5c36dc133c22b59319b179f5ddc6 Mon Sep 17 00:00:00 2001 From: Jeffrey Seyfried Date: Thu, 7 Jul 2016 04:12:20 +0000 Subject: cleanup: Refactor parser method `finish_parsing_statement` -> `parse_full_stmt`. --- src/libsyntax/ext/tt/macro_rules.rs | 8 +------- src/libsyntax/parse/parser.rs | 18 ++++++++++++------ 2 files changed, 13 insertions(+), 13 deletions(-) (limited to 'src/libsyntax/ext') diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 7b09a44b814..50ac99efc00 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -118,18 +118,12 @@ impl<'a> MacResult for ParserAnyMacro<'a> { fn make_stmts(self: Box>) -> Option> { - 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 454320337ed..5617d223e8c 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -4044,8 +4044,8 @@ impl<'a> Parser<'a> { 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 @@ impl<'a> Parser<'a> { })) } - /// 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> { + 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 @@ impl<'a> Parser<'a> { } } - 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> { -- cgit 1.4.1-3-g733a5 From 57fac56cb51d1a8ca0f6d76f869ccbb0a67b0f45 Mon Sep 17 00:00:00 2001 From: Jeffrey Seyfried Date: Tue, 12 Jul 2016 03:56:19 +0000 Subject: Start a best-effort warning cycle. --- src/libsyntax/ext/tt/macro_rules.rs | 2 +- src/libsyntax/parse/parser.rs | 41 +++++++++++++++++++--- src/test/compile-fail/missing-semicolon-warning.rs | 22 ++++++++++++ 3 files changed, 59 insertions(+), 6 deletions(-) create mode 100644 src/test/compile-fail/missing-semicolon-warning.rs (limited to 'src/libsyntax/ext') diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 50ac99efc00..db12ef24f71 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -123,7 +123,7 @@ impl<'a> MacResult for ParserAnyMacro<'a> { let mut parser = self.parser.borrow_mut(); match parser.token { token::Eof => break, - _ => match parser.parse_full_stmt() { + _ => match parser.parse_full_stmt(true) { 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 5617d223e8c..c6374e59c1b 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -4044,7 +4044,7 @@ impl<'a> Parser<'a> { let mut stmts = vec![]; while !self.eat(&token::CloseDelim(token::Brace)) { - if let Some(stmt) = self.parse_full_stmt()? { + if let Some(stmt) = self.parse_full_stmt(false)? { stmts.push(stmt); } else if self.token == token::Eof { break; @@ -4064,7 +4064,7 @@ impl<'a> Parser<'a> { /// 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> { + pub fn parse_full_stmt(&mut self, macro_expanded: bool) -> PResult<'a, Option> { let mut stmt = match self.parse_stmt_() { Some(stmt) => stmt, None => return Ok(None), @@ -4075,6 +4075,23 @@ impl<'a> Parser<'a> { self.token == token::Semi || self.token == token::Eof { stmt.node = StmtKind::Mac(mac); } else { + // We used to incorrectly stop parsing macro-expanded statements here. + // If the next token will be an error anyway but could have parsed with the + // earlier behavior, stop parsing here and emit a warning to avoid breakage. + if macro_expanded && self.token.can_begin_expr() && match self.token { + // These tokens can continue an expression, so we can't stop parsing and warn. + token::OpenDelim(token::Paren) | token::OpenDelim(token::Bracket) | + token::BinOp(token::Minus) | token::BinOp(token::Star) | + token::BinOp(token::And) | token::BinOp(token::Or) | + token::AndAnd | token::OrOr | + token::DotDot | token::DotDotDot => false, + _ => true, + } { + self.warn_missing_semicolon(); + stmt.node = StmtKind::Mac(mac); + return Ok(Some(stmt)); + } + let (mac, _style, attrs) = mac.unwrap(); let e = self.mk_mac_expr(stmt.span.lo, stmt.span.hi, mac.node, ThinVec::new()); let e = self.parse_dot_or_call_expr_with(e, stmt.span.lo, attrs)?; @@ -4083,11 +4100,12 @@ impl<'a> Parser<'a> { } } - stmt = self.handle_trailing_semicolon(stmt)?; + stmt = self.handle_trailing_semicolon(stmt, macro_expanded)?; Ok(Some(stmt)) } - fn handle_trailing_semicolon(&mut self, mut stmt: Stmt) -> PResult<'a, Stmt> { + fn handle_trailing_semicolon(&mut self, mut stmt: Stmt, macro_expanded: bool) + -> PResult<'a, Stmt> { match stmt.node { StmtKind::Expr(ref expr) if self.token != token::Eof => { // expression without semicolon @@ -4102,7 +4120,12 @@ impl<'a> Parser<'a> { } } StmtKind::Local(..) => { - self.expect_one_of(&[token::Semi], &[])?; + // We used to incorrectly allow a macro-expanded let statement to lack a semicolon. + if macro_expanded && self.token != token::Semi { + self.warn_missing_semicolon(); + } else { + self.expect_one_of(&[token::Semi], &[])?; + } } _ => {} } @@ -4115,6 +4138,14 @@ impl<'a> Parser<'a> { Ok(stmt) } + fn warn_missing_semicolon(&self) { + self.diagnostic().struct_span_warn(self.span, { + &format!("expected `;`, found `{}`", self.this_token_to_string()) + }).note({ + "This was erroneously allowed and will become a hard error in a future release" + }).emit(); + } + // Parses a sequence of bounds if a `:` is found, // otherwise returns empty list. fn parse_colon_then_ty_param_bounds(&mut self, diff --git a/src/test/compile-fail/missing-semicolon-warning.rs b/src/test/compile-fail/missing-semicolon-warning.rs new file mode 100644 index 00000000000..bbc958b87a5 --- /dev/null +++ b/src/test/compile-fail/missing-semicolon-warning.rs @@ -0,0 +1,22 @@ +// Copyright 2016 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(rustc_attrs)] +#![allow(unused)] + +macro_rules! m { + ($($e1:expr),*; $($e2:expr),*) => { + $( let x = $e1 )*; //~ WARN expected `;` + $( println!("{}", $e2) )*; //~ WARN expected `;` + } +} + +#[rustc_error] +fn main() { m!(0, 0; 0, 0); } //~ ERROR compilation successful -- cgit 1.4.1-3-g733a5