Struct BorrowedRestrictedExpr

pub struct BorrowedRestrictedExpr<'a>(/* private fields */);

While RestrictedExpr wraps an owned Expr, BorrowedRestrictedExpr wraps a borrowed Expr, with the same invariants.

We derive Copy for this type because it’s just a single reference, and &T is Copy for all T.

Implementations

impl<'a> BorrowedRestrictedExpr<'a>

pub fn new(expr: &'a Expr) -> Result<Self, RestrictedExpressionError>

Create a new BorrowedRestrictedExpr from an &Expr.

This function is “safe” in the sense that it will verify that the provided expr does indeed qualify as a “restricted” expression, returning an error if not.

Note this check requires recursively walking the AST. For a version of this function that doesn’t perform this check, see new_unchecked() below.

pub fn new_unchecked(expr: &'a Expr) -> Self

Create a new BorrowedRestrictedExpr from an &Expr, where the caller is responsible for ensuring that the Expr is a valid “restricted expression”. If it is not, internal invariants will be violated, which may lead to other errors later, panics, or even incorrect results.

For a “safer” version of this function that returns an error for invalid inputs, see new() above.

pub fn to_natural_json(self) -> Result<Value, JsonSerializationError>

Write a BorrowedRestrictedExpr in “natural JSON” format.

Used to output the context as a map from Strings to JSON Values

pub fn to_owned(self) -> RestrictedExpr

Convert BorrowedRestrictedExpr to RestrictedExpr. This has approximately the cost of cloning the Expr.

pub fn as_bool(&self) -> Option<bool>

Get the bool value of this RestrictedExpr if it’s a boolean, or None if it is not a boolean

pub fn as_long(&self) -> Option<i64>

Get the i64 value of this RestrictedExpr if it’s a long, or None if it is not a long

pub fn as_string(&self) -> Option<&SmolStr>

Get the SmolStr value of this RestrictedExpr if it’s a string, or None if it is not a string

pub fn as_euid(&self) -> Option<&EntityUID>

Get the EntityUID value of this RestrictedExpr if it’s an entity reference, or None if it is not an entity reference

pub fn as_unknown(&self) -> Option<&Unknown>

Get Unknown value of this RestrictedExpr if it’s an Unknown, or None if it is not an Unknown

pub fn as_set_elements( &self, ) -> Option<impl Iterator<Item = BorrowedRestrictedExpr<'_>>>

Iterate over the elements of the set if this RestrictedExpr is a set, or None if it is not a set

pub fn as_record_pairs( &self, ) -> Option<impl Iterator<Item = (&SmolStr, BorrowedRestrictedExpr<'_>)>>

Iterate over the (key, value) pairs of the record if this RestrictedExpr is a record, or None if it is not a record

pub fn as_extn_fn_call( &self, ) -> Option<(&Name, impl Iterator<Item = BorrowedRestrictedExpr<'_>>)>

Get the name and args of the called extension function if this RestrictedExpr is an extension function call, or None if it is not an extension function call

pub fn try_type_of(&self, extensions: &Extensions<'_>) -> Option<Type>

Try to compute the runtime type of this expression. See Expr::try_type_of for exactly what this computes.

On a restricted expression, there are fewer cases where we might fail to compute the type, but there are still unknowns and extension function calls which may cause this function to return None .

Methods from Deref<Target = Expr>

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 data(&self) -> &T

Access the data stored on the Expr.

pub fn source_loc(&self) -> Option<&Loc>

Access the Loc stored on the Expr.

pub fn is_ref(&self) -> bool

Check whether this expression is an entity reference

This is used for policy scopes, 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 scopes, 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 = Slot> + '_

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

pub fn try_type_of(&self, extensions: &Extensions<'_>) -> Option<Type>

Try to compute the runtime type of this expression. This operation may fail (returning None), for example, when asked to get the type of any variables, any attributes of entities or records, or an unknown without an explicitly annotated type.

Also note that this is not typechecking the expression. It does not check that the expression actually evaluates to a value (as opposed to erroring).

Because of these limitations, this function should only be used to obtain a type for use in diagnostics such as error strings.

pub fn contains_unknown(&self) -> bool

Check if an expression contains any symbolic unknowns

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

Get all unknowns in an expression

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

Substitute unknowns with concrete values.

Ignores unmapped unknowns. Ignores type annotations on unknowns.

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

Substitute unknowns with concrete values.

Ignores unmapped unknowns. Errors if the substituted value does not match the type annotation on the unknown.

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<'a> Clone for BorrowedRestrictedExpr<'a>

fn clone(&self) -> BorrowedRestrictedExpr<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for BorrowedRestrictedExpr<'a>

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

Formats the value using the given formatter.

impl<'a> Display for BorrowedRestrictedExpr<'a>

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<'a> Hash for BorrowedRestrictedExpr<'a>

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<'a> PartialEq for BorrowedRestrictedExpr<'a>

fn eq(&self, other: &BorrowedRestrictedExpr<'a>) -> 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<'a> Serialize for BorrowedRestrictedExpr<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Deref for BorrowedRestrictedExpr<'a>

type Target = Expr

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a> Copy for BorrowedRestrictedExpr<'a>

impl<'a> Eq for BorrowedRestrictedExpr<'a>

impl<'a> StructuralPartialEq for BorrowedRestrictedExpr<'a>