Enum PythonNode 

pub enum PythonNode {
    Module(Vec<PythonNode>),
    Assign {
        target: String,
        value: Box<PythonNode>,
    },
    BinOp {
        left: Box<PythonNode>,
        op: BinaryOp,
        right: Box<PythonNode>,
    },
    UnaryOp {
        op: UnaryOp,
        operand: Box<PythonNode>,
    },
    IntLit(i64),
    FloatLit(f64),
    StrLit(String),
    BoolLit(bool),
    NoneLit,
    Name(String),
    If {
        test: Box<PythonNode>,
        body: Vec<PythonNode>,
        orelse: Vec<PythonNode>,
    },
    While {
        test: Box<PythonNode>,
        body: Vec<PythonNode>,
    },
    For {
        target: String,
        iter: Box<PythonNode>,
        body: Vec<PythonNode>,
    },
    FuncDef {
        name: String,
        args: Vec<String>,
        body: Vec<PythonNode>,
    },
    Call {
        func: String,
        args: Vec<PythonNode>,
    },
    Return(Option<Box<PythonNode>>),
    Pass,
    Break,
    Continue,
    List(Vec<PythonNode>),
    Compare {
        left: Box<PythonNode>,
        op: CompareOp,
        right: Box<PythonNode>,
    },
}

Python AST node types for generation

Variants

Module(Vec<PythonNode>)

Module (root node)

Assign

Assignment statement: name = expr

Fields

target: String

Variable name being assigned to

value: Box<PythonNode>

Expression value

BinOp

Binary operation: left op right

Fields

left: Box<PythonNode>

Left operand

op: BinaryOp

Binary operator

right: Box<PythonNode>

Right operand

UnaryOp

Unary operation: op operand

Fields

op: UnaryOp

Unary operator

operand: Box<PythonNode>

Operand expression

IntLit(i64)

Integer literal

FloatLit(f64)

Float literal

StrLit(String)

String literal

BoolLit(bool)

Boolean literal

NoneLit

None literal

Name(String)

Variable reference

If

If statement

Fields

test: Box<PythonNode>

Condition expression

body: Vec<PythonNode>

If body statements

orelse: Vec<PythonNode>

Else body statements

While

While loop

Fields

test: Box<PythonNode>

Loop condition

body: Vec<PythonNode>

Loop body statements

For

For loop

Fields

target: String

Loop variable name

iter: Box<PythonNode>

Iterable expression

body: Vec<PythonNode>

Loop body statements

FuncDef

Function definition

Fields

name: String

Function name

args: Vec<String>

Parameter names

body: Vec<PythonNode>

Function body statements

Call

Function call

Fields

func: String

Function name

args: Vec<PythonNode>

Argument expressions

Return(Option<Box<PythonNode>>)

Return statement

Pass

Pass statement

Break

Break statement

Continue

Continue statement

List(Vec<PythonNode>)

List literal

Compare

Comparison: left op right

Fields

left: Box<PythonNode>

Left operand

op: CompareOp

Comparison operator

right: Box<PythonNode>

Right operand

Implementations

impl PythonNode

pub fn to_code(&self, indent: usize) -> String

Convert AST node to Python source code

pub fn depth(&self) -> usize

Calculate AST depth

Trait Implementations

impl Clone for PythonNode

fn clone(&self) -> PythonNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PythonNode

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

Formats the value using the given formatter.

impl PartialEq for PythonNode

fn eq(&self, other: &PythonNode) -> 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 StructuralPartialEq for PythonNode