Struct ASTNode 

pub struct ASTNode<N> {
    pub node: N,
    pub info: SourceInfo,
}

Metadata for our syntax trees

Fields

node: N

Main data represented

info: SourceInfo

additional information

Implementations

impl ASTNode<Option<Policies>>

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

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

pub fn to_policyset(&self, errs: &'_ mut Vec<ParseError>) -> Option<PolicySet>

convert cst::Policies to ast::PolicySet

impl ASTNode<Option<Policy>>

pub fn to_policy_or_template( &self, id: PolicyID, errs: &'_ mut Vec<ParseError>, ) -> Option<Either<StaticPolicy, Template>>

Convert cst::Policy to an AST InlinePolicy or Template

pub fn to_policy( &self, id: PolicyID, errs: &'_ mut Vec<ParseError>, ) -> Option<StaticPolicy>

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

pub fn to_policy_template( &self, id: PolicyID, errs: &'_ mut Vec<ParseError>, ) -> Option<Template>

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

impl ASTNode<Option<Annotation>>

pub fn to_kv_pair(&self, errs: &'_ mut Vec<ParseError>) -> Option<(Id, SmolStr)>

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

impl ASTNode<Option<Ident>>

pub fn to_valid_ident(&self, errs: &'_ mut Vec<ParseError>) -> Option<Id>

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

impl ASTNode<Option<Expr>>

pub fn to_expr(&self, errs: &'_ mut Vec<ParseError>) -> Option<Expr>

convert cst::Expr to ast::Expr

impl ASTNode<Option<Primary>>

pub fn to_string_literal( &self, errs: &'_ mut Vec<ParseError>, ) -> Option<SmolStr>

convert cst::Primary representing a string literal to a SmolStr. Fails (and adds to errs) if the Primary wasn’t a string literal.

impl ASTNode<Option<Ref>>

pub fn to_ref(&self, errs: &'_ mut Vec<ParseError>) -> Option<EntityUID>

convert cst::Ref to ast::EntityUID

impl<N> ASTNode<N>

pub fn new(node: N, left: usize, right: usize) -> Self

Create a new Node from main data

pub fn from_source(node: N, info: SourceInfo) -> Self

Create a new Node from main data

pub fn as_ref(&self) -> ASTNode<&N>

like Option.as_ref()

pub fn map<D>(self, f: impl FnOnce(N) -> D) -> ASTNode<D>

map the main data, leaving the SourceInfo alone

pub fn into_inner(self) -> (N, SourceInfo)

consume the Node, producing the main data and the SourceInfo

impl<T> ASTNode<Option<T>>

Convenience methods on ASTNode<Option<T>>

pub fn as_inner_pair(&self) -> (&SourceInfo, Option<&T>)

Similar to .as_inner(), but also gives access to the SourceInfo

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

Get the inner data as &T, if it exists

pub fn collapse(&self) -> Option<ASTNode<&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, &SourceInfo) -> 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, SourceInfo) -> Option<R>,

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

Trait Implementations

impl<N: Clone> Clone for ASTNode<N>

fn clone(&self) -> ASTNode<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug> Debug for ASTNode<N>

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

Formats the value using the given formatter.

impl<N: PartialEq> PartialEq for ASTNode<N>

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<N: Eq> Eq for ASTNode<N>