Struct rslint_parser::Parse

pub struct Parse<T> { /* fields omitted */ }

A utility struct for managing the result of a parser job

Implementations

impl<T> Parse<T>

pub fn new(green: GreenNode, errors: Vec<ParserError>) -> Parse<T>

pub fn green(self) -> GreenNode

Consume the parse result and get its green node. This is useful for multithreaded accesses to the tree as syntax nodes are not sync but green nodes are.

pub fn syntax(&self) -> SyntaxNode

The syntax node represented by this Parse result

use rslint_parser::{parse_text, ast::IfStmt, SyntaxNodeExt, SyntaxKind, AstNode};

let parse = parse_text(
"
    if (a > 5) {
        /* something */
    }
", 0);

// The first child of the root syntax node (Script) is the if statement.
let if_stmt = parse.syntax().first_child().unwrap();

assert_eq!(if_stmt.kind(), SyntaxKind::IF_STMT);

// The if statement node is untyped, we must first cast it to a typed ast node
// to be able to get properties of it in an easy way.
assert_eq!(if_stmt.to::<IfStmt>().condition().unwrap().syntax().text(), "(a > 5)");

pub fn errors(&self) -> &[ParserError]

Get the errors which ocurred when parsing

impl<T: AstNode> Parse<T>

pub fn to_syntax(self) -> Parse<SyntaxNode>

Convert the result to an untyped SyntaxNode parse.

pub fn tree(&self) -> T

Convert this parse result into a typed AST node.

Panics

Panics if the node represented by this parse result mismatches.

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

Try to convert this parse's untyped syntax node into an AST node.

pub fn ok(self) -> Result<T, Vec<ParserError>>

Convert this parse into a result

Trait Implementations

impl<T> Clone for Parse<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Parse<T>

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

Formats the value using the given formatter.