Struct SpannedExpr 

pub struct SpannedExpr<'src> {
    pub origin: Origin<'src>,
    pub inner: Expr<'src>,
}

An expression along with its source origin (span and unparsed form).

Important: Because of how our parser works internally, an expression’s span is its rule’s span, which can be larger than the expression itself. For example, foo || bar || baz is covered by a single rule, so each decomposed Expr::BinOp within it will have the same span despite logically having different sub-spans of the parent rule’s span.

Fields

origin: Origin<'src>

The expression’s source origin.

inner: Expr<'src>

The expression itself.

Implementations

impl<'a> SpannedExpr<'a>

pub fn dataflow_contexts(&self) -> Vec<(&Context<'a>, &Origin<'a>)>

Returns the contexts in this expression that directly flow into the expression’s evaluation.

For example ${{ foo.bar }} returns foo.bar since the value of foo.bar flows into the evaluation. On the other hand, ${{ foo.bar == 'abc' }} returns no expanded contexts, since the value of foo.bar flows into a boolean evaluation that gets expanded.

pub fn computed_indices(&self) -> Vec<&SpannedExpr<'a>>

Returns any computed indices in this expression.

A computed index is any index operation with a non-literal evaluation, e.g. foo[a.b.c].

pub fn constant_reducible_subexprs(&self) -> Vec<&SpannedExpr<'a>>

Like Expr::constant_reducible, but for all subexpressions rather than the top-level expression.

This has slightly different semantics than constant_reducible: it doesn’t include “trivially” reducible expressions like literals, since flagging these as reducible within a larger expression would be misleading.

Methods from Deref<Target = Expr<'a>>

pub fn is_literal(&self) -> bool

Returns whether the expression is a literal.

pub fn constant_reducible(&self) -> bool

Returns whether the expression is constant reducible.

“Constant reducible” is similar to “constant foldable” but with meta-evaluation semantics: the expression 5 would not be constant foldable in a normal program (because it’s already an atom), but is “constant reducible” in a GitHub Actions expression because an expression containing it (e.g. ${{ 5 }}) can be elided entirely and replaced with 5.

There are three kinds of reducible expressions:

1. Literals, which reduce to their literal value;
2. Binops/unops with reducible subexpressions, which reduce to their evaluation;
3. Select function calls where the semantics of the function mean that reducible arguments make the call itself reducible.

NOTE: This implementation is sound but not complete.

pub fn consteval(&self) -> Option<Evaluation>

Evaluates a constant-reducible expression to its literal value.

Returns Some(Evaluation) if the expression can be constant-evaluated, or None if the expression contains non-constant elements (like contexts or non-reducible function calls).

This implementation follows GitHub Actions’ evaluation semantics as documented at: https://docs.github.com/en/actions/reference/workflows-and-actions/expressions

Examples

use github_actions_expressions::{Expr, Evaluation};

let expr = Expr::parse("'hello'").unwrap();
let result = expr.consteval().unwrap();
assert_eq!(result.sema().to_string(), "hello");

let expr = Expr::parse("true && false").unwrap();
let result = expr.consteval().unwrap();
assert_eq!(result, Evaluation::Boolean(false));

Trait Implementations

impl<'src> Debug for SpannedExpr<'src>

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

Formats the value using the given formatter.

impl<'a> Deref for SpannedExpr<'a>

type Target = Expr<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'doc> From<&SpannedExpr<'doc>> for Fragment<'doc>

fn from(expr: &SpannedExpr<'doc>) -> Self

Converts to this type from the input type.

impl<'src> PartialEq for SpannedExpr<'src>

fn eq(&self, other: &SpannedExpr<'src>) -> 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<'src> StructuralPartialEq for SpannedExpr<'src>