Struct RestrictedExpr

pub struct RestrictedExpr(/* private fields */);

A few places in Core use these “restricted expressions” (for lack of a better term) which are in some sense the minimal subset of Expr required to express all possible Values.

Specifically, “restricted” expressions are defined as expressions containing only the following:

• bool, int, and string literals
• literal EntityUIDs such as User::“alice”
• extension function calls, where the arguments must be other things on this list
• set and record literals, where the values must be other things on this list

That means the following are not allowed in “restricted” expressions:

• principal, action, resource, context
• builtin operators and functions, including ., in, has, like, .contains()
• if-then-else expressions

These restrictions represent the expressions that are allowed to appear as attribute values in Slice and Context.

Implementations

impl RestrictedExpr

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

Create a new RestrictedExpr 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: Expr) -> Self

Create a new RestrictedExpr 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 with_maybe_source_loc(self, source_loc: Option<Loc>) -> Self

Return the RestrictedExpr, but with the new source_loc (or None).

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

Create a RestrictedExpr that’s just a single Literal.

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

pub fn unknown(u: Unknown) -> Self

Create a RestrictedExpr that’s just a single Unknown.

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

Create a RestrictedExpr which evaluates to a Set of the given RestrictedExprs

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

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

Throws an error if any key occurs two or more times.

pub fn call_extension_fn( function_name: Name, args: impl IntoIterator<Item = RestrictedExpr>, ) -> Self

Create a RestrictedExpr which calls the given extension function

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

Write a RestrictedExpr in “natural JSON” format.

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

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

impl RestrictedExpr

pub fn as_borrowed(&self) -> BorrowedRestrictedExpr<'_>

Turn an &RestrictedExpr into a BorrowedRestrictedExpr

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 AsRef<Expr> for RestrictedExpr

fn as_ref(&self) -> &Expr

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

impl Clone for RestrictedExpr

fn clone(&self) -> RestrictedExpr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RestrictedExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RestrictedExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RestrictedExpr

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

Formats the value using the given formatter.

impl From<Context> for RestrictedExpr

fn from(value: Context) -> 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 RestrictedExpr

fn from(value: Value) -> RestrictedExpr

Converts to this type from the input type.

impl From<ValueKind> for RestrictedExpr

fn from(value: ValueKind) -> RestrictedExpr

Converts to this type from the input type.

impl FromStr for RestrictedExpr

type Err = RestrictedExpressionParseError

The associated error which can be returned from parsing.

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

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

impl Hash for RestrictedExpr

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 PartialEq for RestrictedExpr

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<PartialValue> for RestrictedExpr

type Error = PartialValueToRestrictedExprError

The type returned in the event of a conversion error.

fn try_from( pvalue: PartialValue, ) -> Result<RestrictedExpr, PartialValueToRestrictedExprError>

Performs the conversion.

impl Deref for RestrictedExpr

type Target = Expr

The resulting type after dereferencing.

fn deref(&self) -> &Expr

Dereferences the value.

impl Eq for RestrictedExpr

impl StructuralPartialEq for RestrictedExpr