Struct rslint_parser::Parser

pub struct Parser<'t> {
    pub file_id: usize,
    pub state: ParserState,
    pub syntax: Syntax,
    pub errors: Vec<ParserError>,
    // some fields omitted
}

An extremely fast, error tolerant, completely lossless JavaScript parser

The Parser yields lower level events instead of nodes. These events are then processed into a syntax tree through a TreeSink implementation.

use rslint_parser::{
    Parser,
    syntax::expr,
    tokenize,
    TokenSource,
    ast::GroupingExpr,
    LosslessTreeSink,
    SyntaxNode,
    process,
    AstNode,
    Syntax
};

let source = "(delete b)";

// File id is used for the labels inside parser errors to report them, the file id
// is used to look up a file's source code and path inside of a codespan `Files` implementation.
let (tokens, lexer_errors) = tokenize(source, 0);

assert!(lexer_errors.is_empty());

// The parser uses a token source which manages yielding non-whitespace tokens,
// and giving raw tokens to allow the parser to turn completed markers into syntax nodes
let token_source = TokenSource::new(source, &tokens);

let mut parser = Parser::new(token_source, 0, Syntax::default());

// Use one of the syntax parsing functions to parse an expression.
// This adds node and token events to the parser which are then used to make a node.
// A completed marker marks the start and end indices in the events vec which signify
// the Start event, and the Finish event.
// Completed markers can be turned into an ast node with parse_marker on the parser
let completed_marker = expr::expr(&mut parser).unwrap();

parser.parse_marker::<GroupingExpr>(&completed_marker);

// Make a new text tree sink, its job is assembling events into a rowan GreenNode.
// At each point (Start, Token, Finish, Error) it also consumes whitespace.
// Other abstractions can also yield lossy syntax nodes if whitespace is not wanted.
// Swap this for a LossyTreeSink for a lossy AST result.
let mut sink = LosslessTreeSink::new(source, &tokens);

// Consume the parser and get its events, then apply them to a tree sink with `process`.
let (events, errors) = parser.finish();
process(&mut sink, events, errors);

let (green, errors) = sink.finish();

assert!(errors.is_empty());

// Make a new SyntaxNode from the green node
let untyped_node = SyntaxNode::new_root(green);

assert!(GroupingExpr::can_cast(untyped_node.kind()));

// Convert the untyped SyntaxNode into a typed AST node
let typed_expr = GroupingExpr::cast(untyped_node).unwrap();

assert_eq!(typed_expr.inner().unwrap().syntax().text(), "delete b");

Fields

file_id: usize

state: ParserState

syntax: Syntax

errors: Vec<ParserError>

Implementations

impl<'t> Parser<'t>

pub fn new(
    tokens: TokenSource<'t>,
    file_id: usize,
    syntax: Syntax
) -> Parser<'t>

Make a new parser

pub fn token_src(&self, token: &Token) -> &str

Get the source code of a token

pub fn finish(self) -> (Vec<Event>, Vec<ParserError>)

Consume the parser and return the list of events it produced

pub fn cur(&self) -> SyntaxKind

Get the current token kind of the parser

pub fn cur_tok(&self) -> Token

Get the current token of the parser

pub fn nth(&self, n: usize) -> SyntaxKind

Look ahead at a token and get its kind, The max lookahead is 4.

pub fn nth_tok(&self, n: usize) -> Token

Look ahead at a token, The max lookahead is 4.

pub fn at(&self, kind: SyntaxKind) -> bool

Check if the parser is currently at a specific token

pub fn nth_at(&self, n: usize, kind: SyntaxKind) -> bool

Check if a token lookahead is something, n must be smaller or equal to 4

pub fn eat(&mut self, kind: SyntaxKind) -> bool

Consume the next token if kind matches.

pub fn err_recover(
    &mut self,
    error: impl Into<ParserError>,
    recovery: TokenSet,
    include_braces: bool
) -> Option<()>

Recover from an error with a recovery set or by using a { or }.

pub fn err_recover_no_err(&mut self, recovery: TokenSet, include_braces: bool)

Recover from an error but don’t add an error to the events

pub fn start(&mut self) -> Marker

Starts a new node in the syntax tree. All nodes and tokens consumed between the start and the corresponding Marker::complete belong to the same node.

pub fn has_linebreak_before_n(&self, n: usize) -> bool

Check if there was a linebreak before a lookahead

pub fn bump(&mut self, kind: SyntaxKind)

Consume the next token if kind matches.

pub fn bump_remap(&mut self, kind: SyntaxKind)

Consume any token but cast it as a different kind

pub fn bump_any(&mut self)

Advances the parser by one token

pub fn err_builder(&self, message: &str) -> Diagnostic

Make a new error builder with error severity

pub fn error(&mut self, err: impl Into<ParserError>)

Add an error

pub fn at_ts(&self, kinds: TokenSet) -> bool

Check if the parser’s current token is contained in a token set

pub fn cur_src(&self) -> &str

Get the source code of the parser’s current token.

Panics

This method panics if the token range and source code range mismatch

pub fn nth_src(&self, n: usize) -> &str

pub fn expect(&mut self, kind: SyntaxKind) -> bool

Try to eat a specific token kind, if the kind is not there then add an error to the events stack.

pub fn marker_range(&self, marker: &CompletedMarker) -> Range<usize>

Get the byte index range of a completed marker for error reporting.

pub fn parse_marker<T: AstNode>(&self, marker: &CompletedMarker) -> T

Parse a completed marker into an ast node.

Panics

Panics if the AST node represented by the marker does not match the generic

pub fn source(&self, range: TextRange) -> &str

Get the source code of a range

pub fn rewind(&mut self, checkpoint: Checkpoint)

Rewind the parser back to a previous position in time

pub fn checkpoint(&self) -> Checkpoint

Get a checkpoint representing the progress of the parser at this point in time

pub fn token_pos(&self) -> usize

Get the current token position

pub fn warning_builder(&self, message: &str) -> Diagnostic

Make a new error builder with warning severity

pub fn err_and_bump(&mut self, err: impl Into<ParserError>)

Bump and add an error event

pub fn err_if_not_ts(
    &mut self,
    marker: impl BorrowMut<CompletedMarker>,
    err: &str
)

pub fn try_parse<F>(&mut self, func: F) -> Option<CompletedMarker> where
    F: FnOnce(&mut Parser<'_>) -> Option<CompletedMarker>, 

Try running a parser function and backtrack if any errors occured

pub fn span_text(&self, span: impl Span) -> &str

pub fn marker_vec_range(&self, markers: &[CompletedMarker]) -> Range<usize>

pub fn expr_with_semi_recovery(
    &mut self,
    assign: bool
) -> Option<CompletedMarker>

impl<'t> Parser<'t>

pub fn with_state<'a>(&'a mut self, state: ParserState) -> StateGuard<'a, 't>

Trait Implementations

impl<'t> Clone for Parser<'t>

fn clone(&self) -> Parser<'t>

Returns a copy of the value.

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

Performs copy-assignment from source.