      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103

    /// Parse the input TokenStream of a macro, triggering a compile error if the
    /// tokens fail to parse.
    ///
    /// Refer to the [`parse` module] documentation for more details about parsing
    /// in Syn.
    ///
    /// [`parse` module]: parse/index.html
    ///
    /// # Intended usage
    ///
    /// ```edition2018
    /// extern crate proc_macro;
    ///
    /// use proc_macro::TokenStream;
    /// use syn::{parse_macro_input, Result};
    /// use syn::parse::{Parse, ParseStream};
    ///
    /// struct MyMacroInput {
    ///     /* ... */
    /// }
    ///
    /// impl Parse for MyMacroInput {
    ///     fn parse(input: ParseStream) -> Result<Self> {
    ///         /* ... */
    /// #       Ok(MyMacroInput {})
    ///     }
    /// }
    ///
    /// # const IGNORE: &str = stringify! {
    /// #[proc_macro]
    /// # };
    /// pub fn my_macro(tokens: TokenStream) -> TokenStream {
    ///     let input = parse_macro_input!(tokens as MyMacroInput);
    ///
    ///     /* ... */
    /// #   "".parse().unwrap()
    /// }
    /// ```
    #[macro_export(local_inner_macros)]
    macro_rules! parse_macro_input {
        ($tokenstream:ident as $ty:ty) => {
            match $crate::parse_macro_input::parse::<$ty>($tokenstream) {
                $crate::export::Ok(data) => data,
                $crate::export::Err(err) => {
                    return $crate::export::TokenStream::from(err.to_compile_error());
                }
            }
        };
        ($tokenstream:ident) => {
            parse_macro_input!($tokenstream as _)
        };
    }

    ////////////////////////////////////////////////////////////////////////////////
    // Can parse any type that implements Parse.

    use parse::{Parse, ParseStream, Parser, Result};
    use proc_macro::TokenStream;

    // Not public API.
    #[doc(hidden)]
    pub fn parse<T: ParseMacroInput>(token_stream: TokenStream) -> Result<T> {
        T::parse.parse(token_stream)
    }

    // Not public API.
    #[doc(hidden)]
    pub trait ParseMacroInput: Sized {
        fn parse(input: ParseStream) -> Result<Self>;
    }

    impl<T: Parse> ParseMacroInput for T {
        fn parse(input: ParseStream) -> Result<Self> {
            <T as Parse>::parse(input)
        }
    }

    ////////////////////////////////////////////////////////////////////////////////
    // Any other types that we want `parse_macro_input!` to be able to parse.

    #[cfg(any(feature = "full", feature = "derive"))]
    use AttributeArgs;

    #[cfg(any(feature = "full", feature = "derive"))]
    impl ParseMacroInput for AttributeArgs {
        fn parse(input: ParseStream) -> Result<Self> {
            let mut metas = Vec::new();

            loop {
                if input.is_empty() {
                    break;
                }
                let value = input.parse()?;
                metas.push(value);
                if input.is_empty() {
                    break;
                }
                input.parse::<Token![,]>()?;
            }

            Ok(metas)
        }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)