Struct cedar_policy_core::ast::Expr

pub struct Expr<T = ()> { /* private fields */ }

Internal AST for expressions used by the policy evaluator. This structure is a wrapper around an ExprKind, which is the expression variant this object contains. It also contains source information about where the expression was written in policy source code, and some generic data which is stored on each node of the AST. Cloning is O(1).

Implementations

impl<T> Expr<T>

pub fn expr_kind(&self) -> &ExprKind<T>

Access the inner ExprKind for this Expr. The ExprKind is the enum which specifies the expression variant, so it must be accessed by any code matching and recursing on an expression.

pub fn into_expr_kind(self) -> ExprKind<T>

Access the inner ExprKind, taking ownership.

pub fn data(&self) -> &T

Access the data stored on the Expr.

pub fn into_data(self) -> T

Access the data stored on the Expr, taking ownership.

pub fn source_info(&self) -> &Option<SourceInfo>

Access the data stored on the Expr.

pub fn into_source_info(self) -> Option<SourceInfo>

Access the data stored on the Expr, taking ownership.

pub fn set_data(&mut self, data: T)

Update the data for this Expr. A convenient function used by the Validator in one place.

pub fn is_ref(&self) -> bool

Check whether this expression is an entity reference

This is used for policy headers, where some syntax is required to be an entity reference.

pub fn is_slot(&self) -> bool

Check whether this expression is a slot.

pub fn is_ref_set(&self) -> bool

Check whether this expression is a set of entity references

This is used for policy headers, where some syntax is required to be an entity reference set.

pub fn subexpressions(&self) -> impl Iterator<Item = &Self>

Iterate over all sub-expressions in this expression

pub fn slots(&self) -> impl Iterator<Item = &SlotId>

Iterate over all of the slots in this policy AST

pub fn is_projectable(&self) -> bool

Determine if the expression is projectable under partial evaluation An expression is projectable if it’s guaranteed to never error on evaluation This is true if the expression is entirely composed of values or unknowns

impl Expr

pub fn val(v: impl Into<Literal>) -> Self

Create an Expr that’s just a single Literal.

Note that you can pass this a Literal, an i64, a String, etc.

pub fn unknown(name: impl Into<SmolStr>) -> Self

Create an unknown value

pub fn unknown_with_type(name: impl Into<SmolStr>, t: Option<Type>) -> Self

Create an unknown value, with an optional type annotation

pub fn var(v: Var) -> Self

Create an Expr that’s just this literal Var

pub fn slot(s: SlotId) -> Self

Create an Expr that’s just this SlotId

pub fn ite(test_expr: Expr, then_expr: Expr, else_expr: Expr) -> Self

Create a ternary (if-then-else) Expr.

test_expr must evaluate to a Bool type

pub fn not(e: Expr) -> Self

Create a ‘not’ expression. e must evaluate to Bool type

pub fn is_eq(e1: Expr, e2: Expr) -> Self

Create a ‘==’ expression

pub fn noteq(e1: Expr, e2: Expr) -> Self

Create a ‘!=’ expression

pub fn and(e1: Expr, e2: Expr) -> Self

Create an ‘and’ expression. Arguments must evaluate to Bool type

pub fn or(e1: Expr, e2: Expr) -> Self

Create an ‘or’ expression. Arguments must evaluate to Bool type

pub fn less(e1: Expr, e2: Expr) -> Self

Create a ‘<’ expression. Arguments must evaluate to Long type

pub fn lesseq(e1: Expr, e2: Expr) -> Self

Create a ‘<=’ expression. Arguments must evaluate to Long type

pub fn greater(e1: Expr, e2: Expr) -> Self

Create a ‘>’ expression. Arguments must evaluate to Long type

pub fn greatereq(e1: Expr, e2: Expr) -> Self

Create a ‘>=’ expression. Arguments must evaluate to Long type

pub fn add(e1: Expr, e2: Expr) -> Self

Create an ‘add’ expression. Arguments must evaluate to Long type

pub fn sub(e1: Expr, e2: Expr) -> Self

Create a ‘sub’ expression. Arguments must evaluate to Long type

pub fn mul(e1: Expr, e2: Expr) -> Self

Create a ‘mul’ expression. Arguments must evaluate to Long type

pub fn neg(e: Expr) -> Self

Create a ‘neg’ expression. e must evaluate to Long type.

pub fn is_in(e1: Expr, e2: Expr) -> Self

Create an ‘in’ expression. First argument must evaluate to Entity type. Second argument must evaluate to either Entity type or Set type where all set elements have Entity type.

pub fn contains(e1: Expr, e2: Expr) -> Self

Create a ‘contains’ expression. First argument must have Set type.

pub fn contains_all(e1: Expr, e2: Expr) -> Self

Create a ‘contains_all’ expression. Arguments must evaluate to Set type

pub fn contains_any(e1: Expr, e2: Expr) -> Self

Create an ‘contains_any’ expression. Arguments must evaluate to Set type

pub fn set(exprs: impl IntoIterator<Item = Expr>) -> Self

Create an Expr which evaluates to a Set of the given Exprs

pub fn record(pairs: impl IntoIterator<Item = (SmolStr, Expr)>) -> Self

Create an Expr which evaluates to a Record with the given (key, value) pairs.

pub fn call_extension_fn(fn_name: Name, args: Vec<Expr>) -> Self

Create an Expr which calls the extension function with the given Name on args

pub fn unary_app(op: impl Into<UnaryOp>, arg: Expr) -> Self

Create an application Expr which applies the given built-in unary operator to the given arg

pub fn binary_app(op: impl Into<BinaryOp>, arg1: Expr, arg2: Expr) -> Self

Create an application Expr which applies the given built-in binary operator to arg1 and arg2

pub fn get_attr(expr: Expr, attr: SmolStr) -> Self

Create an Expr which gets the attribute of some Entity or the field of some record.

expr must evaluate to either Entity or Record type

pub fn has_attr(expr: Expr, attr: SmolStr) -> Self

Create an Expr which tests for the existence of a given attribute on a given Entity, or field on a given record.

expr must evaluate to either Entity or Record type

pub fn like(expr: Expr, pattern: impl IntoIterator<Item = PatternElem>) -> Self

Create a ‘like’ expression.

expr must evaluate to a String type

pub fn is_unknown(&self) -> bool

Check if an expression contains any symbolic unknowns

pub fn unknowns(&self) -> impl Iterator<Item = &str>

Get all unknowns in an expression

pub fn substitute( &self, definitions: &HashMap<SmolStr, Value>, ) -> Result<Expr, SubstitutionError>

Substitute unknowns with values If a definition is missing, it will be left as an unknown, and can be filled in later.

impl<T> Expr<T>

pub fn eq_shape<U>(&self, other: &Expr<U>) -> bool

Return true if this expression (recursively) has the same expression kind as the argument expression. This accounts for the full recursive shape of the expression, but does not consider source information or any generic data annotated on expression. This should behave the same as the default implementation of Eq before source information and generic data were added.

pub fn hash_shape<H>(&self, state: &mut H)

where H: Hasher,

Implementation of hashing corresponding to equality as implemented by eq_shape. Must satisfy the usual relationship between equality and hashing.

Trait Implementations

impl<'a> AsRef<Expr> for BorrowedRestrictedExpr<'a>

fn as_ref(&self) -> &'a Expr

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Expr> for RestrictedExpr

fn as_ref(&self) -> &Expr

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Expr<T>

fn clone(&self) -> Expr<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Expr<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Expr<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Expr

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

Formats the value using the given formatter.

impl<'a> From<BorrowedRestrictedExpr<'a>> for &'a Expr

fn from(r: BorrowedRestrictedExpr<'a>) -> &'a Expr

Converts to this type from the input type.

impl From<Expr> for Clause

fn from(expr: Expr) -> Clause

Converts to this type from the input type.

impl From<Expr> for Expr

fn from(expr: Expr) -> Expr

Converts to this type from the input type.

impl From<Expr> for PartialValue

fn from(e: Expr) -> Self

Converts to this type from the input type.

impl From<ExtensionValueWithArgs> for Expr

fn from(val: ExtensionValueWithArgs) -> Self

Converts to this type from the input type.

impl From<PartialValue> for Expr

fn from(val: PartialValue) -> Self

Converts to this type from the input type.

impl From<RestrictedExpr> for Expr

fn from(r: RestrictedExpr) -> Expr

Converts to this type from the input type.

impl From<Value> for Expr

fn from(v: Value) -> Self

Converts to this type from the input type.

impl FromStr for Expr

type Err = ParseErrors

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Expr, Self::Err>

Parses a string s to return a value of this type.

impl<T: Hash> Hash for Expr<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for Expr<T>

fn eq(&self, other: &Expr<T>) -> 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<T> Serialize for Expr<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Clause> for Expr

type Error = EstToAstError

The type returned in the event of a conversion error.

fn try_from(clause: Clause) -> Result<Expr, EstToAstError>

Performs the conversion.

impl TryFrom<Expr> for Expr

type Error = EstToAstError

The type returned in the event of a conversion error.

fn try_from(expr: Expr) -> Result<Expr, EstToAstError>

Performs the conversion.

impl TryFrom<Expr> for Value

type Error = NotValue

The type returned in the event of a conversion error.

fn try_from(value: Expr) -> Result<Self, Self::Error>

Performs the conversion.

impl<T: Eq> Eq for Expr<T>

impl<T> StructuralPartialEq for Expr<T>