Trait Parser 

pub trait Parser<L: Language + Send + Sync>
where
    L::ElementType: From<L::TokenType>,
{
    // Required method
    fn parse<'a, S: Source + ?Sized>(
        &self,
        text: &'a S,
        edits: &[TextEdit],
        cache: &'a mut impl ParseCache<L>,
    ) -> ParseOutput<'a, L>;
}

Core parser trait that defines the interface for language parsers.

This trait is responsible for converting a stream of tokens into a green tree (a lossless, immutable syntax tree). It supports incremental parsing by taking previous edits and using a cache for reuse.

Usage Scenario

The Parser is typically used after lexical analysis to:

1. Take a sequence of tokens produced by a Lexer.
2. Build a GreenNode tree representing the hierarchical structure of the source.
3. Handle incremental updates by reusing nodes from a previous GreenNode tree.

Incremental Parsing

The parse method should ideally be able to reuse nodes from a previous parse if the source has only changed partially. This is facilitated by the ParseCache and the provided TextEdits.

Required Methods

fn parse<'a, S: Source + ?Sized>( &self, text: &'a S, edits: &[TextEdit], cache: &'a mut impl ParseCache<L>, ) -> ParseOutput<'a, L>

The core parsing entry point for converting tokens into a syntax tree.

This method orchestrates the parsing process. It performs lexical analysis (if not already cached) and then builds a green tree structure. It handles incremental reuse automatically if the cache contains a previous tree.

Arguments

• text - The source text to parse.
• edits - A slice of TextEdits representing changes since the last parse. Used for incremental parsing.
• cache - The ParseCache for resources, incremental reuse, and diagnostics.

Returns

A ParseOutput containing the root GreenNode and any diagnostics.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors