Enum Expr 

pub enum Expr {
    Struct {
        name: String,
        name_span: ExprSpan,
        fields: Vec<RecordInit>,
        span: ExprSpan,
    },
    Literal {
        value: Literal,
        span: ExprSpan,
    },
    Ident {
        name: String,
        span: ExprSpan,
    },
    Op {
        name: String,
        operands: Vec<Expr>,
        span: ExprSpan,
    },
    Apply {
        callee: Box<Expr>,
        args: Vec<Expr>,
        span: ExprSpan,
    },
    Member {
        receiver: Box<Expr>,
        name: String,
        name_span: ExprSpan,
        args: Option<Vec<Expr>>,
        span: ExprSpan,
    },
    Tuple {
        elements: Vec<Expr>,
        span: ExprSpan,
    },
    Array {
        elements: Vec<Expr>,
        type_annotation: Option<TypeExpr>,
        annotation_span: Option<ExprSpan>,
        span: ExprSpan,
    },
    TupleIndex {
        base: Box<Expr>,
        index: usize,
        span: ExprSpan,
    },
    If {
        cond: Box<Expr>,
        then_branch: Box<Expr>,
        else_branch: Option<Box<Expr>>,
        span: ExprSpan,
    },
    Logical {
        op: LogicalOp,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
        span: ExprSpan,
    },
    Cast {
        expr: Box<Expr>,
        type_name: String,
        span: ExprSpan,
    },
    Closure {
        params: Vec<ClosureParam>,
        body: Box<Expr>,
        span: ExprSpan,
    },
}

A parsed CEL expression with source spans on every node.

Built by AstContext; consumed as-is by adam-lang (method bodies/initializers), the language server (hover/goto), the formatter, and the future macro-compilation backend. Carries no resolved types or operator overloads — resolution is deferred to a later, separate type-checking phase.

Logical is kept distinct from If (rather than desugaring a || b to if a { true } else { b }, which is how DynSegmentContext executes it) so a formatter can round-trip a || b as a || b.

Variants

Struct

A named record constructor, unresolved until semantic checking.

Examples

use cel_parser::{AstContext, Expr, OpLookup, Parser};
let expr = Parser::<AstContext>::new(OpLookup::new())
    .parse_str_ast("Point { x: 1.0 }").unwrap();
assert!(matches!(expr, Expr::Struct { fields, .. } if fields.len() == 1));

Fields

name: String

The constructor’s type name, not a value reference.

name_span: ExprSpan

The constructor name token’s span.

fields: Vec<RecordInit>

Field labels and expressions in their written evaluation order.

span: ExprSpan

The whole constructor, including the closing brace.

Literal

A literal value (10i32, "x", true, (), …).

Fields

value: Literal

The literal’s value.

span: ExprSpan

The literal token’s span.

Ident

A bare identifier reference or zero-arg builtin lookup (x, pi) — unresolved.

Fields

name: String

The identifier’s name.

span: ExprSpan

The identifier token’s span.

Op

A prefix (arity 1) or infix (arity 2) operator application (-x, a + b, a == b).

Fields

name: String

The operator’s name (e.g. "+", "-", "==").

operands: Vec<Expr>

The operand sub-expressions, in source order.

span: ExprSpan

The span of the whole operator application.

Apply

A call: callee(args...) — the grammar’s "()" operator.

Fields

callee: Box<Expr>

The expression being called.

args: Vec<Expr>

The argument sub-expressions, in source order.

span: ExprSpan

The span of the whole call, including its argument list.

Member

A direct receiver operation (receiver.name or receiver.name(args...)).

The label is not an identifier reference. Type and overload resolution are deferred.

Examples

use cel_parser::{AstContext, Expr, OpLookup, Parser};
let expr = Parser::<AstContext>::new(OpLookup::new()).parse_str_ast("a.x()").unwrap();
assert!(matches!(expr, Expr::Member { args: Some(args), .. } if args.is_empty()));

Fields

receiver: Box<Expr>

The receiver, evaluated before explicit arguments.

name: String

The operation’s name.

name_span: ExprSpan

The member name token’s span.

args: Option<Vec<Expr>>

Explicit arguments in source order; None preserves property spelling.

span: ExprSpan

The span from the receiver through the name or closing parenthesis.

Tuple

A tuple literal ((a, b, ...); a 1-tuple is (a,)).

Fields

elements: Vec<Expr>

The element sub-expressions, in source order.

span: ExprSpan

The span of the whole tuple, including its parentheses.

Array

An array literal ([a, b, ...], [a, b]: [T], or []: [T]). An unannotated empty array is still rejected by the grammar (see https://github.com/stlab/cel-rs/issues/212), but a typed empty array is recorded here with elements.is_empty(). type_annotation stores the complete recursive array type exactly as written, including nested arrays and custom leaf names such as Custom. Whether the elements share one type, whether type_annotation names a complete array type are deferred to the later type-checking phase (see the module doc comment), same as TupleIndex’s deferred bounds check.

Fields

elements: Vec<Expr>

The element sub-expressions, in source order.

type_annotation: Option<TypeExpr>

The optional declared array type, as written after :.

annotation_span: Option<ExprSpan>

The span from the : token through the end of the declared type, when present.

span: ExprSpan

The span of the whole array literal, including its brackets and any annotation.

TupleIndex

A tuple index (base.N). Whether base is actually a tuple and N is in range is unchecked here — deferred to the type-checking phase (see the module doc comment).

Fields

base: Box<Expr>

The expression being indexed.

index: usize

The index.

span: ExprSpan

The span from the start of base through the index token.

If

An if cond { then } else { else_ } expression.

Fields

cond: Box<Expr>

The condition.

then_branch: Box<Expr>

The then-branch.

else_branch: Option<Box<Expr>>

The else-branch, or None if no else/else if was written.

span: ExprSpan

The span of the whole if/else construct.

Logical

A short-circuiting &&/||.

Fields

op: LogicalOp

Which logical operator.

lhs: Box<Expr>

The left-hand side.

rhs: Box<Expr>

The right-hand side.

span: ExprSpan

The span of the whole logical expression.

Cast

A cast (expr as Type). Whether type_name is a recognized type and whether a conversion from expr’s type exists is unchecked here — deferred to the type-checking phase (see the module doc comment), same as TupleIndex’s deferred bounds check.

Fields

expr: Box<Expr>

The expression being converted.

type_name: String

The target type’s name, as written (e.g. "i32") - unresolved.

span: ExprSpan

The span of the whole expr as Type construct.

Closure

A closure literal (|x: i32| x + 1, or || 1i32 with no parameters).

Fields

params: Vec<ClosureParam>

The closure’s declared parameters, in source order.

body: Box<Expr>

The closure’s body expression.

span: ExprSpan

The span of the whole closure literal, from its opening |/|| through body.

Implementations

impl Expr

pub fn span(&self) -> ExprSpan

Returns this node’s source span.

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.