Change:
afaik, it's because the context where you're using the macro (expr, item, etc.) stopped parsing before that token. We should mention that context.
Is this fixed? I think this was fixed the referenced pull request.
I'd prefer a message like

Discussion:
/// about e.g. the semicolon in `macro_rules! kapow { () => { /// panic!(); } }` doesn't get picked up by .parse_expr(), but it's /// allowed to be there. <del> fn ensure_complete_parse(&self, allow_semi: bool) { </del> <ins> fn ensure_complete_parse(&self, allow_semi: bool, context: &str) { </ins> let mut parser = self.parser.borrow_mut(); if allow_semi && parser.token == token::Semi { panictry!(parser.bump())

parser.span_err(span, &msg[..]); let msg = format!("caused by the macro expansion here; the usage  <del> of `{}` is likely invalid in this context", self.macro_ident); </del> <ins> of `{}!` is likely invalid in {} context", self.macro_ident, context); </ins> parser.span_note(self.site_span, &msg[..]); } }

impl<'a> MacResult for ParserAnyMacro<'a> { fn make_expr(self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Expr>> { let ret = panictry!(self.parser.borrow_mut().parse_expr()); <del> self.ensure_complete_parse(true); </del> <ins> self.ensure_complete_parse(true, "expression"); </ins> Some(ret) } fn make_pat(self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Pat>> { let ret = panictry!(self.parser.borrow_mut().parse_pat()); <del> self.ensure_complete_parse(false); </del> <ins> self.ensure_complete_parse(false, "pattern"); </ins> Some(ret) } fn make_items(self: Box<ParserAnyMacro<'a>>) -> Option<SmallVector<P<ast::Item>>> {

while let Some(item) = panictry!(self.parser.borrow_mut().parse_item()) { ret.push(item); } <del> self.ensure_complete_parse(false); </del> <ins> self.ensure_complete_parse(false, "item"); </ins> Some(ret) }

_ => ret.push(panictry!(parser.parse_impl_item())) } } <del> self.ensure_complete_parse(false); </del> <ins> self.ensure_complete_parse(false, "item"); </ins> Some(ret) }

} } } <del> self.ensure_complete_parse(false); </del> <ins> self.ensure_complete_parse(false, "statement"); </ins> Some(ret) } fn make_ty(self: Box<ParserAnyMacro<'a>>) -> Option<P<ast::Ty>> { let ret = panictry!(self.parser.borrow_mut().parse_ty()); <del> self.ensure_complete_parse(true); </del> <ins> self.ensure_complete_parse(false, "type"); </ins> Some(ret) } }

tt @ &TokenTree::Sequence(..) => { check_matcher(cx, Some(tt).into_iter(), &Eof); }, <del> _ => cx.span_err(sp, "Invalid macro matcher; matchers must be contained  </del> <ins> _ => cx.span_err(sp, "invalid macro matcher; matchers must be contained  </ins> in balanced delimiters or a repetition indicator") }; // we don't abort on errors on rejection, the driver will do that for us

// except according to those terms. macro_rules! invalid { <del> _ => (); //~^ ERROR Invalid macro matcher </del> <ins> _ => (); //~^ ERROR invalid macro matcher </ins> } fn main() {

<ins> // 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 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(type_macros)] macro_rules! t { () => ( String ; );     //~ ERROR macro expansion ignores token `;` } fn main() { let i: Vec<t!()>;       //~ NOTE caused by the macro expansion here } </ins>

<ins> // 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 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![feature(type_macros)] // (typeof used because it's surprisingly hard to find an unparsed token after a stmt) macro_rules! m { () => ( i ; typeof );   //~ ERROR `typeof` is a reserved keyword //~| ERROR macro expansion ignores token `typeof` //~| ERROR macro expansion ignores token `typeof` //~| ERROR macro expansion ignores token `;` //~| ERROR macro expansion ignores token `;` //~| ERROR macro expansion ignores token `i` } m!();               //~ NOTE the usage of `m!` is likely invalid in item context fn main() { let a: m!();    //~ NOTE the usage of `m!` is likely invalid in type context let i = m!();   //~ NOTE the usage of `m!` is likely invalid in expression context match 0 { m!() => {}  //~ NOTE the usage of `m!` is likely invalid in pattern context } m!();           //~ NOTE the usage of `m!` is likely invalid in statement context } </ins>