/// just into the compiler's internal macro table, for `make_def`).
pub trait MacResult {
/// Define a new macro.
+ // this should go away; the idea that a macro might expand into
+ // either a macro definition or an expression, depending on what
+ // the context wants, is kind of silly.
fn make_def(&self) -> Option<MacroDef> {
None
}
fn make_items(&self) -> Option<SmallVector<Gc<ast::Item>>> {
None
}
+
+ /// Create zero or more methods.
+ fn make_methods(&self) -> Option<SmallVector<Gc<ast::Method>>> {
+ None
+ }
+
/// Create a pattern.
fn make_pat(&self) -> Option<Gc<ast::Pat>> {
None
span: sp,
}
}
+
}
impl MacResult for DummyResult {
Some(DummyResult::raw_pat(self.span))
}
fn make_items(&self) -> Option<SmallVector<Gc<ast::Item>>> {
+ // this code needs a comment... why not always just return the Some() ?
+ if self.expr_only {
+ None
+ } else {
+ Some(SmallVector::zero())
+ }
+ }
+ fn make_methods(&self) -> Option<SmallVector<Gc<ast::Method>>> {
if self.expr_only {
None
} else {
impl<'a> ParserAnyMacro<'a> {
/// Make sure we don't have any tokens left to parse, so we don't
/// silently drop anything. `allow_semi` is so that "optional"
- /// semilons at the end of normal expressions aren't complained
+ /// semicolons at the end of normal expressions aren't complained
/// about e.g. the semicolon in `macro_rules! kapow( () => {
/// fail!(); } )` doesn't get picked up by .parse_expr(), but it's
/// allowed to be there.
let mut ret = SmallVector::zero();
loop {
let mut parser = self.parser.borrow_mut();
+ // so... do outer attributes attached to the macro invocation
+ // just disappear? This question applies to make_methods, as
+ // well.
match parser.parse_item_with_outer_attributes() {
Some(item) => ret.push(item),
None => break
self.ensure_complete_parse(false);
Some(ret)
}
+
+ fn make_methods(&self) -> Option<SmallVector<Gc<ast::Method>>> {
+ let mut ret = SmallVector::zero();
+ loop {
+ let mut parser = self.parser.borrow_mut();
+ match parser.token {
+ EOF => break,
+ _ => ret.push(parser.parse_method(None))
+ }
+ }
+ self.ensure_complete_parse(false);
+ Some(ret)
+ }
+
fn make_stmt(&self) -> Option<Gc<ast::Stmt>> {
let attrs = self.parser.borrow_mut().parse_outer_attributes();
let ret = self.parser.borrow_mut().parse_stmt(attrs);