Struct rustc_parse::parser::diagnostics::SnapshotParser

pub struct SnapshotParser<'a> {
    parser: Parser<'a>,
}

SnapshotParser is used to create a snapshot of the parser without causing duplicate errors being emitted when the Parser is dropped.

Fields

parser: Parser<'a>

Methods from Deref<Target = Parser<'a>>

pub(super) fn parse_outer_attributes(&mut self) -> PResult<'a, AttrWrapper>

Parses attributes that appear before an item.

pub fn parse_attribute( &mut self, inner_parse_policy: InnerAttrPolicy ) -> PResult<'a, Attribute>

Matches attribute = # ! [ meta_item ]. inner_parse_policy prescribes how to handle inner attributes.

fn annotate_following_item_if_applicable( &self, err: &mut Diagnostic, span: Span, attr_type: OuterAttributeType ) -> Option<Span>

pub(super) fn error_on_forbidden_inner_attr( &self, attr_sp: Span, policy: InnerAttrPolicy )

pub fn parse_attr_item(&mut self, capture_tokens: bool) -> PResult<'a, AttrItem>

Parses an inner part of an attribute (the path and following tokens). The tokens must be either a delimited token stream, or empty token stream, or the “legacy” key-value form. PATH ( TOKEN_STREAM ) PATH [ TOKEN_STREAM ] PATH { TOKEN_STREAM } PATH PATH = UNSUFFIXED_LIT The delimiters or = are still put into the resulting token stream.

pub(crate) fn parse_inner_attributes(&mut self) -> PResult<'a, AttrVec>

Parses attributes that appear after the opening of an item. These should be preceded by an exclamation mark, but we accept and warn about one terminated by a semicolon.

Matches inner_attrs*.

pub(crate) fn parse_unsuffixed_meta_item_lit( &mut self ) -> PResult<'a, MetaItemLit>

pub fn parse_cfg_attr( &mut self ) -> PResult<'a, (MetaItem, Vec<(AttrItem, Span)>)>

Parses cfg_attr(pred, attr_item_list) where attr_item_list is comma-delimited.

pub(crate) fn parse_meta_seq_top( &mut self ) -> PResult<'a, ThinVec<NestedMetaItem>>

Matches COMMASEP(meta_item_inner).

pub fn parse_meta_item(&mut self) -> PResult<'a, MetaItem>

Matches the following grammar (per RFC 1559).

meta_item : PATH ( '=' UNSUFFIXED_LIT | '(' meta_item_inner? ')' )? ;
meta_item_inner : (meta_item | UNSUFFIXED_LIT) (',' meta_item_inner)? ;

pub(crate) fn parse_meta_item_kind(&mut self) -> PResult<'a, MetaItemKind>

fn parse_meta_item_inner(&mut self) -> PResult<'a, NestedMetaItem>

Matches meta_item_inner : (meta_item | UNSUFFIXED_LIT) ;.

pub fn collect_tokens_trailing_token<R: HasAttrs + HasTokens>( &mut self, attrs: AttrWrapper, force_collect: ForceCollect, f: impl FnOnce(&mut Self, AttrVec) -> PResult<'a, (R, TrailingToken)> ) -> PResult<'a, R>

Records all tokens consumed by the provided callback, including the current token. These tokens are collected into a LazyAttrTokenStream, and returned along with the result of the callback.

Note: If your callback consumes an opening delimiter (including the case where you call collect_tokens when the current token is an opening delimiter), you must also consume the corresponding closing delimiter.

That is, you can consume something ([{ }]) or ([{}]), but not ([{}]

This restriction shouldn’t be an issue in practice, since this function is used to record the tokens for a parsed AST item, which always has matching delimiters.

pub fn struct_span_err<S: Into<MultiSpan>>( &self, sp: S, m: impl Into<DiagnosticMessage> ) -> DiagnosticBuilder<'a, ErrorGuaranteed>

pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: impl Into<String>) -> !

pub(super) fn diagnostic(&self) -> &'a Handler

pub(super) fn restore_snapshot(&mut self, snapshot: SnapshotParser<'a>)

Replace self with snapshot.parser.

pub fn create_snapshot_for_diagnostic(&self) -> SnapshotParser<'a>

Create a snapshot of the Parser.

pub(super) fn span_to_snippet( &self, span: Span ) -> Result<String, SpanSnippetError>

pub(super) fn expected_ident_found( &mut self, recover: bool ) -> PResult<'a, (Ident, bool)>

Emits an error with suggestions if an identifier was expected but not found.

Returns a possibly recovered identifier.

pub(super) fn expected_ident_found_err( &mut self ) -> DiagnosticBuilder<'a, ErrorGuaranteed>

pub(super) fn is_lit_bad_ident(&mut self) -> Option<(usize, Symbol)>

Checks if the current token is a integer or float literal and looks like it could be a invalid identifier with digits at the start.

Returns the number of characters (bytes) composing the invalid portion of the identifier and the valid portion of the identifier.

pub(super) fn expected_one_of_not_found( &mut self, edible: &[TokenKind], inedible: &[TokenKind] ) -> PResult<'a, bool>

fn check_too_many_raw_str_terminators(&mut self, err: &mut Diagnostic) -> bool

pub fn maybe_suggest_struct_literal( &mut self, lo: Span, s: BlockCheckMode, maybe_struct_name: Token, can_be_struct_literal: bool ) -> Option<PResult<'a, P<Block>>>

pub(super) fn eat_to_tokens(&mut self, kets: &[&TokenKind])

Eats and discards tokens until one of kets is encountered. Respects token trees, passes through any errors encountered. Used for error recovery.

pub(super) fn check_trailing_angle_brackets( &mut self, segment: &PathSegment, end: &[&TokenKind] ) -> bool

This function checks if there are trailing angle brackets and produces a diagnostic to suggest removing them.

let _ = [1, 2, 3].into_iter().collect::<Vec<usize>>>>();
                                                   ^^ help: remove extra angle brackets

If true is returned, then trailing brackets were recovered, tokens were consumed up until one of the tokens in ‘end’ was encountered, and an error was emitted.

pub(super) fn check_turbofish_missing_angle_brackets( &mut self, segment: &mut PathSegment )

Check if a method call with an intended turbofish has been written without surrounding angle brackets.

pub(super) fn check_mistyped_turbofish_with_multiple_type_params( &mut self, e: DiagnosticBuilder<'a, ErrorGuaranteed>, expr: &mut P<Expr> ) -> PResult<'a, ()>

When writing a turbofish with multiple type parameters missing the leading ::, we will encounter a parse error when encountering the first ,.

pub(super) fn suggest_add_missing_let_for_stmt( &mut self, err: &mut DiagnosticBuilder<'a, ErrorGuaranteed> )

Suggest add the missing let before the identifier in stmt a: Ty = 1 -> let a: Ty = 1

fn attempt_chained_comparison_suggestion( &mut self, err: &mut ComparisonOperatorsCannotBeChained, inner_op: &Expr, outer_op: &Spanned<AssocOp> ) -> bool

Check to see if a pair of chained operators looks like an attempt at chained comparison, e.g. 1 < x <= 3. If so, suggest either splitting the comparison into two, or parenthesising the leftmost comparison.

pub(super) fn check_no_chained_comparison( &mut self, inner_op: &Expr, outer_op: &Spanned<AssocOp> ) -> PResult<'a, Option<P<Expr>>>

Produces an error if comparison operators are chained (RFC #558). We only need to check the LHS, not the RHS, because all comparison ops have same precedence (see fn precedence) and are left-associative (see fn fixity).

This can also be hit if someone incorrectly writes foo<bar>() when they should have used the turbofish (foo::<bar>()) syntax. We attempt some heuristic recovery if that is the case.

Keep in mind that given that outer_op.is_comparison() holds and comparison ops are left associative we can infer that we have:

          outer_op
          /   \
    inner_op   r2
       /  \
     l1    r1

fn consume_fn_args(&mut self) -> Result<(), ()>

pub(super) fn maybe_report_ambiguous_plus( &mut self, impl_dyn_multi: bool, ty: &Ty )

pub(super) fn maybe_recover_from_question_mark(&mut self, ty: P<Ty>) -> P<Ty>

Swift lets users write Ty? to mean Option<Ty>. Parse the construct and recover from it.

pub(super) fn maybe_recover_from_ternary_operator(&mut self) -> bool

Rust has no ternary operator (cond ? then : else). Parse it and try to recover from it if then and else are valid expressions. Returns whether it was a ternary operator.

pub(super) fn maybe_recover_from_bad_type_plus( &mut self, ty: &Ty ) -> PResult<'a, ()>

pub(super) fn recover_from_prefix_increment( &mut self, operand_expr: P<Expr>, op_span: Span, start_stmt: bool ) -> PResult<'a, P<Expr>>

pub(super) fn recover_from_postfix_increment( &mut self, operand_expr: P<Expr>, op_span: Span, start_stmt: bool ) -> PResult<'a, P<Expr>>

pub(super) fn recover_from_postfix_decrement( &mut self, operand_expr: P<Expr>, op_span: Span, start_stmt: bool ) -> PResult<'a, P<Expr>>

fn recover_from_inc_dec( &mut self, base: P<Expr>, kind: IncDecRecovery, op_span: Span ) -> PResult<'a, P<Expr>>

fn prefix_inc_dec_suggest( &mut self, base_src: String, kind: IncDecRecovery, (pre_span, post_span): (Span, Span) ) -> MultiSugg

fn postfix_inc_dec_suggest( &mut self, base_src: String, kind: IncDecRecovery, (pre_span, post_span): (Span, Span) ) -> MultiSugg

fn inc_dec_standalone_suggest( &mut self, kind: IncDecRecovery, (pre_span, post_span): (Span, Span) ) -> MultiSugg

pub(super) fn maybe_recover_from_bad_qpath<T: RecoverQPath>( &mut self, base: P<T> ) -> PResult<'a, P<T>>

Tries to recover from associated item paths like [T]::AssocItem / (T, U)::AssocItem. Attempts to convert the base expression/pattern/type into a type, parses the ::AssocItem tail, and combines them into a <Ty>::AssocItem expression/pattern/type.

pub(super) fn maybe_recover_from_bad_qpath_stage_2<T: RecoverQPath>( &mut self, ty_span: Span, ty: P<Ty> ) -> PResult<'a, P<T>>

Given an already parsed Ty, parses the ::AssocItem tail and combines them into a <Ty>::AssocItem expression/pattern/type.

pub fn maybe_consume_incorrect_semicolon(&mut self, items: &[P<Item>]) -> bool

pub(super) fn unexpected_try_recover( &mut self, t: &TokenKind ) -> PResult<'a, bool>

Creates a DiagnosticBuilder for an unexpected token t and tries to recover if it is a closing delimiter.

pub(super) fn expect_semi(&mut self) -> PResult<'a, ()>

pub(super) fn recover_colon_as_semi(&mut self) -> bool

pub(super) fn recover_incorrect_await_syntax( &mut self, lo: Span, await_sp: Span ) -> PResult<'a, P<Expr>>

Consumes alternative await syntaxes like await!(<expr>), await <expr>, await? <expr>, await(<expr>), and await { <expr> }.

fn recover_await_macro(&mut self) -> PResult<'a, (Span, P<Expr>, bool)>

fn recover_await_prefix( &mut self, await_sp: Span ) -> PResult<'a, (Span, P<Expr>, bool)>

fn error_on_incorrect_await( &self, lo: Span, hi: Span, expr: &Expr, is_question: bool ) -> Span

pub(super) fn recover_from_await_method_call(&mut self)

If encountering future.await(), consumes and emits an error.

pub(super) fn try_macro_suggestion(&mut self) -> PResult<'a, P<Expr>>

pub(super) fn recover_parens_around_for_head( &mut self, pat: P<Pat>, begin_paren: Option<Span> ) -> P<Pat>

Recovers a situation like for ( $pat in $expr ) and suggest writing for $pat in $expr instead.

This should be called before parsing the $block.

pub(super) fn recover_seq_parse_error( &mut self, delim: Delimiter, lo: Span, result: PResult<'a, P<Expr>> ) -> P<Expr>

pub(super) fn recover_stmt(&mut self)

Eats tokens until we can be relatively sure we reached the end of the statement. This is something of a best-effort heuristic.

We terminate when we find an unmatched } (without consuming it).

pub(super) fn recover_stmt_( &mut self, break_on_semi: SemiColonMode, break_on_block: BlockMode )

If break_on_semi is Break, then we will stop consuming tokens after finding (and consuming) a ; outside of {} or [] (note that this is approximate – it can mean we break too early due to macros, but that should only lead to sub-optimal recovery, not inaccurate parsing).

If break_on_block is Break, then we will stop consuming tokens after finding (and consuming) a brace-delimited block.

pub(super) fn check_for_for_in_in_typo(&mut self, in_span: Span)

pub(super) fn eat_incorrect_doc_comment_for_param_type(&mut self)

pub(super) fn parameter_without_type( &mut self, err: &mut Diagnostic, pat: P<Pat>, require_name: bool, first_param: bool ) -> Option<Ident>

pub(super) fn recover_arg_parse(&mut self) -> PResult<'a, (P<Pat>, P<Ty>)>

pub(super) fn recover_bad_self_param( &mut self, param: Param ) -> PResult<'a, Param>

pub(super) fn consume_block( &mut self, delim: Delimiter, consume_close: ConsumeClosingDelim )

pub(super) fn expected_expression_found( &self ) -> DiagnosticBuilder<'a, ErrorGuaranteed>

fn consume_tts(&mut self, acc: i64, modifier: &[(TokenKind, i64)])

pub(super) fn deduplicate_recovered_params_names( &self, fn_inputs: &mut ThinVec<Param> )

Replace duplicated recovered parameters with _ pattern to avoid unnecessary errors.

This is necessary because at this point we don’t know whether we parsed a function with anonymous parameters or a function with names but no types. In order to minimize unnecessary errors, we assume the parameters are in the shape of fn foo(a, b, c) where the parameters are names (so we don’t emit errors about not being able to find b in the local scope), but if we find the same name multiple times, like in fn foo(i8, i8), we deduplicate them to not complain about duplicated parameter names.

pub fn handle_ambiguous_unbraced_const_arg( &mut self, args: &mut ThinVec<AngleBracketedArg> ) -> PResult<'a, bool>

Handle encountering a symbol in a generic argument list that is not a , or >. In this case, we emit an error and try to suggest enclosing a const argument in braces if it looks like the user has forgotten them.

pub fn handle_unambiguous_unbraced_const_arg(&mut self) -> PResult<'a, P<Expr>>

Attempt to parse a generic const argument that has not been enclosed in braces. There are a limited number of expressions that are permitted without being encoded in braces:

• Literals.
• Single-segment paths (i.e. standalone generic const parameters). All other expressions that can be parsed will emit an error suggesting the expression be wrapped in braces.

fn recover_const_param_decl( &mut self, ty_generics: Option<&Generics> ) -> Option<GenericArg>

pub fn recover_const_param_declaration( &mut self, ty_generics: Option<&Generics> ) -> PResult<'a, Option<GenericArg>>

pub fn recover_const_arg( &mut self, start: Span, err: DiagnosticBuilder<'a, ErrorGuaranteed> ) -> PResult<'a, GenericArg>

Try to recover from possible generic const argument without { and }.

When encountering code like foo::< bar + 3 > or foo::< bar - baz > we suggest foo::<{ bar + 3 }> and foo::<{ bar - baz }>, respectively. We only provide a suggestion if we think that the resulting expression would be well formed.

pub(crate) fn recover_unbraced_const_arg_that_can_begin_ty( &mut self, snapshot: SnapshotParser<'a> ) -> Option<P<Expr>>

Try to recover from an unbraced const argument whose first token could begin a type.

pub fn dummy_const_arg_needs_braces( &self, err: DiagnosticBuilder<'a, ErrorGuaranteed>, span: Span ) -> GenericArg

Creates a dummy const argument, and reports that the expression must be enclosed in braces

pub(crate) fn maybe_recover_colon_colon_in_pat_typo( &mut self, first_pat: P<Pat>, expected: Option<Expected> ) -> P<Pat>

Some special error handling for the “top-level” patterns in a match arm, for loop, let, &c. (in contrast to subpatterns within such).

pub(crate) fn maybe_recover_unexpected_block_label(&mut self) -> bool

pub(crate) fn maybe_recover_unexpected_comma( &mut self, lo: Span, is_mac_invoc: bool, rt: CommaRecoveryMode ) -> PResult<'a, ()>

Some special error handling for the “top-level” patterns in a match arm, for loop, let, &c. (in contrast to subpatterns within such).

pub(crate) fn maybe_recover_bounds_doubled_colon( &mut self, ty: &Ty ) -> PResult<'a, ()>

pub fn is_diff_marker( &mut self, long_kind: &TokenKind, short_kind: &TokenKind ) -> bool

fn diff_marker( &mut self, long_kind: &TokenKind, short_kind: &TokenKind ) -> Option<Span>

pub fn recover_diff_marker(&mut self)

fn skip_pat_list(&mut self) -> PResult<'a, ()>

Parse and throw away a parenthesized comma separated sequence of patterns until ) is reached.

pub fn parse_expr(&mut self) -> PResult<'a, P<Expr>>

Parses an expression.

pub fn parse_expr_force_collect(&mut self) -> PResult<'a, P<Expr>>

Parses an expression, forcing tokens to be collected

pub fn parse_expr_anon_const(&mut self) -> PResult<'a, AnonConst>

fn parse_expr_catch_underscore( &mut self, restrictions: Restrictions ) -> PResult<'a, P<Expr>>

fn parse_expr_paren_seq(&mut self) -> PResult<'a, ThinVec<P<Expr>>>

Parses a sequence of expressions delimited by parentheses.

pub(super) fn parse_expr_res( &mut self, r: Restrictions, already_parsed_attrs: Option<AttrWrapper> ) -> PResult<'a, P<Expr>>

Parses an expression, subject to the given restrictions.

fn parse_expr_assoc( &mut self, already_parsed_attrs: Option<AttrWrapper> ) -> PResult<'a, P<Expr>>

Parses an associative expression.

This parses an expression accounting for associativity and precedence of the operators in the expression.

pub(super) fn parse_expr_assoc_with( &mut self, min_prec: usize, lhs: LhsExpr ) -> PResult<'a, P<Expr>>

Parses an associative expression with operators of at least min_prec precedence.

fn should_continue_as_assoc_expr(&mut self, lhs: &Expr) -> bool

fn error_found_expr_would_be_stmt(&self, lhs: &Expr)

We’ve found an expression that would be parsed as a statement, but the next token implies this should be parsed as an expression. For example: if let Some(x) = x { x } else { 0 } / 2.

fn check_assoc_op(&self) -> Option<Spanned<AssocOp>>

Possibly translate the current token to an associative operator. The method does not advance the current token.

Also performs recovery for and / or which are mistaken for && and || respectively.

fn expr_is_complete(&self, e: &Expr) -> bool

Checks if this expression is a successfully parsed statement.

fn parse_expr_range( &mut self, prec: usize, lhs: P<Expr>, op: AssocOp, cur_op_span: Span ) -> PResult<'a, P<Expr>>

Parses x..y, x..=y, and x../x..=. The other two variants are handled in parse_prefix_range_expr below.

fn is_at_start_of_range_notation_rhs(&self) -> bool

fn parse_expr_prefix_range( &mut self, attrs: Option<AttrWrapper> ) -> PResult<'a, P<Expr>>

Parses prefix-forms of range notation: ..expr, .., ..=expr.

fn parse_expr_prefix( &mut self, attrs: Option<AttrWrapper> ) -> PResult<'a, P<Expr>>

Parses a prefix-unary-operator expr.

fn parse_expr_prefix_common(&mut self, lo: Span) -> PResult<'a, (Span, P<Expr>)>

fn parse_expr_unary( &mut self, lo: Span, op: UnOp ) -> PResult<'a, (Span, ExprKind)>

fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)>

Recover on ~expr in favor of !expr.

fn parse_expr_box(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)>

Parse box expr - this syntax has been removed, but we still parse this for now to provide an automated way to fix usages of it

fn is_mistaken_not_ident_negation(&self) -> bool

fn recover_not_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)>

Recover on not expr in favor of !expr.

fn interpolated_or_expr_span(&self, expr: &Expr) -> Span

Returns the span of expr if it was not interpolated, or the span of the interpolated token.

fn parse_assoc_op_cast( &mut self, lhs: P<Expr>, lhs_span: Span, expr_kind: fn(_: P<Expr>, _: P<Ty>) -> ExprKind ) -> PResult<'a, P<Expr>>

fn parse_and_disallow_postfix_after_cast( &mut self, cast_expr: P<Expr> ) -> PResult<'a, P<Expr>>

Parses a postfix operators such as ., ?, or index ([]) after a cast, then emits an error and returns the newly parsed tree. The resulting parse tree for &x as T[0] has a precedence of ((&x) as T)[0].

fn parse_expr_borrow(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)>

Parse & mut? <expr> or & raw [ const | mut ] <expr>.

fn error_remove_borrow_lifetime(&self, span: Span, lt_span: Span)

fn parse_borrow_modifiers(&mut self, lo: Span) -> (BorrowKind, Mutability)

Parse mut? or raw [ const | mut ].

fn parse_expr_dot_or_call( &mut self, attrs: Option<AttrWrapper> ) -> PResult<'a, P<Expr>>

Parses a.b or a(13) or a[4] or just a.

pub(super) fn parse_expr_dot_or_call_with( &mut self, e0: P<Expr>, lo: Span, attrs: AttrVec ) -> PResult<'a, P<Expr>>

fn parse_expr_dot_or_call_with_( &mut self, e: P<Expr>, lo: Span ) -> PResult<'a, P<Expr>>

fn parse_dot_suffix_expr( &mut self, lo: Span, base: P<Expr> ) -> PResult<'a, P<Expr>>

fn error_unexpected_after_dot(&self)

fn break_up_float(&mut self, float: Symbol) -> DestructuredFloat

fn parse_expr_tuple_field_access_float( &mut self, lo: Span, base: P<Expr>, float: Symbol, suffix: Option<Symbol> ) -> P<Expr>

fn parse_field_name_maybe_tuple(&mut self) -> PResult<'a, ThinVec<Ident>>

fn parse_expr_tuple_field_access( &mut self, lo: Span, base: P<Expr>, field: Symbol, suffix: Option<Symbol>, next_token: Option<(Token, Spacing)> ) -> P<Expr>

fn parse_expr_fn_call(&mut self, lo: Span, fun: P<Expr>) -> P<Expr>

Parse a function call expression, expr(...).

fn maybe_recover_struct_lit_bad_delims( &mut self, lo: Span, open_paren: Span, seq: &mut PResult<'a, P<Expr>>, snapshot: Option<(SnapshotParser<'a>, ExprKind)> ) -> Option<P<Expr>>

If we encounter a parser state that looks like the user has written a struct literal with parentheses instead of braces, recover the parser state and provide suggestions.

fn parse_expr_index(&mut self, lo: Span, base: P<Expr>) -> PResult<'a, P<Expr>>

Parse an indexing expression expr[...].

fn parse_dot_suffix( &mut self, self_arg: P<Expr>, lo: Span ) -> PResult<'a, P<Expr>>

Assuming we have just parsed ., continue parsing into an expression.

fn parse_expr_bottom(&mut self) -> PResult<'a, P<Expr>>

At the bottom (top?) of the precedence hierarchy, Parses things like parenthesized exprs, macros, return, etc.

N.B., this does not parse outer attributes, and is private because it only works correctly if called from parse_dot_or_call_expr().

fn parse_expr_lit(&mut self) -> PResult<'a, P<Expr>>

fn parse_expr_tuple_parens( &mut self, restrictions: Restrictions ) -> PResult<'a, P<Expr>>

fn parse_expr_array_or_repeat( &mut self, close_delim: Delimiter ) -> PResult<'a, P<Expr>>

fn parse_expr_path_start(&mut self) -> PResult<'a, P<Expr>>

pub(super) fn parse_expr_labeled( &mut self, label_: Label, consume_colon: bool ) -> PResult<'a, P<Expr>>

Parse 'label: $expr. The label is already parsed.

pub(super) fn recover_unclosed_char<L>( &self, lifetime: Ident, mk_lit_char: impl FnOnce(Symbol, Span) -> L, err: impl FnOnce(&Self) -> DiagnosticBuilder<'a, ErrorGuaranteed> ) -> L

Emit an error when a char is parsed as a lifetime because of a missing quote.

fn recover_do_catch(&mut self) -> PResult<'a, P<Expr>>

Recover on the syntax do catch { ... } suggesting try { ... } instead.

fn parse_expr_opt(&mut self) -> PResult<'a, Option<P<Expr>>>

Parse an expression if the token can begin one.

fn parse_expr_return(&mut self) -> PResult<'a, P<Expr>>

Parse "return" expr?.

fn parse_expr_yeet(&mut self) -> PResult<'a, P<Expr>>

Parse "do" "yeet" expr?.

fn parse_expr_become(&mut self) -> PResult<'a, P<Expr>>

Parse "become" expr, with "become" token already eaten.

fn parse_expr_break(&mut self) -> PResult<'a, P<Expr>>

Parse "break" (('label (:? expr)?) | expr?) with "break" token already eaten. If the label is followed immediately by a : token, the label and : are parsed as part of the expression (i.e. a labeled loop). The language team has decided in #87026 to require parentheses as a visual aid to avoid confusion if the break expression of an unlabeled break is a labeled loop (as in break 'lbl: loop {}); a labeled break with an unlabeled loop as its value expression only gets a warning for compatibility reasons; and a labeled break with a labeled loop does not even get a warning because there is no ambiguity.

fn parse_expr_continue(&mut self, lo: Span) -> PResult<'a, P<Expr>>

Parse "continue" label?.

fn parse_expr_yield(&mut self) -> PResult<'a, P<Expr>>

Parse "yield" expr?.

fn parse_expr_builtin(&mut self) -> PResult<'a, P<Expr>>

Parse builtin # ident(args,*).

pub(crate) fn parse_builtin<T>( &mut self, parse: impl FnOnce(&mut Parser<'a>, Span, Ident) -> PResult<'a, Option<T>> ) -> PResult<'a, T>

pub(crate) fn parse_expr_offset_of(&mut self, lo: Span) -> PResult<'a, P<Expr>>

pub fn parse_str_lit(&mut self) -> Result<StrLit, Option<MetaItemLit>>

Returns a string literal if the next token is a string literal. In case of error returns Some(lit) if the next token is a literal with a wrong kind, and returns None if the next token is not literal at all.

fn handle_missing_lit<L>( &mut self, mk_lit_char: impl FnOnce(Symbol, Span) -> L ) -> PResult<'a, L>

pub(super) fn parse_token_lit(&mut self) -> PResult<'a, (Lit, Span)>

pub(super) fn parse_meta_item_lit(&mut self) -> PResult<'a, MetaItemLit>

fn recover_after_dot(&mut self) -> Option<Token>

pub(super) fn parse_opt_token_lit(&mut self) -> Option<(Lit, Span)>

Matches lit = true | false | token_lit. Returns None if the next token is not a literal.

pub(super) fn parse_opt_meta_item_lit(&mut self) -> Option<MetaItemLit>

Matches lit = true | false | token_lit. Returns None if the next token is not a literal.

pub(super) fn expect_no_tuple_index_suffix(&self, span: Span, suffix: Symbol)

pub fn parse_literal_maybe_minus(&mut self) -> PResult<'a, P<Expr>>

Matches '-' lit | lit (cf. ast_validation::AstValidator::check_expr_within_pat). Keep this in sync with Token::can_begin_literal_maybe_minus.

fn is_array_like_block(&mut self) -> bool

fn maybe_suggest_brackets_instead_of_braces( &mut self, lo: Span ) -> Option<P<Expr>>

Emits a suggestion if it looks like the user meant an array but accidentally used braces, causing the code to be interpreted as a block expression.

fn suggest_missing_semicolon_before_array( &self, prev_span: Span, open_delim_span: Span ) -> PResult<'a, ()>

pub(super) fn parse_expr_block( &mut self, opt_label: Option<Label>, lo: Span, blk_mode: BlockCheckMode ) -> PResult<'a, P<Expr>>

Parses a block or unsafe block.

fn parse_simple_block(&mut self) -> PResult<'a, P<Expr>>

Parse a block which takes no attributes and has no label

fn parse_expr_closure(&mut self) -> PResult<'a, P<Expr>>

Parses a closure expression (e.g., move |args| expr).

fn parse_capture_clause(&mut self) -> PResult<'a, CaptureBy>

Parses an optional move prefix to a closure-like construct.

fn parse_fn_block_decl(&mut self) -> PResult<'a, (P<FnDecl>, Span)>

Parses the |arg, arg| header of a closure.

fn parse_fn_block_param(&mut self) -> PResult<'a, Param>

Parses a parameter in a closure header (e.g., |arg, arg|).

fn parse_expr_if(&mut self) -> PResult<'a, P<Expr>>

Parses an if expression (if token already eaten).

fn parse_if_after_cond( &mut self, lo: Span, cond: P<Expr> ) -> PResult<'a, P<Expr>>

fn parse_expr_cond(&mut self) -> PResult<'a, P<Expr>>

Parses the condition of a if or while expression.

fn parse_expr_let(&mut self, restrictions: Restrictions) -> PResult<'a, P<Expr>>

Parses a let $pat = $expr pseudo-expression.

fn parse_expr_else(&mut self) -> PResult<'a, P<Expr>>

Parses an else { ... } expression (else token already eaten).

fn error_on_if_block_attrs( &self, ctx_span: Span, is_ctx_else: bool, branch_span: Span, attrs: AttrWrapper )

fn error_on_extra_if(&mut self, cond: &P<Expr>) -> PResult<'a, ()>

fn parse_expr_for( &mut self, opt_label: Option<Label>, lo: Span ) -> PResult<'a, P<Expr>>

Parses for <src_pat> in <src_expr> <src_loop_block> (for token already eaten).

fn recover_loop_else( &mut self, loop_kind: &'static str, loop_kw: Span ) -> PResult<'a, ()>

Recovers from an else clause after a loop (for...else, while...else)

fn error_missing_in_for_loop(&mut self)

fn parse_expr_while( &mut self, opt_label: Option<Label>, lo: Span ) -> PResult<'a, P<Expr>>

Parses a while or while let expression (while token already eaten).

fn parse_expr_loop( &mut self, opt_label: Option<Label>, lo: Span ) -> PResult<'a, P<Expr>>

Parses loop { ... } (loop token already eaten).

pub(crate) fn eat_label(&mut self) -> Option<Label>

fn parse_expr_match(&mut self) -> PResult<'a, P<Expr>>

Parses a match ... { ... } expression (match token already eaten).

fn parse_arm_body_missing_braces( &mut self, first_expr: &P<Expr>, arrow_span: Span ) -> Option<P<Expr>>

Attempt to recover from match arm body with statements and no surrounding braces.

pub(super) fn parse_arm(&mut self) -> PResult<'a, Arm>

fn parse_match_guard_condition(&mut self) -> PResult<'a, P<Expr>>

pub(crate) fn is_builtin(&self) -> bool

fn parse_try_block(&mut self, span_lo: Span) -> PResult<'a, P<Expr>>

Parses a try {...} expression (try token already eaten).

fn is_do_catch_block(&self) -> bool

fn is_do_yeet(&self) -> bool

fn is_try_block(&self) -> bool

fn parse_async_block(&mut self) -> PResult<'a, P<Expr>>

Parses an async move? {...} expression.

fn is_async_block(&self) -> bool

fn is_certainly_not_a_block(&self) -> bool

fn maybe_parse_struct_expr( &mut self, qself: &Option<P<QSelf>>, path: &Path ) -> Option<PResult<'a, P<Expr>>>

pub(super) fn parse_struct_fields( &mut self, pth: Path, recover: bool, close_delim: Delimiter ) -> PResult<'a, (ThinVec<ExprField>, StructRest, bool)>

pub(super) fn parse_expr_struct( &mut self, qself: Option<P<QSelf>>, pth: Path, recover: bool ) -> PResult<'a, P<Expr>>

Precondition: already parsed the ‘{’.

fn find_struct_error_after_field_looking_code(&self) -> Option<ExprField>

Use in case of error after field-looking code: S { foo: () with a }.

fn recover_struct_comma_after_dotdot(&mut self, span: Span)

fn recover_struct_field_dots(&mut self, close_delim: Delimiter) -> bool

fn recover_ident_into_label(&mut self, ident: Ident) -> Label

Converts an ident into ’label and emits an “expected a label, found an identifier” error.

fn parse_expr_field(&mut self) -> PResult<'a, ExprField>

Parses ident (COLON expr)?.

fn error_on_eq_field_init(&self, field_name: Ident)

Check for =. This means the source incorrectly attempts to initialize a field with an eq rather than a colon.

fn err_dotdotdot_syntax(&self, span: Span)

fn err_larrow_operator(&self, span: Span)

fn mk_assign_op(&self, binop: BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ExprKind

fn mk_range( &mut self, start: Option<P<Expr>>, end: Option<P<Expr>>, limits: RangeLimits ) -> ExprKind

fn mk_unary(&self, unop: UnOp, expr: P<Expr>) -> ExprKind

fn mk_binary(&self, binop: BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ExprKind

fn mk_index(&self, expr: P<Expr>, idx: P<Expr>, brackets_span: Span) -> ExprKind

fn mk_call(&self, f: P<Expr>, args: ThinVec<P<Expr>>) -> ExprKind

fn mk_await_expr(&mut self, self_arg: P<Expr>, lo: Span) -> P<Expr>

pub(crate) fn mk_expr_with_attrs( &self, span: Span, kind: ExprKind, attrs: AttrVec ) -> P<Expr>

pub(crate) fn mk_expr(&self, span: Span, kind: ExprKind) -> P<Expr>

pub(super) fn mk_expr_err(&self, span: Span) -> P<Expr>

fn mk_expr_sp(&self, lhs: &P<Expr>, lhs_span: Span, rhs_span: Span) -> Span

Create expression span ensuring the span of the parent node is larger than the span of lhs and rhs, including the attributes.

fn collect_tokens_for_expr( &mut self, attrs: AttrWrapper, f: impl FnOnce(&mut Self, AttrVec) -> PResult<'a, P<Expr>> ) -> PResult<'a, P<Expr>>

fn parse_lt_param_bounds(&mut self) -> GenericBounds

Parses bounds of a lifetime parameter BOUND + BOUND + BOUND, possibly with trailing +.

BOUND = LT_BOUND (e.g., `'a`)

fn parse_ty_param( &mut self, preceding_attrs: AttrVec ) -> PResult<'a, GenericParam>

Matches typaram = IDENT (? unbound)? optbounds ( EQ ty )?.

pub(crate) fn parse_const_param( &mut self, preceding_attrs: AttrVec ) -> PResult<'a, GenericParam>

pub(crate) fn recover_const_param_with_mistyped_const( &mut self, preceding_attrs: AttrVec, mistyped_const_ident: Ident ) -> PResult<'a, GenericParam>

pub(super) fn parse_generic_params( &mut self ) -> PResult<'a, ThinVec<GenericParam>>

Parses a (possibly empty) list of lifetime and type parameters, possibly including a trailing comma and erroneous trailing attributes.

pub(super) fn parse_generics(&mut self) -> PResult<'a, Generics>

Parses a set of optional generic type parameter declarations. Where clauses are not parsed here, and must be added later via parse_where_clause().

matches generics = ( ) | ( < > ) | ( < typaramseq ( , )? > ) | ( < lifetimes ( , )? > ) | ( < lifetimes , typaramseq ( , )? > ) where typaramseq = ( typaram ) | ( typaram , typaramseq )

pub(super) fn parse_where_clause(&mut self) -> PResult<'a, WhereClause>

Parses an optional where-clause.

where T : Trait<U, V> + 'b, 'a : 'b

pub(super) fn parse_struct_where_clause( &mut self, struct_name: Ident, body_insertion_point: Span ) -> PResult<'a, (WhereClause, Option<ThinVec<FieldDef>>)>

fn parse_where_clause_common( &mut self, struct_: Option<(Ident, Span)> ) -> PResult<'a, (WhereClause, Option<ThinVec<FieldDef>>)>

fn parse_ty_where_predicate_or_recover_tuple_struct_body( &mut self, struct_: Option<(Ident, Span)>, pred_lo: Span, where_sp: Span ) -> PResult<'a, PredicateOrStructBody>

fn parse_ty_where_predicate(&mut self) -> PResult<'a, WherePredicate>

pub(super) fn choose_generics_over_qpath(&self, start: usize) -> bool

pub fn parse_crate_mod(&mut self) -> PResult<'a, Crate>

Parses a source module as a crate. This is the main entry point for the parser.

fn parse_item_mod( &mut self, attrs: &mut AttrVec ) -> PResult<'a, (Ident, ItemKind)>

Parses a mod <foo> { ... } or mod <foo>; item.

pub fn parse_mod( &mut self, term: &TokenKind ) -> PResult<'a, (AttrVec, ThinVec<P<Item>>, ModSpans)>

Parses the contents of a module (inner attributes followed by module items).

pub fn parse_item( &mut self, force_collect: ForceCollect ) -> PResult<'a, Option<P<Item>>>

fn parse_item_( &mut self, fn_parse_mode: FnParseMode, force_collect: ForceCollect ) -> PResult<'a, Option<Item>>

pub(super) fn parse_item_common( &mut self, attrs: AttrWrapper, mac_allowed: bool, attrs_allowed: bool, fn_parse_mode: FnParseMode, force_collect: ForceCollect ) -> PResult<'a, Option<Item>>

fn parse_item_common_( &mut self, attrs: AttrVec, mac_allowed: bool, attrs_allowed: bool, fn_parse_mode: FnParseMode ) -> PResult<'a, Option<Item>>

fn error_on_unconsumed_default(&self, def: Defaultness, kind: &ItemKind)

Error in-case default was parsed in an in-appropriate context.

fn parse_item_kind( &mut self, attrs: &mut AttrVec, macros_allowed: bool, lo: Span, vis: &Visibility, def: &mut Defaultness, fn_parse_mode: FnParseMode, case: Case ) -> PResult<'a, Option<(Ident, ItemKind)>>

Parses one of the items allowed by the flags.

fn recover_import_as_use(&mut self) -> PResult<'a, Option<(Ident, ItemKind)>>

fn parse_use_item(&mut self) -> PResult<'a, (Ident, ItemKind)>

pub(super) fn is_path_start_item(&mut self) -> bool

When parsing a statement, would the start of a path be an item?

fn isnt_macro_invocation(&mut self) -> bool

Are we sure this could not possibly be a macro invocation?

fn recover_missing_kw_before_item(&mut self) -> PResult<'a, ()>

Recover on encountering a struct or method definition where the user forgot to add the struct or fn keyword after writing pub: pub S {}.

fn parse_item_builtin(&mut self) -> PResult<'a, Option<(Ident, ItemKind)>>

fn parse_item_macro(&mut self, vis: &Visibility) -> PResult<'a, MacCall>

Parses an item macro, e.g., item!();.

fn recover_attrs_no_item(&mut self, attrs: &[Attribute]) -> PResult<'a, ()>

Recover if we parsed attributes and expected an item but there was none.

fn is_async_fn(&self) -> bool

fn parse_polarity(&mut self) -> ImplPolarity

fn parse_item_impl( &mut self, attrs: &mut AttrVec, defaultness: Defaultness ) -> PResult<'a, (Ident, ItemKind)>

Parses an implementation item.

impl<'a, T> TYPE { /* impl items */ }
impl<'a, T> TRAIT for TYPE { /* impl items */ }
impl<'a, T> !TRAIT for TYPE { /* impl items */ }
impl<'a, T> const TRAIT for TYPE { /* impl items */ }

We actually parse slightly more relaxed grammar for better error reporting and recovery.

"impl" GENERICS "const"? "!"? TYPE "for"? (TYPE | "..") ("where" PREDICATES)? "{" BODY "}"
"impl" GENERICS "const"? "!"? TYPE ("where" PREDICATES)? "{" BODY "}"

fn parse_item_list<T>( &mut self, attrs: &mut AttrVec, parse_item: impl FnMut(&mut Parser<'a>) -> PResult<'a, Option<Option<T>>> ) -> PResult<'a, ThinVec<T>>

fn recover_doc_comment_before_brace(&mut self) -> bool

Recover on a doc comment before }.

fn parse_defaultness(&mut self) -> Defaultness

Parses defaultness (i.e., default or nothing).

fn check_auto_or_unsafe_trait_item(&mut self) -> bool

Is this an (unsafe auto? | auto) trait item?

fn parse_item_trait( &mut self, attrs: &mut AttrVec, lo: Span ) -> PResult<'a, (Ident, ItemKind)>

Parses unsafe? auto? trait Foo { ... } or trait Foo = Bar;.

pub fn parse_impl_item( &mut self, force_collect: ForceCollect ) -> PResult<'a, Option<Option<P<AssocItem>>>>

pub fn parse_trait_item( &mut self, force_collect: ForceCollect ) -> PResult<'a, Option<Option<P<AssocItem>>>>

fn parse_assoc_item( &mut self, fn_parse_mode: FnParseMode, force_collect: ForceCollect ) -> PResult<'a, Option<Option<P<AssocItem>>>>

Parses associated items.

fn parse_type_alias( &mut self, defaultness: Defaultness ) -> PResult<'a, (Ident, ItemKind)>

Parses a type alias with the following grammar:

TypeAlias = "type" Ident Generics (":" GenericBounds)? WhereClause ("=" Ty)? WhereClause ";" ;

The "type" has already been eaten.

fn parse_use_tree(&mut self) -> PResult<'a, UseTree>

Parses a UseTree.

USE_TREE = [`::`] `*` |
           [`::`] `{` USE_TREE_LIST `}` |
           PATH `::` `*` |
           PATH `::` `{` USE_TREE_LIST `}` |
           PATH [`as` IDENT]

fn parse_use_tree_glob_or_nested(&mut self) -> PResult<'a, UseTreeKind>

Parses * or {...}.

fn parse_use_tree_list(&mut self) -> PResult<'a, ThinVec<(UseTree, NodeId)>>

Parses a UseTreeKind::Nested(list).

USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`]

fn parse_rename(&mut self) -> PResult<'a, Option<Ident>>

fn parse_ident_or_underscore(&mut self) -> PResult<'a, Ident>

fn parse_item_extern_crate(&mut self) -> PResult<'a, (Ident, ItemKind)>

Parses extern crate links.

Examples

extern crate foo;
extern crate bar as foo;

fn parse_crate_name_with_dashes(&mut self) -> PResult<'a, Ident>

fn parse_item_foreign_mod( &mut self, attrs: &mut AttrVec, unsafety: Unsafe ) -> PResult<'a, (Ident, ItemKind)>

Parses extern for foreign ABIs modules.

extern is expected to have been consumed before calling this method.

Examples

extern "C" {}
extern {}

pub fn parse_foreign_item( &mut self, force_collect: ForceCollect ) -> PResult<'a, Option<Option<P<ForeignItem>>>>

Parses a foreign item (one in an extern { ... } block).

fn error_bad_item_kind<T>( &self, span: Span, kind: &ItemKind, ctx: &'static str ) -> Option<T>

fn is_unsafe_foreign_mod(&self) -> bool

fn is_static_global(&mut self) -> bool

fn recover_const_mut(&mut self, const_span: Span)

Recover on const mut with const already eaten.

fn recover_const_impl( &mut self, const_span: Span, attrs: &mut AttrVec, defaultness: Defaultness ) -> PResult<'a, (Ident, ItemKind)>

Recover on const impl with const already eaten.

fn parse_static_item( &mut self, mutability: Mutability ) -> PResult<'a, (Ident, StaticItem)>

Parse a static item with the prefix "static" "mut"? already parsed and stored in mutability.

Static = "static" "mut"? $ident ":" $ty (= $expr)? ";" ;

fn parse_const_item( &mut self ) -> PResult<'a, (Ident, Generics, P<Ty>, Option<P<Expr>>)>

Parse a constant item with the prefix "const" already parsed.

Const = "const" ($ident | "_") Generics ":" $ty (= $expr)? WhereClause ";" ;

fn recover_missing_global_item_type( &mut self, colon_present: bool, m: Option<Mutability> ) -> P<Ty>

We were supposed to parse ":" $ty but the : or the type was missing. This means that the type is missing.

fn parse_item_enum(&mut self) -> PResult<'a, (Ident, ItemKind)>

Parses an enum declaration.

fn parse_enum_variant(&mut self) -> PResult<'a, Option<Variant>>

fn parse_item_struct(&mut self) -> PResult<'a, (Ident, ItemKind)>

Parses struct Foo { ... }.

fn parse_item_union(&mut self) -> PResult<'a, (Ident, ItemKind)>

Parses union Foo { ... }.

pub(crate) fn parse_record_struct_body( &mut self, adt_ty: &str, ident_span: Span, parsed_where: bool ) -> PResult<'a, (ThinVec<FieldDef>, bool)>

pub(super) fn parse_tuple_struct_body( &mut self ) -> PResult<'a, ThinVec<FieldDef>>

fn parse_field_def(&mut self, adt_ty: &str) -> PResult<'a, FieldDef>

Parses an element of a struct declaration.

fn parse_single_struct_field( &mut self, adt_ty: &str, lo: Span, vis: Visibility, attrs: AttrVec ) -> PResult<'a, FieldDef>

Parses a structure field declaration.

fn expect_field_ty_separator(&mut self) -> PResult<'a, ()>

fn parse_name_and_ty( &mut self, adt_ty: &str, lo: Span, vis: Visibility, attrs: AttrVec ) -> PResult<'a, FieldDef>

Parses a structure field.

fn parse_field_ident(&mut self, adt_ty: &str, lo: Span) -> PResult<'a, Ident>

Parses a field identifier. Specialized version of parse_ident_common for better diagnostics and suggestions.

fn parse_item_decl_macro(&mut self, lo: Span) -> PResult<'a, (Ident, ItemKind)>

Parses a declarative macro 2.0 definition. The macro keyword has already been parsed.

MacBody = "{" TOKEN_STREAM "}" ;
MacParams = "(" TOKEN_STREAM ")" ;
DeclMac = "macro" Ident MacParams? MacBody ;

fn is_macro_rules_item(&mut self) -> IsMacroRulesItem

Is this a possibly malformed start of a macro_rules! foo item definition?

fn parse_item_macro_rules( &mut self, vis: &Visibility, has_bang: bool ) -> PResult<'a, (Ident, ItemKind)>

Parses a macro_rules! foo { ... } declarative macro.

fn complain_if_pub_macro(&self, vis: &Visibility, macro_rules: bool)

Item macro invocations or macro_rules! definitions need inherited visibility. If that’s not the case, emit an error.

fn eat_semi_for_macro_if_needed(&mut self, args: &DelimArgs)

fn report_invalid_macro_expansion_item(&self, args: &DelimArgs)

fn recover_nested_adt_item(&mut self, keyword: Symbol) -> PResult<'a, bool>

Checks if current token is one of tokens which cannot be nested like kw::Enum. In case it is, we try to parse the item and report error about nested types.

fn parse_fn( &mut self, attrs: &mut AttrVec, fn_parse_mode: FnParseMode, sig_lo: Span, vis: &Visibility, case: Case ) -> PResult<'a, (Ident, FnSig, Generics, Option<P<Block>>)>

Parse a function starting from the front matter (const ...) to the body { ... } or ;.

fn parse_fn_body( &mut self, attrs: &mut AttrVec, ident: &Ident, sig_hi: &mut Span, req_body: bool ) -> PResult<'a, Option<P<Block>>>

Parse the “body” of a function. This can either be ; when there’s no body, or e.g. a block when the function is a provided one.

pub(super) fn check_fn_front_matter( &mut self, check_pub: bool, case: Case ) -> bool

Is the current token the start of an FnHeader / not a valid parse?

check_pub adds additional pub to the checks in case users place it wrongly, can be used to ensure pub never comes after default.

pub(super) fn parse_fn_front_matter( &mut self, orig_vis: &Visibility, case: Case ) -> PResult<'a, FnHeader>

Parses all the “front matter” (or “qualifiers”) for a fn declaration, up to and including the fn keyword. The formal grammar is:

Extern = "extern" StringLit? ;
FnQual = "const"? "async"? "unsafe"? Extern? ;
FnFrontMatter = FnQual "fn" ;

vis represents the visibility that was already parsed, if any. Use Visibility::Inherited when no visibility is known.

pub(super) fn parse_fn_decl( &mut self, req_name: fn(_: Edition) -> bool, ret_allow_plus: AllowPlus, recover_return_sign: RecoverReturnSign ) -> PResult<'a, P<FnDecl>>

Parses the parameter list and result type of a function declaration.

pub(super) fn parse_fn_params( &mut self, req_name: fn(_: Edition) -> bool ) -> PResult<'a, ThinVec<Param>>

Parses the parameter list of a function, including the ( and ) delimiters.

fn parse_param_general( &mut self, req_name: fn(_: Edition) -> bool, first_param: bool ) -> PResult<'a, Param>

Parses a single function parameter.

• self is syntactically allowed when first_param holds.

fn parse_self_param(&mut self) -> PResult<'a, Option<Param>>

Returns the parsed optional self parameter and whether a self shortcut was used.

fn is_named_param(&self) -> bool

fn recover_self_param(&mut self) -> bool

pub fn parse_nonterminal( &mut self, kind: NonterminalKind ) -> PResult<'a, ParseNtResult>

Parse a non-terminal (e.g. MBE :pat or :ident). Inlined because there is only one call site.

pub fn parse_pat_no_top_alt( &mut self, expected: Option<Expected>, syntax_loc: Option<PatternLocation> ) -> PResult<'a, P<Pat>>

Parses a pattern.

Corresponds to pat<no_top_alt> in RFC 2535 and does not admit or-patterns at the top level. Used when parsing the parameters of lambda expressions, functions, function pointers, and pat macro fragments.

pub fn parse_pat_allow_top_alt( &mut self, expected: Option<Expected>, rc: RecoverComma, ra: RecoverColon, rt: CommaRecoveryMode ) -> PResult<'a, P<Pat>>

Parses a pattern.

Corresponds to top_pat in RFC 2535 and allows or-pattern at the top level. Used for parsing patterns in all cases when pat<no_top_alt> is not used.

Note that after the FCP in https://github.com/rust-lang/rust/issues/81415, a leading vert is allowed in nested or-patterns, too. This allows us to simplify the grammar somewhat.

fn parse_pat_allow_top_alt_inner( &mut self, expected: Option<Expected>, rc: RecoverComma, ra: RecoverColon, rt: CommaRecoveryMode, syntax_loc: Option<PatternLocation> ) -> PResult<'a, (P<Pat>, bool)>

Returns the pattern and a bool indicating whether we recovered from a trailing vert (true = recovered).

pub(super) fn parse_pat_before_ty( &mut self, expected: Option<Expected>, rc: RecoverComma, syntax_loc: PatternLocation ) -> PResult<'a, (P<Pat>, bool)>

Parse a pattern and (maybe) a Colon in positions where a pattern may be followed by a type annotation (e.g. for let bindings or fn params).

Generally, this corresponds to pat_no_top_alt followed by an optional Colon. It will eat the Colon token if one is present.

The return value represents the parsed pattern and true if a Colon was parsed (false otherwise).

pub(super) fn parse_fn_param_pat_colon(&mut self) -> PResult<'a, (P<Pat>, bool)>

Parse the pattern for a function or function pointer parameter, followed by a colon.

The return value represents the parsed pattern and true if a Colon was parsed (false otherwise).

fn eat_or_separator(&mut self, lo: Option<Span>) -> EatOrResult

Eat the or-pattern | separator. If instead a || token is encountered, recover and pretend we parsed |.

fn recover_trailing_vert(&mut self, lo: Option<Span>) -> bool

Recover if | or || is the current token and we have one of the tokens =>, if, =, :, ;, ,, ], ), or } ahead of us.

These tokens all indicate that we reached the end of the or-pattern list and can now reliably say that the | was an illegal trailing vert. Note that there are more tokens such as @ for which we know that the | is an illegal parse. However, the user’s intent is less clear in that case.

fn parse_pat_with_range_pat( &mut self, allow_range_pat: bool, expected: Option<Expected>, syntax_loc: Option<PatternLocation> ) -> PResult<'a, P<Pat>>

Parses a pattern, with a setting whether modern range patterns (e.g., a..=b, a..b are allowed).

fn recover_dotdotdot_rest_pat(&mut self, lo: Span) -> PatKind

Recover from a typoed ... pattern that was encountered Ref: Issue #70388

fn recover_intersection_pat(&mut self, lhs: P<Pat>) -> PResult<'a, P<Pat>>

Try to recover the more general form intersect ::= $pat_lhs @ $pat_rhs.

Allowed binding patterns generated by binding ::= ref? mut? $ident @ $pat_rhs should already have been parsed by now at this point, if the next token is @ then we can try to parse the more general form.

Consult parse_pat_ident for the binding grammar.

The notion of intersection patterns are found in e.g. F# where they are called AND-patterns.

fn ban_pat_range_if_ambiguous(&self, pat: &Pat)

Ban a range pattern if it has an ambiguous interpretation.

fn parse_pat_deref( &mut self, expected: Option<Expected> ) -> PResult<'a, PatKind>

Parse &pat / &mut pat.

fn parse_pat_tuple_or_parens(&mut self) -> PResult<'a, PatKind>

Parse a tuple or parenthesis pattern.

fn parse_pat_ident_mut( &mut self, syntax_loc: Option<PatternLocation> ) -> PResult<'a, PatKind>

Parse a mutable binding with the mut token already eaten.

fn ban_mut_general_pat(&self, lo: Span, pat: &Pat, changed_any_binding: bool)

Error on mut $pat where $pat is not an ident.

fn recover_additional_muts(&mut self)

Eat any extraneous muts and error + recover if we ate any.

fn parse_pat_mac_invoc(&mut self, path: Path) -> PResult<'a, PatKind>

Parse macro invocation

fn fatal_unexpected_non_pat( &mut self, err: DiagnosticBuilder<'a, ErrorGuaranteed>, expected: Option<Expected> ) -> PResult<'a, P<Pat>>

fn parse_range_end(&mut self) -> Option<Spanned<RangeEnd>>

Parses the range pattern end form ".." | "..." | "..=" ;.

fn parse_pat_range_begin_with( &mut self, begin: P<Expr>, re: Spanned<RangeEnd> ) -> PResult<'a, PatKind>

Parse a range pattern $begin $form $end? where $form = ".." | "..." | "..=" ;. $begin $form has already been parsed.

pub(super) fn inclusive_range_with_incorrect_end(&mut self)

fn parse_pat_range_to(&mut self, re: Spanned<RangeEnd>) -> PResult<'a, PatKind>

Parse a range-to pattern, ..X or ..=X where X remains to be parsed.

The form ...X is prohibited to reduce confusion with the potential expression syntax ...expr for splatting in expressions.

fn is_pat_range_end_start(&self, dist: usize) -> bool

Is the token dist away from the current suitable as the start of a range patterns end?

fn parse_pat_range_end(&mut self) -> PResult<'a, P<Expr>>

fn is_start_of_pat_with_path(&mut self) -> bool

Is this the start of a pattern beginning with a path?

fn can_be_ident_pat(&mut self) -> bool

Would parse_pat_ident be appropriate here?

fn parse_pat_ident( &mut self, binding_annotation: BindingAnnotation, syntax_loc: Option<PatternLocation> ) -> PResult<'a, PatKind>

Parses ident or ident @ pat. Used by the copy foo and ref foo patterns to give a good error message when parsing mistakes like ref foo(a, b).

fn parse_pat_struct( &mut self, qself: Option<P<QSelf>>, path: Path ) -> PResult<'a, PatKind>

Parse a struct (“record”) pattern (e.g. Foo { ... } or Foo::Bar { ... }).

fn parse_pat_tuple_struct( &mut self, qself: Option<P<QSelf>>, path: Path ) -> PResult<'a, PatKind>

Parse tuple struct or tuple variant pattern (e.g. Foo(...) or Foo::Bar(...)).

fn isnt_pattern_start(&self) -> bool

Are we sure this could not possibly be the start of a pattern?

Currently, this only accounts for tokens that can follow identifiers in patterns, but this can be extended as necessary.

fn parse_pat_box(&mut self) -> PResult<'a, PatKind>

Parses box pat

fn parse_pat_fields(&mut self) -> PResult<'a, (ThinVec<PatField>, bool)>

Parses the fields of a struct-like pattern.

fn recover_bad_dot_dot(&self)

Recover on ... or _ as if it were .. to avoid further errors. See issue #46718.

fn parse_pat_field(&mut self, lo: Span, attrs: AttrVec) -> PResult<'a, PatField>

pub(super) fn mk_pat_ident( &self, span: Span, ann: BindingAnnotation, ident: Ident ) -> P<Pat>

pub(super) fn mk_pat(&self, span: Span, kind: PatKind) -> P<Pat>

pub(super) fn parse_qpath( &mut self, style: PathStyle ) -> PResult<'a, (P<QSelf>, Path)>

Parses a qualified path. Assumes that the leading < has been parsed already.

qualified_path = <type [as trait_ref]>::path

Examples

<T>::default <T as U>::a <T as U>::F::a<S> (without disambiguator) <T as U>::F::a::<S> (with disambiguator)

fn recover_colon_before_qpath_proj(&mut self) -> bool

Recover from an invalid single colon, when the user likely meant a qualified path. We avoid emitting this if not followed by an identifier, as our assumption that the user intended this to be a qualified path may not be correct.

<Bar as Baz<T>>:Qux
               ^ help: use double colon

pub(super) fn parse_path(&mut self, style: PathStyle) -> PResult<'a, Path>

pub(super) fn parse_path_inner( &mut self, style: PathStyle, ty_generics: Option<&Generics> ) -> PResult<'a, Path>

Parses simple paths.

path = [::] segment+ segment = ident | ident[::]<args> | ident[::](args) [-> type]

Examples

a::b::C<D> (without disambiguator) a::b::C::<D> (with disambiguator) Fn(Args) (without disambiguator) Fn::(Args) (with disambiguator)

pub(super) fn parse_path_segments( &mut self, segments: &mut ThinVec<PathSegment>, style: PathStyle, ty_generics: Option<&Generics> ) -> PResult<'a, ()>

pub(super) fn parse_path_segment( &mut self, style: PathStyle, ty_generics: Option<&Generics> ) -> PResult<'a, PathSegment>

pub(super) fn parse_path_segment_ident(&mut self) -> PResult<'a, Ident>

fn parse_angle_args_with_leading_angle_bracket_recovery( &mut self, style: PathStyle, lo: Span, ty_generics: Option<&Generics> ) -> PResult<'a, ThinVec<AngleBracketedArg>>

Parses generic args (within a path segment) with recovery for extra leading angle brackets. For the purposes of understanding the parsing logic of generic arguments, this function can be thought of being the same as just calling self.parse_angle_args() if the source had the correct amount of leading angle brackets.

bar::<<<<T as Foo>::Output>();
     ^^ help: remove extra angle brackets

pub(super) fn parse_angle_args( &mut self, ty_generics: Option<&Generics> ) -> PResult<'a, ThinVec<AngleBracketedArg>>

Parses (possibly empty) list of generic arguments / associated item constraints, possibly including trailing comma.

fn parse_angle_arg( &mut self, ty_generics: Option<&Generics> ) -> PResult<'a, Option<AngleBracketedArg>>

Parses a single argument in the angle arguments <...> of a path segment.

fn parse_assoc_equality_term( &mut self, ident: Ident, eq: Span ) -> PResult<'a, AssocConstraintKind>

Parse the term to the right of an associated item equality constraint. That is, parse <term> in Item = <term>. Right now, this only admits types in <term>.

pub(super) fn expr_is_valid_const_arg(&self, expr: &P<Expr>) -> bool

We do not permit arbitrary expressions as const arguments. They must be one of:

• An expression surrounded in {}.
• A literal.
• A numeric literal prefixed by -.
• A single-segment path.

pub(super) fn parse_const_arg(&mut self) -> PResult<'a, AnonConst>

Parse a const argument, e.g. <3>. It is assumed the angle brackets will be parsed by the caller.

pub(super) fn parse_generic_arg( &mut self, ty_generics: Option<&Generics> ) -> PResult<'a, Option<GenericArg>>

Parse a generic argument in a path segment. This does not include constraints, e.g., Item = u8, which is handled in parse_angle_arg.

fn get_ident_from_generic_arg( &self, gen_arg: &GenericArg ) -> Result<(bool, Ident, Option<GenericArgs>), ()>

Given a arg inside of generics, we try to destructure it as if it were the LHS in LHS = ..., i.e. an associated type binding. This returns a bool indicating if there are any for<'a, 'b> binder args, the identifier, and any GAT arguments.

pub fn parse_stmt( &mut self, force_collect: ForceCollect ) -> PResult<'a, Option<Stmt>>

Parses a statement. This stops just before trailing semicolons on everything but items. e.g., a StmtKind::Semi parses to a StmtKind::Expr, leaving the trailing ; unconsumed.

pub fn parse_stmt_without_recovery( &mut self, capture_semi: bool, force_collect: ForceCollect ) -> PResult<'a, Option<Stmt>>

If force_collect is ForceCollect::Yes, forces collection of tokens regardless of whether or not we have attributes

fn parse_stmt_path_start( &mut self, lo: Span, attrs: AttrWrapper ) -> PResult<'a, Stmt>

fn parse_stmt_mac( &mut self, lo: Span, attrs: AttrVec, path: Path ) -> PResult<'a, Stmt>

Parses a statement macro mac!(args) provided a path representing mac. At this point, the ! token after the path has already been eaten.

fn error_outer_attrs(&self, attrs: AttrWrapper)

Error on outer attributes in this context. Also error if the previous token was a doc comment.

fn recover_stmt_local_after_let( &mut self, lo: Span, attrs: AttrWrapper, subdiagnostic: fn(_: Span) -> InvalidVariableDeclarationSub ) -> PResult<'a, Stmt>

fn parse_local_mk( &mut self, lo: Span, attrs: AttrWrapper, capture_semi: bool, force_collect: ForceCollect ) -> PResult<'a, Stmt>

fn parse_local(&mut self, attrs: AttrVec) -> PResult<'a, P<Local>>

Parses a local variable declaration.

fn check_let_else_init_bool_expr(&self, init: &Expr)

fn check_let_else_init_trailing_brace(&self, init: &Expr)

fn parse_initializer( &mut self, eq_optional: bool ) -> PResult<'a, Option<P<Expr>>>

Parses the RHS of a local variable declaration (e.g., = 14;).

pub(super) fn parse_block(&mut self) -> PResult<'a, P<Block>>

Parses a block. No inner attributes are allowed.

fn error_block_no_opening_brace_msg( &mut self, msg: Cow<'static, str> ) -> DiagnosticBuilder<'a, ErrorGuaranteed>

fn error_block_no_opening_brace<T>(&mut self) -> PResult<'a, T>

pub(super) fn parse_inner_attrs_and_block( &mut self ) -> PResult<'a, (AttrVec, P<Block>)>

Parses a block. Inner attributes are allowed.

pub(super) fn parse_block_common( &mut self, lo: Span, blk_mode: BlockCheckMode, can_be_struct_literal: bool ) -> PResult<'a, (AttrVec, P<Block>)>

Parses a block. Inner attributes are allowed.

pub(crate) fn parse_block_tail( &mut self, lo: Span, s: BlockCheckMode, recover: AttemptLocalParseRecovery ) -> PResult<'a, P<Block>>

Parses the rest of a block expression or function body. Precondition: already parsed the ‘{’.

pub fn parse_full_stmt( &mut self, recover: AttemptLocalParseRecovery ) -> PResult<'a, Option<Stmt>>

Parses a statement, including the trailing semicolon.

pub(super) fn mk_block( &self, stmts: ThinVec<Stmt>, rules: BlockCheckMode, span: Span ) -> P<Block>

pub(super) fn mk_stmt(&self, span: Span, kind: StmtKind) -> Stmt

pub(super) fn mk_stmt_err(&self, span: Span) -> Stmt

pub(super) fn mk_block_err(&self, span: Span) -> P<Block>

pub fn parse_ty(&mut self) -> PResult<'a, P<Ty>>

Parses a type.

pub(super) fn parse_ty_with_generics_recovery( &mut self, ty_params: &Generics ) -> PResult<'a, P<Ty>>

pub fn parse_ty_for_field_def(&mut self) -> PResult<'a, P<Ty>>

Parse a type suitable for a field defintion. The difference from parse_ty is that this version allows anonymous structs and unions.

pub(super) fn parse_ty_for_param(&mut self) -> PResult<'a, P<Ty>>

Parse a type suitable for a function or function pointer parameter. The difference from parse_ty is that this version allows ... (CVarArgs) at the top level of the type.

pub(super) fn parse_ty_no_plus(&mut self) -> PResult<'a, P<Ty>>

Parses a type in restricted contexts where + is not permitted.

Example 1: &'a TYPE + is prohibited to maintain operator priority (P(+) < P(&)). Example 2: value1 as TYPE + value2 + is prohibited to avoid interactions with expression grammar.

pub(super) fn parse_as_cast_ty(&mut self) -> PResult<'a, P<Ty>>

Parses a type following an as cast. Similar to parse_ty_no_plus, but signaling origin for better diagnostics involving ?.

pub(super) fn parse_ty_no_question_mark_recover(&mut self) -> PResult<'a, P<Ty>>

pub(super) fn parse_ty_for_where_clause(&mut self) -> PResult<'a, P<Ty>>

Parse a type without recovering : as -> to avoid breaking code such as where fn() : for<'a>

pub(super) fn parse_ret_ty( &mut self, allow_plus: AllowPlus, recover_qpath: RecoverQPath, recover_return_sign: RecoverReturnSign ) -> PResult<'a, FnRetTy>

Parses an optional return type [ -> TY ] in a function declaration.

fn parse_ty_common( &mut self, allow_plus: AllowPlus, allow_c_variadic: AllowCVariadic, recover_qpath: RecoverQPath, recover_return_sign: RecoverReturnSign, ty_generics: Option<&Generics>, recover_question_mark: RecoverQuestionMark ) -> PResult<'a, P<Ty>>

fn parse_anon_struct_or_union(&mut self) -> PResult<'a, P<Ty>>

Parse an anonymous struct or union (only for field definitions):

#[repr(C)]
struct Foo {
    _: struct { // anonymous struct
        x: u32,
        y: f64,
    }
    _: union { // anonymous union
        z: u32,
        w: f64,
    }
}

fn parse_ty_tuple_or_parens( &mut self, lo: Span, allow_plus: AllowPlus ) -> PResult<'a, TyKind>

Parses either:

• (TYPE), a parenthesized type.
• (TYPE,), a tuple with a single field of type TYPE.

fn parse_bare_trait_object( &mut self, lo: Span, allow_plus: AllowPlus ) -> PResult<'a, TyKind>

fn parse_remaining_bounds_path( &mut self, generic_params: ThinVec<GenericParam>, path: Path, lo: Span, parse_plus: bool ) -> PResult<'a, TyKind>

fn parse_remaining_bounds( &mut self, bounds: GenericBounds, plus: bool ) -> PResult<'a, TyKind>

Parse the remainder of a bare trait object type given an already parsed list.

fn parse_ty_ptr(&mut self) -> PResult<'a, TyKind>

Parses a raw pointer type: *[const | mut] $type.

fn parse_array_or_slice_ty(&mut self) -> PResult<'a, TyKind>

Parses an array ([TYPE; EXPR]) or slice ([TYPE]) type. The opening [ bracket is already eaten.

fn parse_borrowed_pointee(&mut self) -> PResult<'a, TyKind>

fn parse_typeof_ty(&mut self) -> PResult<'a, TyKind>

fn parse_ty_bare_fn( &mut self, lo: Span, params: ThinVec<GenericParam>, param_insertion_point: Option<Span>, recover_return_sign: RecoverReturnSign ) -> PResult<'a, TyKind>

Parses a function pointer type (TyKind::BareFn).

   [unsafe] [extern "ABI"] fn (S) -> T
//  ^~~~~^          ^~~~^     ^~^    ^
//    |               |        |     |
//    |               |        |   Return type
// Function Style    ABI  Parameter types

We actually parse FnHeader FnDecl, but we error on const and async qualifiers.

fn recover_fn_ptr_with_generics( &mut self, lo: Span, params: &mut ThinVec<GenericParam>, param_insertion_point: Option<Span> ) -> PResult<'a, ()>

Recover from function pointer types with a generic parameter list (e.g. fn<'a>(&'a str)).

fn parse_impl_ty(&mut self, impl_dyn_multi: &mut bool) -> PResult<'a, TyKind>

Parses an impl B0 + ... + Bn type.

fn is_explicit_dyn_type(&mut self) -> bool

Is a dyn B0 + ... + Bn type allowed here?

fn parse_dyn_ty(&mut self, impl_dyn_multi: &mut bool) -> PResult<'a, TyKind>

Parses a dyn B0 + ... + Bn type.

Note that this does not parse bare trait objects.

fn parse_path_start_ty( &mut self, lo: Span, allow_plus: AllowPlus, ty_generics: Option<&Generics> ) -> PResult<'a, TyKind>

Parses a type starting with a path.

This can be:

1. a type macro, mac!(...),
2. a bare trait object, B0 + ... + Bn,
3. or a path, path::to::MyType.

pub(super) fn parse_generic_bounds(&mut self) -> PResult<'a, GenericBounds>

fn parse_generic_bounds_common( &mut self, allow_plus: AllowPlus ) -> PResult<'a, GenericBounds>

Parses bounds of a type parameter BOUND + BOUND + ..., possibly with trailing +.

See parse_generic_bound for the BOUND grammar.

pub(super) fn can_begin_anon_struct_or_union(&mut self) -> bool

fn can_begin_bound(&mut self) -> bool

Can the current token begin a bound?

fn parse_generic_bound(&mut self) -> PResult<'a, GenericBound>

Parses a bound according to the grammar:

BOUND = TY_BOUND | LT_BOUND

fn parse_generic_lt_bound( &mut self, lo: Span, inner_lo: Span, has_parens: bool ) -> PResult<'a, GenericBound>

Parses a lifetime (“outlives”) bound, e.g. 'a, according to:

LT_BOUND = LIFETIME

fn error_lt_bound_with_modifiers(&self, modifiers: BoundModifiers)

Emits an error if any trait bound modifiers were present.

fn recover_paren_lifetime( &mut self, lo: Span, inner_lo: Span ) -> PResult<'a, ()>

Recover on ('lifetime) with ( already eaten.

fn parse_ty_bound_modifiers(&mut self) -> PResult<'a, BoundModifiers>

Parses the modifiers that may precede a trait in a bound, e.g. ?Trait or ~const Trait.

If no modifiers are present, this does not consume any tokens.

TY_BOUND_MODIFIERS = ["~const"] ["?"]

fn parse_generic_ty_bound( &mut self, lo: Span, has_parens: bool, modifiers: BoundModifiers, leading_token: &Token ) -> PResult<'a, GenericBound>

Parses a type bound according to:

TY_BOUND = TY_BOUND_NOPAREN | (TY_BOUND_NOPAREN)
TY_BOUND_NOPAREN = [TY_BOUND_MODIFIERS] [for<LT_PARAM_DEFS>] SIMPLE_PATH

For example, this grammar accepts ~const ?for<'a: 'b> m::Trait<'a>.

fn recover_path_from_fn(&mut self) -> Option<Path>

pub(super) fn parse_late_bound_lifetime_defs( &mut self ) -> PResult<'a, ThinVec<GenericParam>>

Optionally parses for<$generic_params>.

fn recover_fn_trait_with_lifetime_params( &mut self, fn_path: &mut Path, lifetime_defs: &mut ThinVec<GenericParam> ) -> PResult<'a, ()>

Recover from Fn-family traits (Fn, FnMut, FnOnce) with lifetime arguments (e.g. FnOnce<'a>(&'a str) -> bool). Up to generic arguments have already been eaten.

pub(super) fn check_lifetime(&mut self) -> bool

pub(super) fn expect_lifetime(&mut self) -> Lifetime

Parses a single lifetime 'a or panics.

pub(super) fn mk_ty(&self, span: Span, kind: TyKind) -> P<Ty>

fn may_recover(&self) -> bool

Whether the parser is allowed to recover from broken code.

If this returns false, recovering broken code into valid code (especially if this recovery does lookahead) is not allowed. All recovery done by the parser must be gated behind this check.

Technically, this only needs to restrict eager recovery by doing lookahead at more tokens. But making the distinction is very subtle, and simply forbidding all recovery is a lot simpler to uphold.

pub fn unexpected<T>(&mut self) -> PResult<'a, T>

pub fn expect(&mut self, t: &TokenKind) -> PResult<'a, bool>

Expects and consumes the token t. Signals an error if the next token is not t.

pub fn expect_one_of( &mut self, edible: &[TokenKind], inedible: &[TokenKind] ) -> PResult<'a, bool>

Expect next token to be edible or inedible token. If edible, then consume it; if inedible, then return without consuming anything. Signal a fatal error if next token is unexpected.

pub fn parse_ident(&mut self) -> PResult<'a, Ident>

fn parse_ident_common(&mut self, recover: bool) -> PResult<'a, Ident>

fn ident_or_err(&mut self, recover: bool) -> PResult<'a, (Ident, bool)>

fn check(&mut self, tok: &TokenKind) -> bool

Checks if the next token is tok, and returns true if so.

This method will automatically add tok to expected_tokens if tok is not encountered.

fn check_noexpect(&self, tok: &TokenKind) -> bool

pub fn eat_noexpect(&mut self, tok: &TokenKind) -> bool

Consumes a token ‘tok’ if it exists. Returns whether the given token was present.

the main purpose of this function is to reduce the cluttering of the suggestions list which using the normal eat method could introduce in some cases.

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

Consumes a token ‘tok’ if it exists. Returns whether the given token was present.

fn check_keyword(&mut self, kw: Symbol) -> bool

If the next token is the given keyword, returns true without eating it. An expectation is also added for diagnostics purposes.

fn check_keyword_case(&mut self, kw: Symbol, case: Case) -> bool

pub fn eat_keyword(&mut self, kw: Symbol) -> bool

If the next token is the given keyword, eats it and returns true. Otherwise, returns false. An expectation is also added for diagnostics purposes.

fn eat_keyword_case(&mut self, kw: Symbol, case: Case) -> bool

Eats a keyword, optionally ignoring the case. If the case differs (and is ignored) an error is issued. This is useful for recovery.

fn eat_keyword_noexpect(&mut self, kw: Symbol) -> bool

fn expect_keyword(&mut self, kw: Symbol) -> PResult<'a, ()>

If the given word is not a keyword, signals an error. If the next token is not the given word, signals an error. Otherwise, eats it.

fn is_kw_followed_by_ident(&self, kw: Symbol) -> bool

Is the given keyword kw followed by a non-reserved identifier?

fn check_or_expected(&mut self, ok: bool, typ: TokenType) -> bool

fn check_ident(&mut self) -> bool

fn check_path(&mut self) -> bool

fn check_type(&mut self) -> bool

fn check_const_arg(&mut self) -> bool

fn check_const_closure(&self) -> bool

fn check_inline_const(&self, dist: usize) -> bool

fn check_plus(&mut self) -> bool

Checks to see if the next token is either + or +=. Otherwise returns false.

fn break_and_eat(&mut self, expected: TokenKind) -> bool

Eats the expected token if it’s present possibly breaking compound tokens like multi-character operators in process. Returns true if the token was eaten.

fn eat_plus(&mut self) -> bool

Eats + possibly breaking tokens like += in process.

fn expect_and(&mut self) -> PResult<'a, ()>

Eats & possibly breaking tokens like && in process. Signals an error if & is not eaten.

fn expect_or(&mut self) -> PResult<'a, ()>

Eats | possibly breaking tokens like || in process. Signals an error if | was not eaten.

fn eat_lt(&mut self) -> bool

Eats < possibly breaking tokens like << in process.

fn expect_lt(&mut self) -> PResult<'a, ()>

Eats < possibly breaking tokens like << in process. Signals an error if < was not eaten.

fn expect_gt(&mut self) -> PResult<'a, ()>

Eats > possibly breaking tokens like >> in process. Signals an error if > was not eaten.

fn expect_any_with_type( &mut self, kets: &[&TokenKind], expect: TokenExpectType ) -> bool

fn parse_seq_to_before_tokens<T>( &mut self, kets: &[&TokenKind], sep: SeqSep, expect: TokenExpectType, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T> ) -> PResult<'a, (ThinVec<T>, bool, bool)>

fn recover_missing_braces_around_closure_body( &mut self, closure_spans: ClosureSpans, expect_err: DiagnosticBuilder<'_, ErrorGuaranteed> ) -> PResult<'a, ()>

fn parse_seq_to_before_end<T>( &mut self, ket: &TokenKind, sep: SeqSep, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T> ) -> PResult<'a, (ThinVec<T>, bool, bool)>

Parses a sequence, not including the closing delimiter. The function f must consume tokens until reaching the next separator or closing bracket.

fn parse_seq_to_end<T>( &mut self, ket: &TokenKind, sep: SeqSep, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T> ) -> PResult<'a, (ThinVec<T>, bool)>

Parses a sequence, including the closing delimiter. The function f must consume tokens until reaching the next separator or closing bracket.

fn parse_unspanned_seq<T>( &mut self, bra: &TokenKind, ket: &TokenKind, sep: SeqSep, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T> ) -> PResult<'a, (ThinVec<T>, bool)>

Parses a sequence, including the closing delimiter. The function f must consume tokens until reaching the next separator or closing bracket.

fn parse_delim_comma_seq<T>( &mut self, delim: Delimiter, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T> ) -> PResult<'a, (ThinVec<T>, bool)>

fn parse_paren_comma_seq<T>( &mut self, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T> ) -> PResult<'a, (ThinVec<T>, bool)>

fn bump_with(&mut self, next: (Token, Spacing))

Advance the parser by one token using provided token as the next one.

fn inlined_bump_with(&mut self, (next_token, next_spacing): (Token, Spacing))

This always-inlined version should only be used on hot code paths.

pub fn bump(&mut self)

Advance the parser by one token.

pub fn look_ahead<R>(&self, dist: usize, looker: impl FnOnce(&Token) -> R) -> R

Look-ahead dist tokens of self.token and get access to that token there. When dist == 0 then the current token is looked at. Eof will be returned if the look-ahead is any distance past the end of the tokens.

fn is_keyword_ahead(&self, dist: usize, kws: &[Symbol]) -> bool

Returns whether any of the given keywords are dist tokens ahead of the current one.

fn parse_asyncness(&mut self, case: Case) -> Async

Parses asyncness: async or nothing.

fn parse_unsafety(&mut self, case: Case) -> Unsafe

Parses unsafety: unsafe or nothing.

fn parse_constness(&mut self, case: Case) -> Const

Parses constness: const or nothing.

fn parse_closure_constness(&mut self) -> Const

Parses constness for closures (case sensitive, feature-gated)

fn parse_constness_(&mut self, case: Case, is_closure: bool) -> Const

fn parse_const_block(&mut self, span: Span, pat: bool) -> PResult<'a, P<Expr>>

Parses inline const expressions.

fn parse_mutability(&mut self) -> Mutability

Parses mutability (mut or nothing).

fn parse_const_or_mut(&mut self) -> Option<Mutability>

Possibly parses mutability (const or mut).

fn parse_field_name(&mut self) -> PResult<'a, Ident>

fn parse_delim_args(&mut self) -> PResult<'a, P<DelimArgs>>

fn parse_attr_args(&mut self) -> PResult<'a, AttrArgs>

fn parse_delim_args_inner(&mut self) -> Option<DelimArgs>

fn parse_or_use_outer_attributes( &mut self, already_parsed_attrs: Option<AttrWrapper> ) -> PResult<'a, AttrWrapper>

pub fn parse_token_tree(&mut self) -> TokenTree

Parses a single token tree from the input.

pub fn parse_tokens(&mut self) -> TokenStream

fn with_res<T>( &mut self, res: Restrictions, f: impl FnOnce(&mut Self) -> T ) -> T

Evaluates the closure with restrictions in place.

Afters the closure is evaluated, restrictions are reset.

pub fn parse_visibility( &mut self, fbt: FollowedByType ) -> PResult<'a, Visibility>

Parses pub and pub(in path) plus shortcuts pub(crate) for pub(in crate), pub(self) for pub(in self) and pub(super) for pub(in super). If the following element can’t be a tuple (i.e., it’s a function definition), then it’s not a tuple struct field), and the contents within the parentheses aren’t valid, so emit a proper diagnostic.

fn recover_incorrect_vis_restriction(&mut self) -> PResult<'a, ()>

Recovery for e.g. pub(something) fn ... or struct X { pub(something) y: Z }

fn parse_extern(&mut self, case: Case) -> Extern

Parses extern string_literal?.

fn parse_abi(&mut self) -> Option<StrLit>

Parses a string literal as an ABI spec.

pub fn collect_tokens_no_attrs<R: HasAttrs + HasTokens>( &mut self, f: impl FnOnce(&mut Self) -> PResult<'a, R> ) -> PResult<'a, R>

fn is_import_coupler(&mut self) -> bool

::{ or ::*

pub fn clear_expected_tokens(&mut self)

pub fn approx_token_stream_pos(&self) -> usize

Trait Implementations

impl<'a> Deref for SnapshotParser<'a>

type Target = Parser<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> DerefMut for SnapshotParser<'a>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 264 bytes