Struct ParseCtxt

pub(crate) struct ParseCtxt<'a> {
    pub(crate) ctx: SyntaxContext,
    pub(crate) parent: Option<LocalDefId>,
    pub(crate) tokens: Cursor<'a>,
    pub(crate) sess: &'a mut ParseSess,
}

Fields

ctx: SyntaxContext

parent: Option<LocalDefId>

tokens: Cursor<'a>

sess: &'a mut ParseSess

Implementations

impl<'cx> ParseCtxt<'cx>

pub(crate) fn at(&mut self, n: usize) -> (BytePos, Token, BytePos)

Returns the token (and span) at the requested position.

pub(crate) fn peek<T: Peek>(&mut self, t: T) -> bool

Looks at the next token in the underlying cursor to determine whether it matches the requested type of token. Does not advance the position of the cursor.

pub(crate) fn peek2<T1: Peek, T2: Peek>(&mut self, t1: T1, t2: T2) -> bool

Looks at the next two tokens

pub(crate) fn peek3<T1: Peek, T2: Peek, T3: Peek>( &mut self, t1: T1, t2: T2, t3: T3, ) -> bool

Looks at the next three tokens

pub(crate) fn peek_binop(&mut self) -> Option<(BinOp, usize)>

Looks whether the next token matches a binary operation. In case of a match, returns the corresponding binary operation and its size in number of tokens. This function doesn’t advance the position of the underlying cursor.

pub(crate) fn advance(&mut self)

Advances the underlying cursor to the next token

pub(crate) fn advance_by(&mut self, n: usize)

Advances the underlying cursor by the requested number of tokens

pub(crate) fn advance_if<T: Peek>(&mut self, t: T) -> bool

Looks at the next token and advances the cursor if it matches the requested rule. Returns true if there was a match.

pub(crate) fn advance_if2<T1: Peek, T2: Peek>(&mut self, t1: T1, t2: T2) -> bool

Looks at the next two tokens advacing the cursor if there’s a match on both of them

pub(crate) fn expect<T: Peek>(&mut self, t: T) -> ParseResult

If the next token matches the requested type of token advances the cursor, otherwise returns an unexpected token error.

pub(crate) fn lookahead1(&mut self) -> Lookahead1<'_, 'cx>

See documentation for Lookahead1

impl<'a> ParseCtxt<'a>

pub(crate) fn new( sess: &'a mut ParseSess, tokens: &'a TokenStream, span: Span, ) -> Self

pub(crate) fn next_node_id(&mut self) -> NodeId

pub(crate) fn mk_span(&self, lo: BytePos, hi: BytePos) -> Span

pub(crate) fn lo(&self) -> BytePos

pub(crate) fn hi(&self) -> BytePos

pub(crate) fn unexpected_token( &mut self, expected: Vec<&'static str>, ) -> ParseError

pub(crate) fn cannot_be_chained(&self, lo: BytePos, hi: BytePos) -> ParseError