# [−][src]Crate proc_macro2

A wrapper around the procedural macro API of the compiler's `proc_macro` crate. This library serves three purposes:

- Bring proc-macro-like functionality to other contexts like build.rs and main.rs. Types from `proc_macro` are entirely specific to procedural macros and cannot ever exist in code outside of a procedural macro. Meanwhile `proc_macro2` types may exist anywhere including non-macro code. By developing foundational libraries like syn and quote against `proc_macro2` rather than `proc_macro`, the procedural macro ecosystem becomes easily applicable to many other use cases and we avoid reimplementing non-macro equivalents of those libraries.

- Make procedural macros unit testable. As a consequence of being specific to procedural macros, nothing that uses `proc_macro` can be executed from a unit test. In order for helper libraries or components of a macro to be testable in isolation, they must be implemented using `proc_macro2`.

- Provide the latest and greatest APIs across all compiler versions. Procedural macros were first introduced to Rust in 1.15.0 with an extremely minimal interface. Since then, many improvements have landed to make macros more flexible and easier to write. This library tracks the procedural macro API of the most recent stable compiler but employs a polyfill to provide that API consistently across any compiler since 1.15.0.

# Usage

The skeleton of a typical procedural macro typically looks like this:

    extern crate proc_macro;

    # const IGNORE: &str = stringify! {
    #[proc_macro_derive(MyDerive)]
    # };
    pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
        let input = proc_macro2::TokenStream::from(input);

        let output: proc_macro2::TokenStream = {
            /* transform input */
            # input
        };

        proc_macro::TokenStream::from(output)
    }

If parsing with Syn, you'll use `parse_macro_input!` instead to propagate parse errors correctly back to the compiler when parsing fails.

# Unstable features

The default feature set of proc-macro2 tracks the most recent stable compiler API. Functionality in `proc_macro` that is not yet stable is not exposed by proc-macro2 by default.

To opt into the additional APIs available in the most recent nightly compiler, the `procmacro2_semver_exempt` config flag must be passed to rustc. As usual, we will polyfill those nightly-only APIs all the way back to Rust 1.15.0. As these are unstable APIs that track the nightly compiler, minor versions of proc-macro2 may make breaking changes to them at any time.

    RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build

Note that this must not only be done for your crate, but for any crate that depends on your crate. This infectious nature is intentional, as it serves as a reminder that you are outside of the normal semver guarantees.

Semver exempt methods are marked as such in the proc-macro2 documentation.

## Modules

token_stream | Public implementation details for the `TokenStream` type, such as iterators.

## Structs

Group | A delimited token stream.
Ident | A word of Rust code, which may be a keyword or legal variable name.
LexError | Error returned from `TokenStream::from_str`.
Literal | A literal string (`"hello"`), byte string (`b"hello"`), character (`'a'`), byte character (`b'a'`), an integer or floating point number with or without a suffix (`1`, `1u8`, `2.3`, `2.3f32`).
Punct | An `Punct` is an single punctuation character like `+`, `-` or `#`.
Span | A region of source code, along with macro expansion information.
TokenStream | An abstract stream of tokens, or more concretely a sequence of token trees.

## Enums

Delimiter | Describes how a sequence of token trees is delimited.
Spacing | Whether an `Punct` is followed immediately by another `Punct` or followed by another token or whitespace.
TokenTree | A single token or a delimited sequence of token trees (e.g. `[1, (), ..]`).

# 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`)