Enum Expr

pub enum Expr<'src> {
    Literal(Literal<'src>),
    Star,
    Call {
        func: Function<'src>,
        args: Vec<Expr<'src>>,
    },
    Identifier(Identifier<'src>),
    Index(Box<Expr<'src>>),
    Context(Context<'src>),
    BinOp {
        lhs: Box<Expr<'src>>,
        op: BinOp,
        rhs: Box<Expr<'src>>,
    },
    UnOp {
        op: UnOp,
        expr: Box<Expr<'src>>,
    },
}

Represents a GitHub Actions expression.

Variants

Literal(Literal<'src>)

A literal value.

Star

The * literal within an index or context.

Call

A function call.

Fields

func: Function<'src>

The function name, e.g. foo in foo().

args: Vec<Expr<'src>>

The function’s arguments.

Identifier(Identifier<'src>)

A context identifier component, e.g. github in github.actor.

Index(Box<Expr<'src>>)

A context index component, e.g. [0] in foo[0].

Context(Context<'src>)

A full context reference.

BinOp

A binary operation, either logical or arithmetic.

Fields

lhs: Box<Expr<'src>>

The LHS of the binop.

op: BinOp

The binary operator.

rhs: Box<Expr<'src>>

The RHS of the binop.

UnOp

A unary operation. Negation (!) is currently the only UnOp.

Fields

op: UnOp

The unary operator.

expr: Box<Expr<'src>>

The expression to apply the operator to.

Implementations

impl<'src> Expr<'src>

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 has_constant_reducible_subexpr(&self) -> bool

Like Self::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.

pub fn dataflow_contexts(&self) -> Vec<&Context<'src>>

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 parse(expr: &str) -> Result<Expr<'_>>

Parses the given string into an expression.

Trait Implementations

impl<'src> Debug for Expr<'src>

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

Formats the value using the given formatter.

impl<'src> From<&'src str> for Expr<'src>

fn from(s: &'src str) -> Self

Converts to this type from the input type.

impl From<String> for Expr<'_>

fn from(s: String) -> Self

Converts to this type from the input type.

impl From<bool> for Expr<'_>

fn from(b: bool) -> Self

Converts to this type from the input type.

impl From<f64> for Expr<'_>

fn from(n: f64) -> Self

Converts to this type from the input type.

impl<'src> PartialEq for Expr<'src>

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