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

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

`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