Struct Parse 

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

The result of parsing: a syntax tree and a collection of errors.

This type is designed to be stored in Salsa databases as it contains the thread-safe GreenNode instead of the non-thread-safe SyntaxNode.

Implementations

impl<T> Parse<T>

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

Create a new Parse result from a GreenNode and errors

pub fn new_with_positioned_errors( green: GreenNode, errors: Vec<String>, positioned_errors: Vec<PositionedParseError>, ) -> Parse<T>

Create a new Parse result from a GreenNode, errors, and positioned errors

pub fn green(&self) -> &GreenNode

Get the green node (thread-safe representation)

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

Get the syntax errors

pub fn positioned_errors(&self) -> &[PositionedParseError]

Get parse errors with position information

pub fn error_messages(&self) -> Vec<String>

Get parse errors as strings (for backward compatibility if needed)

pub fn ok(&self) -> bool

Check if there are any errors

pub fn to_result(self) -> Result<T, ParseError>

where T: AstNode<Language = Lang>,

Convert to a Result, returning the tree if there are no errors

pub fn tree(&self) -> T

where T: AstNode<Language = Lang>,

Get the parsed syntax tree

Returns the syntax tree even if there are parse errors. Use errors() or positioned_errors() to check for errors if needed. This allows for error-resilient tooling that can work with partial/invalid input.

pub fn syntax_node(&self) -> SyntaxNode<Lang>

Get the syntax node

impl Parse<Deb822>

pub fn parse_deb822(text: &str) -> Parse<Deb822>

Parse deb822 text, returning a Parse result

pub fn reparse(&self, new_text: &str, edit: TextRange) -> Parse<Deb822>

Incrementally reparse after a text edit.

Given the new full text and the range that was edited (in the new text coordinates after the edit has been applied), this tries to reuse unchanged paragraphs from the previous parse and only reparse the affected region.

Falls back to a full reparse if the edit spans the entire file or if incremental reparsing is not beneficial.

Trait Implementations

impl<T> Clone for Parse<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Parse<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> PartialEq for Parse<T>

where T: PartialEq,

fn eq(&self, other: &Parse<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for Parse<T>

where T: Eq,

impl<T> Send for Parse<T>

impl<T> StructuralPartialEq for Parse<T>

impl<T> Sync for Parse<T>