Struct rstml::recoverable::RecoverableContext

pub struct RecoverableContext { /* private fields */ }

Context that is provided in ParseRecoverable interface. Used to save Diagnostic messages or syn::Result.

Also can be extended with user needs through RecoveryConfig.

Implementations

impl RecoverableContext

pub fn parse_simple_until<T: Parse, E: Parse>( &mut self, input: ParseStream<'_>, ) -> Option<(T, E)>

Like parse_simple, but splits the tokenstream at E first only parsing the tokens before it as T.

Note: This is an internal function exported to make parsing of custom nodes easier. It has some quirks, e.g., parse_simple_until<Expr, Token![>]>, would not support any Expr containing a >.

It is not considered stable.

pub fn parse_tokens_until_call<T, F, U>( &mut self, input: ParseStream<'_>, stop_fn: F, ) -> (Vec<T>, Option<U>)

where T: ParseRecoverable + Spanned, F: Fn(ParseStream<'_>) -> Result<U>,

Parse array of toknes using recoverable parser. Stops parsing when other branch could parse anything.

Note: This is an internal function exported to make parsing of custom nodes easier. It is not considered stable.

Example:

let tokens:proc_macro2::TokenStream = quote::quote!(few idents seperated by spaces and then minus sign - that will stop parsing).into();
let concat_idents_without_minus = |input: ParseStream| -> Result<String> {
    let (idents, _minus) = parser.parse_tokens_until::<Ident, _, _>(input, |i|
        i.parse::<Token![-]>()
    )?;
    let mut new_str = String::new();
    for ident in idents {
        new_str.push_str(&ident.to_string())
    }
    // .. skip rest idents in input
    Ok(new_str)
};
let concated = concat_idents_without_minus.parse2(tokens)?;
assert_eq!(concated, "fewidentsseperatedbyspacesandthenminussign");

pub fn parse_tokens_with_conflicted_ending<T, F, U>( &mut self, input: ParseStream<'_>, separator: F, ) -> (Vec<T>, Option<U>)

where T: ParseRecoverable, F: Fn(ParseStream<'_>) -> Result<U>,

Two-phase parsing, firstly find separator, and then parses array of tokens before separator. For simple input this method will work like parse_tokens_until. Internally it creates intermediate `TokenStream`` and copy of all tokens until separator token is found. It is usefull when separator (or it’s part) can be treated as part of token T.

Note: This is an internal function exported to make parsing of custom nodes easier. It is not considered stable.

Example:

let tokens = quote!(some_expr_seperated + with - lt_gt * tokens <> other part);

In this example “<” can can be parsed as part of expression, but we want to split tokens after “<>” was found. So instead of parsing all input as expression, firstly we need to seperate it into two chunks.

impl RecoverableContext

pub fn new(config: RecoveryConfig) -> Self

pub fn config(&self) -> &RecoveryConfig

pub fn parse_result<T>(self, val: Option<T>) -> ParsingResult<T>

pub fn parse_simple<T: Parse>(&mut self, input: ParseStream<'_>) -> Option<T>

Parse token using syn::parse::Parse

pub fn parse_mixed_fn<F, T>( &mut self, input: ParseStream<'_>, parser: F, ) -> Option<T>

where F: FnMut(&mut Self, ParseStream<'_>) -> Result<T, Error>,

Parse token using closure

pub fn parse_recoverable<T: ParseRecoverable>( &mut self, input: ParseStream<'_>, ) -> Option<T>

Parse token using ParseRecoverable

pub fn save_diagnostics<T>(&mut self, val: Result<T>) -> Option<T>

Save diagnostic message of syn::Result and convert result to Option, that can be used directly as output in ParseRecoverable::parse_recoverable

pub fn push_diagnostic(&mut self, diagnostic: impl Into<Diagnostic>)

Push custom message of syn::Error or proc_macro2_diagnostics::Diagnostic

Trait Implementations

impl Clone for RecoverableContext

fn clone(&self) -> RecoverableContext

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RecoverableContext

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

Formats the value using the given formatter.

impl Default for RecoverableContext

fn default() -> RecoverableContext

Returns the “default value” for a type.

impl PartialEq for RecoverableContext

fn eq(&self, other: &Self) -> 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 RecoverableContext