Module syn::token

source · []
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.

  • Peekinginput.peek(Token![...])

  • Parsinginput.parse::<Token![...]>()?

  • Printingquote!( ... #the_token ... )

  • Construction from a Spanlet the_token = Token![...](sp)

  • Field access to its span — let sp = the_token.span

Structs

abstract
as
async
auto
await
become
box
{...}
[...]
break
const
continue
crate
default
do
...
dyn
else
enum
extern
final
fn
for
>=
None-delimited group
if
impl
in
<=
let
loop
macro
match
mod
move
mut
!=
override
(...)
priv
pub
ref
return
<<
>>
static
struct
super
trait
try
type
typeof
union
unsafe
unsized
use
virtual
where
while
yield

Traits

Marker trait for types that represent single tokens.