pub(crate) trait Parse<'db>: Sized {
type Output: Update;
// Required methods
fn opt_parse(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Option<Self::Output>, ParseFail<'db>>;
fn expected() -> Expected;
// Provided methods
fn can_eat(db: &'db dyn Db, parser: &Parser<'_, 'db>) -> bool { ... }
fn eat(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Self::Output, ParseFail<'db>> { ... }
fn eat_comma(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<SpanVec<'db, Self::Output>, ParseFail<'db>> { ... }
fn eat_many(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<SpanVec<'db, Self::Output>, ParseFail<'db>> { ... }
fn eat_delimited<T>(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
delimiter: Delimiter,
eat_method: impl FnOnce(&'db dyn Db, &mut Parser<'_, 'db>) -> Result<T, ParseFail<'db>>,
) -> Result<T, ParseFail<'db>> { ... }
fn opt_parse_delimited<T>(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
delimiter: Delimiter,
eat_method: impl FnOnce(&'db dyn Db, &mut Parser<'_, 'db>) -> Result<T, ParseFail<'db>>,
) -> Result<Option<T>, ParseFail<'db>> { ... }
fn opt_parse_comma(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Option<SpanVec<'db, Self::Output>>, ParseFail<'db>> { ... }
fn opt_parse_separated(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
separator: Op,
) -> Result<Option<SpanVec<'db, Self::Output>>, ParseFail<'db>> { ... }
fn opt_parse_guarded(
guard_op: impl ParseGuard,
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Option<Self::Output>, ParseFail<'db>> { ... }
}Expand description
Parse an instance of Self from the given Parser.
There are several parsing methods depending on how many instances of Self you wish to parse:
opt_parse– 0 or 1 instance (x?in a regex)opt_parse_comma– comma-separated list, returnsNoneif no elements foundopt_parse_delimited– delimited comma-separated list,Noneif no delimiters are foundeat– exactly 1 instance (xin a regex`)eat_comma– comma-separated list, returns an empty list if no elements foundeat_delimited– delimited comma-separated list where delimiters are mandatory
Implementors need only provide opt_parse, the rest are automatically provided.
§Return values
The opt_parse methods return an Result<Option<_>, ParseFail<'db>> as follows:
Ok(Some(v))– parse succeeded (possibly with recovery, in which case diagnostics will be stored into theParser).Ok(None)– no instance ofSelfwas found.Err(err)– a malformed instance ofSelfwas found. Some tokens were consumed.
The eat methods return a Result<_, ParseFail<'db>> and hence only distinguish success and error.
§Diagnostics
Parsing something can never report diagnostics to the user.
Any diagnostics need to be accumulated in the Parser.
Required Associated Types§
Required Methods§
Sourcefn opt_parse(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Option<Self::Output>, ParseFail<'db>>
fn opt_parse( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Option<Self::Output>, ParseFail<'db>>
Parse a single instance of Self, returning Ok(Some(v)).
Returns Ok(None) if Self was not present or Err(err)
if Self appeared to be present but was ill-formed.
Invariants maintained by this method:
- If
Ok(None)is returned, consumed NO tokens and reported NO diagnostics. - If
Erris returned, consumed at least one token (not true foreatmethods).
fn expected() -> Expected
Provided Methods§
Sourcefn can_eat(db: &'db dyn Db, parser: &Parser<'_, 'db>) -> bool
fn can_eat(db: &'db dyn Db, parser: &Parser<'_, 'db>) -> bool
Speculatively parses to see if we could eat a Self
without any error. Never consumes tokens nor produces an error.
Sourcefn eat(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Self::Output, ParseFail<'db>>
fn eat( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Self::Output, ParseFail<'db>>
Parses an instance of Self from the given Parser, reporting an error if no instance is found.
Sourcefn eat_comma(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<SpanVec<'db, Self::Output>, ParseFail<'db>>
fn eat_comma( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<SpanVec<'db, Self::Output>, ParseFail<'db>>
Parse zero-or-more comma-separated instances of Self returning a vector.
Accepts trailing commas.
Sourcefn eat_many(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<SpanVec<'db, Self::Output>, ParseFail<'db>>
fn eat_many( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<SpanVec<'db, Self::Output>, ParseFail<'db>>
Parse zero-or-more instances of Self returning a vector.
Sourcefn eat_delimited<T>(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
delimiter: Delimiter,
eat_method: impl FnOnce(&'db dyn Db, &mut Parser<'_, 'db>) -> Result<T, ParseFail<'db>>,
) -> Result<T, ParseFail<'db>>
fn eat_delimited<T>( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, delimiter: Delimiter, eat_method: impl FnOnce(&'db dyn Db, &mut Parser<'_, 'db>) -> Result<T, ParseFail<'db>>, ) -> Result<T, ParseFail<'db>>
Eat a comma separated list of Self, delimited by delimiter
(e.g., (a, b, c)).
Sourcefn opt_parse_delimited<T>(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
delimiter: Delimiter,
eat_method: impl FnOnce(&'db dyn Db, &mut Parser<'_, 'db>) -> Result<T, ParseFail<'db>>,
) -> Result<Option<T>, ParseFail<'db>>
fn opt_parse_delimited<T>( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, delimiter: Delimiter, eat_method: impl FnOnce(&'db dyn Db, &mut Parser<'_, 'db>) -> Result<T, ParseFail<'db>>, ) -> Result<Option<T>, ParseFail<'db>>
Parse a delimited list of Self
e.g., (a, b, c) or [a, b, c]. Returns None if
the given delimiters indicated by delimiter are not found.
Sourcefn opt_parse_comma(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Option<SpanVec<'db, Self::Output>>, ParseFail<'db>>
fn opt_parse_comma( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Option<SpanVec<'db, Self::Output>>, ParseFail<'db>>
Parse a comma separated list of Self
Sourcefn opt_parse_separated(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
separator: Op,
) -> Result<Option<SpanVec<'db, Self::Output>>, ParseFail<'db>>
fn opt_parse_separated( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, separator: Op, ) -> Result<Option<SpanVec<'db, Self::Output>>, ParseFail<'db>>
Parse a separator separated list of Self
Sourcefn opt_parse_guarded(
guard_op: impl ParseGuard,
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Option<Self::Output>, ParseFail<'db>>
fn opt_parse_guarded( guard_op: impl ParseGuard, db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Option<Self::Output>, ParseFail<'db>>
If guard_op appears, then parse Self
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
Implementations on Foreign Types§
Source§impl<'db> Parse<'db> for Literal<'db>
impl<'db> Parse<'db> for Literal<'db>
Source§fn opt_parse(
db: &'db dyn Db,
parser: &mut Parser<'_, 'db>,
) -> Result<Option<Self::Output>, ParseFail<'db>>
fn opt_parse( db: &'db dyn Db, parser: &mut Parser<'_, 'db>, ) -> Result<Option<Self::Output>, ParseFail<'db>>
Parses literal values from tokens.
This implementation demonstrates the parser’s commitment model:
- No commitment: Returns
Ok(None)if no literal token is found - Commitment: Once a literal token is detected, consumes it and returns the value
- Error after commitment: If token consumption fails, would return
Err(though this is unlikely for literals)
§Supported Literals
- Tokenizer literals: Integers and strings from
TokenKind::Literal - Boolean keywords:
trueandfalsekeywords are treated as boolean literals
§String Literal Processing
For string literals, this method:
- Takes the raw text from the tokenizer (with escape sequences still as text)
- Creates a
Literal::new(db, LiteralKind::String, raw_text) - Does not interpret escape sequences - this is currently a bug
Future implementations should either have the tokenizer pre-process escapes or add escape interpretation here.