Allow path as value in name-value attribute

Author: dtolnay

compiler/rustc_parse/src/parser/attr.rs

@@ -159,6 +159,7 @@ impl<'a> Parser<'a> {
     ///     PATH `{` TOKEN_STREAM `}`
     ///     PATH
     ///     PATH `=` UNSUFFIXED_LIT
+    ///     PATH `=` PATH
     /// The delimiters or `=` are still put into the resulting token stream.
     pub fn parse_attr_item(&mut self, capture_tokens: bool) -> PResult<'a, ast::AttrItem> {
         let item = match self.token.kind {
@@ -230,6 +231,11 @@ impl<'a> Parser<'a> {
 
     crate fn parse_unsuffixed_lit(&mut self) -> PResult<'a, ast::Lit> {
         let lit = self.parse_lit()?;
+        self.require_unsuffixed(&lit);
+        Ok(lit)
+    }
+
+    crate fn require_unsuffixed(&self, lit: &ast::Lit) {
         debug!("checking if {:?} is unusuffixed", lit);
 
         if !lit.kind.is_unsuffixed() {
@@ -240,8 +246,6 @@ impl<'a> Parser<'a> {
                 )
                 .emit();
         }
-
-        Ok(lit)
     }
 
     /// Parses `cfg_attr(pred, attr_item_list)` where `attr_item_list` is comma-delimited.

compiler/rustc_parse/src/parser/mod.rs

@@ -934,16 +934,22 @@ impl<'a> Parser<'a> {
                             is_interpolated_expr = true;
                         }
                     }
-                    let token_tree = if is_interpolated_expr {
+                    let token_stream: TokenStream = if is_interpolated_expr {
                         // We need to accept arbitrary interpolated expressions to continue
                         // supporting things like `doc = $expr` that work on stable.
                         // Non-literal interpolated expressions are rejected after expansion.
-                        self.parse_token_tree()
+                        self.parse_token_tree().into()
+                    } else if let Some(lit) = self.parse_opt_lit() {
+                        self.require_unsuffixed(&lit);
+                        lit.token_tree().into()
+                    } else if self.check(&token::ModSep) || self.token.ident().is_some() {
+                        self.collect_tokens_only(|this| this.parse_path(PathStyle::Mod))?
                     } else {
-                        self.parse_unsuffixed_lit()?.token_tree()
+                        let msg = "expected a literal or ::-separated path";
+                        return Err(self.struct_span_err(self.token.span, msg));
                     };
 
-                    MacArgs::Eq(eq_span, token_tree.into())
+                    MacArgs::Eq(eq_span, token_stream)
                 } else {
                     MacArgs::Empty
                 }
@@ -1254,6 +1260,14 @@ impl<'a> Parser<'a> {
         Ok((ret, Some(LazyTokenStream::new(lazy_impl))))
     }
 
+    fn collect_tokens_only<R>(
+        &mut self,
+        f: impl FnOnce(&mut Self) -> PResult<'a, R>,
+    ) -> PResult<'a, TokenStream> {
+        let (_ignored, tokens) = self.collect_tokens(f)?;
+        Ok(tokens)
+    }
+
     /// `::{` or `::*`
     fn is_import_coupler(&mut self) -> bool {
         self.check(&token::ModSep)

src/test/ui/attr-eq-token-tree.rs

@@ -1,2 +1,2 @@
-#[my_attr = !] //~ ERROR unexpected token: `!`
+#[my_attr = !] //~ ERROR expected a literal or ::-separated path
 fn main() {}

src/test/ui/attr-eq-token-tree.stderr

@@ -1,4 +1,4 @@
-error: unexpected token: `!`
+error: expected a literal or ::-separated path
   --> $DIR/attr-eq-token-tree.rs:1:13
    |
 LL | #[my_attr = !]

src/test/ui/attributes/path-eq-path.rs

@@ -0,0 +1,11 @@
+#[cfg(any())]
+extern "C++" {
+    #[namespace = std::experimental]
+    type any;
+
+    #[rust = std::option::Option<T>]
+    //~^ ERROR expected one of `::` or `]`, found `<`
+    type optional;
+}
+
+fn main() {}

src/test/ui/attributes/path-eq-path.stderr

@@ -0,0 +1,14 @@
+error: expected one of `::` or `]`, found `<`
+  --> $DIR/path-eq-path.rs:6:33
+   |
+LL | extern "C++" {
+   |              - while parsing this item list starting here
+...
+LL |     #[rust = std::option::Option<T>]
+   |                                 ^ expected one of `::` or `]`
+...
+LL | }
+   | - the item list ends here
+
+error: aborting due to previous error
+

src/test/ui/macros/macro-attribute.rs

@@ -1,2 +1,2 @@
-#[doc = $not_there] //~ ERROR unexpected token: `$`
+#[doc = $not_there] //~ ERROR expected a literal or ::-separated path
 fn main() { }

src/test/ui/macros/macro-attribute.stderr

@@ -1,4 +1,4 @@
-error: unexpected token: `$`
+error: expected a literal or ::-separated path
   --> $DIR/macro-attribute.rs:1:9
    |
 LL | #[doc = $not_there]

src/test/ui/parser/attr-bad-meta-2.rs

@@ -1,2 +1,2 @@
-#[path =] //~ ERROR unexpected token: `]`
+#[path =] //~ ERROR expected a literal or ::-separated path
 mod m {}

src/test/ui/parser/attr-bad-meta-2.stderr

@@ -1,4 +1,4 @@
-error: unexpected token: `]`
+error: expected a literal or ::-separated path
   --> $DIR/attr-bad-meta-2.rs:1:9
    |
 LL | #[path =]