Enum Expr 

pub enum Expr {
    Missing,
    Literal(Literal),
    Name(SmolStr),
    SelfExpr,
    Super,
    Bin {
        op: BinOp,
        lhs: ExprId,
        rhs: ExprId,
    },
    Unary {
        op: UnOp,
        operand: ExprId,
    },
    Ternary {
        cond: ExprId,
        then_branch: ExprId,
        else_branch: ExprId,
    },
    Call {
        callee: ExprId,
        args: Vec<ExprId>,
    },
    Field {
        receiver: ExprId,
        name: SmolStr,
        name_range: TextRange,
    },
    Index {
        base: ExprId,
        index: ExprId,
    },
    Is {
        operand: ExprId,
        ty: Option<AstPtr>,
        negated: bool,
    },
    Cast {
        operand: ExprId,
        ty: Option<AstPtr>,
    },
    In {
        lhs: ExprId,
        rhs: ExprId,
        negated: bool,
    },
    Await(ExprId),
    Array(Vec<ExprId>),
    Dict(Vec<(ExprId, Option<ExprId>)>),
    Lambda {
        params: Vec<ParamBinding>,
        body: Block,
    },
    Preload {
        arg: Option<ExprId>,
        path: Option<SmolStr>,
    },
    GetNode {
        path: Option<SmolStr>,
        unique: bool,
    },
    Paren(ExprId),
}

A lowered expression. Children are referenced by ExprId.

Variants

Missing

An unlowerable / recovered expression (typed Error, suppresses cascade).

Literal(Literal)

A literal.

Name(SmolStr)

A bare identifier reference.

SelfExpr

self.

Super

super.

Bin

A binary expression.

Fields

op: BinOp

The operator.

lhs: ExprId

Left operand.

rhs: ExprId

Right operand.

Unary

A prefix unary expression.

Fields

op: UnOp

The operator.

operand: ExprId

The operand.

Ternary

a if c else b.

Fields

cond: ExprId

The condition.

then_branch: ExprId

Value when the condition holds.

else_branch: ExprId

Value otherwise.

Call

callee(args…).

Fields

callee: ExprId

The callee.

args: Vec<ExprId>

The argument expressions.

Field

receiver.name.

Fields

receiver: ExprId

The receiver.

name: SmolStr

The member name.

name_range: TextRange

The member-name token range (for hover / member-completion context).

Index

base[index].

Fields

base: ExprId

The indexed value.

index: ExprId

The index expression.

Is

operand is [not] T — always bool; narrows on the true branch.

Fields

operand: ExprId

The tested operand.

ty: Option<AstPtr>

The TypeRef node tested against.

negated: bool

Whether it was is not.

Cast

operand as T — optimistic downcast to T.

Fields

operand: ExprId

The operand.

ty: Option<AstPtr>

The target TypeRef node.

In

lhs [not] in rhs — always bool.

Fields

lhs: ExprId

The needle.

rhs: ExprId

The haystack.

negated: bool

Whether it was not in.

Await(ExprId)

await operand.

Array(Vec<ExprId>)

[a, b, …].

Dict(Vec<(ExprId, Option<ExprId>)>)

{ k: v, … } (value is None only on recovery).

Lambda

func(...): … — an anonymous function (typed Callable).

Fields

params: Vec<ParamBinding>

The lambda parameters.

body: Block

The lambda body.

Preload

preload(path) — a compile-time resource reference. When path is a constant string literal (the only form Godot accepts), it is captured here so inference can resolve it to the declaring file’s ScriptRef (M3); a non-literal argument leaves path None (the seam).

Fields

arg: Option<ExprId>

The lowered path argument expression, if present (kept so it is still type-walked).

path: Option<SmolStr>

The constant-folded path string (unquoted), when the argument is a string literal.

GetNode

$Path / %Unique / get_node("…") — a node-path access. In Phase 2 this was always Object(Node); Phase-4 M1 resolves the literal path against the owning scene to the node’s concrete type. A computed get_node(var) keeps path: None (stays Node, never warns).

Fields

path: Option<SmolStr>

The literal node path ("Panel/VBox/Button", or a %Unique name), or None if computed.

unique: bool

true for the %Unique form (resolve via unique_name_in_owner); false for $Path.

Paren(ExprId)

(inner).

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Eq for Expr

impl PartialEq for Expr

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