Struct syntax::parse::parser::Parser

pub struct Parser<'a> {
    pub sess: &'a ParseSess,
    pub token: Token,
    pub span: Span,
    pub meta_var_span: Option<Span>,
    pub prev_span: Span,
    pub restrictions: Restrictions,
    pub obsolete_set: HashSet<ObsoleteSyntax>,
    pub directory: Directory,
    pub recurse_into_file_modules: bool,
    pub root_module_name: Option<String>,
    pub expected_tokens: Vec<TokenType>,
    pub desugar_doc_comments: bool,
    pub cfg_mods: bool,
    // some fields omitted
}

Fields

sess: &'a ParseSess

token: Token

the current token:

span: Span

the span of the current token:

meta_var_span: Option<Span>

the span of the previous token:

prev_span: Span

restrictions: Restrictions

obsolete_set: HashSet<ObsoleteSyntax>

The set of seen errors about obsolete syntax. Used to suppress extra detail when the same error is seen twice

directory: Directory

Used to determine the path to externally loaded source files

recurse_into_file_modules: bool

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

expected_tokens: Vec<TokenType>

desugar_doc_comments: bool

cfg_mods: bool

Whether 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>,
    recurse_into_file_modules: bool,
    desugar_doc_comments: bool
) -> Self

pub fn token_to_string(token: &Token) -> String

Convert a token to a string using self's reader

pub fn this_token_to_string(&self) -> String

Convert the current token to a string using self's reader

pub fn token_descr(&self) -> Option<&'static str>

pub fn this_token_descr(&self) -> String

pub fn unexpected_last<T>(&self, t: &Token) -> PResult<'a, T>

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

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

Expect and consume the token t. Signal an error if the next token is not t.

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

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 check(&mut self, tok: &Token) -> bool

Check if the next token is tok, and return true if so.

This method will automatically add tok to expected_tokens if tok is not encountered.

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

Consume token 'tok' if it exists. Returns true if the given token was present, false otherwise.

pub fn check_keyword(&mut self, kw: Keyword) -> bool

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

If the next token is the given keyword, eat it and return true. Otherwise, return false.

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

pub fn expect_keyword(&mut self, kw: Keyword) -> PResult<'a, ()>

If the given word is not a keyword, signal an error. If the next token is not the given word, signal an error. Otherwise, eat it.

pub fn expect_no_suffix(&self, sp: Span, kind: &str, suffix: Option<Name>)

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

Expect and consume a GT. if a >> is seen, replace it with a single > and continue. If a GT is not seen, signal an error.

pub fn parse_seq_to_before_gt_or_return<T, F>(
    &mut self,
    sep: Option<Token>,
    f: F
) -> PResult<'a, (Vec<T>, bool)> where
    F: FnMut(&mut Parser<'a>) -> PResult<'a, Option<T>>, 

pub fn parse_seq_to_before_gt<T, F>(
    &mut self,
    sep: Option<Token>,
    f: F
) -> PResult<'a, Vec<T>> where
    F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, 

Parse a sequence bracketed by '<' and '>', stopping before the '>'.

pub fn parse_seq_to_gt<T, F>(
    &mut self,
    sep: Option<Token>,
    f: F
) -> PResult<'a, Vec<T>> where
    F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, 

pub fn parse_seq_to_gt_or_return<T, F>(
    &mut self,
    sep: Option<Token>,
    f: F
) -> PResult<'a, (Vec<T>, bool)> where
    F: FnMut(&mut Parser<'a>) -> PResult<'a, Option<T>>, 

pub fn eat_to_tokens(&mut self, kets: &[&Token])

Eat and discard tokens until one of kets is encountered. Respects token trees, passes through any errors encountered. Used for error recovery.

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

Parse 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: &Token,
    sep: SeqSep,
    f: F
) -> PResult<'a, Vec<T>> where
    F: FnMut(&mut Parser<'a>) -> PResult<'a, T>, 

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

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

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

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

pub fn bump(&mut self)

Advance the parser by one token

pub fn bump_with(&mut self, next: Token, span: Span)

Advance the parser using provided token as a next one. Use this when consuming a part of a token. For example a single < from <<.

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

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 span_fatal_help<S: Into<MultiSpan>>(
    &self,
    sp: S,
    m: &str,
    help: &str
) -> DiagnosticBuilder<'a>

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

pub fn warn(&self, m: &str)

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

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

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

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

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

pub fn abort_if_errors(&self)

pub fn diagnostic(&self) -> &'a Handler

pub fn token_is_bare_fn_keyword(&mut self) -> bool

Is the current token one of the keywords that signals a bare function type?

pub fn parse_ty_bare_fn(
    &mut self,
    generic_params: Vec<GenericParam>
) -> PResult<'a, TyKind>

parse a TyKind::BareFn type:

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

Parse the items in a trait declaration

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

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

pub fn parse_arg_general(&mut self, require_name: bool) -> PResult<'a, Arg>

This version of parse arg doesn't necessarily require identifier names.

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

Parse a single function argument

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

Parse an argument in a lambda header e.g. |arg, arg|

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

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

Matches token_lit = LIT_INTEGER | ...

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

Matches lit = true | false | token_lit

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

matches '-' lit | lit (cf. ast_validation::AstValidator::check_expr_within_pat)

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

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_common(
    &mut self,
    style: PathStyle,
    enable_warning: bool
) -> PResult<'a, Path>

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 back-compat. This is used when parsing derive macro paths in #[derive] attributes.

pub fn expect_lifetime(&mut self) -> Lifetime

Parse single lifetime 'a or panic.

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

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

Parse ident (COLON expr)?

pub fn mk_expr(
    &mut self,
    span: Span,
    node: ExprKind,
    attrs: ThinVec<Attribute>
) -> P<Expr>

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

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

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

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

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

pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: Spanned<usize>) -> ExprKind

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

pub fn mk_mac_expr(
    &mut self,
    span: Span,
    m: Mac_,
    attrs: ThinVec<Attribute>
) -> P<Expr>

pub fn mk_lit_u32(&mut self, i: u32, attrs: ThinVec<Attribute>) -> P<Expr>

pub fn parse_block_expr(
    &mut self,
    lo: Span,
    blk_mode: BlockCheckMode,
    outer_attrs: ThinVec<Attribute>
) -> PResult<'a, P<Expr>>

Parse a block or unsafe block

pub fn parse_dot_or_call_expr(
    &mut self,
    already_parsed_attrs: Option<ThinVec<Attribute>>
) -> PResult<'a, P<Expr>>

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

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

pub fn process_potential_macro_variable(&mut self)

pub fn parse_token_tree(&mut self) -> TokenTree

parse a single token tree from the input.

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

pub fn parse_tokens(&mut self) -> TokenStream

pub fn parse_prefix_expr(
    &mut self,
    already_parsed_attrs: Option<ThinVec<Attribute>>
) -> PResult<'a, P<Expr>>

Parse a prefix-unary-operator expr

pub fn parse_assoc_expr(
    &mut self,
    already_parsed_attrs: Option<ThinVec<Attribute>>
) -> PResult<'a, P<Expr>>

Parse an associative expression

This parses an expression accounting for associativity and precedence of the operators in the expression.

pub fn parse_assoc_expr_with(
    &mut self,
    min_prec: usize,
    lhs: LhsExpr
) -> PResult<'a, P<Expr>>

Parse an associative expression with operators of at least min_prec precedence

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

Parse an 'if' or 'if let' expression ('if' token already eaten)

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

Parse an 'if let' expression ('if' token already eaten)

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

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

pub fn parse_for_expr(
    &mut self,
    opt_label: Option<Label>,
    span_lo: Span,
    attrs: ThinVec<Attribute>
) -> PResult<'a, P<Expr>>

Parse a 'for' .. 'in' expression ('for' token already eaten)

pub fn parse_while_expr(
    &mut self,
    opt_label: Option<Label>,
    span_lo: Span,
    attrs: ThinVec<Attribute>
) -> PResult<'a, P<Expr>>

Parse a 'while' or 'while let' expression ('while' token already eaten)

pub fn parse_while_let_expr(
    &mut self,
    opt_label: Option<Label>,
    span_lo: Span,
    attrs: ThinVec<Attribute>
) -> PResult<'a, P<Expr>>

Parse a 'while let' expression ('while' token already eaten)

pub fn parse_loop_expr(
    &mut self,
    opt_label: Option<Label>,
    span_lo: Span,
    attrs: ThinVec<Attribute>
) -> PResult<'a, P<Expr>>

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

Parse a do catch {...} expression (do catch token already eaten)

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

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

Parse an expression

pub fn with_res<F, T>(&mut self, r: Restrictions, f: F) -> T where
    F: FnOnce(&mut Self) -> T, 

Evaluate the closure with restrictions in place.

After the closure is evaluated, restrictions are reset.

pub fn parse_expr_res(
    &mut self,
    r: Restrictions,
    already_parsed_attrs: Option<ThinVec<Attribute>>
) -> PResult<'a, P<Expr>>

Parse an expression, subject to the given restrictions

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

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

Parse a block. No inner attrs are allowed.

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

Parse a statement, including the trailing semicolon.

pub fn parse_generic_params(&mut self) -> PResult<'a, Vec<GenericParam>>

Parses (possibly empty) list of lifetime and type parameters, possibly including trailing comma and erroneous trailing attributes.

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

Parse 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 fn parse_where_clause(&mut self) -> PResult<'a, WhereClause>

Parses an optional where clause and places it in generics.

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

pub fn parse_fn_decl(&mut self, allow_variadic: bool) -> PResult<'a, P<FnDecl>>

Parse the argument list and result type of a function declaration

pub fn is_const_item(&mut self) -> bool

true if we are looking at const ID, false for things like const fn etc

pub fn parse_fn_front_matter(
    &mut self
) -> PResult<'a, (Spanned<Constness>, Unsafety, Abi)>

parses all the "front matter" for a fn declaration, up to and including the fn keyword:

• const fn
• unsafe fn
• const unsafe fn
• extern fn
• etc

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

Parse an impl item.

pub fn parse_record_struct_body(&mut self) -> PResult<'a, Vec<StructField>>

pub fn parse_tuple_struct_body(&mut self) -> PResult<'a, Vec<StructField>>

pub fn parse_single_struct_field(
    &mut self,
    lo: Span,
    vis: Visibility,
    attrs: Vec<Attribute>
) -> PResult<'a, StructField>

Parse a structure field declaration

pub fn parse_visibility(
    &mut self,
    can_take_tuple: bool
) -> PResult<'a, Visibility>

Parse pub, pub(crate) and pub(in path) plus shortcuts 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, it's not a tuple struct field) and the contents within the parens isn't valid, 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,
    codemap: &CodeMap
) -> ModulePath

Returns either a path to a module, or .

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_outer_attributes(&mut self) -> PResult<'a, Vec<Attribute>>

Parse attributes that appear before an item

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_path_and_tokens(&mut self) -> PResult<'a, (Path, TokenStream)>

pub fn parse_inner_attributes(&mut self) -> PResult<'a, Vec<Attribute>>

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

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

impl<'a> Parser<'a>

pub fn parse_expansion(
    &mut self,
    kind: ExpansionKind,
    macro_legacy_warnings: bool
) -> PResult<'a, Expansion>

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

Trait Implementations

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.

impl<'a> ParserObsoleteMethods for Parser<'a>

fn obsolete(&mut self, sp: Span, kind: ObsoleteSyntax)

Reports an obsolete syntax non-fatal error.

fn report(
    &mut self,
    sp: Span,
    kind: ObsoleteSyntax,
    kind_str: &str,
    desc: &str,
    error: bool
)