Struct 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 filename: Option<String>,
    pub mod_path_stack: Vec<InternedString>,
    pub open_braces: Vec<(DelimToken, Span)>,
    pub owns_directory: bool,
    pub root_module_name: Option<String>,
    pub expected_tokens: Vec<TokenType>,
    // some fields omitted
}
Unstable (rustc_private)

Fields

sess: &'a ParseSess
Unstable (rustc_private)
token: Token
Unstable (rustc_private)

the current token:

span: Span
Unstable (rustc_private)

the span of the current token:

last_span: Span
Unstable (rustc_private)

the span of the prior token:

cfg: CrateConfig
Unstable (rustc_private)
last_token: Option<Box<Token>>
Unstable (rustc_private)

the previous token or None (only stashed sometimes).

buffer: [TokenAndSpan; 4]
Unstable (rustc_private)
buffer_start: isize
Unstable (rustc_private)
buffer_end: isize
Unstable (rustc_private)
tokens_consumed: usize
Unstable (rustc_private)
restrictions: Restrictions
Unstable (rustc_private)
quote_depth: usize
Unstable (rustc_private)
reader: Box<Reader + 'a>
Unstable (rustc_private)
interner: Rc<IdentInterner>
Unstable (rustc_private)
obsolete_set: HashSet<ObsoleteSyntax>
Unstable (rustc_private)

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

filename: Option<String>
Unstable (rustc_private)

Used to determine the path to externally loaded source files

mod_path_stack: Vec<InternedString>
Unstable (rustc_private)
open_braces: Vec<(DelimToken, Span)>
Unstable (rustc_private)

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

owns_directory: bool
Unstable (rustc_private)

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>
Unstable (rustc_private)

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>
Unstable (rustc_private)

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

Unstable (rustc_private)

Convert a token to a string using self's reader

fn this_token_to_string(&self) -> String

Unstable (rustc_private)

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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<'a, ()>

Unstable (rustc_private)

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<'a, ()>

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

Unstable (rustc_private)

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<'a, ()>

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

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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)

Unstable (rustc_private)

Signal an error if the given string is a strict keyword

fn check_reserved_keywords(&mut self)

Unstable (rustc_private)

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

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>

Unstable (rustc_private)

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>

Unstable (rustc_private)

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

Unstable (rustc_private)

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<'a, Spanned<Vec<T>>> where F: FnMut(&mut Parser<'a>) -> PResult<'a, T>

fn bump(&mut self)

Unstable (rustc_private)

Advance the parser by one token

fn bump_and_get(&mut self) -> Token

Unstable (rustc_private)

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

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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_ty_path(&mut self) -> PResult<'a, TyKind>

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

Unstable (rustc_private)

parse a TyKind::BareFn type:

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

Unstable (rustc_private)

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

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

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

Unstable (rustc_private)

Parse the items in a trait declaration

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

Unstable (rustc_private)

Parse a possibly mutable type

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

Unstable (rustc_private)

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

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

Unstable (rustc_private)

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

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

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

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

Unstable (rustc_private)

Parse a single function argument

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

Matches token_lit = LIT_INTEGER | ...

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

Unstable (rustc_private)

Matches lit = true | false | token_lit

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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

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

Unstable (rustc_private)

Examples: - a::b::c

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

Unstable (rustc_private)

parses 0 or 1 lifetime

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

Unstable (rustc_private)

Parses a single lifetime Matches lifetime = LIFETIME

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

Unstable (rustc_private)

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

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

Parse mutability (mut or nothing).

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

Unstable (rustc_private)

Parse ident COLON expr

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

Unstable (rustc_private)

Parse a block or unsafe block

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

Unstable (rustc_private)

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: ThinAttributes) -> PResult<'a, P<Expr>>

fn check_unknown_macro_variable(&mut self)

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

Unstable (rustc_private)

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

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

Unstable (rustc_private)

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<ThinAttributes>) -> PResult<'a, P<Expr>>

Unstable (rustc_private)

Parse a prefix-unary-operator expr

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

Unstable (rustc_private)

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

Unstable (rustc_private)

Parse an associative expression with operators of at least min_prec precedence

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

Unstable (rustc_private)

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

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

Unstable (rustc_private)

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

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

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

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

Unstable (rustc_private)

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<'a, P<Expr>>

Unstable (rustc_private)

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<'a, P<Expr>>

Unstable (rustc_private)

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<'a, P<Expr>>

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

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

Unstable (rustc_private)

Parse an expression

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

Unstable (rustc_private)

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<'a, P<Expr>>

Unstable (rustc_private)

Parse an expression, subject to the given restrictions

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

Unstable (rustc_private)

Parse a pattern.

fn parse_stmt(&mut self) -> PResult<'a, Option<Stmt>>

Unstable (rustc_private)

Parse a statement. may include decl.

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

Unstable (rustc_private)

Parse a block. No inner attrs are allowed.

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

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

Unstable (rustc_private)

Parse the argument list and result type of a function declaration

fn is_const_item(&mut self) -> bool

Unstable (rustc_private)

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

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

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, vis: Visibility, attrs: Vec<Attribute>) -> PResult<'a, StructField>

Unstable (rustc_private)

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

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

Unstable (rustc_private)

Parse attributes that appear before an item

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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

Unstable (rustc_private)

matches meta_item = IDENT | IDENT = lit | IDENT meta_seq

Trait Implementations

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

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

Unstable (rustc_private)

Reports an obsolete syntax non-fatal error.

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