Struct syntex_syntax::parse::parser::Parser [−] [src]

pub struct Parser<'a> {
    pub sess: &'a ParseSess,
    pub token: Token,
    pub span: Span,
    pub prev_span: Span,
    pub cfg: CrateConfig,
    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 obsolete_set: HashSet<ObsoleteSyntax>,
    pub directory: PathBuf,
    pub open_braces: Vec<(DelimToken, Span)>,
    pub owns_directory: bool,
    pub root_module_name: Option<String>,
    pub expected_tokens: Vec<TokenType>,
    // some fields omitted
}

Fields

sess: &'a ParseSess token: Token

the current token:

span: Span

the span of the current token:

prev_span: Span

the span of the previous token:

cfg: CrateConfig buffer: [TokenAndSpan; 4] buffer_start: isize buffer_end: isize tokens_consumed: usize restrictions: Restrictions quote_depth: usize reader: Box<Reader + 'a> 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: PathBuf

Used to determine the path to externally loaded source files

open_braces: Vec<(DelimToken, Span)>

Stack of open delimiters and their spans. Used for error message.

owns_directory: bool

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

Methods

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

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 this_token_descr(&self) -> String

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

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

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

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

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

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.

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 check_contextual_keyword(&mut self, ident: Ident) -> bool

fn eat_contextual_keyword(&mut self, ident: Ident) -> bool

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.

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

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

fn parse_seq_to_before_gt<T, F>(&mut self, sep: Option<Token>, f: F) -> PResult<'a, P<[T]>> where F: FnMut(&mut Parser<'a>) -> PResult<'a, 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<'a, P<[T]>> where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>

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

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.

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.

fn parse_seq_to_before_end<T, F>(&mut self, ket: &Token, sep: SeqSep, f: F) -> 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.

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.

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>

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 bump_with(&mut self, next: Token, lo: BytePos, hi: BytePos)

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

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) -> DiagnosticBuilder<'a>

fn span_fatal(&self, sp: Span, m: &str) -> DiagnosticBuilder<'a>

fn span_fatal_help(&self, sp: Span, m: &str, help: &str) -> DiagnosticBuilder<'a>

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_err_help(&self, sp: Span, m: &str, h: &str)

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

fn abort_if_errors(&self)

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

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<'a, TyKind>

fn parse_impl_trait_type(&mut self) -> PResult<'a, TyKind>

fn parse_ty_path(&mut self) -> PResult<'a, TyKind>

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

parse a TyKind::BareFn type:

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

fn parse_trait_item(&mut self) -> PResult<'a, TraitItem>

Parse the items in a trait declaration

fn parse_trait_items(&mut self) -> PResult<'a, Vec<TraitItem>>

Parse the items in a trait declaration

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

Parse a possibly mutable type

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

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

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

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

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

Parse a type.

fn parse_borrowed_pointee(&mut self) -> PResult<'a, TyKind>

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

fn is_named_argument(&mut self) -> bool

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

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

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

Parse a single function argument

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

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

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

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

Matches token_lit = LIT_INTEGER | ...

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

Matches lit = true | false | token_lit

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

matches '-' lit | lit

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

fn parse_qualified_path(&mut self, mode: PathStyle) -> PResult<'a, (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: PathStyle) -> PResult<'a, 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<'a, 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<'a, Vec<PathSegment>>

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

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

Examples: - a::b::c

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

parses 0 or 1 lifetime

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

Parses a single lifetime Matches lifetime = LIFETIME

fn parse_lifetime_defs(&mut self, followed_by_ty_params: Option<&mut Vec<Attribute>>) -> PResult<'a, Vec<LifetimeDef>>

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

If followed_by_ty_params is None, then we are in a context where only lifetime parameters are allowed, and thus we should error if we encounter attributes after the bound lifetimes.

If followed_by_ty_params is Some(r), then there may be type parameter bindings after the lifetimes, so we should pass along the parsed attributes to be attached to the first such type parmeter.

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

Parse mutability (mut or nothing).

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

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

Parse ident COLON expr

fn mk_expr(&mut self, lo: BytePos, hi: BytePos, node: ExprKind, attrs: ThinVec<Attribute>) -> P<Expr>

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

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

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

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

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

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

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

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

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

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

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

Parse a block or unsafe block

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

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

fn check_unknown_macro_variable(&mut self)

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

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

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

parse a single token tree from the input.

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

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

Parse a prefix-unary-operator expr

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.

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

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

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

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

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

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

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

fn parse_for_expr(&mut self, opt_ident: Option<SpannedIdent>, span_lo: BytePos, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>>

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

fn parse_while_expr(&mut self, opt_ident: Option<SpannedIdent>, span_lo: BytePos, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>>

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

fn parse_while_let_expr(&mut self, opt_ident: Option<SpannedIdent>, span_lo: BytePos, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>>

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

fn parse_loop_expr(&mut self, opt_ident: Option<SpannedIdent>, span_lo: BytePos, attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>>

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

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

Parse an expression

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.

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

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

Parse a pattern.

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.

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

Parse a block. No inner attrs are allowed.

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

Parse a statement, including the trailing semicolon.

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 )

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

fn parse_fn_decl(&mut self, allow_variadic: bool) -> PResult<'a, 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<'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

fn parse_impl_item(&mut self) -> PResult<'a, ImplItem>

Parse an impl item.

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

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

fn parse_single_struct_field(&mut self, lo: BytePos, vis: Visibility, attrs: Vec<Attribute>) -> PResult<'a, 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<'a, Option<P<Item>>>

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.

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

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

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

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

Parse attributes that appear before an item

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

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*

fn parse_meta_item(&mut self) -> PResult<'a, P<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>
[src]

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

fn ensure_complete_parse(&mut self, macro_name: Name, kind_name: &str, span: Span)

Trait Implementations

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

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)