Enum ValueExpr 

pub enum ValueExpr {
    Literal(Value),
    Variable(String),
    PropertyAccess {
        object: Box<ValueExpr>,
        property: String,
    },
    ArrayIndex {
        array: Box<ValueExpr>,
        index: Box<ValueExpr>,
    },
    ObjectLiteral {
        fields: Vec<ObjectField>,
    },
    ArrayLiteral {
        items: Vec<ValueExpr>,
    },
    ArrayMethod {
        array: Box<ValueExpr>,
        method: ArrayMethodCall,
    },
    NumberMethod {
        number: Box<ValueExpr>,
        method: NumberMethodCall,
    },
    BinaryOp {
        left: Box<ValueExpr>,
        op: BinaryOperator,
        right: Box<ValueExpr>,
    },
    UnaryOp {
        op: UnaryOperator,
        operand: Box<ValueExpr>,
    },
    Ternary {
        condition: Box<ValueExpr>,
        consequent: Box<ValueExpr>,
        alternate: Box<ValueExpr>,
    },
    OptionalChain {
        object: Box<ValueExpr>,
        property: String,
    },
    NullishCoalesce {
        left: Box<ValueExpr>,
        right: Box<ValueExpr>,
    },
    Await {
        expr: Box<ValueExpr>,
    },
    PromiseAll {
        items: Vec<ValueExpr>,
    },
    ApiCall {
        method: String,
        path: PathTemplate,
        body: Option<Box<ValueExpr>>,
    },
    Block {
        bindings: Vec<(String, ValueExpr)>,
        result: Box<ValueExpr>,
    },
    McpCall {
        server_id: String,
        tool_name: String,
        args: Option<Box<ValueExpr>>,
    },
    SdkCall {
        operation: String,
        args: Option<Box<ValueExpr>>,
    },
    BuiltinCall {
        func: BuiltinFunction,
        args: Vec<ValueExpr>,
    },
}

An expression that produces a value.

Variants

Literal(Value)

Literal value (null, bool, number, string)

Variable(String)

Variable reference

PropertyAccess

Property access: obj.prop

Fields

object: Box<ValueExpr>

property: String

ArrayIndex

Array index: arr[0]

Fields

array: Box<ValueExpr>

index: Box<ValueExpr>

ObjectLiteral

Object literal: { key: value, ...spread }

Fields

fields: Vec<ObjectField>

ArrayLiteral

Array literal: [1, 2, 3]

Fields

items: Vec<ValueExpr>

ArrayMethod

Array method call

Fields

array: Box<ValueExpr>

method: ArrayMethodCall

NumberMethod

Number method call: num.toFixed(), etc.

Fields

number: Box<ValueExpr>

method: NumberMethodCall

BinaryOp

Binary operation: a + b, a === b, etc.

Fields

left: Box<ValueExpr>

op: BinaryOperator

right: Box<ValueExpr>

UnaryOp

Unary operation: !a

Fields

op: UnaryOperator

operand: Box<ValueExpr>

Ternary

Ternary: cond ? a : b

Fields

condition: Box<ValueExpr>

consequent: Box<ValueExpr>

alternate: Box<ValueExpr>

OptionalChain

Optional chaining: obj?.prop

Fields

object: Box<ValueExpr>

property: String

NullishCoalesce

Nullish coalescing: a ?? b

Fields

left: Box<ValueExpr>

right: Box<ValueExpr>

Await

Await expression (for Promise.all, etc.)

Fields

expr: Box<ValueExpr>

PromiseAll

Promise.all: Promise.all([...])

Fields

items: Vec<ValueExpr>

ApiCall

API call expression (when used inline, not as a statement)

Fields

method: String

path: PathTemplate

body: Option<Box<ValueExpr>>

Block

Block expression with local variable bindings and a final result. Used for arrow function block bodies: x => { const a = x.foo; return a; }

Fields

bindings: Vec<(String, ValueExpr)>

Local variable bindings: [(name, expr), ...]

result: Box<ValueExpr>

The final expression to evaluate and return

McpCall

MCP tool call expression: mcp.call('server', 'tool', args)

Fields

server_id: String

tool_name: String

args: Option<Box<ValueExpr>>

SdkCall

SDK call expression (used in non-assignment contexts): api.getCostAndUsage({ ... })

Fields

operation: String

args: Option<Box<ValueExpr>>

BuiltinCall

Built-in function call: parseFloat(x), Math.abs(x), Object.keys(obj)

Fields

func: BuiltinFunction

args: Vec<ValueExpr>

Trait Implementations

impl Clone for ValueExpr

fn clone(&self) -> ValueExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValueExpr

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

Formats the value using the given formatter.

impl Serialize for ValueExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.