Enum syntax::ast::TokenTreeUnstable

pub enum TokenTree {
    TtToken(Span, Token),
    TtDelimited(Span, Rc<Delimited>),
    TtSequence(Span, Rc<SequenceRepetition>),
}

When the main rust parser encounters a syntax-extension invocation, it parses the arguments to the invocation as a token-tree. This is a very loose structure, such that all sorts of different AST-fragments can be passed to syntax extensions using a uniform type.

If the syntax extension is an MBE macro, it will attempt to match its LHS token tree against the provided token tree, and if it finds a match, will transcribe the RHS token tree, splicing in any captured macro_parser::matched_nonterminals into the SubstNts it finds.

The RHS of an MBE macro is the only place SubstNts are substituted. Nothing special happens to misnamed or misplaced SubstNts. For macro invocations; parsing is delegated to the macro

Variants

TtToken	A single token
TtDelimited	A delimited sequence of token trees
TtSequence	A kleene-style repetition sequence with a span

Methods

impl TokenTree

fn len(&self) -> usize

fn get_tt(&self, index: usize) -> TokenTree

fn get_span(&self) -> Span

Returns the Span corresponding to this token tree.

Trait Implementations

impl ToTokens for TokenTree

fn to_tokens(&self, _cx: &ExtCtxt) -> Vec<TokenTree>

Derived Implementations

impl Debug for TokenTree

fn fmt(&self, __arg_0: &mut Formatter) -> Result

impl Hash for TokenTree

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

impl Decodable for TokenTree

fn decode<__D: Decoder>(__arg_0: &mut __D) -> Result<TokenTree, Error>

impl Encodable for TokenTree

fn encode<__S: Encoder>(&self, __arg_0: &mut __S) -> Result<(), Error>

impl Eq for TokenTree

fn assert_receiver_is_total_eq(&self)

impl PartialEq for TokenTree

fn eq(&self, __arg_0: &TokenTree) -> bool

fn ne(&self, __arg_0: &TokenTree) -> bool

impl Clone for TokenTree

fn clone(&self) -> TokenTree

fn clone_from(&mut self, source: &Self)