diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 80ee92608a5..346fb3580e1 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -208,10 +208,11 @@ impl IdentMacroExpander for F } // Use a macro because forwarding to a simple function has type system issues -macro_rules! make_stmt_default { +macro_rules! make_stmts_default { ($me:expr) => { $me.make_expr().map(|e| { - P(codemap::respan(e.span, ast::StmtExpr(e, ast::DUMMY_NODE_ID))) + SmallVector::one(P(codemap::respan( + e.span, ast::StmtExpr(e, ast::DUMMY_NODE_ID)))) }) } } @@ -238,12 +239,12 @@ pub trait MacResult { None } - /// Create a statement. + /// Create zero or more statements. /// /// By default this attempts to create an expression statement, /// returning None if that fails. - fn make_stmt(self: Box) -> Option> { - make_stmt_default!(self) + fn make_stmts(self: Box) -> Option>> { + make_stmts_default!(self) } } @@ -276,7 +277,7 @@ make_MacEager! { pat: P, items: SmallVector>, impl_items: SmallVector>, - stmt: P, + stmts: SmallVector>, } impl MacResult for MacEager { @@ -292,10 +293,10 @@ impl MacResult for MacEager { self.impl_items } - fn make_stmt(self: Box) -> Option> { - match self.stmt { - None => make_stmt_default!(self), - s => s, + fn make_stmts(self: Box) -> Option>> { + match self.stmts.as_ref().map_or(0, |s| s.len()) { + 0 => make_stmts_default!(self), + _ => self.stmts, } } @@ -384,10 +385,11 @@ impl MacResult for DummyResult { Some(SmallVector::zero()) } } - fn make_stmt(self: Box) -> Option> { - Some(P(codemap::respan(self.span, - ast::StmtExpr(DummyResult::raw_expr(self.span), - ast::DUMMY_NODE_ID)))) + fn make_stmts(self: Box) -> Option>> { + Some(SmallVector::one(P( + codemap::respan(self.span, + ast::StmtExpr(DummyResult::raw_expr(self.span), + ast::DUMMY_NODE_ID))))) } } diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index dd0c7d716b7..5f4ec01791c 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -720,37 +720,49 @@ pub fn expand_item_mac(it: P, } /// Expand a stmt -fn expand_stmt(s: Stmt, fld: &mut MacroExpander) -> SmallVector> { - let (mac, style) = match s.node { +fn expand_stmt(stmt: P, fld: &mut MacroExpander) -> SmallVector> { + let stmt = stmt.and_then(|stmt| stmt); + let (mac, style) = match stmt.node { StmtMac(mac, style) => (mac, style), - _ => return expand_non_macro_stmt(s, fld) + _ => return expand_non_macro_stmt(stmt, fld) }; - let expanded_stmt = match expand_mac_invoc(mac.and_then(|m| m), s.span, - |r| r.make_stmt(), - mark_stmt, fld) { - Some(stmt) => stmt, - None => { - return SmallVector::zero(); + + let maybe_new_items = + expand_mac_invoc(mac.and_then(|m| m), stmt.span, + |r| r.make_stmts(), + |stmts, mark| stmts.move_map(|m| mark_stmt(m, mark)), + fld); + + let mut fully_expanded = match maybe_new_items { + Some(stmts) => { + // Keep going, outside-in. + let new_items = stmts.into_iter().flat_map(|s| { + fld.fold_stmt(s).into_iter() + }).collect(); + fld.cx.bt_pop(); + new_items } + None => SmallVector::zero() }; - // Keep going, outside-in. - let fully_expanded = fld.fold_stmt(expanded_stmt); - fld.cx.bt_pop(); - + // If this is a macro invocation with a semicolon, then apply that + // semicolon to the final statement produced by expansion. if style == MacStmtWithSemicolon { - fully_expanded.into_iter().map(|s| s.map(|Spanned {node, span}| { - Spanned { - node: match node { - StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id), - _ => node /* might already have a semi */ - }, - span: span - } - })).collect() - } else { - fully_expanded + if let Some(stmt) = fully_expanded.pop() { + let new_stmt = stmt.map(|Spanned {node, span}| { + Spanned { + node: match node { + StmtExpr(e, stmt_id) => StmtSemi(e, stmt_id), + _ => node /* might already have a semi */ + }, + span: span + } + }); + fully_expanded.push(new_stmt); + } } + + fully_expanded } // expand a non-macro stmt. this is essentially the fallthrough for @@ -1355,7 +1367,7 @@ impl<'a, 'b> Folder for MacroExpander<'a, 'b> { } fn fold_stmt(&mut self, stmt: P) -> SmallVector> { - stmt.and_then(|stmt| expand_stmt(stmt, self)) + expand_stmt(stmt, self) } fn fold_block(&mut self, block: P) -> P { @@ -1502,8 +1514,8 @@ fn mark_pat(pat: P, m: Mrk) -> P { } // apply a given mark to the given stmt. Used following the expansion of a macro. -fn mark_stmt(expr: P, m: Mrk) -> P { - Marker{mark:m}.fold_stmt(expr) +fn mark_stmt(stmt: P, m: Mrk) -> P { + Marker{mark:m}.fold_stmt(stmt) .expect_one("marking a stmt didn't return exactly one stmt") } diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs index 009075540fa..730da6cc594 100644 --- a/src/libsyntax/ext/tt/macro_rules.rs +++ b/src/libsyntax/ext/tt/macro_rules.rs @@ -99,10 +99,24 @@ impl<'a> MacResult for ParserAnyMacro<'a> { Some(ret) } - fn make_stmt(self: Box>) -> Option> { - let ret = self.parser.borrow_mut().parse_stmt(); - self.ensure_complete_parse(true); - ret + fn make_stmts(self: Box>) + -> Option>> { + let mut ret = SmallVector::zero(); + loop { + let mut parser = self.parser.borrow_mut(); + match parser.token { + token::Eof => break, + _ => match parser.parse_stmt_nopanic() { + Ok(maybe_stmt) => match maybe_stmt { + Some(stmt) => ret.push(stmt), + None => (), + }, + Err(_) => break, + } + } + } + self.ensure_complete_parse(false); + Some(ret) } } diff --git a/src/libsyntax/util/small_vector.rs b/src/libsyntax/util/small_vector.rs index 1649934f4b1..6b864d52947 100644 --- a/src/libsyntax/util/small_vector.rs +++ b/src/libsyntax/util/small_vector.rs @@ -69,6 +69,20 @@ impl SmallVector { } } + pub fn pop(&mut self) -> Option { + match self.repr { + Zero => None, + One(..) => { + let one = mem::replace(&mut self.repr, Zero); + match one { + One(v1) => Some(v1), + _ => unreachable!() + } + } + Many(ref mut vs) => vs.pop(), + } + } + pub fn push(&mut self, v: T) { match self.repr { Zero => self.repr = One(v), diff --git a/src/test/compile-fail/macro-incomplete-parse.rs b/src/test/compile-fail/macro-incomplete-parse.rs index b3ce84c7e6f..32770d90189 100644 --- a/src/test/compile-fail/macro-incomplete-parse.rs +++ b/src/test/compile-fail/macro-incomplete-parse.rs @@ -17,7 +17,8 @@ macro_rules! ignored_item { } macro_rules! ignored_expr { - () => ( 1, 2 ) //~ ERROR macro expansion ignores token `,` + () => ( 1, //~ ERROR unexpected token: `,` + 2 ) //~ ERROR macro expansion ignores token `2` } macro_rules! ignored_pat { diff --git a/src/test/run-pass/macro-nested_stmt_macros.rs b/src/test/run-pass/macro-nested_stmt_macros.rs new file mode 100644 index 00000000000..5997a4f18e7 --- /dev/null +++ b/src/test/run-pass/macro-nested_stmt_macros.rs @@ -0,0 +1,32 @@ +// Copyright 2015 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. + +macro_rules! foo { + () => { + struct Bar; + struct Baz; + } +} + +macro_rules! grault { + () => { + foo!(); + struct Xyzzy; + } +} + +fn static_assert_exists() { } + +fn main() { + grault!(); + static_assert_exists::(); + static_assert_exists::(); + static_assert_exists::(); +} diff --git a/src/test/run-pass/macro-stmt_macro_in_expr_macro.rs b/src/test/run-pass/macro-stmt_macro_in_expr_macro.rs new file mode 100644 index 00000000000..c5badd78a63 --- /dev/null +++ b/src/test/run-pass/macro-stmt_macro_in_expr_macro.rs @@ -0,0 +1,29 @@ +// Copyright 2015 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. + +macro_rules! foo { + () => { + struct Bar; + struct Baz; + } +} + +macro_rules! grault { + () => {{ + foo!(); + struct Xyzzy; + 0 + }} +} + +fn main() { + let x = grault!(); + assert_eq!(x, 0); +}