Struct syntax::parse::parser::Parser

pub struct Parser<'a> {
    pub sess: &'a ParseSess,
    pub token: Token,
    pub prev_span: Span,
    pub recurse_into_file_modules: bool,
    pub root_module_name: Option<String>,
    pub cfg_mods: bool,
    // some fields omitted
}

Fields

sess: &'a ParseSess

token: Token

The current normalized token. "Normalized" means that some interpolated tokens ($i: ident and $l: lifetime meta-variables) are replaced with non-interpolated identifier and lifetime tokens they refer to. Perhaps the normalized / non-normalized setup can be simplified somehow.

prev_span: Span

Span of the previous non-normalized token.

recurse_into_file_modules: bool

true to parse sub-modules in other files.

root_module_name: Option<String>

Name of the root module this parser originated from. If None, then the name is not known. This does not change while the parser is descending into modules, and sub-parsers have new values for this name.

cfg_mods: bool

true we should configure out of line modules as we parse.

Methods

impl<'a> Parser<'a>

pub fn new(
    sess: &'a ParseSess,
    tokens: TokenStream,
    directory: Option<Directory<'a>>,
    recurse_into_file_modules: bool,
    desugar_doc_comments: bool,
    subparser_name: Option<&'static str>
) -> Self

pub fn this_token_to_string(&self) -> String

Converts the current token to a string using self's reader.

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

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

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

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

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

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

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

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

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

pub fn parse_seq_to_end<T, F>(
    &mut self,
    ket: &TokenKind,
    sep: SeqSep,
    f: F
) -> PResult<'a, Vec<T>> where
    F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, 

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

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

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

pub fn bump(&mut self)

Advance the parser by one token

pub fn look_ahead<R, F>(&self, dist: usize, f: F) -> R where
    F: FnOnce(&Token) -> R, 

pub fn parse_trait_item(&mut self, at_end: &mut bool) -> PResult<'a, TraitItem>

Parses the items in a trait declaration.

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

Parses a type.

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

Parses simple paths.

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

Examples

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

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

Like parse_path, but also supports parsing Word meta items into paths for backwards-compatibility. This is used when parsing derive macro paths in #[derive] attributes.

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

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

pub fn parse_tokens(&mut self) -> TokenStream

pub fn parse_async_block(
    &mut self,
    attrs: ThinVec<Attribute>
) -> PResult<'a, P<Expr>>

Parses an async move {...} expression.

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

Parses an expression.

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

Parses a pattern.

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

Parse 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_block(&mut self) -> PResult<'a, P<Block>>

Parses a block. No inner attributes are allowed.

pub fn parse_impl_item(&mut self, at_end: &mut bool) -> PResult<'a, ImplItem>

Parses an impl item.

pub fn parse_visibility(
    &mut self,
    can_take_tuple: bool
) -> 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.

pub fn submod_path_from_attr(
    attrs: &[Attribute],
    dir_path: &Path
) -> Option<PathBuf>

pub fn default_submod_path(
    id: Ident,
    relative: Option<Ident>,
    dir_path: &Path,
    source_map: &SourceMap
) -> ModulePath

Returns a path to a module.

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

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

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

pub fn parse_optional_str(&mut self) -> Option<(Symbol, StrStyle, Option<Name>)>

pub fn parse_str(&mut self) -> PResult<'a, (Symbol, StrStyle)>

impl<'a> Parser<'a>

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

Matches attribute = # ! [ meta_item ]

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

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

Per RFC#1559, matches the following grammar:

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

impl<'a> Parser<'a>

pub fn fatal(&self, m: &str) -> DiagnosticBuilder<'a>

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

pub fn span_fatal_err<S: Into<MultiSpan>>(
    &self,
    sp: S,
    err: Error
) -> DiagnosticBuilder<'a>

pub fn bug(&self, m: &str) -> !

pub fn span_err<S: Into<MultiSpan>>(&self, sp: S, m: &str)

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

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

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

impl<'a> Parser<'a>

pub fn parse_ast_fragment(
    &mut self,
    kind: AstFragmentKind,
    macro_legacy_warnings: bool
) -> PResult<'a, AstFragment>

pub fn ensure_complete_parse(
    &mut self,
    macro_path: &Path,
    kind_name: &str,
    span: Span
)

Trait Implementations

impl<'a> Drop for Parser<'a>

fn drop(&mut self)

Executes the destructor for this type.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.