Struct syntax::parse::parser::ParserUnstable

pub struct Parser<'a> {
    pub sess: &'a ParseSess,
    pub token: Token,
    pub span: Span,
    pub last_span: Span,
    pub cfg: CrateConfig,
    pub last_token: Option<Box<Token>>,
    pub buffer: [TokenAndSpan; 4],
    pub buffer_start: isize,
    pub buffer_end: isize,
    pub tokens_consumed: usize,
    pub restrictions: Restrictions,
    pub quote_depth: usize,
    pub reader: Box<Reader + 'a>,
    pub interner: Rc<IdentInterner>,
    pub obsolete_set: HashSet<ObsoleteSyntax>,
    pub mod_path_stack: Vec<InternedString>,
    pub open_braces: Vec<Span>,
    pub owns_directory: bool,
    pub root_module_name: Option<String>,
    pub expected_tokens: Vec<TokenType>,
}

Fields

sess
token	the current token:
span	the span of the current token:
last_span	the span of the prior token:
cfg
last_token	the previous token or None (only stashed sometimes).
buffer
buffer_start
buffer_end
tokens_consumed
restrictions
quote_depth
reader
interner
obsolete_set	The set of seen errors about obsolete syntax. Used to suppress extra detail when the same error is seen twice
mod_path_stack	Used to determine the path to externally loaded source files
open_braces	Stack of spans of open delimiters. Used for error message.
owns_directory	Flag if this parser "owns" the directory that it is currently parsing in. This will affect how nested files are looked up.
root_module_name	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

Methods

impl<'a> Parser<'a>

fn new(sess: &'a ParseSess, cfg: CrateConfig, rdr: Box<Reader + 'a>) -> Parser<'a>

fn token_to_string(token: &Token) -> String

Convert a token to a string using self's reader

fn this_token_to_string(&self) -> String

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

fn unexpected_last(&self, t: &Token) -> !

fn unexpected(&mut self) -> !

fn expect(&mut self, t: &Token)

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

fn expect_one_of(&mut self, edible: &[Token], inedible: &[Token])

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.

fn check_for_erroneous_unit_struct_expecting(&mut self, expected: &[Token]) -> bool

Check for erroneous ident { }; if matches, signal error and recover (without consuming any expected input token). Returns true if and only if input was consumed for recovery.

fn commit_expr(&mut self, e: &Expr, edible: &[Token], inedible: &[Token])

Commit to parsing a complete expression e expected to be followed by some token from the set edible + inedible. Recover from anticipated input errors, discarding erroneous characters.

fn commit_expr_expecting(&mut self, e: &Expr, edible: Token)

fn commit_stmt(&mut self, edible: &[Token], inedible: &[Token])

Commit to parsing a complete statement s, which expects to be followed by some token from the set edible + inedible. Check for recoverable input errors, discarding erroneous characters.

fn commit_stmt_expecting(&mut self, edible: Token)

fn parse_ident(&mut self) -> Ident

fn parse_ident_or_self_type(&mut self) -> Ident

fn parse_path_list_item(&mut self) -> PathListItem

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

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

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

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

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

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

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

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

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

fn expect_keyword(&mut self, kw: Keyword)

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.

fn check_strict_keywords(&mut self)

Signal an error if the given string is a strict keyword

fn check_reserved_keywords(&mut self)

Signal an error if the current token is a reserved keyword

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

fn expect_gt(&mut self)

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.

fn parse_seq_to_before_gt_or_return<T, F>(&mut self, sep: Option<Token>, f: F) -> (OwnedSlice<T>, bool) where F: FnMut(&mut Parser) -> Option<T>

fn parse_seq_to_before_gt<T, F>(&mut self, sep: Option<Token>, f: F) -> OwnedSlice<T> where F: FnMut(&mut Parser) -> T

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

fn parse_seq_to_gt<T, F>(&mut self, sep: Option<Token>, f: F) -> OwnedSlice<T> where F: FnMut(&mut Parser) -> T

fn parse_seq_to_gt_or_return<T, F>(&mut self, sep: Option<Token>, f: F) -> (OwnedSlice<T>, bool) where F: FnMut(&mut Parser) -> Option<T>

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

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

fn parse_seq_to_before_end<T, F>(&mut self, ket: &Token, sep: SeqSep, f: F) -> Vec<T> where F: FnMut(&mut Parser) -> T

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

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

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

fn parse_enum_variant_seq<T, F>(&mut self, bra: &Token, ket: &Token, sep: SeqSep, f: F) -> Vec<T> where F: FnMut(&mut Parser) -> T

Parse a sequence parameter of enum variant. For consistency purposes, these should not be empty.

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

fn bump(&mut self)

Advance the parser by one token

fn bump_and_get(&mut self) -> Token

Advance the parser by one token and return the bumped token.

fn replace_token(&mut self, next: Token, lo: BytePos, hi: BytePos)

EFFECT: replace the current token and span with the given one

fn buffer_length(&mut self) -> isize

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

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

fn span_fatal(&self, sp: Span, m: &str) -> !

fn span_fatal_help(&self, sp: Span, m: &str, help: &str) -> !

fn span_note(&self, sp: Span, m: &str)

fn span_help(&self, sp: Span, m: &str)

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

fn warn(&self, m: &str)

fn span_warn(&self, sp: Span, m: &str)

fn span_err(&self, sp: Span, m: &str)

fn span_bug(&self, sp: Span, m: &str) -> !

fn abort_if_errors(&self)

fn id_to_interned_str(&mut self, id: Ident) -> InternedString

fn token_is_bare_fn_keyword(&mut self) -> bool

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

fn token_is_closure_keyword(&mut self) -> bool

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

fn get_lifetime(&mut self) -> Ident

fn parse_for_in_type(&mut self) -> Ty_

fn parse_ty_path(&mut self) -> Ty_

fn parse_ty_bare_fn(&mut self, lifetime_defs: Vec<LifetimeDef>) -> Ty_

parse a TyBareFn type:

fn parse_proc_type(&mut self, lifetime_defs: Vec<LifetimeDef>) -> Ty_

Parses a procedure type (proc). The initial proc keyword must already have been parsed.

fn parse_obsolete_closure_kind(&mut self)

Parses an obsolete closure kind (&:, &mut:, or :).

fn parse_ty_bare_fn_or_ty_closure(&mut self, lifetime_defs: Vec<LifetimeDef>) -> Ty_

fn parse_ty_closure(&mut self, lifetime_defs: Vec<LifetimeDef>) -> Ty_

Parse a TyClosure type

fn parse_unsafety(&mut self) -> Unsafety

fn parse_trait_items(&mut self) -> Vec<TraitItem>

Parse the items in a trait declaration

fn parse_mt(&mut self) -> MutTy

Parse a possibly mutable type

fn parse_ret_ty(&mut self) -> FunctionRetTy

Parse optional return type [ -> TY ] in function decl

fn parse_ty_sum(&mut self) -> P<Ty>

Parse a type in a context where T1+T2 is allowed.

fn parse_ty(&mut self) -> P<Ty>

Parse a type.

fn parse_borrowed_pointee(&mut self) -> Ty_

fn parse_ptr(&mut self) -> MutTy

fn is_named_argument(&mut self) -> bool

fn parse_arg_general(&mut self, require_name: bool) -> Arg

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

fn parse_arg(&mut self) -> Arg

Parse a single function argument

fn parse_fn_block_arg(&mut self) -> Arg

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

fn maybe_parse_fixed_length_of_vec(&mut self) -> Option<P<Expr>>

fn lit_from_token(&self, tok: &Token) -> Lit_

Matches token_lit = LIT_INTEGER | ...

fn parse_lit(&mut self) -> Lit

Matches lit = true | false | token_lit

fn parse_literal_maybe_minus(&mut self) -> P<Expr>

matches '-' lit | lit

fn parse_path(&mut self, mode: PathParsingMode) -> Path

Parses a path and optional type parameter bounds, depending on the mode. The mode parameter determines whether lifetimes, types, and/or bounds are permitted and whether :: must precede type parameter groups.

fn parse_path_segments_without_colons(&mut self) -> Vec<PathSegment>

Examples: - a::b<T,U>::c<V,W> - a::b<T,U>::c(V) -> W - a::b<T,U>::c(V)

fn parse_path_segments_with_colons(&mut self) -> Vec<PathSegment>

Examples: - a::b::<T,U>::c

fn parse_path_segments_without_types(&mut self) -> Vec<PathSegment>

Examples: - a::b::c

fn parse_opt_lifetime(&mut self) -> Option<Lifetime>

parses 0 or 1 lifetime

fn parse_lifetime(&mut self) -> Lifetime

Parses a single lifetime Matches lifetime = LIFETIME

fn parse_lifetime_defs(&mut self) -> Vec<LifetimeDef>

Parses lifetime_defs = [ lifetime_defs { ',' lifetime_defs } ] where lifetime_def = lifetime [':' lifetimes]

fn parse_lifetimes(&mut self, sep: Token) -> Vec<Lifetime>

matches lifetimes = ( lifetime ) | ( lifetime , lifetimes ) actually, it matches the empty one too, but putting that in there messes up the grammar....

Parses zero or more comma separated lifetimes. Expects each lifetime to be followed by either a comma or >. Used when parsing type parameter lists, where we expect something like <'a, 'b, T>.

fn parse_mutability(&mut self) -> Mutability

Parse mutability declaration (mut/const/imm)

fn parse_field(&mut self) -> Field

Parse ident COLON expr

fn mk_expr(&mut self, lo: BytePos, hi: BytePos, node: Expr_) -> P<Expr>

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

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

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

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

fn mk_range(&mut self, start: Option<P<Expr>>, end: Option<P<Expr>>) -> Expr_

fn mk_field(&mut self, expr: P<Expr>, ident: SpannedIdent) -> Expr_

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

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

fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos, m: Mac_) -> P<Expr>

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

fn parse_bottom_expr(&mut self) -> P<Expr>

At the bottom (top?) of the precedence hierarchy, parse things like parenthesized exprs, macros, return, etc.

fn parse_block_expr(&mut self, lo: BytePos, blk_mode: BlockCheckMode) -> P<Expr>

Parse a block or unsafe block

fn parse_dot_or_call_expr(&mut self) -> P<Expr>

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

fn parse_dot_or_call_expr_with(&mut self, e0: P<Expr>) -> P<Expr>

fn check_unknown_macro_variable(&mut self)

fn parse_sep_and_kleene_op(&mut self) -> (Option<Token>, KleeneOp)

Parse an optional separator followed by a Kleene-style repetition token (+ or *).

fn parse_token_tree(&mut self) -> TokenTree

parse a single token tree from the input.

fn parse_all_token_trees(&mut self) -> Vec<TokenTree>

fn parse_prefix_expr(&mut self) -> P<Expr>

Parse a prefix-operator expr

fn parse_binops(&mut self) -> P<Expr>

Parse an expression of binops

fn parse_more_binops(&mut self, lhs: P<Expr>, min_prec: usize) -> P<Expr>

Parse an expression of binops of at least min_prec precedence

fn parse_assign_expr(&mut self) -> P<Expr>

Parse an assignment expression.... actually, this seems to be the main entry point for parsing an arbitrary expression.

fn parse_assign_expr_with(&mut self, lhs: P<Expr>) -> P<Expr>

fn parse_if_expr(&mut self) -> P<Expr>

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

fn parse_if_let_expr(&mut self) -> P<Expr>

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

fn parse_lambda_expr(&mut self, capture_clause: CaptureClause) -> P<Expr>

fn parse_else_expr(&mut self) -> P<Expr>

fn parse_for_expr(&mut self, opt_ident: Option<Ident>) -> P<Expr>

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

fn parse_while_expr(&mut self, opt_ident: Option<Ident>) -> P<Expr>

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

fn parse_while_let_expr(&mut self, opt_ident: Option<Ident>) -> P<Expr>

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

fn parse_loop_expr(&mut self, opt_ident: Option<Ident>) -> P<Expr>

fn parse_arm(&mut self) -> Arm

fn parse_expr(&mut self) -> P<Expr>

Parse an expression

fn parse_expr_res(&mut self, r: Restrictions) -> P<Expr>

Parse an expression, subject to the given restrictions

fn parse_pat(&mut self) -> P<Pat>

Parse a pattern.

fn parse_stmt(&mut self, item_attrs: Vec<Attribute>) -> P<Stmt>

Parse a statement. may include decl. Precondition: any attributes are parsed already

fn parse_block(&mut self) -> P<Block>

Parse a block. No inner attrs are allowed.

fn parse_generics(&mut self) -> 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 )

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

Parse the argument list and result type of a function declaration

fn parse_method_with_outer_attributes(&mut self) -> P<Method>

Parse a method in a trait impl

fn parse_method(&mut self, attrs: Vec<Attribute>, visa: Visibility) -> P<Method>

Parse a method in a trait impl, starting with attrs attributes.

fn parse_record_struct_body(&mut self, class_name: &Ident) -> Vec<StructField>

fn parse_tuple_struct_body(&mut self, class_name: &Ident, generics: &mut Generics) -> Vec<StructField>

fn parse_single_struct_field(&mut self, vis: Visibility, attrs: Vec<Attribute>) -> StructField

Parse a structure field declaration

fn parse_item_with_outer_attributes(&mut self) -> Option<P<Item>>

fn parse_item(&mut self, attrs: Vec<Attribute>) -> Option<P<Item>>

fn parse_crate_mod(&mut self) -> Crate

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

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

fn parse_str(&mut self) -> (InternedString, StrStyle)

Trait Implementations

impl<'a> ParserAttr for Parser<'a>

fn parse_outer_attributes(&mut self) -> Vec<Attribute>

Parse attributes that appear before an item

fn parse_attribute(&mut self, permit_inner: bool) -> Attribute

Matches attribute = # ! [ meta_item ]

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

fn parse_inner_attrs_and_next(&mut self) -> (Vec<Attribute>, 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. In addition to a vector of inner attributes, this function also returns a vector that may contain the first outer attribute of the next item (since we can't know whether the attribute is an inner attribute of the containing item or an outer attribute of the first contained item until we see the semi). matches inner_attrs* outer_attr? you can make the 'next' field an Option, but the result is going to be more useful as a vector.

fn parse_meta_item(&mut self) -> P<MetaItem>

matches meta_item = IDENT | IDENT = lit | IDENT meta_seq

fn parse_meta_seq(&mut self) -> Vec<P<MetaItem>>

matches meta_seq = ( COMMASEP(meta_item) )

fn parse_optional_meta(&mut self) -> Vec<P<MetaItem>>

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

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

Reports an obsolete syntax non-fatal error.

fn obsolete_expr(&mut self, sp: Span, kind: ObsoleteSyntax) -> P<Expr>

Reports an obsolete syntax non-fatal error, and returns a placeholder expression

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

fn is_obsolete_ident(&mut self, ident: &str) -> bool

fn eat_obsolete_ident(&mut self, ident: &str) -> bool