Enum ludtwig_parser::ast::SyntaxNode

pub enum SyntaxNode {
    Root(Vec<SyntaxNode>),
    Tag(Tag),
    Plain(Plain),
    Whitespace,
    HtmlComment(HtmlComment),
    OutputExpression(OutputExpression),
    TwigComment(TwigComment),
    TwigStatement(TwigStatement),
    TwigStructure(TwigStructure<SyntaxNode>),
}

The base enum for each syntax element in a document. Each variant represents some sort of structured representation of the document syntax. This is the foundation for the AST (abstract syntax tree) that is produced by the parser.

Variants

Root(Vec<SyntaxNode>)

The root of the AST which contains other SyntaxNode values.

Tag(Tag)

Plain old Html tag that can have any value as a name (even vue components for example). It may also have attributes. It can also have children which are only a list of SyntaxNode instances. For example <h2 class="bold">...</h2>

Plain(Plain)

Basically only plain text but does only represent text without line break characters or indentation.

Whitespace

Some sort of whitespace (can be anything from spaces to tabs to line breaks). Multiple sequential forms of whitespace will always result in only one instance of this.

HtmlComment(HtmlComment)

Comments in Html that look like <!-- some comment -->

OutputExpression(OutputExpression)

Some expression to output something like
twig: {{ my_counter|e }} (can be php)
vue: {{ myCounter.count }} (can be javascript)

TwigComment(TwigComment)

Comment in twig syntax: {# some comment #}

TwigStatement(TwigStatement)

Some execute statement that has no children / has no closing syntax.

Examples

{% set foo = 'foo' %}

or {% parent %}

or ...

TwigStructure(TwigStructure<SyntaxNode>)

Some hierarchical twig syntax.

Examples

{% block my_block_name %}...{% endblock %}

Notes

This is preferred over TwigStatement by the parser if it sees special keywords like block right after the {% .

Implementations

impl SyntaxNode

pub fn is_whitespace(&self) -> bool

impl SyntaxNode

pub fn context_iter(&self) -> AstContextIterator<'_, SyntaxNode>

Create a borrowing iterator over this &SyntaxNode and all it's children (and their children, ...). It visits in a pre-order tree traversal:

1. visits the node itself
2. visits all the child nodes

Also each node is visited with a IteratorContext that contains the following information:

• the parent node of the currently visited one.
• the previous node in the tree before the visited one (same depth).
• the after node in the tree that occurs after the visited one (same depth).

pub fn context_attribute_iter(&self) -> AstContextIterator<'_, TagAttribute>

Create a borrowing iterator over the &TagAttributes of a &Tag that iterates over all nested attributes with a context. If this &SyntaxNode is not a &Tag it will return an empty iterator.

Also each attribute is visited with a IteratorContext that contains the following information:

• the parent attribute of the currently visited one.
• the previous attribute in the tree before the visited one (same depth).
• the after attribute in the tree that occurs after the visited one (same depth).

impl SyntaxNode

pub fn iter(&self) -> AstIterator<'_, SyntaxNode>

Create a borrowing iterator over this &SyntaxNode and all it's children (and their children, ...). It visits in a pre-order tree traversal:

1. visits the node itself
2. visits all the child nodes

pub fn attribute_iter(&self) -> AstIterator<'_, TagAttribute>

Create a borrowing iterator over the &TagAttributes of a &Tag that iterates over all nested attributes. If this &SyntaxNode is not a &Tag it will return an empty iterator.

It visits in a pre-order tree traversal:

1. visits the attribute itself
2. visits all the child attributes

Trait Implementations

impl Clone for SyntaxNode

fn clone(&self) -> SyntaxNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SyntaxNode

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

Formats the value using the given formatter.

impl Eq for SyntaxNode

impl<'a> IntoIterator for &'a SyntaxNode

type Item = &'a SyntaxNode

The type of the elements being iterated over.

type IntoIter = AstIterator<'a, SyntaxNode>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Create a borrowing iterator over this &SyntaxNode and all it's children (and their children, ...). It visits in a pre-order tree traversal:

1. visits the node itself
2. visits all the child nodes

impl PartialEq<SyntaxNode> for SyntaxNode

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

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

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

This method tests for !=.

impl StructuralEq for SyntaxNode

impl StructuralPartialEq for SyntaxNode