Enum syntax::ast::TokenTreeExperimental

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) -> uint

fn get_tt(&self, index: uint) -> 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 Show for TokenTree

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

impl<__S: Writer> Hash<__S> for TokenTree

fn hash(&self, __arg_0: &mut __S)

impl<__D: Decoder<__E>, __E> Decodable<__D, __E> for TokenTree

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

impl<__S: Encoder<__E>, __E> Encodable<__S, __E> for TokenTree

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

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)