Enum ParsedSyntax 

pub enum ParsedSyntax {
    Absent,
    Present(CompletedMarker),
}

Syntax that is either present in the source tree or absent.

This type is commonly used as the return type of parse functions with the following types

Parse Rule conventions

• A parse rule must return ParsedSyntax::Present if it is able to parse a node or at least parts of it. For example, the parse_for_statement should return ParsedSyntax::Present for for ( even tough many of the required children are missing because it is still able to parse parts of the for statement.
• A parse rule must return ParsedSyntax::Absent if the expected node isn’t present in the source code. In most cases, this means if the first expected token isn’t present, for example, if the for keyword isn’t present when parsing a for statement.

However, it can be possible for rules to recover even if the first token doesn’t match. One example is when parsing an assignment target that has an optional default. The rule can recover even if the assignment target is missing as long as the cursor is then positioned at an = token.

The rule must then return ParsedSyntax::Present with the partial parsed node.

• A parse rule must not eat any tokens when it returns ParsedSyntax::Absent
• A parse rule must not add any errors when it returns ParsedSyntax::Absent

This is a custom enum over using Option because ParsedSyntax::Absent values must be handled by the caller.

Variants

Absent

A syntax that isn’t present in the source code. Used when a parse rule can’t match the current token of the parser.

Present(CompletedMarker)

A completed syntax node with all or some of its children.

Implementations

impl ParsedSyntax

pub fn ok(self) -> Option<CompletedMarker>

Converts from ParsedSyntax to Option<CompletedMarker>.

Converts self into an Option<CompletedMarker>, consuming self

pub fn and_then<F>(self, op: F) -> ParsedSyntax

where F: FnOnce(CompletedMarker) -> ParsedSyntax,

Calls op if the syntax is present and otherwise returns ParsedSyntax::Absent

pub fn or_else<F>(self, op: F) -> ParsedSyntax

where F: FnOnce() -> ParsedSyntax,

Calls op if the syntax is absent and otherwise returns ParsedSyntax::Present

pub fn is_present(&self) -> bool

Returns true if the parsed syntax is ParsedSyntax::Present

pub fn is_absent(&self) -> bool

Returns true if the parsed syntax is ParsedSyntax::Absent

pub fn unwrap(self) -> CompletedMarker

It returns the contained ParsedSyntax::Present value, consuming the self value

Panics

Panics if the current syntax is ParsedSyntax::Absent

pub fn unwrap_or(self, default: CompletedMarker) -> CompletedMarker

Returns the contained ParsedSyntax::Present value or passed default

pub fn unwrap_or_else<F>(self, default: F) -> CompletedMarker

where F: FnOnce() -> CompletedMarker,

Returns the contained ParsedSyntax::Present value or computes it from a clojure.

pub fn expect(self, msg: &str) -> CompletedMarker

Returns the contained ParsedSyntax::Present value, consuming the self value.

Panics

Panics if the value is an ParsedSyntax::Absent with a custom panic message provided by msg.

pub fn map<F>(self, mapper: F) -> ParsedSyntax

where F: FnOnce(CompletedMarker) -> CompletedMarker,

Maps a ParsedSyntax::Present ParsedSyntax by applying a function to a contained ParsedSyntax::Present value, leaving an ParsedSyntax::Absent value untouched.

This function can be used to compose the results of two functions.

pub fn kind<P>(&self, p: &P) -> Option<<P as Parser>::Kind>

where P: Parser,

Returns the kind of the syntax if it is present or None otherwise

pub fn add_diagnostic_if_present<P, E, D>( self, p: &mut P, error_builder: E, ) -> Option<CompletedMarker>

where P: Parser, E: FnOnce(&P, TextRange) -> D, D: ToDiagnostic<P>,

Adds a diagnostic at the current parser position if the syntax is present and return its marker.

pub fn or_add_diagnostic<P, E, D>( self, p: &mut P, error_builder: E, ) -> Option<CompletedMarker>

where P: Parser, E: FnOnce(&P, TextRange) -> D, D: ToDiagnostic<P>,

It returns the syntax if present or adds a diagnostic at the current parser position.

pub fn precede_or_add_diagnostic<P, E, D>( self, p: &mut P, error_builder: E, ) -> Marker

where P: Parser, E: FnOnce(&P, TextRange) -> D, D: ToDiagnostic<P>,

It creates and returns a marker preceding this parsed syntax if it is present or starts a new marker and adds an error to the current parser position. See [CompletedMarker.precede]

pub fn precede<P>(self, p: &mut P) -> Marker

where P: Parser,

Creates a new marker that precedes this syntax or starts a new marker

pub fn or_recover_with_token_set<P, E>( self, p: &mut P, recovery: &ParseRecoveryTokenSet<<P as Parser>::Kind>, error_builder: E, ) -> Result<CompletedMarker, RecoveryError>

where P: Parser, E: FnOnce(&P, TextRange) -> ParseDiagnostic,

Returns this Syntax if it is present in the source text or tries to recover the parser if the syntax is absent. The recovery…

• eats all unexpected tokens into a Bogus* node until the parser reaches one of the “safe tokens” configured in the ParseRecoveryTokenSet.
• creates an error using the passed in error builder and adds it to the parsing diagnostics.

The error recovery can fail if the parser is located at the EOF token or if the parser is already at a valid position according to the ParseRecoveryTokenSet.

pub fn or_recover<'source, P, E, R>( self, p: &mut P, recovery: &R, error_builder: E, ) -> Result<CompletedMarker, RecoveryError>

where P: Parser, R: ParseRecovery<Parser<'source> = P>, E: FnOnce(&P, TextRange) -> ParseDiagnostic,

Returns this Syntax if it is present in the source text or tries to recover the parser if the syntax is absent. The recovery…

• eats all unexpected tokens into a Bogus* node until the parser reaches one of the “safe tokens” configured in the ParseRecovery.
• creates an error using the passed in error builder and adds it to the parsing diagnostics.

The error recovery can fail if the parser is located at the EOF token or if the parser is already at a valid position according to the ParseRecovery.

Trait Implementations

impl Debug for ParsedSyntax

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

Formats the value using the given formatter.

impl From<CompletedMarker> for ParsedSyntax

fn from(marker: CompletedMarker) -> ParsedSyntax

Converts to this type from the input type.

impl From<Option<CompletedMarker>> for ParsedSyntax

fn from(option: Option<CompletedMarker>) -> ParsedSyntax

Converts to this type from the input type.

impl PartialEq for ParsedSyntax

fn eq(&self, other: &ParsedSyntax) -> 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 Eq for ParsedSyntax

impl StructuralPartialEq for ParsedSyntax