Trait moore_svlog::ast::AnyNode

pub trait AnyNode<'a>: BasicNode<'a> + AnyNodeData + Display + Send + Sync {
    fn id(&self) -> NodeId;
    fn span(&self) -> Span;
    fn order(&self) -> usize;

    fn human_span(&self) -> Span { ... }
    fn get_parent(&self) -> Option<&'a (dyn AnyNode<'a> + 'a)> { ... }
    fn link(
        &'a self, 
        parent: Option<&'a (dyn AnyNode<'a> + 'a)>, 
        order: &mut usize
    ) { ... }
    fn link_attach(&'a self, parent: &'a (dyn AnyNode<'a> + 'a), order: usize) { ... }
    fn as_ptr(&self) -> *const u8 { ... }
}

An AST node.

Required methods

fn id(&self) -> NodeId

Get this node’s unique ID.

fn span(&self) -> Span

Get this node’s span in the input.

fn order(&self) -> usize

Get this node’s lexical order.

Provided methods

fn human_span(&self) -> Span

Get a span that is terse and suitable to pinpoint the node for a human.

fn get_parent(&self) -> Option<&'a (dyn AnyNode<'a> + 'a)>

Get this node’s parent.

fn link(&'a self, parent: Option<&'a (dyn AnyNode<'a> + 'a)>, order: &mut usize)

Link up this node.

fn link_attach(&'a self, parent: &'a (dyn AnyNode<'a> + 'a), order: usize)

Link up this node as an expansion of another node.

All subnodes inherit the order from their parent. Useful if a node is generated as part of a later expansion/analysis pass, but needs to hook into the AST somewhere.

fn as_ptr(&self) -> *const u8

Convert this node reference to a pointer for identity comparisons.

Trait Implementations

impl<'a> Hash for &'a (dyn AnyNode<'a> + 'a)

pub fn hash<H>(&self, h: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq<&'a (dyn AnyNode<'a> + 'a)> for &'a (dyn AnyNode<'a> + 'a)

pub fn eq(&self, other: &&'a (dyn AnyNode<'a> + 'a)) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> Eq for &'a (dyn AnyNode<'a> + 'a)

Implementors

impl<'a> AnyNode<'a> for DefNode<'a>

impl<'a> AnyNode<'a> for TypeOrExpr<'a>

impl<'a, T> AnyNode<'a> for Node<'a, T> where
    T: Debug + ForEachChild<'a> + Send + Sync,
    Node<'a, T>: BasicNode<'a>,
    Node<'a, T>: Display,
    Node<'a, T>: AnyNodeData, 

Automatically implement AnyNode for Node<T> if enough information is present.