Module token

Help

Expand description

Tokens representing Rust punctuation, keywords, and delimiters.

The type names in this module can be difficult to keep straight, so we prefer to use the Token! macro instead. This is a type-macro that expands to the token type of the given token.

§Example

The ItemStatic syntax tree node is defined like this.

pub struct ItemStatic {
    pub attrs: Vec<Attribute>,
    pub vis: Visibility,
    pub static_token: Token![static],
    pub mutability: Option<Token![mut]>,
    pub ident: Ident,
    pub colon_token: Token![:],
    pub ty: Box<Type>,
    pub eq_token: Token![=],
    pub expr: Box<Expr>,
    pub semi_token: Token![;],
}

§Parsing

Keywords and punctuation can be parsed through the ParseStream::parse method. Delimiter tokens are parsed using the parenthesized!, bracketed! and braced! macros.

use syn::{Attribute, Result};
use syn::parse::{Parse, ParseStream};

// Parse the ItemStatic struct shown above.
impl Parse for ItemStatic {
    fn parse(input: ParseStream) -> Result<Self> {
        Ok(ItemStatic {
            attrs: input.call(Attribute::parse_outer)?,
            vis: input.parse()?,
            static_token: input.parse()?,
            mutability: input.parse()?,
            ident: input.parse()?,
            colon_token: input.parse()?,
            ty: input.parse()?,
            eq_token: input.parse()?,
            expr: input.parse()?,
            semi_token: input.parse()?,
        })
    }
}

§Other operations

Every keyword and punctuation token supports the following operations.

Peeking — input.peek(Token![...])
Parsing — input.parse::<Token![...]>()?
Printing — quote!( ... #the_token ... )
Construction from a Span — let the_token = Token![...](sp)
Field access to its span — let sp = the_token.span

Structs§

Abstract: abstract
Add: +
AddEq: +=
And: &
AndAnd: &&
AndEq: &=
As: as
Async: async
At: @
Auto: auto
Await: await
Bang: !
Become: become
Box: box
Brace: {...}
Bracket: [...]
Break: break
Caret: ^
CaretEq: ^=
Colon: :
Colon2: ::
Comma: ,
Const: const
Continue: continue
Crate: crate
Default: default
Div: /
DivEq: /=
Do: do
Dollar: $
Dot: .
Dot2: ..
Dot3: ...
DotDotEq: ..=
Dyn: dyn
Else: else
Enum: enum
Eq: =
EqEq: ==
Extern: extern
FatArrow: =>
Final: final
Fn: fn
For: for
Ge: >=
Group: None-delimited group
Gt: >
If: if
Impl: impl
In: in
LArrow: <-
Le: <=
Let: let
Loop: loop
Lt: <
Macro: macro
Match: match
Mod: mod
Move: move
MulEq: *=
Mut: mut
Ne: !=
Or: |
OrEq: |=
OrOr: ||
Override: override
Paren: (...)
Pound: #
Priv: priv
Pub: pub
Question: ?
RArrow: ->
Ref: ref
Rem: %
RemEq: %=
Return: return
SelfType: Self
SelfValue: self
Semi: ;
Shl: <<
ShlEq: <<=
Shr: >>
ShrEq: >>=
Star: *
Static: static
Struct: struct
Sub: -
SubEq: -=
Super: super
Tilde: ~
Trait: trait
Try: try
Type: type
Typeof: typeof
Underscore: _
Union: union
Unsafe: unsafe
Unsized: unsized
Use: use
Virtual: virtual
Where: where
While: while
Yield: yield

Traits§

Token: Marker trait for types that represent single tokens.