rustc_parse::parser

Struct Parser

source
pub struct Parser<'a> {
Show 17 fields pub psess: &'a ParseSess, pub token: Token, token_spacing: Spacing, pub prev_token: Token, pub capture_cfg: bool, restrictions: Restrictions, expected_tokens: Vec<TokenType>, token_cursor: TokenCursor, num_bump_calls: u32, break_last_token: u32, unmatched_angle_bracket_count: u16, angle_bracket_nesting: u16, last_unexpected_token_span: Option<Span>, subparser_name: Option<&'static str>, capture_state: CaptureState, current_closure: Option<ClosureSpans>, recovery: Recovery,
}

Fields§

§psess: &'a ParseSess§token: Token

The current token.

§token_spacing: Spacing

The spacing for the current token.

§prev_token: Token

The previous token.

§capture_cfg: bool§restrictions: Restrictions§expected_tokens: Vec<TokenType>§token_cursor: TokenCursor§num_bump_calls: u32§break_last_token: u32§unmatched_angle_bracket_count: u16

This field is used to keep track of how many left angle brackets we have seen. This is required in order to detect extra leading left angle brackets (< characters) and error appropriately.

See the comments in the parse_path_segment function for more details.

§angle_bracket_nesting: u16§last_unexpected_token_span: Option<Span>§subparser_name: Option<&'static str>

If present, this Parser is not parsing Rust code but rather a macro call.

§capture_state: CaptureState§current_closure: Option<ClosureSpans>

This allows us to recover when the user forget to add braces around multiple statements in the closure body.

§recovery: Recovery

Whether the parser is allowed to do recovery. This is disabled when parsing macro arguments, see #103534

Implementations§

source§

impl<'a> Parser<'a>

source

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

Parses attributes that appear before an item.

source

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.

source

fn annotate_following_item_if_applicable( &self, err: &mut Diag<'_>, span: Span, attr_type: OuterAttributeType, suggest_to_outer: bool, ) -> Option<Span>

source

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

source

pub fn parse_attr_item( &mut self, force_collect: ForceCollect, ) -> 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.

source

pub 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*.

source

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

source

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

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

source

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

Matches COMMASEP(meta_item_inner).

source

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

Parse a meta item per RFC 1559.

MetaItem = SimplePath ( '=' UNSUFFIXED_LIT | '(' MetaSeq? ')' )? ;
MetaSeq = MetaItemInner (',' MetaItemInner)* ','? ;
source

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

source

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

Parse an inner meta item per RFC 1559.

MetaItemInner = UNSUFFIXED_LIT | MetaItem ;
source§

impl<'a> Parser<'a>

source

pub(super) fn collect_pos(&self) -> CollectPos

source

pub(super) fn collect_tokens<R: HasAttrs + HasTokens>( &mut self, pre_attr_pos: Option<CollectPos>, attrs: AttrWrapper, force_collect: ForceCollect, f: impl FnOnce(&mut Self, AttrVec) -> PResult<'a, (R, Trailing, UsePreAttrPos)>, ) -> PResult<'a, R>

Parses code with f. If appropriate, it records the tokens (in LazyAttrTokenStream form) that were parsed in the result, accessible via the HasTokens trait. The Trailing part of the callback’s result indicates if an extra token should be captured, e.g. a comma or semicolon. The UsePreAttrPos part of the callback’s result indicates if we should use pre_attr_pos as the collection start position (only required in a few cases).

The attrs passed in are in AttrWrapper form, which is opaque. The AttrVec within is passed to f. See the comment on AttrWrapper for details.

pre_attr_pos is the position before the outer attributes (or the node itself, if no outer attributes are present). It is only needed if f can return UsePreAttrPos::Yes.

Note: If your callback consumes an opening delimiter (including the case where self.token is an opening delimiter on entry to this function), you must also consume the corresponding closing delimiter. E.g. you can consume something ([{ }]) or ([{}]), but not ([{}]. This restriction isn’t a problem in practice, because parsed AST items always have matching delimiters.

The following example code will be used to explain things in comments below. It has an outer attribute and an inner attribute. Parsing it involves two calls to this method, one of which is indirectly recursive.

#[cfg_eval]                         // token pos
mod m {                             //   0.. 3
    #[cfg_attr(cond1, attr1)]       //   3..12
    fn g() {                        //  12..17
        #![cfg_attr(cond2, attr2)]  //  17..27
        let _x = 3;                 //  27..32
    }                               //  32..33
}                                   //  33..34
source§

impl<'a> Parser<'a>

source

pub fn dcx(&self) -> DiagCtxtHandle<'a>

source

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

Replace self with snapshot.parser.

source

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

Create a snapshot of the Parser.

source

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

source

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

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

Returns a possibly recovered identifier.

source

pub(super) fn expected_ident_found_err(&mut self) -> Diag<'a>

source

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.

source

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

source

fn check_for_misspelled_kw(&self, err: &mut Diag<'_>, expected: &[TokenType])

Checks if the current token or the previous token are misspelled keywords and adds a helpful suggestion.

source

pub(super) fn attr_on_non_tail_expr(&self, expr: &Expr) -> ErrorGuaranteed

The user has written #[attr] expr which is unsupported. (#106020)

source

fn check_too_many_raw_str_terminators(&mut self, err: &mut Diag<'_>) -> bool

source

pub(super) 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>>>

source

pub(super) fn recover_closure_body( &mut self, err: Diag<'a>, before: Token, prev: Token, token: Token, lo: Span, decl_hi: Span, ) -> PResult<'a, P<Expr>>

source

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.

source

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

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.

source

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.

source

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

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

source

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

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

source

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. The return value indicates if recovery happened.

source

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
source

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

source

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

source

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.

source

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

Rust has no ternary operator (cond ? then : else). Parse it and try to recover from it if then and else are valid expressions. Returns an err if this appears to be a ternary expression.

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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.

source

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.

source

pub fn maybe_consume_incorrect_semicolon( &mut self, previous_item: Option<&Item>, ) -> bool

This function gets called in places where a semicolon is NOT expected and if there’s a semicolon it emits the appropriate error and returns true.

source

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

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

source

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

source

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

source

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> }.

source

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

source

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

source

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

source

pub(super) fn recover_from_await_method_call(&mut self)

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

source

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

source

pub(super) fn expect_gt_or_maybe_suggest_closing_generics( &mut self, params: &[GenericParam], ) -> PResult<'a, ()>

When trying to close a generics list and encountering code like

impl<S: Into<std::borrow::Cow<'static, str>> From<S> for Canonical {}
                                         // ^ missing > here

we provide a structured suggestion on the error from expect_gt.

source

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

source

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).

source

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.

source

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

source

pub(super) fn eat_incorrect_doc_comment_for_param_type(&mut self)

source

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

source

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

source

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

source

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

source

pub(super) fn expected_expression_found(&self) -> Diag<'a>

source

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

source

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.

source

pub(super) 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.

source

pub(super) 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.
source

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

source

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

source

pub(super) fn recover_const_arg( &mut self, start: Span, err: Diag<'a>, ) -> 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.

source

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.

source

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

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

source

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).

source

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

source

pub(crate) fn maybe_recover_unexpected_comma( &mut self, lo: Span, 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).

source

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

source

pub(crate) fn maybe_err_dotdotlt_syntax( &self, maybe_lt: Token, err: PErr<'a>, ) -> PErr<'a>

Check for exclusive ranges written as ..<

source

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

This checks if this is a conflict marker, depending of the parameter passed.

  • <<<<<<<
  • |||||||
  • =======
  • >>>>>>>
source

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

source

pub(super) fn recover_vcs_conflict_marker(&mut self)

source

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

source

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

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

source§

impl<'a> Parser<'a>

source

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

Parses an expression.

source

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

Parses an expression, forcing tokens to be collected.

source

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

source

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

source

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

Parses a sequence of expressions delimited by parentheses.

source

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

Parses an expression, subject to the given restrictions.

source

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

Parses an associative expression with operators of at least min_prec precedence. The bool in the return value indicates if it was an assoc expr, i.e. with an operator followed by a subexpression (e.g. 1 + 2).

source

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

Parses the rest of an associative expression (i.e. the part after the lhs) with operators of at least min_prec precedence. The bool in the return value indicates if something was actually parsed.

source

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

source

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.

source

pub(super) 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.

source

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

Checks if this expression is a successfully parsed statement.

source

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.

source

fn is_at_start_of_range_notation_rhs(&self) -> bool

source

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

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

source

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

Parses a prefix-unary-operator expr.

source

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

source

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

source

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

Recover on ~expr in favor of !expr.

source

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

Parse box expr - this syntax has been removed, but we still parse this for now to provide a more useful error

source

fn is_mistaken_not_ident_negation(&self) -> bool

source

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

Recover on not expr in favor of !expr.

source

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.

source

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>>

source

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

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

source

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

source

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

Parse mut? or raw [ const | mut ].

source

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

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

source

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

source

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

source

fn error_unexpected_after_dot(&self) -> ErrorGuaranteed

source

pub(super) fn break_up_float( &self, float: Symbol, span: Span, ) -> DestructuredFloat

We need an identifier or integer, but the next token is a float. Break the float into components to extract the identifier or integer.

See also TokenKind::break_two_token_op which does similar splitting of >> into >.

source

fn parse_floating_field_access(&mut self) -> PResult<'a, P<[Ident]>>

Parse the field access used in offset_of, matched by $(e:expr)+. Currently returns a list of idents. However, it should be possible in future to also do array indices, which might be arbitrary expressions.

source

fn mk_expr_tuple_field_access( &self, lo: Span, ident_span: Span, base: P<Expr>, field: Symbol, suffix: Option<Symbol>, ) -> P<Expr>

source

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

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

source

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

source

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

Parse an indexing expression expr[...].

source

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.

source

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_expr_dot_or_call.

source

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

source

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

source

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

source

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

source

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.

source

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

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

source

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

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

source

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

Parse an expression if the token can begin one.

source

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

Parse "return" expr?.

source

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

Parse "do" "yeet" expr?.

source

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

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

source

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.

source

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

Parse "continue" label?.

source

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

Parse "yield" expr?.

source

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

Parse builtin # ident(args,*).

source

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

source

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

Built-in macro for offset_of! expressions.

source

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

Built-in macro for type ascription expressions.

source

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.

source

pub(crate) fn mk_token_lit_char(name: Symbol, span: Span) -> (Lit, Span)

source

fn mk_meta_item_lit_char(name: Symbol, span: Span) -> MetaItemLit

source

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

source

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

source

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

source

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

source

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.

source

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.

source

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

source

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.

source

fn is_array_like_block(&mut self) -> bool

source

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.

source

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

source

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.

source

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

Parse a block which takes no attributes and has no label

source

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

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

source

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

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

source

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

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

source

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

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

source

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

Parses an if expression (if token already eaten).

source

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

source

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

Parses the condition of a if or while expression.

source

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

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

source

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

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

source

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

source

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

source

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

source

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

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

source

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)

source

fn error_missing_in_for_loop(&mut self)

source

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).

source

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

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

source

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

source

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

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

source

fn parse_match_block( &mut self, lo: Span, match_span: Span, scrutinee: P<Expr>, match_kind: MatchKind, ) -> PResult<'a, P<Expr>>

Parses the block of a match expr { ... } or a expr.match { ... } expression. This is after the match token and scrutinee are eaten

source

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

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

source

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

source

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

source

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

source

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

source

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

source

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

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

source

fn is_do_catch_block(&self) -> bool

source

fn is_do_yeet(&self) -> bool

source

fn is_try_block(&self) -> bool

source

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

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

source

fn is_gen_block(&self, kw: Symbol, lookahead: usize) -> bool

source

pub(super) fn is_async_gen_block(&self) -> bool

source

fn is_certainly_not_a_block(&self) -> bool

source

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

source

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

source

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

Precondition: already parsed the ‘{’.

source

fn recover_struct_comma_after_dotdot(&mut self, span: Span)

source

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

source

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.

source

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

Parses ident (COLON expr)?.

source

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.

source

fn err_dotdotdot_syntax(&self, span: Span)

source

fn err_larrow_operator(&self, span: Span)

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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.

source

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

source§

impl<'a> Parser<'a>

source

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`)
source

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

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

source

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

source

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

source

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.

source

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 )

source

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

Parses an optional where-clause.

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

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

source

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

source

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>

source

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

source

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

source§

impl<'a> Parser<'a>

source

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.

source

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

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

source

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). We exit once we hit term which can be either

  • EOF (for files)
  • } for mod items
source§

impl<'a> Parser<'a>

source

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

source

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

source

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>>

source

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

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

source

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.

source

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

source

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

source

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

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

source

fn is_reuse_path_item(&mut self) -> bool

source

fn isnt_macro_invocation(&mut self) -> bool

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

source

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

Recover on encountering a struct, enum, or method definition where the user forgot to add the struct, enum, or fn keyword

source

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

source

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

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

source

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

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

source

fn is_async_fn(&self) -> bool

source

fn parse_polarity(&mut self) -> ImplPolarity

source

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 "}"
source

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

source

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>>

source

fn recover_doc_comment_before_brace(&mut self) -> bool

Recover on a doc comment before }.

source

fn parse_defaultness(&mut self) -> Defaultness

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

source

fn check_auto_or_unsafe_trait_item(&mut self) -> bool

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

source

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

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

source

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

source

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

source

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

Parses associated items.

source

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.

source

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]
source

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

Parses * or {...}.

source

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

Parses a UseTreeKind::Nested(list).

USE_TREE_LIST = ∅ | (USE_TREE `,`)* USE_TREE [`,`]
source

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

source

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

source

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

Parses extern crate links.

§Examples
extern crate foo;
extern crate bar as foo;
source

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

source

fn parse_item_foreign_mod( &mut self, attrs: &mut AttrVec, safety: Safety, ) -> 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 {}
source

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).

source

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

source

fn is_unsafe_foreign_mod(&self) -> bool

source

fn is_static_global(&mut self) -> bool

source

fn recover_const_mut(&mut self, const_span: Span)

Recover on const mut with const already eaten.

source

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.

source

fn parse_static_item( &mut self, safety: Safety, 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)? ";" ;
source

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 ";" ;
source

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.

source

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

Parses an enum declaration.

source

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

source

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

Parses struct Foo { ... }.

source

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

Parses union Foo { ... }.

source

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

This function parses the fields of record structs:

  • struct S { ... }
  • enum E { Variant { ... } }
source

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

source

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

Parses an element of a struct declaration.

source

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

Parses a structure field declaration.

source

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

source

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

Parses a structure field.

source

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.

source

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 ;
source

fn is_macro_rules_item(&mut self) -> IsMacroRulesItem

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

source

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

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

source

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.

source

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

source

fn report_invalid_macro_expansion_item(&self, args: &DelimArgs)

source

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.

source§

impl<'a> Parser<'a>

Parsing of functions and methods.

source

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 ;.

source

fn error_fn_body_not_found( &mut self, ident_span: Span, req_body: bool, fn_params_end: Option<Span>, ) -> PResult<'a, ErrorGuaranteed>

Provide diagnostics when function body is not found

source

fn parse_fn_body( &mut self, attrs: &mut AttrVec, ident: &Ident, sig_hi: &mut Span, req_body: bool, fn_params_end: Option<Span>, ) -> 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.

source

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.

source

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.

source

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.

source

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.

source

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.
source

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

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

source

fn is_named_param(&self) -> bool

source

fn recover_self_param(&mut self) -> bool

source§

impl<'a> Parser<'a>

source

pub fn nonterminal_may_begin_with(kind: NonterminalKind, token: &Token) -> bool

Checks whether a non-terminal may begin with a particular token.

Returning false is a stability guarantee that such a matcher will never begin with that token. Be conservative (return true) if not sure. Inlined because it has a single call site.

source

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.

source§

impl<'a> Parser<'a>

source

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.

source

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.

source

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).

source

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).

source

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).

source

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 |.

source

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.

source

fn maybe_recover_trailing_expr( &mut self, pat_span: Span, is_end_bound: bool, ) -> Option<(ErrorGuaranteed, Span)>

Ensures that the last parsed pattern (or pattern range bound) is not followed by an expression.

is_end_bound indicates whether the last parsed thing was the end bound of a range pattern (see parse_pat_range_end) in order to say “expected a pattern range bound” instead of “expected a pattern”;

0..=1 + 2
    ^^^^^

Only the end bound is spanned in this case, and this function has no idea if there was a ..= before pat_span, hence the parameter.

This function returns Some if a trailing expression was recovered, and said expression’s span.

source

pub(super) fn maybe_augment_stashed_expr_in_pats_with_suggestions( &mut self, stmt: &Stmt, )

Called by Parser::parse_stmt_without_recovery, used to add statement-aware subdiagnostics to the errors stashed by Parser::maybe_recover_trailing_expr.

source

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).

source

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

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

source

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.

source

fn ban_pat_range_if_ambiguous(&self, pat: &Pat)

Ban a range pattern if it has an ambiguous interpretation.

source

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

Parse &pat / &mut pat.

source

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

Parse a tuple or parenthesis pattern.

source

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

Parse a mutable binding with the mut token already eaten.

source

fn make_all_value_bindings_mutable(pat: &mut P<Pat>) -> bool

Turn all by-value immutable bindings in a pattern into mutable bindings. Returns true if any change was made.

source

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

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

source

fn recover_additional_muts(&mut self)

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

source

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

Parse macro invocation

source

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

source

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

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

source

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.

source

pub(super) fn inclusive_range_with_incorrect_end(&mut self) -> ErrorGuaranteed

source

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.

source

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?

source

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

Parse a range pattern end bound

source

fn is_start_of_pat_with_path(&mut self) -> bool

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

source

fn can_be_ident_pat(&mut self) -> bool

Would parse_pat_ident be appropriate here?

source

fn parse_pat_ident( &mut self, binding_annotation: BindingMode, 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).

source

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 { ... }).

source

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(...)).

source

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.

source

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

source

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

Parses box pat

source

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

Parses the fields of a struct-like pattern.

source

fn report_misplaced_at_in_struct_pat(&self, prev_field: Ident) -> Diag<'a>

source

fn recover_misplaced_pattern_modifiers( &self, fields: &ThinVec<PatField>, err: &mut Diag<'a>, )

If the user writes S { ref field: name } instead of S { field: ref name }, we suggest the correct code.

source

fn recover_bad_dot_dot(&self)

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

source

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

source

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

source

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

source§

impl<'a> Parser<'a>

source

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)

source

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
source

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

source

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)

source

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

source

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

Eat :: or, potentially, :::.

source

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

source

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

source

fn recover_fn_call_leading_path_sep( &mut self, style: PathStyle, prev_token_before_parsing: Token, error: &mut Diag<'_>, )

Recover $path::(...) as $path(...).

foo::(420, "bar")
   ^^ remove extra separator to make the function call
// or
match x {
   Foo::(420, "bar") => { ... },
      ^^ remove extra separator to turn this into tuple struct pattern
   _ => { ... },
}
source

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
source

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.

source

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.

source

fn parse_assoc_equality_term( &mut self, ident: Ident, gen_args: Option<&GenericArgs>, eq: Span, ) -> PResult<'a, AssocItemConstraintKind>

Parse the term to the right of an associated item equality constraint.

That is, parse $term in Item = $term where $term is a type or a const expression (wrapped in curly braces if complex).

source

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.
source

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.

source

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.

source

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 item binding. This returns a bool indicating if there are any for<'a, 'b> binder args, the identifier, and any GAT arguments.

source§

impl<'a> Parser<'a>

source

pub(super) 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.

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

source

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.

source

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

source

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.

source

fn error_outer_attrs(&self, attrs: AttrWrapper)

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

source

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

source

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

Parses a local variable declaration.

source

fn check_let_else_init_bool_expr(&self, init: &Expr)

source

fn check_let_else_init_trailing_brace(&self, init: &Expr)

source

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

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

source

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

Parses a block. No inner attributes are allowed.

source

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

source

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

source

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

Parses a block. Inner attributes are allowed.

source

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.

source

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 ‘{’.

source

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

Parses a statement, including the trailing semicolon.

source

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

source

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

source

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

source

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

source§

impl<'a> Parser<'a>

source

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

Parses a type.

source

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

source

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.

source

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.

source

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 ?.

source

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

source

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>

source

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.

source

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>>

source

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.
source

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

source

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

source

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.

source

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

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

source

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.

source

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

source

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

source

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.

source

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)).

source

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

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

source

fn parse_precise_capturing_args( &mut self, ) -> PResult<'a, (ThinVec<PreciseCapturingArg>, Span)>

source

fn is_explicit_dyn_type(&mut self) -> bool

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

source

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.

source

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.
source

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

source

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.

source

fn can_begin_bound(&mut self) -> bool

Can the current token begin a bound?

source

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

Parses a bound according to the grammar:

BOUND = TY_BOUND | LT_BOUND
source

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

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

LT_BOUND = LIFETIME
source

fn error_lt_bound_with_modifiers( &self, modifiers: TraitBoundModifiers, binder_span: Option<Span>, ) -> ErrorGuaranteed

Emits an error if any trait bound modifiers were present.

source

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

Recover on ('lifetime) with ( already eaten.

source

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

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.

CONSTNESS = [["~"] "const"]
ASYNCNESS = ["async"]
POLARITY = ["?" | "!"]

See parse_generic_ty_bound for the complete grammar of trait bound modifiers.

source

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

Parses a type bound according to:

TY_BOUND = TY_BOUND_NOPAREN | (TY_BOUND_NOPAREN)
TY_BOUND_NOPAREN = [for<GENERIC_PARAMS> CONSTNESS ASYNCNESS | POLARITY] SIMPLE_PATH

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

source

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

source

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

Optionally parses for<$generic_params>.

source

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.

source

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

source

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

Parses a single lifetime 'a or panics.

source

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

source§

impl<'a> Parser<'a>

source

pub fn new( psess: &'a ParseSess, stream: TokenStream, subparser_name: Option<&'static str>, ) -> Self

source

pub fn recovery(self, recovery: Recovery) -> Self

source

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.

source

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

Version of unexpected that “returns” any type in the Ok (both those functions never return “Ok”, and so can lie like that in the type).

source

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

source

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

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

source

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

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.

source

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

source

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

source

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

source

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.

source

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

source

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.

source

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

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

source

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.

source

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

source

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.

source

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.

source

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

If the next token is the given keyword, eats it and returns true. Otherwise, returns false. No expectation is added.

source

pub 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.

source

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

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

source

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

source

fn check_ident(&mut self) -> bool

source

fn check_path(&mut self) -> bool

source

fn check_type(&mut self) -> bool

source

fn check_const_arg(&mut self) -> bool

source

fn check_const_closure(&self) -> bool

source

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

source

fn check_plus(&mut self) -> bool

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

source

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.

source

fn eat_plus(&mut self) -> bool

Eats + possibly breaking tokens like += in process.

source

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

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

source

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

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

source

fn eat_lt(&mut self) -> bool

Eats < possibly breaking tokens like << in process.

source

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

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

source

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

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

source

fn expect_any_with_type( &mut self, kets_expected: &[&TokenKind], kets_not_expected: &[&TokenKind], ) -> bool

Checks if the next token is contained within kets, and returns true if so.

source

fn parse_seq_to_before_tokens<T>( &mut self, kets_expected: &[&TokenKind], kets_not_expected: &[&TokenKind], sep: SeqSep, f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>, ) -> PResult<'a, (ThinVec<T>, Trailing, Recovered)>

Parses a sequence until the specified delimiters. The function f must consume tokens until reaching the next separator or closing bracket.

source

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

source

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>, Trailing, Recovered)>

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

source

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>, Trailing)>

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

source

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>, Trailing)>

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

source

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

Parses a comma-separated sequence, including both delimiters. The function f must consume tokens until reaching the next separator or closing bracket.

source

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

Parses a comma-separated sequence delimited by parentheses (e.g. (x, y)). The function f must consume tokens until reaching the next separator or closing bracket.

source

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

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

source

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

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

source

pub fn bump(&mut self)

Advance the parser by one token.

source

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.

source

pub(crate) 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.

source

fn parse_coroutine_kind(&mut self, case: Case) -> Option<CoroutineKind>

Parses asyncness: async or nothing.

source

fn parse_safety(&mut self, case: Case) -> Safety

Parses fn unsafety: unsafe, safe or nothing.

source

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

Parses constness: const or nothing.

source

fn parse_closure_constness(&mut self) -> Const

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

source

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

source

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

Parses inline const expressions.

source

fn parse_mutability(&mut self) -> Mutability

Parses mutability (mut or nothing).

source

fn parse_byref(&mut self) -> ByRef

Parses reference binding mode (ref, ref mut, or nothing).

source

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

Possibly parses mutability (const or mut).

source

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

source

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

source

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

source

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

source

pub fn parse_token_tree(&mut self) -> TokenTree

Parses a single token tree from the input.

source

pub fn parse_tokens(&mut self) -> TokenStream

source

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.

source

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.

source

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

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

source

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

Parses extern string_literal?.

source

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

Parses a string literal as an ABI spec.

source

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

source

fn check_path_sep_and_look_ahead( &mut self, looker: impl Fn(&Token) -> bool, ) -> bool

Checks for :: or, potentially, ::: and then look ahead after it.

source

fn is_import_coupler(&mut self) -> bool

::{ or ::*

source

pub(crate) fn debug_lookahead(&self, lookahead: usize) -> impl Debug + '_

source

pub fn clear_expected_tokens(&mut self)

source

pub fn approx_token_stream_pos(&self) -> u32

Trait Implementations§

source§

impl<'a> Clone for Parser<'a>

source§

fn clone(&self) -> Parser<'a>

Returns a copy of the value. Read more
source§

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

Performs copy-assignment from source. Read more

Auto Trait Implementations§

§

impl<'a> DynSend for Parser<'a>

§

impl<'a> DynSync for Parser<'a>

§

impl<'a> Freeze for Parser<'a>

§

impl<'a> !RefUnwindSafe for Parser<'a>

§

impl<'a> !Send for Parser<'a>

§

impl<'a> !Sync for Parser<'a>

§

impl<'a> Unpin for Parser<'a>

§

impl<'a> !UnwindSafe for Parser<'a>

Blanket Implementations§

source§

impl<T> Aligned for T

source§

const ALIGN: Alignment = _

Alignment of Self.
source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T, R> CollectAndApply<T, R> for T

source§

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to f(&iter.collect::<Vec<_>>()).

source§

type Output = R

source§

impl<T> Filterable for T

source§

fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>

Creates a filterable data provider with the given name for debugging. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
source§

type Init = T

The type for initializers.
source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

source§

type Output = T

Should always be Self
source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

source§

fn upcast(self, interner: I) -> U

source§

impl<I, T> UpcastFrom<I, T> for T

source§

fn upcast_from(from: T, _tcx: I) -> T

source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<'a, T> Captures<'a> for T
where T: ?Sized,

source§

impl<T> ErasedDestructor for T
where T: 'static,

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: 288 bytes