Enum ExpandTo

pub enum ExpandTo {
    Statements,
    Items,
    Pattern,
    Type,
    Expr,
}

In Rust, macros expand token trees to token trees. When we want to turn a token tree into an AST node, we need to figure out what kind of AST node we want: something like foo can be a type, an expression, or a pattern.

Naively, one would think that “what this expands to” is a property of a particular macro: macro m1 returns an item, while macro m2 returns an expression, etc. That’s not the case – macros are polymorphic in the result, and can expand to any type of the AST node.

What defines the actual AST node is the syntactic context of the macro invocation. As a contrived example, in let T![*] = T![*]; the first T expands to a pattern, while the second one expands to an expression.

ExpandTo captures this bit of information about a particular macro call site.

Variants

Statements

Items

Pattern

Type

Expr

Implementations

impl ExpandTo

pub fn from_call_site(call: &MacroCall) -> ExpandTo

Trait Implementations

impl Clone for ExpandTo

fn clone(&self) -> ExpandTo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpandTo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for ExpandTo

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ExpandTo

fn eq(&self, other: &ExpandTo) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ExpandTo

impl Eq for ExpandTo

impl StructuralPartialEq for ExpandTo