compiler.expressions

Return anast.Namereferencing a precomputed module-level binding.

Non-constant-safe values (dict, list, set, custom objects) cannot be stored inast.Constantnodes. Instead they are collected during compilation and injected into theexec() namespace as _pc_N.

Wrap an expression in a zero-arg lambda for deferred evaluation.

Used by_is_defined, _default_safe, and _null_coalesce to catchUndefinedErrorat runtime without evaluating the expression eagerly.

Check if node could produce a string value (macro call, filter chain).

Used to determine when numeric coercion is needed for arithmetic operations. Recursively checks nested expressions to catch Filter nodes inside parentheses.

This handles cases like (a | length) + (b | length) where the left/right operands are Filter nodes that need numeric coercion.

Wrap expression in _coerce_numeric() call for arithmetic safety.

Ensures that Markup objects (from macros) are converted to numbers before arithmetic operations, preventing string multiplication.

Compile expression node to Python AST expression.

O(1) dict dispatch bytype(node).__name__.

Compile a ?? b to handle both None and undefined variables.

Uses _null_coalesce helper to catch UndefinedError for undefined variables. Part of RFC: kida-modern-syntax-features.

The helper is called as:

_null_coalesce(lambda: a, lambda: b)

This allows:

• a ?? b to return b if a is undefined (UndefinedError)
• a ?? b to return b if a is None
• a ?? b to return a if a is any other value (including falsy: 0, '', [])

Compile obj?.attr using walrus operator to avoid double evaluation.

obj?.attr compiles to: '' if (_oc := obj) is None else (_oc_val := _getattr_none(_oc, 'attr')) if _oc_val is not None else ''

The double check ensures that:

1. If obj is None, return ''
2. If obj.attr is None, return '' (for output) but preserve None for ??

For null coalescing to work, we need a different approach: the optional chain preserves None so ?? can check it, but for direct output, None becomes ''.

Actually, we return None but rely on the caller to handle None → '' conversion. For output, the expression is wrapped differently.

Simplified: Return None when short-circuiting, let output handle conversion.

Part of RFC: kida-modern-syntax-features.

Compile obj?[key] using walrus operator to avoid double evaluation.

obj?[key] compiles to: None if (_oc := obj) is None else _getitem_none(_oc, key)

Routes through_getitem_none so Mapping receivers return Noneon missing keys (v0.8.0+ semantics), while Sequence/out-of-range accesses still raise understrict_undefined.

Part of RFC: kida-modern-syntax-features.

Compile obj?.method(*args, **kwargs) with short-circuit.

When obj is None or obj.method is UNDEFINED, return None without calling. Uses _optional_call(callee, *args, **kwargs) helper.

Compile range literal to range() call.

1..10 → range(1, 11) # inclusive 1...11 → range(1, 11) # exclusive 1..10 by 2 → range(1, 11, 2)

Part of RFC: kida-modern-syntax-features.

Compile inlined filter to direct method call.

Generates: _str(value).method(*args)

This replaces filter dispatch overhead with a direct method call, providing ~5-10% speedup for filter-heavy templates.

Compile expr ?| filter — skip filter if value is None.

expr ?| uppercompiles to::

None if (_of_N := expr) is None else _filters['upper'](_of_N)

Compile pipeline: expr |> filter1 |> filter2.

Pipelines compile to nested filter calls using the _filters dict, exactly like regular filter chains. The difference is purely syntactic.

expr |> a |> b(x) → _filters['b'](_filters['a'](expr), x)

Validates filter existence at compile time (same as Filter nodes).

Compile safe pipeline: expr ?|> filter1 ?|> filter2.

None-propagating: each step checks for None before applying the filter.

expr ?|> a ?|> b(x)compiles to::

_sp_2 = None if (_sp_1 := expr) is None else _filters['a'](_sp_1)
None if _sp_2 is None else _filters['b'](_sp_2, x)