syntax: Accept meta matchers in macros

This removes the `attr` matcher and adds a `meta` matcher. The previous `attr`
matcher is now ambiguous because it doesn't disambiguate whether it means inner
attribute or outer attribute.

The new behavior can still be achieved by taking an argument of the form
`#[$foo:meta]` (the brackets are part of the macro pattern).

Closes #13067

Author: alexcrichton

src/libstd/comm/mod.rs

@@ -252,7 +252,7 @@ use sync::arc::UnsafeArc;
 pub use comm::select::{Select, Handle};
 
 macro_rules! test (
-    { fn $name:ident() $b:block $($a:attr)*} => (
+    { fn $name:ident() $b:block $(#[$a:meta])*} => (
         mod $name {
             #[allow(unused_imports)];
 
@@ -265,8 +265,8 @@ macro_rules! test (
 
             fn f() $b
 
-            $($a)* #[test] fn uv() { f() }
-            $($a)* #[test] fn native() {
+            $(#[$a])* #[test] fn uv() { f() }
+            $(#[$a])* #[test] fn native() {
                 use native;
                 let (tx, rx) = channel();
                 native::task::spawn(proc() { tx.send(f()) });

src/libstd/io/test.rs

@@ -19,7 +19,7 @@ use std::io::net::ip::*;
 use sync::atomics::{AtomicUint, INIT_ATOMIC_UINT, Relaxed};
 
 macro_rules! iotest (
-    { fn $name:ident() $b:block $($a:attr)* } => (
+    { fn $name:ident() $b:block $(#[$a:meta])* } => (
         mod $name {
             #[allow(unused_imports)];
 
@@ -43,8 +43,8 @@ macro_rules! iotest (
 
             fn f() $b
 
-            $($a)* #[test] fn green() { f() }
-            $($a)* #[test] fn native() {
+            $(#[$a])* #[test] fn green() { f() }
+            $(#[$a])* #[test] fn native() {
                 use native;
                 let (tx, rx) = channel();
                 native::task::spawn(proc() { tx.send(f()) });

src/libsyntax/ext/tt/macro_parser.rs

@@ -441,7 +441,7 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
       "path" => {
         token::NtPath(~p.parse_path(LifetimeAndTypesWithoutColons).path)
       }
-      "attr" => token::NtAttr(@p.parse_attribute(false)),
+      "meta" => token::NtMeta(p.parse_meta_item()),
       "tt" => {
         p.quote_depth += 1u; //but in theory, non-quoted tts might be useful
         let res = token::NtTT(@p.parse_token_tree());

src/libsyntax/parse/attr.rs

@@ -34,9 +34,6 @@ impl<'a> ParserAttr for Parser<'a> {
             debug!("parse_outer_attributes: self.token={:?}",
                    self.token);
             match self.token {
-              token::INTERPOLATED(token::NtAttr(..)) => {
-                attrs.push(self.parse_attribute(false));
-              }
               token::POUND => {
                 attrs.push(self.parse_attribute(false));
               }
@@ -66,11 +63,6 @@ impl<'a> ParserAttr for Parser<'a> {
         debug!("parse_attributes: permit_inner={:?} self.token={:?}",
                permit_inner, self.token);
         let (span, value, mut style) = match self.token {
-            INTERPOLATED(token::NtAttr(attr)) => {
-                assert!(attr.node.style == ast::AttrOuter);
-                self.bump();
-                (attr.span, attr.node.value, ast::AttrOuter)
-            }
             token::POUND => {
                 let lo = self.span.lo;
                 self.bump();
@@ -133,9 +125,6 @@ impl<'a> ParserAttr for Parser<'a> {
         let mut next_outer_attrs: Vec<ast::Attribute> = Vec::new();
         loop {
             let attr = match self.token {
-                token::INTERPOLATED(token::NtAttr(..)) => {
-                    self.parse_attribute(true)
-                }
                 token::POUND => {
                     self.parse_attribute(true)
                 }
@@ -163,6 +152,14 @@ impl<'a> ParserAttr for Parser<'a> {
     // | IDENT = lit
     // | IDENT meta_seq
     fn parse_meta_item(&mut self) -> @ast::MetaItem {
+        match self.token {
+            token::INTERPOLATED(token::NtMeta(e)) => {
+                self.bump();
+                return e
+            }
+            _ => {}
+        }
+
         let lo = self.span.lo;
         let ident = self.parse_ident();
         let name = self.id_to_interned_str(ident);

src/libsyntax/parse/token.rs

@@ -113,7 +113,7 @@ pub enum Nonterminal {
     NtExpr(@ast::Expr),
     NtTy(  P<ast::Ty>),
     NtIdent(~ast::Ident, bool),
-    NtAttr(@ast::Attribute), // #[foo]
+    NtMeta(@ast::MetaItem), // stuff inside brackets for attributes
     NtPath(~ast::Path),
     NtTT(  @ast::TokenTree), // needs @ed to break a circularity
     NtMatchers(Vec<ast::Matcher> )
@@ -129,7 +129,7 @@ impl fmt::Show for Nonterminal {
             NtExpr(..) => f.pad("NtExpr(..)"),
             NtTy(..) => f.pad("NtTy(..)"),
             NtIdent(..) => f.pad("NtIdent(..)"),
-            NtAttr(..) => f.pad("NtAttr(..)"),
+            NtMeta(..) => f.pad("NtMeta(..)"),
             NtPath(..) => f.pad("NtPath(..)"),
             NtTT(..) => f.pad("NtTT(..)"),
             NtMatchers(..) => f.pad("NtMatchers(..)"),
@@ -241,15 +241,15 @@ pub fn to_str(t: &Token) -> ~str {
       INTERPOLATED(ref nt) => {
         match nt {
             &NtExpr(e) => ::print::pprust::expr_to_str(e),
-            &NtAttr(e) => ::print::pprust::attribute_to_str(e),
+            &NtMeta(e) => ::print::pprust::meta_item_to_str(e),
             _ => {
                 ~"an interpolated " +
                     match *nt {
                         NtItem(..) => ~"item",
                         NtBlock(..) => ~"block",
                         NtStmt(..) => ~"statement",
                         NtPat(..) => ~"pattern",
-                        NtAttr(..) => fail!("should have been handled"),
+                        NtMeta(..) => fail!("should have been handled"),
                         NtExpr(..) => fail!("should have been handled above"),
                         NtTy(..) => ~"type",
                         NtIdent(..) => ~"identifier",

src/test/compile-fail/macro-inner-attributes.rs

@@ -11,8 +11,8 @@
 #[feature(macro_rules)];
 
 macro_rules! test ( ($nm:ident,
-                     $a:attr,
-                     $i:item) => (mod $nm { $a; $i }); )
+                     #[$a:meta],
+                     $i:item) => (mod $nm { #![$a] $i }); )
 
 test!(a,
       #[cfg(qux)],

src/test/compile-fail/macro-outer-attributes.rs

@@ -11,8 +11,8 @@
 #[feature(macro_rules)];
 
 macro_rules! test ( ($nm:ident,
-                     $a:attr,
-                     $i:item) => (mod $nm { $a $i }); )
+                     #[$a:meta],
+                     $i:item) => (mod $nm { #[$a] $i }); )
 
 test!(a,
       #[cfg(qux)],

src/test/run-pass/macro-attributes.rs

@@ -13,11 +13,11 @@
 #[feature(macro_rules)];
 
 macro_rules! compiles_fine {
-    ($at:attr) => {
+    (#[$at:meta]) => {
         // test that the different types of attributes work
         #[attribute]
         /// Documentation!
-        $at
+        #[$at]
 
         // check that the attributes are recognised by requiring this
         // to be removed to avoid a compile error

src/test/run-pass/macro-meta-items.rs

@@ -0,0 +1,43 @@
+// Copyright 2013-2014 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.
+
+// ignore-pretty - token trees can't pretty print
+// compile-flags: --cfg foo
+
+#[feature(macro_rules)];
+
+macro_rules! compiles_fine {
+    ($at:meta) => {
+        #[cfg($at)]
+        static MISTYPED: () = "foo";
+    }
+}
+macro_rules! emit {
+    ($at:meta) => {
+        #[cfg($at)]
+        static MISTYPED: &'static str = "foo";
+    }
+}
+
+// item
+compiles_fine!(bar)
+emit!(foo)
+
+fn foo() {
+    println!("{}", MISTYPED);
+}
+
+pub fn main() {
+    // statement
+    compiles_fine!(baz);
+    emit!(baz);
+    println!("{}", MISTYPED);
+}
+