[−][src]Struct rustc_parse::parser::Parser
Fields
sess: &'a ParseSess
token: Token
The current token.
token_spacing: Spacing
The spacing for the current token
prev_token: Token
The previous token.
restrictions: Restrictions
expected_tokens: Vec<TokenType>
token_cursor: TokenCursor
desugar_doc_comments: bool
unmatched_angle_bracket_count: u32
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.
max_angle_bracket_count: u32
unclosed_delims: Vec<UnmatchedBrace>
A list of all unclosed delimiters found by the lexer. If an entry is used for error recovery it gets removed from here. Every entry left at the end gets emitted as an independent error.
last_unexpected_token_span: Option<Span>
last_type_ascription: Option<(Span, bool)>
Span pointing at the :
for the last type ascription the parser has seen, and whether it
looked like it could have been a mistyped path or literal Option:Some(42)
).
subparser_name: Option<&'static str>
If present, this Parser
is not parsing Rust code but rather a macro call.
Implementations
impl<'a> Parser<'a>
[src]
pub(super) fn parse_outer_attributes(&mut self) -> PResult<'a, Vec<Attribute>>
[src]
Parses attributes that appear before an item.
pub fn parse_attribute(
&mut self,
inner_parse_policy: InnerAttrPolicy<'_>
) -> PResult<'a, Attribute>
[src]
&mut self,
inner_parse_policy: InnerAttrPolicy<'_>
) -> PResult<'a, Attribute>
Matches attribute = # ! [ meta_item ]
.
inner_parse_policy
prescribes how to handle inner attributes.
pub(super) fn error_on_forbidden_inner_attr(
&self,
attr_sp: Span,
policy: InnerAttrPolicy<'_>
)
[src]
&self,
attr_sp: Span,
policy: InnerAttrPolicy<'_>
)
pub fn parse_attr_item(&mut self, capture_tokens: bool) -> PResult<'a, AttrItem>
[src]
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, Vec<Attribute>>
[src]
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_lit(&mut self) -> PResult<'a, Lit>
[src]
pub fn parse_cfg_attr(
&mut self
) -> PResult<'a, (MetaItem, Vec<(AttrItem, Span)>)>
[src]
&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, Vec<NestedMetaItem>>
[src]
Matches COMMASEP(meta_item_inner)
.
pub fn parse_meta_item(&mut self) -> PResult<'a, MetaItem>
[src]
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>
[src]
fn parse_meta_item_inner(&mut self) -> PResult<'a, NestedMetaItem>
[src]
Matches meta_item_inner : (meta_item | UNSUFFIXED_LIT) ;
.
impl<'a> Parser<'a>
[src]
pub(super) fn span_fatal_err<S: Into<MultiSpan>>(
&self,
sp: S,
err: Error
) -> DiagnosticBuilder<'a>
[src]
&self,
sp: S,
err: Error
) -> DiagnosticBuilder<'a>
pub fn struct_span_err<S: Into<MultiSpan>>(
&self,
sp: S,
m: &str
) -> DiagnosticBuilder<'a>
[src]
&self,
sp: S,
m: &str
) -> DiagnosticBuilder<'a>
pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> !
[src]
pub(super) fn diagnostic(&self) -> &'a Handler
[src]
pub(super) fn span_to_snippet(
&self,
span: Span
) -> Result<String, SpanSnippetError>
[src]
&self,
span: Span
) -> Result<String, SpanSnippetError>
pub(super) fn expected_ident_found(&self) -> DiagnosticBuilder<'a>
[src]
pub(super) fn expected_one_of_not_found(
&mut self,
edible: &[TokenKind],
inedible: &[TokenKind]
) -> PResult<'a, bool>
[src]
&mut self,
edible: &[TokenKind],
inedible: &[TokenKind]
) -> PResult<'a, bool>
fn check_too_many_raw_str_terminators(
&mut self,
err: &mut DiagnosticBuilder<'_>
) -> bool
[src]
&mut self,
err: &mut DiagnosticBuilder<'_>
) -> bool
pub fn maybe_suggest_struct_literal(
&mut self,
lo: Span,
s: BlockCheckMode
) -> Option<PResult<'a, P<Block>>>
[src]
&mut self,
lo: Span,
s: BlockCheckMode
) -> Option<PResult<'a, P<Block>>>
pub fn maybe_annotate_with_ascription(
&mut self,
err: &mut DiagnosticBuilder<'_>,
maybe_expected_semicolon: bool
)
[src]
&mut self,
err: &mut DiagnosticBuilder<'_>,
maybe_expected_semicolon: bool
)
pub(super) fn eat_to_tokens(&mut self, kets: &[&TokenKind])
[src]
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
[src]
&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 _ = vec![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
)
[src]
&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,
mut e: DiagnosticBuilder<'a>,
expr: &mut P<Expr>
) -> PResult<'a, ()>
[src]
&mut self,
mut e: DiagnosticBuilder<'a>,
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 ,
.
fn attempt_chained_comparison_suggestion(
&mut self,
err: &mut DiagnosticBuilder<'_>,
inner_op: &Expr,
outer_op: &Spanned<AssocOp>
) -> bool
[src]
&mut self,
err: &mut DiagnosticBuilder<'_>,
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>>>
[src]
&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<(), ()>
[src]
pub(super) fn maybe_report_ambiguous_plus(
&mut self,
allow_plus: AllowPlus,
impl_dyn_multi: bool,
ty: &Ty
)
[src]
&mut self,
allow_plus: AllowPlus,
impl_dyn_multi: bool,
ty: &Ty
)
pub(super) fn maybe_recover_from_bad_type_plus(
&mut self,
allow_plus: AllowPlus,
ty: &Ty
) -> PResult<'a, ()>
[src]
&mut self,
allow_plus: AllowPlus,
ty: &Ty
) -> PResult<'a, ()>
pub(super) fn maybe_recover_from_bad_qpath<T: RecoverQPath>(
&mut self,
base: P<T>,
allow_recovery: bool
) -> PResult<'a, P<T>>
[src]
&mut self,
base: P<T>,
allow_recovery: bool
) -> 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>>
[src]
&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(super) fn maybe_consume_incorrect_semicolon(
&mut self,
items: &[P<Item>]
) -> bool
[src]
&mut self,
items: &[P<Item>]
) -> bool
pub(super) fn unexpected_try_recover(
&mut self,
t: &TokenKind
) -> PResult<'a, bool>
[src]
&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, ()>
[src]
pub(super) fn recover_incorrect_await_syntax(
&mut self,
lo: Span,
await_sp: Span,
attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
lo: Span,
await_sp: Span,
attrs: AttrVec
) -> 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)>
[src]
fn recover_await_prefix(
&mut self,
await_sp: Span
) -> PResult<'a, (Span, P<Expr>, bool)>
[src]
&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
[src]
&self,
lo: Span,
hi: Span,
expr: &Expr,
is_question: bool
) -> Span
pub(super) fn recover_from_await_method_call(&mut self)
[src]
If encountering future.await()
, consumes and emits an error.
pub(super) fn try_macro_suggestion(&mut self) -> PResult<'a, P<Expr>>
[src]
pub(super) fn recover_parens_around_for_head(
&mut self,
pat: P<Pat>,
expr: &Expr,
begin_paren: Option<Span>
) -> P<Pat>
[src]
&mut self,
pat: P<Pat>,
expr: &Expr,
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 could_ascription_be_path(&self, node: &ExprKind) -> bool
[src]
pub(super) fn recover_seq_parse_error(
&mut self,
delim: DelimToken,
lo: Span,
result: PResult<'a, P<Expr>>
) -> P<Expr>
[src]
&mut self,
delim: DelimToken,
lo: Span,
result: PResult<'a, P<Expr>>
) -> P<Expr>
pub(super) fn recover_closing_delimiter(
&mut self,
tokens: &[TokenKind],
mut err: DiagnosticBuilder<'a>
) -> PResult<'a, bool>
[src]
&mut self,
tokens: &[TokenKind],
mut err: DiagnosticBuilder<'a>
) -> PResult<'a, bool>
pub(super) fn recover_stmt(&mut self)
[src]
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
)
[src]
&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)
[src]
pub(super) fn eat_incorrect_doc_comment_for_param_type(&mut self)
[src]
pub(super) fn parameter_without_type(
&mut self,
err: &mut DiagnosticBuilder<'_>,
pat: P<Pat>,
require_name: bool,
first_param: bool
) -> Option<Ident>
[src]
&mut self,
err: &mut DiagnosticBuilder<'_>,
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>)>
[src]
pub(super) fn recover_bad_self_param(
&mut self,
mut param: Param
) -> PResult<'a, Param>
[src]
&mut self,
mut param: Param
) -> PResult<'a, Param>
pub(super) fn consume_block(
&mut self,
delim: DelimToken,
consume_close: ConsumeClosingDelim
)
[src]
&mut self,
delim: DelimToken,
consume_close: ConsumeClosingDelim
)
pub(super) fn expected_expression_found(&self) -> DiagnosticBuilder<'a>
[src]
fn consume_tts(&mut self, mut acc: i64, modifier: &[(TokenKind, i64)])
[src]
pub(super) fn deduplicate_recovered_params_names(
&self,
fn_inputs: &mut Vec<Param>
)
[src]
&self,
fn_inputs: &mut Vec<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 Vec<AngleBracketedArg>
) -> PResult<'a, bool>
[src]
&mut self,
args: &mut Vec<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>>
[src]
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.
pub fn recover_const_arg(
&mut self,
start: Span,
mut err: DiagnosticBuilder<'a>
) -> PResult<'a, GenericArg>
[src]
&mut self,
start: Span,
mut err: DiagnosticBuilder<'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 that the resulting expression would be well formed.
pub(super) fn incorrect_move_async_order_found(
&self,
move_async_span: Span
) -> DiagnosticBuilder<'a>
[src]
&self,
move_async_span: Span
) -> DiagnosticBuilder<'a>
Get the diagnostics for the cases where move async
is found.
move_async_span
starts at the 'm' of the move keyword and ends with the 'c' of the async keyword
impl<'a> Parser<'a>
[src]
pub fn parse_expr(&mut self) -> PResult<'a, P<Expr>>
[src]
Parses an expression.
pub(super) fn parse_anon_const_expr(&mut self) -> PResult<'a, AnonConst>
[src]
fn parse_expr_catch_underscore(&mut self) -> PResult<'a, P<Expr>>
[src]
fn parse_paren_expr_seq(&mut self) -> PResult<'a, Vec<P<Expr>>>
[src]
Parses a sequence of expressions delimited by parentheses.
pub(super) fn parse_expr_res(
&mut self,
r: Restrictions,
already_parsed_attrs: Option<AttrVec>
) -> PResult<'a, P<Expr>>
[src]
&mut self,
r: Restrictions,
already_parsed_attrs: Option<AttrVec>
) -> PResult<'a, P<Expr>>
Parses an expression, subject to the given restrictions.
fn parse_assoc_expr(
&mut self,
already_parsed_attrs: Option<AttrVec>
) -> PResult<'a, P<Expr>>
[src]
&mut self,
already_parsed_attrs: Option<AttrVec>
) -> 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_assoc_expr_with(
&mut self,
min_prec: usize,
lhs: LhsExpr
) -> PResult<'a, P<Expr>>
[src]
&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
[src]
fn error_found_expr_would_be_stmt(&self, lhs: &Expr)
[src]
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>>
[src]
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 error_bad_logical_op(&self, bad: &str, good: &str, english: &str)
[src]
Error on and
and or
suggesting &&
and ||
respectively.
fn expr_is_complete(&self, e: &Expr) -> bool
[src]
Checks if this expression is a successfully parsed statement.
fn parse_range_expr(
&mut self,
prec: usize,
lhs: P<Expr>,
op: AssocOp,
cur_op_span: Span
) -> PResult<'a, P<Expr>>
[src]
&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
[src]
fn parse_prefix_range_expr(
&mut self,
attrs: Option<AttrVec>
) -> PResult<'a, P<Expr>>
[src]
&mut self,
attrs: Option<AttrVec>
) -> PResult<'a, P<Expr>>
Parses prefix-forms of range notation: ..expr
, ..
, ..=expr
.
fn parse_prefix_expr(&mut self, attrs: Option<AttrVec>) -> PResult<'a, P<Expr>>
[src]
Parses a prefix-unary-operator expr.
fn parse_prefix_expr_common(&mut self, lo: Span) -> PResult<'a, (Span, P<Expr>)>
[src]
fn parse_unary_expr(
&mut self,
lo: Span,
op: UnOp
) -> PResult<'a, (Span, ExprKind)>
[src]
&mut self,
lo: Span,
op: UnOp
) -> PResult<'a, (Span, ExprKind)>
fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)>
[src]
fn parse_box_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)>
[src]
Parse box expr
.
fn is_mistaken_not_ident_negation(&self) -> bool
[src]
fn recover_not_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)>
[src]
Recover on not expr
in favor of !expr
.
fn interpolated_or_expr_span(
&self,
expr: PResult<'a, P<Expr>>
) -> PResult<'a, (Span, P<Expr>)>
[src]
&self,
expr: PResult<'a, P<Expr>>
) -> PResult<'a, (Span, P<Expr>)>
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>>
[src]
&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>>
[src]
&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_assoc_op_ascribe(
&mut self,
lhs: P<Expr>,
lhs_span: Span
) -> PResult<'a, P<Expr>>
[src]
&mut self,
lhs: P<Expr>,
lhs_span: Span
) -> PResult<'a, P<Expr>>
fn parse_borrow_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)>
[src]
Parse & mut? <expr>
or & raw [ const | mut ] <expr>
.
fn error_remove_borrow_lifetime(&self, span: Span, lt_span: Span)
[src]
fn parse_borrow_modifiers(&mut self, lo: Span) -> (BorrowKind, Mutability)
[src]
Parse mut?
or raw [ const | mut ]
.
fn parse_dot_or_call_expr(
&mut self,
attrs: Option<AttrVec>
) -> PResult<'a, P<Expr>>
[src]
&mut self,
attrs: Option<AttrVec>
) -> PResult<'a, P<Expr>>
Parses a.b
or a(13)
or a[4]
or just a
.
pub(super) fn parse_dot_or_call_expr_with(
&mut self,
e0: P<Expr>,
lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
e0: P<Expr>,
lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
fn parse_dot_or_call_expr_with_(
&mut self,
mut e: P<Expr>,
lo: Span
) -> PResult<'a, P<Expr>>
[src]
&mut self,
mut 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>>
[src]
&mut self,
lo: Span,
base: P<Expr>
) -> PResult<'a, P<Expr>>
fn error_unexpected_after_dot(&self)
[src]
fn parse_tuple_field_access_expr_float(
&mut self,
lo: Span,
base: P<Expr>,
float: Symbol,
suffix: Option<Symbol>
) -> P<Expr>
[src]
&mut self,
lo: Span,
base: P<Expr>,
float: Symbol,
suffix: Option<Symbol>
) -> P<Expr>
fn parse_tuple_field_access_expr(
&mut self,
lo: Span,
base: P<Expr>,
field: Symbol,
suffix: Option<Symbol>,
next_token: Option<(Token, Spacing)>
) -> P<Expr>
[src]
&mut self,
lo: Span,
base: P<Expr>,
field: Symbol,
suffix: Option<Symbol>,
next_token: Option<(Token, Spacing)>
) -> P<Expr>
fn parse_fn_call_expr(&mut self, lo: Span, fun: P<Expr>) -> P<Expr>
[src]
Parse a function call expression, expr(...)
.
fn parse_index_expr(&mut self, lo: Span, base: P<Expr>) -> PResult<'a, P<Expr>>
[src]
Parse an indexing expression expr[...]
.
fn parse_dot_suffix(
&mut self,
self_arg: P<Expr>,
lo: Span
) -> PResult<'a, P<Expr>>
[src]
&mut self,
self_arg: P<Expr>,
lo: Span
) -> PResult<'a, P<Expr>>
Assuming we have just parsed .
, continue parsing into an expression.
fn parse_bottom_expr(&mut self) -> PResult<'a, P<Expr>>
[src]
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_lit_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
fn parse_tuple_parens_expr(
&mut self,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
fn parse_array_or_repeat_expr(
&mut self,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
fn parse_path_start_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
fn parse_labeled_expr(
&mut self,
label: Label,
attrs: AttrVec,
consume_colon: bool
) -> PResult<'a, P<Expr>>
[src]
&mut self,
label: Label,
attrs: AttrVec,
consume_colon: bool
) -> PResult<'a, P<Expr>>
Parse 'label: $expr
. The label is already parsed.
fn error_labeled_expr_must_be_followed_by_colon(&self, lo: Span, span: Span)
[src]
fn recover_do_catch(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Recover on the syntax do catch { ... }
suggesting try { ... }
instead.
fn parse_expr_opt(&mut self) -> PResult<'a, Option<P<Expr>>>
[src]
Parse an expression if the token can begin one.
fn parse_return_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Parse "return" expr?
.
fn parse_break_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Parse "('label ":")? break expr?
.
fn parse_yield_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Parse "yield" expr?
.
pub fn parse_str_lit(&mut self) -> Result<StrLit, Option<Lit>>
[src]
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.
pub(super) fn parse_lit(&mut self) -> PResult<'a, Lit>
[src]
pub(super) fn parse_opt_lit(&mut self) -> Option<Lit>
[src]
Matches lit = true | false | token_lit
.
Returns None
if the next token is not a literal.
fn error_float_lits_must_have_int_part(&self, token: &Token)
[src]
fn report_lit_error(&self, err: LitError, lit: Lit, span: Span)
[src]
pub(super) fn expect_no_suffix(
&self,
sp: Span,
kind: &str,
suffix: Option<Symbol>
)
[src]
&self,
sp: Span,
kind: &str,
suffix: Option<Symbol>
)
pub fn parse_literal_maybe_minus(&mut self) -> PResult<'a, P<Expr>>
[src]
Matches '-' lit | lit
(cf. ast_validation::AstValidator::check_expr_within_pat
).
Keep this in sync with Token::can_begin_literal_maybe_minus
.
pub(super) fn parse_block_expr(
&mut self,
opt_label: Option<Label>,
lo: Span,
blk_mode: BlockCheckMode,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
opt_label: Option<Label>,
lo: Span,
blk_mode: BlockCheckMode,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
Parses a block or unsafe block.
fn recover_quantified_closure_expr(
&mut self,
attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
attrs: AttrVec
) -> PResult<'a, P<Expr>>
Recover on an explicitly quantified closure expression, e.g., for<'a> |x: &'a u8| *x + 1
.
fn parse_closure_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Parses a closure expression (e.g., move |args| expr
).
fn parse_capture_clause(&mut self) -> PResult<'a, CaptureBy>
[src]
Parses an optional move
prefix to a closure-like construct.
fn parse_fn_block_decl(&mut self) -> PResult<'a, P<FnDecl>>
[src]
Parses the |arg, arg|
header of a closure.
fn parse_fn_block_param(&mut self) -> PResult<'a, Param>
[src]
Parses a parameter in a closure header (e.g., |arg, arg|
).
fn parse_if_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Parses an if
expression (if
token already eaten).
fn error_missing_if_cond(&self, lo: Span, span: Span) -> P<Block>
[src]
fn parse_cond_expr(&mut self) -> PResult<'a, P<Expr>>
[src]
Parses the condition of a if
or while
expression.
fn parse_let_expr(&mut self, attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Parses a let $pat = $expr
pseudo-expression.
The let
token has already been eaten.
fn parse_else_expr(&mut self) -> PResult<'a, P<Expr>>
[src]
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: &[Attribute]
)
[src]
&self,
ctx_span: Span,
is_ctx_else: bool,
branch_span: Span,
attrs: &[Attribute]
)
fn parse_for_expr(
&mut self,
opt_label: Option<Label>,
lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
opt_label: Option<Label>,
lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
Parses for <src_pat> in <src_expr> <src_loop_block>
(for
token already eaten).
fn error_missing_in_for_loop(&mut self)
[src]
fn parse_while_expr(
&mut self,
opt_label: Option<Label>,
lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
opt_label: Option<Label>,
lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
Parses a while
or while let
expression (while
token already eaten).
fn parse_loop_expr(
&mut self,
opt_label: Option<Label>,
lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
opt_label: Option<Label>,
lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
Parses loop { ... }
(loop
token already eaten).
fn eat_label(&mut self) -> Option<Label>
[src]
fn parse_match_expr(&mut self, mut attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Parses a match ... { ... }
expression (match
token already eaten).
pub(super) fn parse_arm(&mut self) -> PResult<'a, Arm>
[src]
fn parse_try_block(
&mut self,
span_lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
[src]
&mut self,
span_lo: Span,
mut attrs: AttrVec
) -> PResult<'a, P<Expr>>
Parses a try {...}
expression (try
token already eaten).
fn is_do_catch_block(&self) -> bool
[src]
fn is_try_block(&self) -> bool
[src]
fn parse_async_block(&mut self, mut attrs: AttrVec) -> PResult<'a, P<Expr>>
[src]
Parses an async move? {...}
expression.
fn is_async_block(&self) -> bool
[src]
fn is_certainly_not_a_block(&self) -> bool
[src]
fn maybe_parse_struct_expr(
&mut self,
path: &Path,
attrs: &AttrVec
) -> Option<PResult<'a, P<Expr>>>
[src]
&mut self,
path: &Path,
attrs: &AttrVec
) -> Option<PResult<'a, P<Expr>>>
fn error_struct_lit_not_allowed_here(&self, lo: Span, sp: Span)
[src]
pub(super) fn parse_struct_expr(
&mut self,
pth: Path,
mut attrs: AttrVec,
recover: bool
) -> PResult<'a, P<Expr>>
[src]
&mut self,
pth: Path,
mut attrs: AttrVec,
recover: bool
) -> PResult<'a, P<Expr>>
Precondition: already parsed the '{'.
fn find_struct_error_after_field_looking_code(&self) -> Option<Field>
[src]
Use in case of error after field-looking code: S { foo: () with a }
.
fn recover_struct_comma_after_dotdot(&mut self, span: Span)
[src]
fn parse_field(&mut self) -> PResult<'a, Field>
[src]
Parses ident (COLON expr)?
.
fn error_on_eq_field_init(&self, field_name: Ident)
[src]
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)
[src]
fn err_larrow_operator(&self, span: Span)
[src]
fn mk_assign_op(&self, binop: BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ExprKind
[src]
fn mk_range(
&self,
start: Option<P<Expr>>,
end: Option<P<Expr>>,
limits: RangeLimits
) -> PResult<'a, ExprKind>
[src]
&self,
start: Option<P<Expr>>,
end: Option<P<Expr>>,
limits: RangeLimits
) -> PResult<'a, ExprKind>
fn mk_unary(&self, unop: UnOp, expr: P<Expr>) -> ExprKind
[src]
fn mk_binary(&self, binop: BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ExprKind
[src]
fn mk_index(&self, expr: P<Expr>, idx: P<Expr>) -> ExprKind
[src]
fn mk_call(&self, f: P<Expr>, args: Vec<P<Expr>>) -> ExprKind
[src]
fn mk_await_expr(&mut self, self_arg: P<Expr>, lo: Span) -> PResult<'a, P<Expr>>
[src]
pub(crate) fn mk_expr(
&self,
span: Span,
kind: ExprKind,
attrs: AttrVec
) -> P<Expr>
[src]
&self,
span: Span,
kind: ExprKind,
attrs: AttrVec
) -> P<Expr>
pub(super) fn mk_expr_err(&self, span: Span) -> P<Expr>
[src]
fn mk_expr_sp(&self, lhs: &P<Expr>, lhs_span: Span, rhs_span: Span) -> Span
[src]
Create expression span ensuring the span of the parent node is larger than the span of lhs and rhs, including the attributes.
impl<'a> Parser<'a>
[src]
fn parse_lt_param_bounds(&mut self) -> GenericBounds
[src]
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: Vec<Attribute>
) -> PResult<'a, GenericParam>
[src]
&mut self,
preceding_attrs: Vec<Attribute>
) -> PResult<'a, GenericParam>
Matches typaram = IDENT (
? unbound)? optbounds ( EQ ty )?
.
fn parse_const_param(
&mut self,
preceding_attrs: Vec<Attribute>
) -> PResult<'a, GenericParam>
[src]
&mut self,
preceding_attrs: Vec<Attribute>
) -> PResult<'a, GenericParam>
pub(super) fn parse_generic_params(&mut self) -> PResult<'a, Vec<GenericParam>>
[src]
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>
[src]
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>
[src]
Parses an optional where-clause and places it in generics
.
where T : Trait<U, V> + 'b, 'a : 'b
fn parse_ty_where_predicate(&mut self) -> PResult<'a, WherePredicate>
[src]
pub(super) fn choose_generics_over_qpath(&self, start: usize) -> bool
[src]
impl<'a> Parser<'a>
[src]
pub fn parse_crate_mod(&mut self) -> PResult<'a, Crate>
[src]
Parses a source module as a crate. This is the main entry point for the parser.
fn parse_item_mod(
&mut self,
attrs: &mut Vec<Attribute>
) -> PResult<'a, (Ident, ItemKind)>
[src]
&mut self,
attrs: &mut Vec<Attribute>
) -> PResult<'a, (Ident, ItemKind)>
Parses a mod <foo> { ... }
or mod <foo>;
item.
pub fn parse_mod(
&mut self,
term: &TokenKind,
unsafety: Unsafe
) -> PResult<'a, (Mod, Vec<Attribute>)>
[src]
&mut self,
term: &TokenKind,
unsafety: Unsafe
) -> PResult<'a, (Mod, Vec<Attribute>)>
Parses the contents of a module (inner attributes followed by module items).
fn parse_mod_items(
&mut self,
term: &TokenKind,
inner_lo: Span,
unsafety: Unsafe
) -> PResult<'a, Mod>
[src]
&mut self,
term: &TokenKind,
inner_lo: Span,
unsafety: Unsafe
) -> PResult<'a, Mod>
Given a termination token, parses all of the items in a module.
impl<'a> Parser<'a>
[src]
pub fn parse_item(
&mut self,
force_collect: ForceCollect
) -> PResult<'a, Option<P<Item>>>
[src]
&mut self,
force_collect: ForceCollect
) -> PResult<'a, Option<P<Item>>>
fn parse_item_(
&mut self,
req_name: fn(_: Edition) -> bool,
force_collect: ForceCollect
) -> PResult<'a, Option<Item>>
[src]
&mut self,
req_name: fn(_: Edition) -> bool,
force_collect: ForceCollect
) -> PResult<'a, Option<Item>>
pub(super) fn parse_item_common(
&mut self,
mut attrs: Vec<Attribute>,
mac_allowed: bool,
attrs_allowed: bool,
req_name: fn(_: Edition) -> bool,
force_collect: ForceCollect
) -> PResult<'a, Option<Item>>
[src]
&mut self,
mut attrs: Vec<Attribute>,
mac_allowed: bool,
attrs_allowed: bool,
req_name: fn(_: Edition) -> bool,
force_collect: ForceCollect
) -> PResult<'a, Option<Item>>
fn parse_item_common_(
&mut self,
mut attrs: Vec<Attribute>,
mac_allowed: bool,
attrs_allowed: bool,
req_name: fn(_: Edition) -> bool
) -> PResult<'a, Option<Item>>
[src]
&mut self,
mut attrs: Vec<Attribute>,
mac_allowed: bool,
attrs_allowed: bool,
req_name: fn(_: Edition) -> bool
) -> PResult<'a, Option<Item>>
fn error_on_unmatched_vis(&self, vis: &Visibility)
[src]
Error in-case a non-inherited visibility was parsed but no item followed.
fn error_on_unmatched_defaultness(&self, def: Defaultness)
[src]
Error in-case a default
was parsed but no item followed.
fn error_on_unconsumed_default(&self, def: Defaultness, kind: &ItemKind)
[src]
Error in-case default
was parsed in an in-appropriate context.
fn parse_item_kind(
&mut self,
attrs: &mut Vec<Attribute>,
macros_allowed: bool,
lo: Span,
vis: &Visibility,
def: &mut Defaultness,
req_name: fn(_: Edition) -> bool
) -> PResult<'a, Option<(Ident, ItemKind)>>
[src]
&mut self,
attrs: &mut Vec<Attribute>,
macros_allowed: bool,
lo: Span,
vis: &Visibility,
def: &mut Defaultness,
req_name: fn(_: Edition) -> bool
) -> PResult<'a, Option<(Ident, ItemKind)>>
Parses one of the items allowed by the flags.
pub(super) fn is_path_start_item(&mut self) -> bool
[src]
When parsing a statement, would the start of a path be an item?
fn isnt_macro_invocation(&mut self) -> bool
[src]
Are we sure this could not possibly be a macro invocation?
fn recover_missing_kw_before_item(&mut self) -> PResult<'a, ()>
[src]
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_macro(&mut self, vis: &Visibility) -> PResult<'a, MacCall>
[src]
Parses an item macro, e.g., item!();
.
fn recover_attrs_no_item(&mut self, attrs: &[Attribute]) -> PResult<'a, ()>
[src]
Recover if we parsed attributes and expected an item but there was none.
fn is_async_fn(&self) -> bool
[src]
fn parse_polarity(&mut self) -> ImplPolarity
[src]
fn parse_item_impl(
&mut self,
attrs: &mut Vec<Attribute>,
defaultness: Defaultness
) -> PResult<'a, (Ident, ItemKind)>
[src]
&mut self,
attrs: &mut Vec<Attribute>,
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 Vec<Attribute>,
mut parse_item: impl FnMut(&mut Parser<'a>) -> PResult<'a, Option<Option<T>>>
) -> PResult<'a, Vec<T>>
[src]
&mut self,
attrs: &mut Vec<Attribute>,
mut parse_item: impl FnMut(&mut Parser<'a>) -> PResult<'a, Option<Option<T>>>
) -> PResult<'a, Vec<T>>
fn recover_doc_comment_before_brace(&mut self) -> bool
[src]
Recover on a doc comment before }
.
fn parse_defaultness(&mut self) -> Defaultness
[src]
Parses defaultness (i.e., default
or nothing).
fn check_auto_or_unsafe_trait_item(&mut self) -> bool
[src]
Is this an (unsafe auto? | auto) trait
item?
fn parse_item_trait(
&mut self,
attrs: &mut Vec<Attribute>,
lo: Span
) -> PResult<'a, (Ident, ItemKind)>
[src]
&mut self,
attrs: &mut Vec<Attribute>,
lo: Span
) -> PResult<'a, (Ident, ItemKind)>
Parses unsafe? auto? trait Foo { ... }
or trait Foo = Bar;
.
pub fn parse_impl_item(&mut self) -> PResult<'a, Option<Option<P<AssocItem>>>>
[src]
pub fn parse_trait_item(&mut self) -> PResult<'a, Option<Option<P<AssocItem>>>>
[src]
fn parse_assoc_item(
&mut self,
req_name: fn(_: Edition) -> bool
) -> PResult<'a, Option<Option<P<AssocItem>>>>
[src]
&mut self,
req_name: fn(_: Edition) -> bool
) -> PResult<'a, Option<Option<P<AssocItem>>>>
Parses associated items.
fn parse_type_alias(
&mut self,
def: Defaultness
) -> PResult<'a, (Ident, ItemKind)>
[src]
&mut self,
def: Defaultness
) -> PResult<'a, (Ident, ItemKind)>
Parses a type
alias with the following grammar:
TypeAlias = "type" Ident Generics {":" GenericBounds}? {"=" Ty}? ";" ;
The "type"
has already been eaten.
fn parse_use_tree(&mut self) -> PResult<'a, UseTree>
[src]
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>
[src]
Parses *
or {...}
.
fn parse_use_tree_list(&mut self) -> PResult<'a, Vec<(UseTree, NodeId)>>
[src]
Parses a UseTreeKind::Nested(list)
.
USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`]
fn parse_rename(&mut self) -> PResult<'a, Option<Ident>>
[src]
fn parse_ident_or_underscore(&mut self) -> PResult<'a, Ident>
[src]
fn parse_item_extern_crate(&mut self) -> PResult<'a, (Ident, ItemKind)>
[src]
fn parse_crate_name_with_dashes(&mut self) -> PResult<'a, Ident>
[src]
fn parse_item_foreign_mod(
&mut self,
attrs: &mut Vec<Attribute>,
unsafety: Unsafe
) -> PResult<'a, (Ident, ItemKind)>
[src]
&mut self,
attrs: &mut Vec<Attribute>,
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
) -> PResult<'a, Option<Option<P<ForeignItem>>>>
[src]
&mut self
) -> 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: &str
) -> Option<T>
[src]
&self,
span: Span,
kind: &ItemKind,
ctx: &str
) -> Option<T>
fn error_on_foreign_const(&self, span: Span, ident: Ident)
[src]
fn is_unsafe_foreign_mod(&self) -> bool
[src]
fn is_static_global(&mut self) -> bool
[src]
fn recover_const_mut(&mut self, const_span: Span)
[src]
Recover on const mut
with const
already eaten.
fn recover_const_impl(
&mut self,
const_span: Span,
attrs: &mut Vec<Attribute>,
defaultness: Defaultness
) -> PResult<'a, (Ident, ItemKind)>
[src]
&mut self,
const_span: Span,
attrs: &mut Vec<Attribute>,
defaultness: Defaultness
) -> PResult<'a, (Ident, ItemKind)>
Recover on const impl
with const
already eaten.
fn parse_item_global(
&mut self,
m: Option<Mutability>
) -> PResult<'a, (Ident, P<Ty>, Option<P<Expr>>)>
[src]
&mut self,
m: Option<Mutability>
) -> PResult<'a, (Ident, P<Ty>, Option<P<Expr>>)>
Parse ["const" | ("static" "mut"?)] $ident ":" $ty (= $expr)?
with
["const" | ("static" "mut"?)]
already parsed and stored in m
.
When m
is "const"
, $ident
may also be "_"
.
fn recover_missing_const_type(
&mut self,
id: Ident,
m: Option<Mutability>
) -> P<Ty>
[src]
&mut self,
id: Ident,
m: Option<Mutability>
) -> P<Ty>
We were supposed to parse :
but the :
was missing.
This means that the type is missing.
fn parse_item_enum(&mut self) -> PResult<'a, (Ident, ItemKind)>
[src]
Parses an enum declaration.
fn parse_enum_variant(&mut self) -> PResult<'a, Option<Variant>>
[src]
fn parse_item_struct(&mut self) -> PResult<'a, (Ident, ItemKind)>
[src]
Parses struct Foo { ... }
.
fn parse_item_union(&mut self) -> PResult<'a, (Ident, ItemKind)>
[src]
Parses union Foo { ... }
.
fn parse_record_struct_body(&mut self) -> PResult<'a, (Vec<StructField>, bool)>
[src]
fn parse_tuple_struct_body(&mut self) -> PResult<'a, Vec<StructField>>
[src]
fn parse_struct_decl_field(&mut self) -> PResult<'a, StructField>
[src]
Parses an element of a struct declaration.
fn parse_single_struct_field(
&mut self,
lo: Span,
vis: Visibility,
attrs: Vec<Attribute>
) -> PResult<'a, StructField>
[src]
&mut self,
lo: Span,
vis: Visibility,
attrs: Vec<Attribute>
) -> PResult<'a, StructField>
Parses a structure field declaration.
fn parse_name_and_ty(
&mut self,
lo: Span,
vis: Visibility,
attrs: Vec<Attribute>
) -> PResult<'a, StructField>
[src]
&mut self,
lo: Span,
vis: Visibility,
attrs: Vec<Attribute>
) -> PResult<'a, StructField>
Parses a structure field.
fn parse_item_decl_macro(&mut self, lo: Span) -> PResult<'a, (Ident, ItemKind)>
[src]
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) -> bool
[src]
Is this unambiguously the start of a macro_rules! foo
item defnition?
fn parse_item_macro_rules(
&mut self,
vis: &Visibility
) -> PResult<'a, (Ident, ItemKind)>
[src]
&mut self,
vis: &Visibility
) -> PResult<'a, (Ident, ItemKind)>
Parses a macro_rules! foo { ... }
declarative macro.
fn complain_if_pub_macro(&self, vis: &Visibility, macro_rules: bool)
[src]
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: &MacArgs)
[src]
fn report_invalid_macro_expansion_item(&self, args: &MacArgs)
[src]
fn recover_nested_adt_item(&mut self, keyword: Symbol) -> PResult<'a, bool>
[src]
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.
impl<'a> Parser<'a>
[src]
Parsing of functions and methods.
fn parse_fn(
&mut self,
attrs: &mut Vec<Attribute>,
req_name: fn(_: Edition) -> bool,
sig_lo: Span
) -> PResult<'a, (Ident, FnSig, Generics, Option<P<Block>>)>
[src]
&mut self,
attrs: &mut Vec<Attribute>,
req_name: fn(_: Edition) -> bool,
sig_lo: Span
) -> 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 Vec<Attribute>,
ident: &Ident,
sig_hi: &mut Span
) -> PResult<'a, Option<P<Block>>>
[src]
&mut self,
attrs: &mut Vec<Attribute>,
ident: &Ident,
sig_hi: &mut 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.
pub(super) fn check_fn_front_matter(&mut self) -> bool
[src]
Is the current token the start of an FnHeader
/ not a valid parse?
pub(super) fn parse_fn_front_matter(&mut self) -> PResult<'a, FnHeader>
[src]
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" ;
fn ban_async_in_2015(&self, span: Span)
[src]
We are parsing async fn
. If we are on Rust 2015, emit an error.
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>>
[src]
&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.
fn parse_fn_params(
&mut self,
req_name: fn(_: Edition) -> bool
) -> PResult<'a, Vec<Param>>
[src]
&mut self,
req_name: fn(_: Edition) -> bool
) -> PResult<'a, Vec<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>
[src]
&mut self,
req_name: fn(_: Edition) -> bool,
first_param: bool
) -> PResult<'a, Param>
Parses a single function parameter.
self
is syntactically allowed whenfirst_param
holds.
fn parse_self_param(&mut self) -> PResult<'a, Option<Param>>
[src]
Returns the parsed optional self parameter and whether a self shortcut was used.
fn is_named_param(&self) -> bool
[src]
fn recover_first_param(&mut self) -> &'static str
[src]
impl<'a> Parser<'a>
[src]
pub fn nonterminal_may_begin_with(kind: NonterminalKind, token: &Token) -> bool
[src]
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.
pub fn parse_nonterminal(
&mut self,
kind: NonterminalKind
) -> PResult<'a, Nonterminal>
[src]
&mut self,
kind: NonterminalKind
) -> PResult<'a, Nonterminal>
Parse a non-terminal (e.g. MBE :pat
or :ident
).
impl<'a> Parser<'a>
[src]
pub fn parse_pat(
&mut self,
expected: Option<&'static str>
) -> PResult<'a, P<Pat>>
[src]
&mut self,
expected: Option<&'static str>
) -> 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(super) fn parse_top_pat(
&mut self,
gate_or: GateOr,
rc: RecoverComma
) -> PResult<'a, P<Pat>>
[src]
&mut self,
gate_or: GateOr,
rc: RecoverComma
) -> PResult<'a, P<Pat>>
Entry point to the main pattern parser.
Corresponds to top_pat
in RFC 2535 and allows or-pattern at the top level.
pub(super) fn parse_fn_param_pat(&mut self) -> PResult<'a, P<Pat>>
[src]
Parse the pattern for a function or function pointer parameter.
Special recovery is provided for or-patterns and leading |
.
fn ban_illegal_fn_param_or_pat(&self, pat: &Pat)
[src]
Ban A | B
immediately in a parameter pattern and suggest wrapping in parens.
fn parse_pat_with_or(
&mut self,
expected: Option<&'static str>,
gate_or: GateOr,
rc: RecoverComma
) -> PResult<'a, P<Pat>>
[src]
&mut self,
expected: Option<&'static str>,
gate_or: GateOr,
rc: RecoverComma
) -> PResult<'a, P<Pat>>
Parses a pattern, that may be a or-pattern (e.g. Foo | Bar
in Some(Foo | Bar)
).
Corresponds to pat<allow_top_alt>
in RFC 2535.
fn eat_or_separator(&mut self, lo: Option<Span>) -> bool
[src]
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
[src]
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 ban_unexpected_or_or(&mut self, lo: Option<Span>)
[src]
We have parsed ||
instead of |
. Error and suggest |
instead.
fn maybe_recover_unexpected_comma(
&mut self,
lo: Span,
rc: RecoverComma,
gate_or: GateOr
) -> PResult<'a, ()>
[src]
&mut self,
lo: Span,
rc: RecoverComma,
gate_or: GateOr
) -> 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).
fn skip_pat_list(&mut self) -> PResult<'a, ()>
[src]
Parse and throw away a parentesized comma separated
sequence of patterns until )
is reached.
fn parse_pat_with_or_inner(&mut self) -> PResult<'a, P<Pat>>
[src]
Recursive possibly-or-pattern parser with recovery for an erroneous leading |
.
See parse_pat_with_or
for details on parsing or-patterns.
fn recover_leading_vert(&mut self, lo: Option<Span>, ctx: &str)
[src]
Recover if |
or ||
is here.
The user is thinking that a leading |
is allowed in this position.
fn ban_illegal_vert(&mut self, lo: Option<Span>, pos: &str, ctx: &str)
[src]
A |
or possibly ||
token shouldn't be here. Ban it.
fn parse_pat_with_range_pat(
&mut self,
allow_range_pat: bool,
expected: Option<&'static str>
) -> PResult<'a, P<Pat>>
[src]
&mut self,
allow_range_pat: bool,
expected: Option<&'static str>
) -> 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
[src]
Recover from a typoed ...
pattern that was encountered
Ref: Issue #70388
fn recover_intersection_pat(&mut self, lhs: P<Pat>) -> PResult<'a, P<Pat>>
[src]
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)
[src]
Ban a range pattern if it has an ambiguous interpretation.
fn parse_pat_deref(
&mut self,
expected: Option<&'static str>
) -> PResult<'a, PatKind>
[src]
&mut self,
expected: Option<&'static str>
) -> PResult<'a, PatKind>
Parse &pat
/ &mut pat
.
fn recover_lifetime_in_deref_pat(&mut self)
[src]
fn parse_pat_tuple_or_parens(&mut self) -> PResult<'a, PatKind>
[src]
Parse a tuple or parenthesis pattern.
fn parse_pat_ident_mut(&mut self) -> PResult<'a, PatKind>
[src]
Parse a mutable binding with the mut
token already eaten.
fn recover_mut_ref_ident(&mut self, lo: Span) -> PResult<'a, PatKind>
[src]
Recover on mut ref? ident @ pat
and suggest
that the order of mut
and ref
is incorrect.
fn make_all_value_bindings_mutable(pat: &mut P<Pat>) -> bool
[src]
Turn all by-value immutable bindings in a pattern into mutable bindings.
Returns true
if any change was made.
fn ban_mut_general_pat(&self, lo: Span, pat: &Pat, changed_any_binding: bool)
[src]
Error on mut $pat
where $pat
is not an ident.
fn recover_additional_muts(&mut self)
[src]
Eat any extraneous mut
s and error + recover if we ate any.
fn parse_pat_mac_invoc(&mut self, path: Path) -> PResult<'a, PatKind>
[src]
Parse macro invocation
fn fatal_unexpected_non_pat(
&mut self,
mut err: DiagnosticBuilder<'a>,
expected: Option<&'static str>
) -> PResult<'a, P<Pat>>
[src]
&mut self,
mut err: DiagnosticBuilder<'a>,
expected: Option<&'static str>
) -> PResult<'a, P<Pat>>
fn parse_range_end(&mut self) -> Option<Spanned<RangeEnd>>
[src]
Parses the range pattern end form ".." | "..." | "..=" ;
.
fn parse_pat_range_begin_with(
&mut self,
begin: P<Expr>,
re: Spanned<RangeEnd>
) -> PResult<'a, PatKind>
[src]
&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 error_inclusive_range_with_no_end(&self, span: Span)
[src]
fn parse_pat_range_to(
&mut self,
mut re: Spanned<RangeEnd>
) -> PResult<'a, PatKind>
[src]
&mut self,
mut 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
[src]
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>>
[src]
fn is_start_of_pat_with_path(&mut self) -> bool
[src]
Is this the start of a pattern beginning with a path?
fn can_be_ident_pat(&mut self) -> bool
[src]
Would parse_pat_ident
be appropriate here?
fn parse_pat_ident(&mut self, binding_mode: BindingMode) -> PResult<'a, PatKind>
[src]
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<QSelf>,
path: Path
) -> PResult<'a, PatKind>
[src]
&mut self,
qself: Option<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<QSelf>,
path: Path
) -> PResult<'a, PatKind>
[src]
&mut self,
qself: Option<QSelf>,
path: Path
) -> PResult<'a, PatKind>
Parse tuple struct or tuple variant pattern (e.g. Foo(...)
or Foo::Bar(...)
).
fn error_qpath_before_pat(
&mut self,
path: &Path,
token: &str
) -> PResult<'a, PatKind>
[src]
&mut self,
path: &Path,
token: &str
) -> PResult<'a, PatKind>
Error when there's a qualified path, e.g. <Foo as Bar>::Baz
as the path of e.g., a tuple or record struct pattern.
fn parse_pat_fields(&mut self) -> PResult<'a, (Vec<FieldPat>, bool)>
[src]
Parses the fields of a struct-like pattern.
fn recover_one_fewer_dotdot(&self)
[src]
Recover on ...
as if it were ..
to avoid further errors.
See issue #46718.
fn parse_pat_field(
&mut self,
lo: Span,
attrs: Vec<Attribute>
) -> PResult<'a, FieldPat>
[src]
&mut self,
lo: Span,
attrs: Vec<Attribute>
) -> PResult<'a, FieldPat>
pub(super) fn mk_pat_ident(
&self,
span: Span,
bm: BindingMode,
ident: Ident
) -> P<Pat>
[src]
&self,
span: Span,
bm: BindingMode,
ident: Ident
) -> P<Pat>
fn mk_pat(&self, span: Span, kind: PatKind) -> P<Pat>
[src]
impl<'a> Parser<'a>
[src]
pub(super) fn parse_qpath(
&mut self,
style: PathStyle
) -> PResult<'a, (QSelf, Path)>
[src]
&mut self,
style: PathStyle
) -> PResult<'a, (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
[src]
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>
[src]
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 Vec<PathSegment>,
style: PathStyle
) -> PResult<'a, ()>
[src]
&mut self,
segments: &mut Vec<PathSegment>,
style: PathStyle
) -> PResult<'a, ()>
pub(super) fn parse_path_segment(
&mut self,
style: PathStyle
) -> PResult<'a, PathSegment>
[src]
&mut self,
style: PathStyle
) -> PResult<'a, PathSegment>
pub(super) fn parse_path_segment_ident(&mut self) -> PResult<'a, Ident>
[src]
fn parse_angle_args_with_leading_angle_bracket_recovery(
&mut self,
style: PathStyle,
lo: Span
) -> PResult<'a, Vec<AngleBracketedArg>>
[src]
&mut self,
style: PathStyle,
lo: Span
) -> PResult<'a, Vec<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) -> PResult<'a, Vec<AngleBracketedArg>>
[src]
Parses (possibly empty) list of generic arguments / associated item constraints, possibly including trailing comma.
fn parse_angle_arg(&mut self) -> PResult<'a, Option<AngleBracketedArg>>
[src]
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, P<Ty>>
[src]
&mut self,
ident: Ident,
eq: Span
) -> PResult<'a, P<Ty>>
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
[src]
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>
[src]
Parse a const argument, e.g. <3>
. It is assumed the angle brackets will be parsed by
the caller.
fn parse_generic_arg(&mut self) -> PResult<'a, Option<GenericArg>>
[src]
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<(Ident, Option<GenericArgs>), GenericArg>
[src]
&self,
gen_arg: GenericArg
) -> Result<(Ident, Option<GenericArgs>), GenericArg>
impl<'a> Parser<'a>
[src]
pub fn parse_stmt(
&mut self,
force_collect: ForceCollect
) -> PResult<'a, Option<Stmt>>
[src]
&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.
fn parse_stmt_without_recovery(
&mut self,
capture_semi: bool,
force_collect: ForceCollect
) -> PResult<'a, Option<Stmt>>
[src]
&mut self,
capture_semi: bool,
force_collect: ForceCollect
) -> PResult<'a, Option<Stmt>>
If force_capture
is true, forces collection of tokens regardless of whether
or not we have attributes
fn parse_stmt_path_start(
&mut self,
lo: Span,
attrs: Vec<Attribute>,
force_collect: ForceCollect
) -> PResult<'a, Stmt>
[src]
&mut self,
lo: Span,
attrs: Vec<Attribute>,
force_collect: ForceCollect
) -> PResult<'a, Stmt>
fn parse_stmt_mac(
&mut self,
lo: Span,
attrs: AttrVec,
path: Path
) -> PResult<'a, Stmt>
[src]
&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: &[Attribute])
[src]
Error on outer attributes in this context. Also error if the previous token was a doc comment.
fn recover_stmt_local(
&mut self,
lo: Span,
attrs: AttrVec,
msg: &str,
sugg: &str
) -> PResult<'a, Stmt>
[src]
&mut self,
lo: Span,
attrs: AttrVec,
msg: &str,
sugg: &str
) -> PResult<'a, Stmt>
fn parse_local_mk(
&mut self,
lo: Span,
attrs: AttrVec,
capture_semi: bool,
force_collect: ForceCollect
) -> PResult<'a, Stmt>
[src]
&mut self,
lo: Span,
attrs: AttrVec,
capture_semi: bool,
force_collect: ForceCollect
) -> PResult<'a, Stmt>
fn recover_local_after_let(
&mut self,
lo: Span,
attrs: AttrVec
) -> PResult<'a, Stmt>
[src]
&mut self,
lo: Span,
attrs: AttrVec
) -> PResult<'a, Stmt>
fn parse_local(&mut self, attrs: AttrVec) -> PResult<'a, P<Local>>
[src]
Parses a local variable declaration.
fn parse_initializer(
&mut self,
eq_optional: bool
) -> PResult<'a, Option<P<Expr>>>
[src]
&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>>
[src]
Parses a block. No inner attributes are allowed.
fn error_block_no_opening_brace<T>(&mut self) -> PResult<'a, T>
[src]
pub(super) fn parse_inner_attrs_and_block(
&mut self
) -> PResult<'a, (Vec<Attribute>, P<Block>)>
[src]
&mut self
) -> PResult<'a, (Vec<Attribute>, P<Block>)>
Parses a block. Inner attributes are allowed.
pub(super) fn parse_block_common(
&mut self,
lo: Span,
blk_mode: BlockCheckMode
) -> PResult<'a, (Vec<Attribute>, P<Block>)>
[src]
&mut self,
lo: Span,
blk_mode: BlockCheckMode
) -> PResult<'a, (Vec<Attribute>, 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>>
[src]
&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>>
[src]
&mut self,
recover: AttemptLocalParseRecovery
) -> PResult<'a, Option<Stmt>>
Parses a statement, including the trailing semicolon.
pub(super) fn mk_block(
&self,
stmts: Vec<Stmt>,
rules: BlockCheckMode,
span: Span
) -> P<Block>
[src]
&self,
stmts: Vec<Stmt>,
rules: BlockCheckMode,
span: Span
) -> P<Block>
pub(super) fn mk_stmt(&self, span: Span, kind: StmtKind) -> Stmt
[src]
pub(super) fn mk_stmt_err(&self, span: Span) -> Stmt
[src]
pub(super) fn mk_block_err(&self, span: Span) -> P<Block>
[src]
impl<'a> Parser<'a>
[src]
pub fn parse_ty(&mut self) -> PResult<'a, P<Ty>>
[src]
Parses a type.
pub(super) fn parse_ty_for_param(&mut self) -> PResult<'a, P<Ty>>
[src]
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>>
[src]
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_ty_for_where_clause(&mut self) -> PResult<'a, P<Ty>>
[src]
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>
[src]
&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
) -> PResult<'a, P<Ty>>
[src]
&mut self,
allow_plus: AllowPlus,
allow_c_variadic: AllowCVariadic,
recover_qpath: RecoverQPath,
recover_return_sign: RecoverReturnSign
) -> PResult<'a, P<Ty>>
fn parse_ty_tuple_or_parens(
&mut self,
lo: Span,
allow_plus: AllowPlus
) -> PResult<'a, TyKind>
[src]
&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>
[src]
&mut self,
lo: Span,
allow_plus: AllowPlus
) -> PResult<'a, TyKind>
fn parse_remaining_bounds_path(
&mut self,
generic_params: Vec<GenericParam>,
path: Path,
lo: Span,
parse_plus: bool
) -> PResult<'a, TyKind>
[src]
&mut self,
generic_params: Vec<GenericParam>,
path: Path,
lo: Span,
parse_plus: bool
) -> PResult<'a, TyKind>
fn parse_remaining_bounds(
&mut self,
mut bounds: GenericBounds,
plus: bool
) -> PResult<'a, TyKind>
[src]
&mut self,
mut 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>
[src]
Parses a raw pointer type: *[const | mut] $type
.
fn parse_array_or_slice_ty(&mut self) -> PResult<'a, TyKind>
[src]
Parses an array ([TYPE; EXPR]
) or slice ([TYPE]
) type.
The opening [
bracket is already eaten.
fn parse_borrowed_pointee(&mut self) -> PResult<'a, TyKind>
[src]
fn parse_typeof_ty(&mut self) -> PResult<'a, TyKind>
[src]
fn parse_ty_bare_fn(
&mut self,
lo: Span,
params: Vec<GenericParam>,
recover_return_sign: RecoverReturnSign
) -> PResult<'a, TyKind>
[src]
&mut self,
lo: Span,
params: Vec<GenericParam>,
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 error_fn_ptr_bad_qualifier(&self, span: Span, qual_span: Span, qual: &str)
[src]
Emit an error for the given bad function pointer qualifier.
fn parse_impl_ty(&mut self, impl_dyn_multi: &mut bool) -> PResult<'a, TyKind>
[src]
Parses an impl B0 + ... + Bn
type.
fn is_explicit_dyn_type(&mut self) -> bool
[src]
Is a dyn B0 + ... + Bn
type allowed here?
fn parse_dyn_ty(&mut self, impl_dyn_multi: &mut bool) -> PResult<'a, TyKind>
[src]
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
) -> PResult<'a, TyKind>
[src]
&mut self,
lo: Span,
allow_plus: AllowPlus
) -> PResult<'a, TyKind>
Parses a type starting with a path.
This can be:
- a type macro,
mac!(...)
, - a bare trait object,
B0 + ... + Bn
, - or a path,
path::to::MyType
.
fn error_illegal_c_varadic_ty(&self, lo: Span)
[src]
pub(super) fn parse_generic_bounds(
&mut self,
colon_span: Option<Span>
) -> PResult<'a, GenericBounds>
[src]
&mut self,
colon_span: Option<Span>
) -> PResult<'a, GenericBounds>
fn parse_generic_bounds_common(
&mut self,
allow_plus: AllowPlus,
colon_span: Option<Span>
) -> PResult<'a, GenericBounds>
[src]
&mut self,
allow_plus: AllowPlus,
colon_span: Option<Span>
) -> PResult<'a, GenericBounds>
Parses bounds of a type parameter BOUND + BOUND + ...
, possibly with trailing +
.
See parse_generic_bound
for the BOUND
grammar.
fn can_begin_bound(&mut self) -> bool
[src]
Can the current token begin a bound?
fn error_negative_bounds(
&self,
colon_span: Option<Span>,
bounds: &[GenericBound],
negative_bounds: Vec<Span>
)
[src]
&self,
colon_span: Option<Span>,
bounds: &[GenericBound],
negative_bounds: Vec<Span>
)
fn parse_generic_bound(&mut self) -> PResult<'a, Result<GenericBound, Span>>
[src]
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>
[src]
&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)
[src]
Emits an error if any trait bound modifiers were present.
fn recover_paren_lifetime(
&mut self,
lo: Span,
inner_lo: Span
) -> PResult<'a, ()>
[src]
&mut self,
lo: Span,
inner_lo: Span
) -> PResult<'a, ()>
Recover on ('lifetime)
with (
already eaten.
fn parse_ty_bound_modifiers(&mut self) -> BoundModifiers
[src]
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
) -> PResult<'a, GenericBound>
[src]
&mut self,
lo: Span,
has_parens: bool,
modifiers: BoundModifiers
) -> 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>
.
pub(super) fn parse_late_bound_lifetime_defs(
&mut self
) -> PResult<'a, Vec<GenericParam>>
[src]
&mut self
) -> PResult<'a, Vec<GenericParam>>
Optionally parses for<$generic_params>
.
pub(super) fn check_lifetime(&mut self) -> bool
[src]
pub(super) fn expect_lifetime(&mut self) -> Lifetime
[src]
Parses a single lifetime 'a
or panics.
pub(super) fn mk_ty(&self, span: Span, kind: TyKind) -> P<Ty>
[src]
impl<'a> Parser<'a>
[src]
pub fn new(
sess: &'a ParseSess,
tokens: TokenStream,
desugar_doc_comments: bool,
subparser_name: Option<&'static str>
) -> Self
[src]
sess: &'a ParseSess,
tokens: TokenStream,
desugar_doc_comments: bool,
subparser_name: Option<&'static str>
) -> Self
fn next_tok(&mut self, fallback_span: Span) -> (Token, Spacing)
[src]
pub fn unexpected<T>(&mut self) -> PResult<'a, T>
[src]
pub fn expect(&mut self, t: &TokenKind) -> PResult<'a, bool>
[src]
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>
[src]
&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>
[src]
fn parse_ident_common(&mut self, recover: bool) -> PResult<'a, Ident>
[src]
fn check(&mut self, tok: &TokenKind) -> bool
[src]
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.
pub fn eat(&mut self, tok: &TokenKind) -> bool
[src]
Consumes a token 'tok' if it exists. Returns whether the given token was present.
fn check_keyword(&mut self, kw: Symbol) -> bool
[src]
If the next token is the given keyword, returns true
without eating it.
An expectation is also added for diagnostics purposes.
pub fn eat_keyword(&mut self, kw: Symbol) -> bool
[src]
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_noexpect(&mut self, kw: Symbol) -> bool
[src]
fn expect_keyword(&mut self, kw: Symbol) -> PResult<'a, ()>
[src]
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
[src]
Is the given keyword kw
followed by a non-reserved identifier?
fn check_or_expected(&mut self, ok: bool, typ: TokenType) -> bool
[src]
fn check_ident(&mut self) -> bool
[src]
fn check_path(&mut self) -> bool
[src]
fn check_type(&mut self) -> bool
[src]
fn check_const_arg(&mut self) -> bool
[src]
fn check_inline_const(&self, dist: usize) -> bool
[src]
fn check_plus(&mut self) -> bool
[src]
Checks to see if the next token is either +
or +=
.
Otherwise returns false
.
fn break_and_eat(&mut self, expected: TokenKind) -> bool
[src]
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
[src]
Eats +
possibly breaking tokens like +=
in process.
fn expect_and(&mut self) -> PResult<'a, ()>
[src]
Eats &
possibly breaking tokens like &&
in process.
Signals an error if &
is not eaten.
fn expect_or(&mut self) -> PResult<'a, ()>
[src]
Eats |
possibly breaking tokens like ||
in process.
Signals an error if |
was not eaten.
fn eat_lt(&mut self) -> bool
[src]
Eats <
possibly breaking tokens like <<
in process.
fn expect_lt(&mut self) -> PResult<'a, ()>
[src]
Eats <
possibly breaking tokens like <<
in process.
Signals an error if <
was not eaten.
fn expect_gt(&mut self) -> PResult<'a, ()>
[src]
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
[src]
&mut self,
kets: &[&TokenKind],
expect: TokenExpectType
) -> bool
fn parse_seq_to_before_tokens<T>(
&mut self,
kets: &[&TokenKind],
sep: SeqSep,
expect: TokenExpectType,
mut f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<T>, bool, bool)>
[src]
&mut self,
kets: &[&TokenKind],
sep: SeqSep,
expect: TokenExpectType,
mut f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<T>, bool, bool)>
fn parse_seq_to_before_end<T>(
&mut self,
ket: &TokenKind,
sep: SeqSep,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<T>, bool, bool)>
[src]
&mut self,
ket: &TokenKind,
sep: SeqSep,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<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, (Vec<T>, bool)>
[src]
&mut self,
ket: &TokenKind,
sep: SeqSep,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<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, (Vec<T>, bool)>
[src]
&mut self,
bra: &TokenKind,
ket: &TokenKind,
sep: SeqSep,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<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: DelimToken,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<T>, bool)>
[src]
&mut self,
delim: DelimToken,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<T>, bool)>
fn parse_paren_comma_seq<T>(
&mut self,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<T>, bool)>
[src]
&mut self,
f: impl FnMut(&mut Parser<'a>) -> PResult<'a, T>
) -> PResult<'a, (Vec<T>, bool)>
fn bump_with(&mut self, (next_token, next_spacing): (Token, Spacing))
[src]
Advance the parser by one token using provided token as the next one.
pub fn bump(&mut self)
[src]
Advance the parser by one token.
pub fn look_ahead<R>(&self, dist: usize, looker: impl FnOnce(&Token) -> R) -> R
[src]
Look-ahead dist
tokens of self.token
and get access to that token there.
When dist == 0
then the current token is looked at.
fn is_keyword_ahead(&self, dist: usize, kws: &[Symbol]) -> bool
[src]
Returns whether any of the given keywords are dist
tokens ahead of the current one.
fn parse_asyncness(&mut self) -> Async
[src]
Parses asyncness: async
or nothing.
fn parse_unsafety(&mut self) -> Unsafe
[src]
Parses unsafety: unsafe
or nothing.
fn parse_constness(&mut self) -> Const
[src]
Parses constness: const
or nothing.
fn parse_const_block(&mut self, span: Span) -> PResult<'a, P<Expr>>
[src]
Parses inline const expressions.
fn parse_mutability(&mut self) -> Mutability
[src]
Parses mutability (mut
or nothing).
fn parse_const_or_mut(&mut self) -> Option<Mutability>
[src]
Possibly parses mutability (const
or mut
).
fn parse_field_name(&mut self) -> PResult<'a, Ident>
[src]
fn parse_mac_args(&mut self) -> PResult<'a, P<MacArgs>>
[src]
fn parse_attr_args(&mut self) -> PResult<'a, MacArgs>
[src]
fn parse_mac_args_common(
&mut self,
delimited_only: bool
) -> PResult<'a, MacArgs>
[src]
&mut self,
delimited_only: bool
) -> PResult<'a, MacArgs>
fn parse_or_use_outer_attributes(
&mut self,
already_parsed_attrs: Option<AttrVec>
) -> PResult<'a, AttrVec>
[src]
&mut self,
already_parsed_attrs: Option<AttrVec>
) -> PResult<'a, AttrVec>
pub(crate) fn parse_token_tree(&mut self) -> TokenTree
[src]
Parses a single token tree from the input.
pub fn parse_all_token_trees(&mut self) -> PResult<'a, Vec<TokenTree>>
[src]
Parses a stream of tokens into a list of TokenTree
s, up to EOF.
pub fn parse_tokens(&mut self) -> TokenStream
[src]
fn with_res<T>(
&mut self,
res: Restrictions,
f: impl FnOnce(&mut Self) -> T
) -> T
[src]
&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.
fn is_crate_vis(&self) -> bool
[src]
pub fn parse_visibility(
&mut self,
fbt: FollowedByType
) -> PResult<'a, Visibility>
[src]
&mut self,
fbt: FollowedByType
) -> PResult<'a, Visibility>
Parses pub
, pub(crate)
and pub(in path)
plus shortcuts crate
for pub(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 isn't valid,
so emit a proper diagnostic.
fn recover_incorrect_vis_restriction(&mut self) -> PResult<'a, ()>
[src]
Recovery for e.g. pub(something) fn ...
or struct X { pub(something) y: Z }
fn parse_extern(&mut self) -> PResult<'a, Extern>
[src]
Parses extern string_literal?
.
fn parse_abi(&mut self) -> Option<StrLit>
[src]
Parses a string literal as an ABI spec.
pub fn collect_tokens<R: HasTokens>(
&mut self,
f: impl FnOnce(&mut Self) -> PResult<'a, R>
) -> PResult<'a, R>
[src]
&mut self,
f: impl FnOnce(&mut Self) -> PResult<'a, R>
) -> PResult<'a, R>
pub fn collect_tokens_trailing_token<R: HasTokens>(
&mut self,
f: impl FnOnce(&mut Self) -> PResult<'a, (R, TrailingToken)>
) -> PResult<'a, R>
[src]
&mut self,
f: impl FnOnce(&mut Self) -> 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 LazyTokenStream
, 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 delimeter),
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.
fn is_import_coupler(&mut self) -> bool
[src]
::{
or ::*
pub fn clear_expected_tokens(&mut self)
[src]
Trait Implementations
Auto Trait Implementations
impl<'a> !RefUnwindSafe for Parser<'a>
[src]
impl<'a> !Send for Parser<'a>
[src]
impl<'a> !Sync for Parser<'a>
[src]
impl<'a> Unpin for Parser<'a>
[src]
impl<'a> !UnwindSafe for Parser<'a>
[src]
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,