Struct rustc_ap_rustc_parse::parser::Parser [−][src]
pub struct Parser<'a> { pub sess: &'a ParseSess, pub token: Token, pub token_spacing: Spacing, pub prev_token: Token, pub capture_cfg: bool, pub last_type_ascription: Option<(Span, bool)>, // some fields omitted }
Fields
sess: &'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
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)
).
Implementations
pub fn parse_attribute(
&mut self,
inner_parse_policy: InnerAttrPolicy<'_>
) -> PResult<'a, Attribute>
[src]
pub fn parse_attribute(
&mut self,
inner_parse_policy: InnerAttrPolicy<'_>
) -> PResult<'a, Attribute>
[src]Matches attribute = # ! [ meta_item ]
.
inner_parse_policy
prescribes how to handle inner attributes.
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.
Parses cfg_attr(pred, attr_item_list)
where attr_item_list
is comma-delimited.
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 fn collect_tokens_trailing_token<R: AstLike>(
&mut self,
attrs: AttrWrapper,
force_collect: ForceCollect,
f: impl FnOnce(&mut Self, Vec<Attribute>) -> PResult<'a, (R, TrailingToken)>
) -> PResult<'a, R>
[src]
pub fn collect_tokens_trailing_token<R: AstLike>(
&mut self,
attrs: AttrWrapper,
force_collect: ForceCollect,
f: impl FnOnce(&mut Self, Vec<Attribute>) -> PResult<'a, (R, TrailingToken)>
) -> PResult<'a, R>
[src]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.
pub fn maybe_suggest_struct_literal(
&mut self,
lo: Span,
s: BlockCheckMode
) -> Option<PResult<'a, P<Block>>>
[src]pub fn maybe_annotate_with_ascription(
&mut self,
err: &mut DiagnosticBuilder<'_>,
maybe_expected_semicolon: bool
)
[src]pub fn handle_ambiguous_unbraced_const_arg(
&mut self,
args: &mut Vec<AngleBracketedArg>
) -> PResult<'a, bool>
[src]
pub fn handle_ambiguous_unbraced_const_arg(
&mut self,
args: &mut Vec<AngleBracketedArg>
) -> PResult<'a, bool>
[src]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.
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,
err: DiagnosticBuilder<'a>
) -> PResult<'a, GenericArg>
[src]
pub fn recover_const_arg(
&mut self,
start: Span,
err: DiagnosticBuilder<'a>
) -> PResult<'a, GenericArg>
[src]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.
Parses an expression.
Parses an expression, forcing tokens to be collected
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.
Matches '-' lit | lit
(cf. ast_validation::AstValidator::check_expr_within_pat
).
Keep this in sync with Token::can_begin_literal_maybe_minus
.
Parses a source module as a crate. This is the main entry point for the parser.
pub fn parse_impl_item(
&mut self,
force_collect: ForceCollect
) -> PResult<'a, Option<Option<P<AssocItem>>>>
[src]pub fn parse_trait_item(
&mut self,
force_collect: ForceCollect
) -> PResult<'a, Option<Option<P<AssocItem>>>>
[src]pub fn parse_foreign_item(
&mut self,
force_collect: ForceCollect
) -> PResult<'a, Option<Option<P<ForeignItem>>>>
[src]
pub fn parse_foreign_item(
&mut self,
force_collect: ForceCollect
) -> PResult<'a, Option<Option<P<ForeignItem>>>>
[src]Parses a foreign item (one in an extern { ... }
block).
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.
Parse a non-terminal (e.g. MBE :pat
or :ident
).
Parses a pattern.
Corresponds to pat<no_top_alt>
in RFC 2535 and does not admit or-patterns
at the top level. Used when parsing the parameters of lambda expressions,
functions, function pointers, and pat
macro fragments.
pub fn parse_pat_allow_top_alt(
&mut self,
expected: Option<&'static str>,
rc: RecoverComma
) -> PResult<'a, P<Pat>>
[src]
pub fn parse_pat_allow_top_alt(
&mut self,
expected: Option<&'static str>,
rc: RecoverComma
) -> PResult<'a, P<Pat>>
[src]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.
Parses a statement. This stops just before trailing semicolons on everything but items.
e.g., a StmtKind::Semi
parses to a StmtKind::Expr
, leaving the trailing ;
unconsumed.
pub fn parse_full_stmt(
&mut self,
recover: AttemptLocalParseRecovery
) -> PResult<'a, Option<Stmt>>
[src]
pub fn parse_full_stmt(
&mut self,
recover: AttemptLocalParseRecovery
) -> PResult<'a, Option<Stmt>>
[src]Parses a statement, including the trailing semicolon.
pub fn new(
sess: &'a ParseSess,
tokens: TokenStream,
desugar_doc_comments: bool,
subparser_name: Option<&'static str>
) -> Self
[src]Expects and consumes the token t
. Signals an error if the next token is not t
.
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.
Consumes a token ‘tok’ if it exists. Returns whether the given token was present.
If the next token is the given keyword, eats it and returns true
.
Otherwise, returns false
. An expectation is also added for diagnostics purposes.
Look-ahead dist
tokens of self.token
and get access to that token there.
When dist == 0
then the current token is looked at.
Parses a stream of tokens into a list of TokenTree
s, up to EOF.
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.
Trait Implementations
Auto Trait Implementations
impl<'a> !RefUnwindSafe for Parser<'a>
impl<'a> !UnwindSafe for Parser<'a>
Blanket Implementations
Mutably borrows from an owned value. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
type Output = T
type Output = T
Should always be Self
pub fn vzip(self) -> V