Enum Expression 

#[non_exhaustive]
pub enum Expression {
    Literal(Value),
    Unresolved(Symbolic),
    BinaryOp {
        op: BinaryOp,
        lhs: Box<Expression>,
        rhs: Box<Expression>,
        span: Span,
    },
    UnaryOp {
        op: UnaryOp,
        operand: Box<Expression>,
        span: Span,
    },
    TemplateConcat(Vec<Expression>),
    Array(Vec<Expression>),
    Object(Vec<(Expression, Expression)>),
    FuncCall(Box<FuncCall>),
    Conditional(Box<Conditional>),
    For(Box<ForExpr>),
}

A possibly-resolved HCL expression.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Literal(Value)

A fully-resolved value.

Unresolved(Symbolic)

A symbolic reference the evaluator could not resolve (var.x, local.y, data.z.w, aws_iam_role.r.arn, etc.).

BinaryOp

Binary operation. Subtrees may themselves be Unresolved.

Fields

op: BinaryOp

Operator.

lhs: Box<Expression>

Left-hand side.

rhs: Box<Expression>

Right-hand side.

span: Span

Span of the whole operation.

UnaryOp

Unary operation.

Fields

op: UnaryOp

Operator.

operand: Box<Expression>

Operand.

span: Span

Span.

TemplateConcat(Vec<Expression>)

Template concatenation, e.g. "foo-${var.x}-bar" → parts.

Array(Vec<Expression>)

HCL tuple / array literal whose elements are not all Expression::Literal yet. The loader emits this when the array contains at least one Expression::Unresolved / function call / reference; once every element resolves, the evaluator collapses it to Expression::Literal of Value::List.

Per [10-data-model.md § 2.3 expression-and-values lowering table]: “tuple / object literals → recurse → Value::List / Value::Map once children resolved at evaluator phase; during loader, kept as expression nodes.”

Object(Vec<(Expression, Expression)>)

HCL object literal whose keys or values are not yet fully resolved. Keys are themselves Expression because HCL allows expression keys ({(var.kind) = "x"}) — the IR preserves that until the evaluator can collapse to a Value::Map.

FuncCall(Box<FuncCall>)

Function call.

Conditional(Box<Conditional>)

cond ? a : b.

For(Box<ForExpr>)

[for ... in ...] / {for ... in ...}.

Implementations

impl Expression

pub fn as_literal(&self) -> Option<&Value>

Returns the resolved Value if this expression is a Expression::Literal.

pub fn is_fully_resolved(&self) -> bool

true iff every leaf in the expression tree is a Value (no Symbolic anywhere).

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expression

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

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 Expression