Struct ParseStream 

pub struct ParseStream<'a> { /* private fields */ }

The parsing cursor, similar to syn’s ParseBuffer.

This is the primary interface for consuming tokens during parsing.

Implementations

impl<'a> ParseStream<'a>

pub fn is_empty(&self) -> bool

Returns true if there are no more tokens to parse (except EOF).

pub fn is_empty_raw(&self) -> bool

Returns true if there are no more tokens (including comments) except EOF.

pub fn peek(&self) -> &Token

Peek at the current token without consuming it. Comment tokens are skipped transparently.

pub fn peek_raw(&self) -> &Token

Peek at the raw token at the cursor without skipping comments.

pub fn cursor(&self) -> usize

Get the current cursor position.

pub fn set_cursor(&self, pos: usize)

Set the current cursor position (used for backtracking).

pub fn save_state(&self) -> ParserState

Save the full parser state (cursor + pending_gts) for speculative parsing.

pub fn restore_state(&self, state: ParserState)

Restore the full parser state (cursor + pending_gts) after speculative parsing.

pub fn error<T: Display>(&self, span: Span, msg: T) -> Error

Push an error to the error list.

pub fn split_gt(&self)

Split a >> token into two > tokens for nested generic parsing.

pub fn next(&self) -> &Token

Consume and return the current token regardless of its kind.

pub fn is(&self, kind: &TokenKind) -> bool

Check if the current token matches the given kind.

pub fn is_ident(&self, name: &str) -> bool

Check if the current token is an identifier with the given name.

pub fn is_any_ident(&self) -> bool

Check if the current token is any identifier (including contextual keywords).

pub fn is_type_ident(&self) -> bool

Check if the current token can be used as a type name.

pub fn is_keyword(&self, kind: TokenKind) -> bool

Check if the current token is a given keyword.

pub fn eat(&self, expected: &TokenKind) -> bool

Consume the next token if it matches the expected kind.

pub fn expect(&self, kind: TokenKind) -> Result<()>

If the current token matches the given kind, consume it. Otherwise, report an error.

pub fn look_ahead(&self, n: usize) -> &Token

Look ahead n tokens (skipping comments).

pub fn parse_terminated<T, F>(&self, parse_item: F) -> Result<Vec<T>>

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

Parse a comma-separated list of items terminated by some token.

pub fn parse_separated<T, F>( &self, can_start_fn: fn(&TokenKind) -> bool, parse_item: F, ) -> Result<Vec<T>>

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

Parse zero or more items separated by commas, not requiring a terminator.

pub fn try_parse<T, F>(&self, f: F) -> Option<T>

where F: FnOnce(&ParseStream<'_>) -> Result<T>,

Try to parse something. If parsing fails, revert the cursor.

pub fn parse_parenthesized<T, F>(&self, f: F) -> Result<T>

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

Parse something inside parentheses.

pub fn parse<T: Parse>(&self) -> Result<T>

Parse any type that implements Parse.

pub fn parse_braced<T, F>(&self, f: F) -> Result<T>

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

Parse something inside braces.

pub fn parse_bracketed<T, F>(&self, f: F) -> Result<T>

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

Parse something inside brackets.

pub fn expect_then_raw_span(&self, kind: TokenKind) -> Result<Span>

Consume the expected token, then return the span of the raw token at the cursor. Unlike expect(kind); peek().span, this does NOT skip comments after consuming.

pub fn parse_ident(&self) -> Result<Ident>

Also accepts contextual keywords (record, sealed, var, yield, open, etc.)

pub fn take_errors(&self) -> Vec<Error>

Take any errors accumulated during parsing.

pub fn span_since(&self, start: Span) -> Span

Create a span covering from the given start to the current position.

pub fn skip_comments_to_peek(&self)

Skip past any comment tokens at the current cursor position. This is the public version for explicit comment skipping.

pub fn collect_pending_doc_comments(&self) -> Vec<Comment>

Collect pending doc comments (skipped by peek/advance). Returns only doc comments (/// and /** */), discards regular comments.

pub fn collect_pending_comments(&self) -> Vec<Comment>

Collect all pending comments (skipped by peek/advance).

pub fn collect_leading_doc_comments(&self) -> Vec<Comment>

Collect and consume leading doc comments (/// and /** /). Regular comments (// and / */) are skipped.

pub fn collect_leading_comments(&self) -> Vec<Comment>

Collect and consume all leading comments (both doc and regular).