Module syn::token

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.

# use syn::{Attribute, Expr, Ident, Token, Type, Visibility};
#
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};
#
# enum ItemStatic {}

// Parse the ItemStatic struct shown above.
impl Parse for ItemStatic {
    fn parse(input: ParseStream) -> Result<Self> {
        # use syn::ItemStatic;
        # fn parse(input: ParseStream) -> Result<ItemStatic> {
        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()?,
        })
        # }
        # unimplemented!()
    }
}

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
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	==
Existential	existential
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.