$( #[$attr:meta] )* $var:ident → error: local ambiguity: multiple parsing options

[andersk]

I’m writing a macro that parses enum declarations to work around #16920, and I’ve discovered that it can’t handle attributes on the enum variants like I thought it would. Specifically, the matcher $( #[$attr:meta] )* $var:ident fails to match #[doc = "Bar"] Baz, complaining “error: local ambiguity: multiple parsing options: built-in NTs ident ('var') or 1 other options.”

This doesn’t seem to make sense, since an ident cannot start with #.

Small test case:

#![crate_type = "lib"]

macro_rules! foo {
    (
        pub enum $name:ident {
            $( #[$attr:meta] )* $var:ident
        }
    ) => {
        pub enum $name {
            $( #[$attr] )* $var
        }
    };
}

foo! {
    pub enum Foo {
        #[doc = "Bar"] Baz
    }
}

$ rustc --version --verbose
rustc 1.0.0-beta (9854143cb 2015-04-02) (built 2015-04-02)
binary: rustc
commit-hash: 9854143cba679834bc4ef932858cd5303f015a0e
commit-date: 2015-04-02
build-date: 2015-04-02
host: x86_64-unknown-linux-gnu
release: 1.0.0-beta
$ rustc r.rs
r.rs:17:9: 17:10 error: local ambiguity: multiple parsing options: built-in NTs ident ('var') or 1 other options.
r.rs:17         #[doc = "Bar"] Baz
                ^

[orthecreedence]

@andersk Did you ever find a workaround for this? I'm trying to write a macro that parses structs and I'm running into this:

macro_rules! serializable {
    (
        $(#[$struct_meta:meta])*
        pub struct $name:ident {
            $(
                $(#[$field_meta:meta])*
                $field:ident: $type_:ty
            ),* ,
        }
    ) => {
        $(#[$struct_meta])*
        pub struct $name {
            $(
                $(#[$field_meta])*
               $field: $type_
            ),* ,
        }
    }
}

serializable! {
    #[allow(dead_code)]
    /// This is a test
    pub struct Tester {
        #[allow(dead_code)]
        name: String,
    }
}

Yields:

src\util\serialization.rs:180:13: 180:14 error: local ambiguity: multiple parsing options: built-in NTs ident ('field') or 1 other option.
src\util\serialization.rs:180             #[allow(dead_code)]
                                          ^

rustc 1.10.0 (cfcb716cf 2016-07-03)

[orthecreedence]

Actually, this issue looks like the exact same as #24827

[azriel91]

I managed to implement a workaround while writing a builder macro, which is to have two parts:

• keep matching on the front token as a meta token, save that into a separate place, and recursively call yourself, passing the rest of the tokens
• have another rule that matches on the final pattern that no longer has meta attributes

See code at test.rs (sorry for ugliness, this was a proof of concept which evolved a lot).

I'll convert that to a proper crate and document it this weekend.

Example output for FiveBuilder => Five

    #[doc =
          r" hello everyone"]
    struct Five {
        #[doc = r" doc for i32"]
        something: i32,
    }
    #[doc = "Generated struct builder"]
    struct FiveBuilder {
        #[doc = r" doc for i32"]
        something: Option<i32>,
    }
    impl FiveBuilder {
        /// Construct the builder
        pub fn new() -> FiveBuilder { FiveBuilder{something: Some(0),} }
        /// Build the struct
        pub fn build(self) -> Five {
            let something = self.something.unwrap();
            Five{something: something,}
        }
        #[allow(dead_code)]
        /// Specify a value for the $F_NAME field
        fn something(mut self, value: i32) -> Self {
            self.something = Some(value);
            self
        }
    }

[andersk]

@orthecreedence: #24827 has idents conflicting with other idents; those conflicts are “legitimate”, given Rust’s left-to-right parsing strategy. In contrast, this is about idents conflicting with tokens that cannot possibly be idents. Simpler example, showing that rustc can’t determine that (e.g.) > is not an ident:

macro_rules! foo {
    ( $( > )* $x:ident ) => { };
}
foo!( > a );

error: local ambiguity: multiple parsing options: built-in NTs ident ('x') or 1 other option.
 --> foo.rs:4:7
  |
4 | foo!( > a );
  |       ^

It seems like the same thing happens with any token in place of >.

[beamspease]

I'm running into an error in enum_primitive that according to the bug report is blocked on this issue