mod manual_grammar {
    #[derive(Clone, Debug, Eq, PartialEq, Hash)]
    pub struct UnnamedItem;

    impl quote::ToTokens for UnnamedItem {
        fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
            unimplemented!()
        }
    }

    impl syn::parse::Parse for UnnamedItem {
        fn parse(input: &syn::parse::ParseBuffer) -> syn::parse::Result<Self> {
            unimplemented!()
        }
    }
}
mod test {
    extern crate proc_macro2;
    extern crate quote;
    extern crate syn;

    use crate::manual_grammar::UnnamedItem;

    pub mod kw {
        ::syn::custom_keyword!(GrammarUse);
    }

    pub mod punct {}

    #[macro_export]
    #[doc(hidden)]
    macro_rules! _3d1a7139258f47eba0c8f87a22c3802d {
        ( GrammarUse ) => { self::kw::GrammarUse };
        ( $( $tt:tt )* ) => { ::syn::Token![ $( $tt )* ] };
    }
    pub use _3d1a7139258f47eba0c8f87a22c3802d as Token;

    #[derive(Clone, Debug, Eq, PartialEq, Hash)]
    pub struct Grammar {
        pub kind: GrammarUse,
        pub uses: Vec<(Use)>,
        pub items: Vec<NamedItem>,
    }

    impl ::syn::parse::Parse for Grammar {
        fn parse(
            _a03bdab70b814a91974cb9d6d3ca9c8a: ::syn::parse::ParseStream,
        ) -> ::syn::parse::Result<Self> {
            let mut kind;
            let mut uses;
            let mut items;
            kind = _a03bdab70b814a91974cb9d6d3ca9c8a.parse()?;
            uses = vec![];
            while !_a03bdab70b814a91974cb9d6d3ca9c8a.peek(Token![use]) {
                let _f02d250628f24094a93558926f43cbd9;
                _f02d250628f24094a93558926f43cbd9 = {
                    assert!(!_a03bdab70b814a91974cb9d6d3ca9c8a.peek(Token![use]));
                    let _b1d81c7009f446939f0338e04b903199;
                    _b1d81c7009f446939f0338e04b903199 =
                        _a03bdab70b814a91974cb9d6d3ca9c8a.parse()?;
                    (_b1d81c7009f446939f0338e04b903199)
                };
                uses.push(_f02d250628f24094a93558926f43cbd9);
            }
            items = vec![];
            while !_a03bdab70b814a91974cb9d6d3ca9c8a.is_empty() {
                let _7a2eac31c53b41cb81d7d4b628c3f403;
                _7a2eac31c53b41cb81d7d4b628c3f403 = _a03bdab70b814a91974cb9d6d3ca9c8a.parse()?;
                items.push(_7a2eac31c53b41cb81d7d4b628c3f403);
            }
            Ok(Grammar { kind, uses, items })
        }
    }

    impl ::quote::ToTokens for Grammar {
        fn to_tokens(&self, _a03bdab70b814a91974cb9d6d3ca9c8a: &mut ::proc_macro2::TokenStream) {
            use ::quote::{ToTokens, TokenStreamExt};
            (&self.kind).to_tokens(_a03bdab70b814a91974cb9d6d3ca9c8a);
            for _d29cb56f363349a5971cc63a3cbf7eb5 in (&self.uses) {
                let (_425fba3e7e204b6f8cb3e6427fd67723) = _d29cb56f363349a5971cc63a3cbf7eb5;
                _425fba3e7e204b6f8cb3e6427fd67723.to_tokens(_a03bdab70b814a91974cb9d6d3ca9c8a);
            }
            for _a7f0a0ae90c346ebbe2177d9acf5d40c in (&self.items) {
                _a7f0a0ae90c346ebbe2177d9acf5d40c.to_tokens(_a03bdab70b814a91974cb9d6d3ca9c8a);
            }
        }
    }

    #[derive(Clone, Debug, Eq, PartialEq, Hash)]
    pub struct Use {
        pub r#use: Token![use],
        pub anchor: Option<Token ! [ :: ]>,
        pub tree: syn::UseTree,
    }

    impl ::syn::parse::Parse for Use {
        fn parse(
            _764332f914fd4ffe9435f44d8c4f2321: ::syn::parse::ParseStream,
        ) -> ::syn::parse::Result<Self> {
            let mut r#use;
            let mut anchor;
            let mut tree;
            r#use = _764332f914fd4ffe9435f44d8c4f2321.parse()?;
            anchor = _764332f914fd4ffe9435f44d8c4f2321.parse()?;
            tree = _764332f914fd4ffe9435f44d8c4f2321.parse()?;
            Ok(Use {
                r#use,
                anchor,
                tree,
            })
        }
    }

    impl ::quote::ToTokens for Use {
        fn to_tokens(&self, _764332f914fd4ffe9435f44d8c4f2321: &mut ::proc_macro2::TokenStream) {
            use ::quote::{ToTokens, TokenStreamExt};
            (&self.r#use).to_tokens(_764332f914fd4ffe9435f44d8c4f2321);
            (&self.anchor).to_tokens(_764332f914fd4ffe9435f44d8c4f2321);
            (&self.tree).to_tokens(_764332f914fd4ffe9435f44d8c4f2321);
        }
    }

    #[derive(Clone, Debug, Eq, PartialEq, Hash)]
    pub struct NamedItem {
        pub name: syn::Ident,
        pub colon: Token ! [ : ],
        pub item: UnnamedItem,
    }

    impl ::syn::parse::Parse for NamedItem {
        fn parse(
            _a5cf66811dea48d898f71344f06d65fa: ::syn::parse::ParseStream,
        ) -> ::syn::parse::Result<Self> {
            let mut name;
            let mut colon;
            let mut item;
            name = _a5cf66811dea48d898f71344f06d65fa.parse()?;
            colon = _a5cf66811dea48d898f71344f06d65fa.parse()?;
            item = _a5cf66811dea48d898f71344f06d65fa.parse()?;
            Ok(NamedItem { name, colon, item })
        }
    }

    impl ::quote::ToTokens for NamedItem {
        fn to_tokens(&self, _a5cf66811dea48d898f71344f06d65fa: &mut ::proc_macro2::TokenStream) {
            use ::quote::{ToTokens, TokenStreamExt};
            (&self.name).to_tokens(_a5cf66811dea48d898f71344f06d65fa);
            (&self.colon).to_tokens(_a5cf66811dea48d898f71344f06d65fa);
            (&self.item).to_tokens(_a5cf66811dea48d898f71344f06d65fa);
        }
    }
}