Enum Node 

pub enum Node {
    Literal {
        id: NodeId,
        node_type: Type,
        value: LiteralValue,
    },
    Param {
        id: NodeId,
        name: String,
        index: u32,
        node_type: Type,
    },
    Let {
        id: NodeId,
        name: String,
        node_type: Type,
        value: Box<Node>,
        body: Box<Node>,
    },
    If {
        id: NodeId,
        node_type: Type,
        cond: Box<Node>,
        then_branch: Box<Node>,
        else_branch: Box<Node>,
    },
    Call {
        id: NodeId,
        node_type: Type,
        target: String,
        args: Vec<Node>,
    },
    Return {
        id: NodeId,
        node_type: Type,
        value: Box<Node>,
    },
    BinOp {
        id: NodeId,
        op: BinOpKind,
        node_type: Type,
        lhs: Box<Node>,
        rhs: Box<Node>,
    },
    UnaryOp {
        id: NodeId,
        op: UnaryOpKind,
        node_type: Type,
        operand: Box<Node>,
    },
    Block {
        id: NodeId,
        node_type: Type,
        statements: Vec<Node>,
        result: Box<Node>,
    },
    Loop {
        id: NodeId,
        node_type: Type,
        body: Box<Node>,
    },
    Match {
        id: NodeId,
        node_type: Type,
        scrutinee: Box<Node>,
        arms: Vec<MatchArm>,
    },
    StructLiteral {
        id: NodeId,
        node_type: Type,
        fields: Vec<(String, Node)>,
    },
    FieldAccess {
        id: NodeId,
        node_type: Type,
        object: Box<Node>,
        field: String,
    },
    ArrayLiteral {
        id: NodeId,
        node_type: Type,
        elements: Vec<Node>,
    },
    IndexAccess {
        id: NodeId,
        node_type: Type,
        array: Box<Node>,
        index: Box<Node>,
    },
    Error {
        id: NodeId,
        message: String,
    },
}

The core IR node enum. Each variant represents a different kind of computation in the AIRL intermediate representation.

Nodes are serialized to/from JSON with a "kind" discriminator field.

All variants share:

• id — unique NodeId for patch targeting
• node_type — the Type this node evaluates to (except for Node::Error)

Variants

Literal

A literal value (integer, float, bool, string, unit).

Fields

id: NodeId

node_type: Type

value: LiteralValue

Param

Reference to a function parameter or let-bound local variable.

Fields

id: NodeId

name: String

index: u32

node_type: Type

Let

let name = value in body — introduces a local binding.

Fields

id: NodeId

name: String

node_type: Type

value: Box<Node>

body: Box<Node>

If

if cond then then_branch else else_branch.

Fields

id: NodeId

node_type: Type

cond: Box<Node>

then_branch: Box<Node>

else_branch: Box<Node>

Call

A function call. target is a name (user-defined or builtin like std::io::println).

Fields

id: NodeId

node_type: Type

target: String

args: Vec<Node>

Return

return value — early exit from a function.

Fields

id: NodeId

node_type: Type

value: Box<Node>

BinOp

Binary operator application (lhs op rhs). See BinOpKind.

Fields

id: NodeId

op: BinOpKind

node_type: Type

lhs: Box<Node>

rhs: Box<Node>

UnaryOp

Unary operator application (op operand). See UnaryOpKind.

Fields

id: NodeId

op: UnaryOpKind

node_type: Type

operand: Box<Node>

Block

A sequence of statements followed by a result expression.

Fields

id: NodeId

node_type: Type

statements: Vec<Node>

result: Box<Node>

Loop

Infinite loop — exit only via Return or internal LoopBreak.

Fields

id: NodeId

node_type: Type

body: Box<Node>

Match

Pattern match. Evaluates scrutinee, then the first matching arm’s body.

Fields

id: NodeId

node_type: Type

scrutinee: Box<Node>

arms: Vec<MatchArm>

StructLiteral

Struct literal: { field1: v1, field2: v2 }.

Fields

id: NodeId

node_type: Type

fields: Vec<(String, Node)>

FieldAccess

Access a struct field: object.field.

Fields

id: NodeId

node_type: Type

object: Box<Node>

field: String

ArrayLiteral

Array literal: [e1, e2, e3].

Fields

id: NodeId

node_type: Type

elements: Vec<Node>

IndexAccess

Array index access: array[index].

Fields

id: NodeId

node_type: Type

array: Box<Node>

index: Box<Node>

Error

An explicit error node, used as a placeholder when parsing fails.

Fields

id: NodeId

message: String

Implementations

impl Node

pub fn id(&self) -> &NodeId

Get the NodeId of this node.

pub fn node_type(&self) -> Option<&Type>

Get the type of this node (if it has one).

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Node

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Node