[][src]Struct rustc_ap_rustc_parse::parser::Parser

pub struct Parser<'a> {
    pub sess: &'a ParseSess,
    pub token: Token,
    pub prev_token: Token,
    pub last_type_ascription: Option<(Span, bool)>,
    // some fields omitted
}

Fields

sess: &'a ParseSesstoken: Token

The current token.

prev_token: Token

The previous token.

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

impl<'a> Parser<'a>[src]

pub fn parse_attribute(&mut self, permit_inner: bool) -> PResult<'a, Attribute>[src]

Matches attribute = # ! [ meta_item ].

If permit_inner is true, then a leading ! indicates an inner attribute.

pub fn parse_attr_item(&mut self) -> 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 fn parse_cfg_attr(
    &mut self
) -> PResult<'a, (MetaItem, Vec<(AttrItem, Span)>)>
[src]

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

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)? ;

impl<'a> Parser<'a>[src]

pub fn struct_span_err<S: Into<MultiSpan>>(
    &self,
    sp: S,
    m: &str
) -> DiagnosticBuilder<'a>
[src]

pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: &str) -> ![src]

pub fn maybe_annotate_with_ascription(
    &mut self,
    err: &mut DiagnosticBuilder<'_>,
    maybe_expected_semicolon: bool
)
[src]

impl<'a> Parser<'a>[src]

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

Parses an expression.

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

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.

pub fn parse_mod(
    &mut self,
    term: &TokenKind
) -> PResult<'a, (Mod, Vec<Attribute>)>
[src]

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

impl<'a> Parser<'a>[src]

pub fn parse_item(&mut self) -> PResult<'a, Option<P<Item>>>[src]

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]

pub fn parse_foreign_item(
    &mut self
) -> PResult<'a, Option<Option<P<ForeignItem>>>>
[src]

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

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]

impl<'a> Parser<'a>[src]

pub fn parse_pat(
    &mut self,
    expected: Option<&'static str>
) -> PResult<'a, P<Pat>>
[src]

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.

impl<'a> Parser<'a>[src]

pub fn parse_stmt(&mut self) -> PResult<'a, Option<Stmt>>[src]

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) -> PResult<'a, Option<Stmt>>[src]

Parses a statement, including the trailing semicolon.

impl<'a> Parser<'a>[src]

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

Parses a type.

impl<'a> Parser<'a>[src]

pub fn new(
    sess: &'a ParseSess,
    tokens: TokenStream,
    desugar_doc_comments: bool,
    subparser_name: Option<&'static str>
) -> Self
[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]

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]

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

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

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.

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.

pub fn parse_all_token_trees(&mut self) -> PResult<'a, Vec<TokenTree>>[src]

Parses a stream of tokens into a list of TokenTrees, up to EOF.

pub fn parse_tokens(&mut self) -> TokenStream[src]

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

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.

pub fn collect_tokens<R>(
    &mut self,
    f: impl FnOnce(&mut Self) -> PResult<'a, R>
) -> PResult<'a, (R, TokenStream)>
[src]

Records all tokens consumed by the provided callback, including the current token. These tokens are collected into a TokenStream, 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.

Trait Implementations

impl<'a> Clone for Parser<'a>[src]

impl<'a> Drop for Parser<'a>[src]

Auto Trait Implementations

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

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

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

impl<T> Erased for T[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> MaybeResult<T> for T[src]

type Error = !

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

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

The type returned in the event of a conversion error.

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