Enum Token 

pub enum Token {
    Ident {
        name: String,
    },
    Literal {
        kind: LiteralKind,
        value: String,
    },
    Punct {
        ch: char,
    },
    Keyword {
        name: String,
    },
    Group {
        delimiter: Delimiter,
        tokens: Vec<Token>,
    },
    Path {
        segments: Vec<String>,
    },
    MethodCall {
        receiver: Box<Token>,
        method: String,
        args: Vec<Token>,
    },
    FnCall {
        path: Vec<String>,
        args: Vec<Token>,
    },
    FieldAccess {
        base: Box<Token>,
        field: String,
    },
    BinOp {
        lhs: Box<Token>,
        op: String,
        rhs: Box<Token>,
    },
    UnaryOp {
        op: String,
        expr: Box<Token>,
    },
    If {
        cond: Box<Token>,
        then_branch: Vec<Token>,
        else_branch: Option<Vec<Token>>,
    },
    Match {
        expr: Box<Token>,
        arms: Vec<MatchArm>,
    },
    Let {
        pattern: String,
        ty: Option<String>,
        init: Option<Box<Token>>,
    },
    Return {
        expr: Option<Box<Token>>,
    },
    Block {
        stmts: Vec<Token>,
    },
    Closure {
        params: Vec<String>,
        body: Box<Token>,
    },
    Raw {
        source: String,
    },
}

Simplified token representation for method bodies.

Variants

Ident

An identifier

Fields

name: String

Literal

A literal value

Fields

kind: LiteralKind

value: String

Punct

A punctuation symbol

Fields

ch: char

Keyword

A keyword

Fields

name: String

Group

A group (delimited tokens)

Fields

delimiter: Delimiter

tokens: Vec<Token>

Path

A path (e.g., std::collections::HashMap)

Fields

segments: Vec<String>

MethodCall

A method call

Fields

receiver: Box<Token>

method: String

args: Vec<Token>

FnCall

A function call

Fields

path: Vec<String>

args: Vec<Token>

FieldAccess

A field access

Fields

base: Box<Token>

field: String

BinOp

A binary operation

Fields

lhs: Box<Token>

op: String

rhs: Box<Token>

UnaryOp

A unary operation

Fields

op: String

expr: Box<Token>

If

An if expression

Fields

cond: Box<Token>

then_branch: Vec<Token>

else_branch: Option<Vec<Token>>

Match

A match expression

Fields

expr: Box<Token>

arms: Vec<MatchArm>

Let

A let binding

Fields

pattern: String

ty: Option<String>

init: Option<Box<Token>>

Return

A return statement

Fields

expr: Option<Box<Token>>

Block

A block

Fields

stmts: Vec<Token>

Closure

A closure

Fields

params: Vec<String>

body: Box<Token>

Raw

Raw source when we can’t parse further

Fields

source: String

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Token

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Token

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Token

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.