Struct syntex_syntax::parse::parser::Parser

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) -> FatalError

fn unexpected(&mut self) -> FatalError

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

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]) -> PResult<()>

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]) -> PResult<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]) -> PResult<()>

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) -> PResult<()>

fn commit_stmt(&mut self, edible: &[Token], inedible: &[Token]) -> PResult<()>

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) -> PResult<()>

fn parse_ident(&mut self) -> PResult<Ident>

fn parse_ident_or_self_type(&mut self) -> PResult<Ident>

fn parse_path_list_item(&mut self) -> PResult<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) -> PResult<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) -> PResult<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) -> PResult<bool>

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

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) -> PResult<()>

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) -> PResult<()>

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) -> PResult<(OwnedSlice<T>, bool)> where F: FnMut(&mut Parser) -> PResult<Option<T>>

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

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

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

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

fn parse_seq_to_end<T, F>(&mut self, ket: &Token, sep: SeqSep, f: F) -> PResult<Vec<T>> where F: FnMut(&mut Parser) -> PResult<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) -> PResult<Vec<T>> where F: FnMut(&mut Parser) -> PResult<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) -> PResult<Vec<T>> where F: FnMut(&mut Parser) -> PResult<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) -> PResult<Vec<T>> where F: FnMut(&mut Parser) -> PResult<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) -> PResult<Spanned<Vec<T>>> where F: FnMut(&mut Parser) -> PResult<T>

fn bump(&mut self) -> PResult<()>

Advance the parser by one token

fn bump_and_get(&mut self) -> PResult<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) -> FatalError

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

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

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

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

fn span_suggestion(&self, sp: Span, m: &str, n: String)

fn fileline_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 get_lifetime(&mut self) -> Ident

fn parse_for_in_type(&mut self) -> PResult<Ty_>

fn parse_ty_path(&mut self) -> PResult<Ty_>

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

parse a TyBareFn type:

fn parse_obsolete_closure_kind(&mut self) -> PResult<()>

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

fn parse_unsafety(&mut self) -> PResult<Unsafety>

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

Parse the items in a trait declaration

fn parse_mt(&mut self) -> PResult<MutTy>

Parse a possibly mutable type

fn parse_ret_ty(&mut self) -> PResult<FunctionRetTy>

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

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

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

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

Parse a type.

fn parse_borrowed_pointee(&mut self) -> PResult<Ty_>

fn parse_ptr(&mut self) -> PResult<MutTy>

fn is_named_argument(&mut self) -> bool

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

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

fn parse_arg(&mut self) -> PResult<Arg>

Parse a single function argument

fn parse_fn_block_arg(&mut self) -> PResult<Arg>

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

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

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

Matches token_lit = LIT_INTEGER | ...

fn parse_lit(&mut self) -> PResult<Lit>

Matches lit = true | false | token_lit

fn parse_pat_literal_maybe_minus(&mut self) -> PResult<P<Expr>>

matches '-' lit | lit

fn parse_qualified_path(&mut self, mode: PathParsingMode) -> PResult<(QSelf, Path)>

Parses qualified path.

Assumes that the leading < has been parsed already.

Qualifed paths are a part of the universal function call syntax (UFCS).

qualified_path = <type [as trait_ref]>::path

See parse_path for mode meaning.

Examples:

<T as U>::a <T as U>::F::a::<S>

fn parse_path(&mut self, mode: PathParsingMode) -> PResult<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) -> PResult<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) -> PResult<Vec<PathSegment>>

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

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

Examples: - a::b::c

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

parses 0 or 1 lifetime

fn parse_lifetime(&mut self) -> PResult<Lifetime>

Parses a single lifetime Matches lifetime = LIFETIME

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

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

fn parse_lifetimes(&mut self, sep: Token) -> PResult<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) -> PResult<Mutability>

Parse mutability declaration (mut/const/imm)

fn parse_field(&mut self) -> PResult<Field>

Parse ident COLON expr

fn mk_expr(&mut self, lo: BytePos, hi: BytePos, node: Expr_, attrs: ThinAttributes) -> 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_, attrs: ThinAttributes) -> P<Expr>

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

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

Parse a block or unsafe block

fn parse_dot_or_call_expr(&mut self, already_parsed_attrs: Option<ThinAttributes>) -> PResult<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>, attrs: ThinAttributes) -> PResult<P<Expr>>

fn check_unknown_macro_variable(&mut self) -> PResult<()>

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

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

fn parse_token_tree(&mut self) -> PResult<TokenTree>

parse a single token tree from the input.

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

fn parse_prefix_expr(&mut self, already_parsed_attrs: Option<ThinAttributes>) -> PResult<P<Expr>>

Parse a prefix-unary-operator expr

fn parse_assoc_expr(&mut self, already_parsed_attrs: Option<ThinAttributes>) -> PResult<P<Expr>>

Parse an associative expression

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

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

Parse an associative expression with operators of at least min_prec precedence

fn parse_if_expr(&mut self, attrs: ThinAttributes) -> PResult<P<Expr>>

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

fn parse_if_let_expr(&mut self, attrs: ThinAttributes) -> PResult<P<Expr>>

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

fn parse_lambda_expr(&mut self, lo: BytePos, capture_clause: CaptureClause, attrs: ThinAttributes) -> PResult<P<Expr>>

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

fn parse_for_expr(&mut self, opt_ident: Option<Ident>, span_lo: BytePos, attrs: ThinAttributes) -> PResult<P<Expr>>

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

fn parse_while_expr(&mut self, opt_ident: Option<Ident>, span_lo: BytePos, attrs: ThinAttributes) -> PResult<P<Expr>>

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

fn parse_while_let_expr(&mut self, opt_ident: Option<Ident>, span_lo: BytePos, attrs: ThinAttributes) -> PResult<P<Expr>>

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

fn parse_loop_expr(&mut self, opt_ident: Option<Ident>, span_lo: BytePos, attrs: ThinAttributes) -> PResult<P<Expr>>

fn parse_arm(&mut self) -> PResult<Arm>

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

Parse an expression

fn with_res<F>(&mut self, r: Restrictions, f: F) -> PResult<P<Expr>> where F: FnOnce(&mut Self) -> PResult<P<Expr>>

Evaluate the closure with restrictions in place.

After the closure is evaluated, restrictions are reset.

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

Parse an expression, subject to the given restrictions

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

Parse a pattern.

fn parse_stmt(&mut self) -> PResult<Option<P<Stmt>>>

Parse a statement. may include decl.

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

Parse a block. No inner attrs are allowed.

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

Parses an optional where clause and places it in generics.

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

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

Parse the argument list and result type of a function declaration

fn is_const_item(&mut self) -> bool

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

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

fn parse_impl_item(&mut self) -> PResult<P<ImplItem>>

Parse an impl item.

fn parse_record_struct_body(&mut self, parse_pub: ParsePub) -> PResult<Vec<StructField>>

fn parse_tuple_struct_body(&mut self, parse_pub: ParsePub) -> PResult<Vec<StructField>>

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

Parse a structure field declaration

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

fn default_submod_path(id: Ident, dir_path: &Path, codemap: &CodeMap) -> ModulePath

Returns either a path to a module, or .

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

fn parse_crate_mod(&mut self) -> PResult<Crate>

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

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

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

impl<'a> Parser<'a>

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

Parse attributes that appear before an item

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

Matches attribute = # ! [ meta_item ]

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

fn parse_inner_attributes(&mut self) -> PResult<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*

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

matches meta_item = IDENT | IDENT = lit | IDENT meta_seq

Trait Implementations

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)