Struct Node

pub struct Node<T> {
    pub node: T,
    pub loc: Loc,
}

Metadata for our syntax trees

Fields

node: T

Main data represented

loc: Loc

Source location

Implementations

impl Node<Option<Expr>>

pub fn to_ref(&self, var: Var) -> Result<EntityUID, ParseErrors>

Extract a single EntityUID from this expression. The expression must be exactly a single entity literal expression.

pub fn to_ref_or_slot(&self, var: Var) -> Result<EntityReference, ParseErrors>

Extract a single EntityUID or a template slot from this expression. The expression must be exactly a single entity literal expression or a single template slot.

pub fn to_refs(&self, var: Var) -> Result<OneOrMultipleRefs, ParseErrors>

Extract a single EntityUID or set of EntityUIDs from this expression. The expression must either be exactly a single entity literal expression a single set literal expression, containing some number of entity literals.

impl Node<Option<Policies>>

pub fn with_generated_policyids( &self, ) -> Result<impl Iterator<Item = (PolicyID, &Node<Option<Policy>>)>, ParseErrors>

Iterate over the Policy nodes in this cst::Policies, with corresponding generated PolicyIDs

pub fn to_policyset(&self) -> Result<PolicySet, ParseErrors>

convert cst::Policies to ast::PolicySet

impl Node<Option<Policy>>

pub fn to_policy_or_template( &self, id: PolicyID, ) -> Result<Either<StaticPolicy, Template>, ParseErrors>

Convert cst::Policy to an AST InlinePolicy or Template

pub fn to_policy(&self, id: PolicyID) -> Result<StaticPolicy, ParseErrors>

Convert cst::Policy to an AST InlinePolicy. (Will fail if the CST is for a template)

pub fn to_policy_template(&self, id: PolicyID) -> Result<Template, ParseErrors>

Convert cst::Policy to ast::Template. Works for inline policies as well, which will become templates with 0 slots

impl Node<Option<Annotation>>

pub fn to_kv_pair<T>( &self, annotation_constructor: impl Fn(Option<SmolStr>, &Loc) -> T, ) -> Result<(AnyId, T), ParseErrors>

Get the (k, v) pair for the annotation. Critically, this checks validity for the strings and does unescaping

impl Node<Option<Ident>>

pub fn to_valid_ident(&self) -> Result<Id, ParseErrors>

Convert cst::Ident to ast::Id. Fails for reserved or invalid identifiers

pub fn to_any_ident(&self) -> Result<AnyId, ParseErrors>

Convert cst::Ident to ast::AnyId. This method does not fail for reserved identifiers; see notes on ast::AnyId. (It does fail for invalid identifiers, but there are no invalid identifiers at the time of this writing; see notes on cst::Ident::Invalid)

impl Node<Option<Expr>>

pub fn to_expr(&self) -> Result<Expr, ParseErrors>

convert cst::Expr to ast::Expr

impl Node<Option<Member>>

pub fn to_lit(&self) -> Option<&Literal>

Try to convert cst::Member into a cst::Literal, i.e. match Member(Primary(Literal(_), [])). It does not match the Expr arm of Primary, which means expressions like (1) are not considered as literals on the CST level.

impl Node<Option<Primary>>

pub fn to_string_literal(&self) -> Result<SmolStr, ParseErrors>

convert cst::Primary representing a string literal to a SmolStr.

impl Node<Option<Ref>>

pub fn to_ref(&self) -> Result<EntityUID, ParseErrors>

convert cst::Ref to ast::EntityUID

impl<T> Node<T>

pub fn with_source_loc(node: T, loc: Loc) -> Self

Create a new Node with the given source location

pub fn map<R>(self, f: impl FnOnce(T) -> R) -> Node<R>

Transform the inner value while retaining the attached source info.

pub fn as_ref(&self) -> Node<&T>

Converts from &Node<T> to Node<&T>.

pub fn as_mut(&mut self) -> Node<&mut T>

Converts from &mut Node<T> to Node<&mut T>.

pub fn into_inner(self) -> (T, Loc)

Consume the Node, yielding the node and attached source info.

pub fn to_ast_err(&self, error_kind: impl Into<ToASTErrorKind>) -> ToASTError

Utility to construct a ToAstError with the source location taken from this node.

impl<T: Clone> Node<&T>

pub fn cloned(self) -> Node<T>

Converts a Node<&T> to a Node<T> by cloning the inner value.

impl<T: Copy> Node<&T>

pub fn copied(self) -> Node<T>

Converts a Node<&T> to a Node<T> by copying the inner value.

impl<T> Node<Option<T>>

Convenience methods on Node<Option<T>>

pub fn as_inner(&self) -> Option<&T>

Get the inner data as &T, if it exists

pub fn collapse(&self) -> Option<Node<&T>>

None if the node is empty, otherwise a node without the Option

pub fn apply<F, R>(&self, f: F) -> Option<R>

where F: FnOnce(&T, &Loc) -> Option<R>,

Apply the function f to the main data and source info. Returns None if no main data or if f returns None.

pub fn into_apply<F, R>(self, f: F) -> Option<R>

where F: FnOnce(T, Loc) -> Option<R>,

Apply the function f to the main data and Loc, consuming them. Returns None if no main data or if f returns None.

pub fn try_as_inner(&self) -> Result<&T, ToASTError>

Get node data if present or return the error EmptyNodeInvariantViolation

pub fn try_into_inner(self) -> Result<T, ToASTError>

Get node data if present or return the error EmptyNodeInvariantViolation

Trait Implementations

impl<T: Clone> Clone for Node<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Node<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Node<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<T: Diagnostic> Diagnostic for Node<T>

fn source_code(&self) -> Option<&dyn SourceCode>

Source code to apply this Diagnostic’s Diagnostic::labels to.

fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>>

Labels to apply to this Diagnostic’s Diagnostic::source_code

fn code<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

Unique diagnostic code that can be used to look up more information about this Diagnostic. Ideally also globally unique, and documented in the toplevel crate’s documentation for easy searching. Rust path format (foo::bar::baz) is recommended, but more classic codes like E0123 or enums will work just fine.

fn severity(&self) -> Option<Severity>

Diagnostic severity. This may be used by ReportHandlers to change the display format of this diagnostic.

fn help<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

Additional help text related to this Diagnostic. Do you have any advice for the poor soul who’s just run into this issue?

fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

URL to visit for a more detailed explanation/help about this Diagnostic.

fn related<'a>( &'a self, ) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>>

Additional related Diagnostics.

fn diagnostic_source(&self) -> Option<&dyn Diagnostic>

The cause of the error.

impl<T: Display> Display for Node<T>

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

Formats the value using the given formatter.

impl<T: Error> Error for Node<T>

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<T: Hash> Hash for Node<T>

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

ignores metadata

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 Node<T>

fn eq(&self, other: &Self) -> bool

ignores metadata

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 Node<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<&Node<Option<Add>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(a: &Node<Option<Add>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<And>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(a: &Node<Option<And>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<Expr>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(e: &Node<Option<Expr>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<Literal>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(lit: &Node<Option<Literal>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<Member>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(m: &Node<Option<Member>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<Mult>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(m: &Node<Option<Mult>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<Name>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(name: &Node<Option<Name>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<Or>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(o: &Node<Option<Or>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<Relation>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(r: &Node<Option<Relation>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl TryFrom<&Node<Option<Unary>>> for Expr

type Error = ParseErrors

The type returned in the event of a conversion error.

fn try_from(u: &Node<Option<Unary>>) -> Result<Expr, ParseErrors>

Performs the conversion.

impl<T: Eq> Eq for Node<T>