1
Fork 0

Remove Parser methods that duplicate DiagCtxt methods.

This commit is contained in:
Nicholas Nethercote 2023-12-18 21:09:22 +11:00
parent d86a48278f
commit ec9af0d6cb
11 changed files with 54 additions and 61 deletions

View file

@ -155,7 +155,7 @@ pub fn expand_include<'cx>(
if self.p.token != token::Eof { if self.p.token != token::Eof {
let token = pprust::token_to_string(&self.p.token); let token = pprust::token_to_string(&self.p.token);
let msg = format!("expected item, found `{token}`"); let msg = format!("expected item, found `{token}`");
self.p.struct_span_err(self.p.token.span, msg).emit(); self.p.dcx().struct_span_err(self.p.token.span, msg).emit();
} }
break; break;

View file

@ -257,7 +257,7 @@ impl<'a> TokenTreesReader<'a> {
// This might be the beginning of the `if`/`while` body (i.e., the end of the condition) // This might be the beginning of the `if`/`while` body (i.e., the end of the condition)
in_cond = false; in_cond = false;
} else if maybe_andand == token::AndAnd && maybe_let.is_keyword(kw::Let) { } else if maybe_andand == token::AndAnd && maybe_let.is_keyword(kw::Let) {
let mut err = parser.struct_span_err( let mut err = parser.dcx().struct_span_err(
parser.token.span, parser.token.span,
"found a `{` in the middle of a let-chain", "found a `{` in the middle of a let-chain",
); );

View file

@ -200,7 +200,7 @@ impl<'a> Parser<'a> {
if let InnerAttrPolicy::Forbidden(reason) = policy { if let InnerAttrPolicy::Forbidden(reason) = policy {
let mut diag = match reason.as_ref().copied() { let mut diag = match reason.as_ref().copied() {
Some(InnerAttrForbiddenReason::AfterOuterDocComment { prev_doc_comment_span }) => { Some(InnerAttrForbiddenReason::AfterOuterDocComment { prev_doc_comment_span }) => {
let mut diag = self.struct_span_err( let mut diag = self.dcx().struct_span_err(
attr_sp, attr_sp,
fluent::parse_inner_attr_not_permitted_after_outer_doc_comment, fluent::parse_inner_attr_not_permitted_after_outer_doc_comment,
); );
@ -209,7 +209,7 @@ impl<'a> Parser<'a> {
diag diag
} }
Some(InnerAttrForbiddenReason::AfterOuterAttribute { prev_outer_attr_sp }) => { Some(InnerAttrForbiddenReason::AfterOuterAttribute { prev_outer_attr_sp }) => {
let mut diag = self.struct_span_err( let mut diag = self.dcx().struct_span_err(
attr_sp, attr_sp,
fluent::parse_inner_attr_not_permitted_after_outer_attr, fluent::parse_inner_attr_not_permitted_after_outer_attr,
); );
@ -218,7 +218,7 @@ impl<'a> Parser<'a> {
diag diag
} }
Some(InnerAttrForbiddenReason::InCodeBlock) | None => { Some(InnerAttrForbiddenReason::InCodeBlock) | None => {
self.struct_span_err(attr_sp, fluent::parse_inner_attr_not_permitted) self.dcx().struct_span_err(attr_sp, fluent::parse_inner_attr_not_permitted)
} }
}; };

View file

@ -34,8 +34,8 @@ use rustc_ast::{
use rustc_ast_pretty::pprust; use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{ use rustc_errors::{
pluralize, AddToDiagnostic, Applicability, DiagCtxt, Diagnostic, DiagnosticBuilder, pluralize, AddToDiagnostic, Applicability, DiagCtxt, Diagnostic, DiagnosticBuilder, FatalError,
DiagnosticMessage, FatalError, MultiSpan, PResult, PResult,
}; };
use rustc_session::errors::ExprParenthesesNeeded; use rustc_session::errors::ExprParenthesesNeeded;
use rustc_span::source_map::Spanned; use rustc_span::source_map::Spanned;
@ -239,21 +239,7 @@ impl<'a> DerefMut for SnapshotParser<'a> {
} }
impl<'a> Parser<'a> { impl<'a> Parser<'a> {
#[rustc_lint_diagnostics] pub fn dcx(&self) -> &'a DiagCtxt {
#[track_caller]
pub fn struct_span_err<S: Into<MultiSpan>>(
&self,
sp: S,
m: impl Into<DiagnosticMessage>,
) -> DiagnosticBuilder<'a> {
self.dcx().struct_span_err(sp, m)
}
pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: impl Into<DiagnosticMessage>) -> ! {
self.dcx().span_bug(sp, msg)
}
pub(super) fn dcx(&self) -> &'a DiagCtxt {
&self.sess.dcx &self.sess.dcx
} }
@ -610,7 +596,7 @@ impl<'a> Parser<'a> {
}; };
self.last_unexpected_token_span = Some(self.token.span); self.last_unexpected_token_span = Some(self.token.span);
// FIXME: translation requires list formatting (for `expect`) // FIXME: translation requires list formatting (for `expect`)
let mut err = self.struct_span_err(self.token.span, msg_exp); let mut err = self.dcx().struct_span_err(self.token.span, msg_exp);
if let TokenKind::Ident(symbol, _) = &self.prev_token.kind { if let TokenKind::Ident(symbol, _) = &self.prev_token.kind {
if ["def", "fun", "func", "function"].contains(&symbol.as_str()) { if ["def", "fun", "func", "function"].contains(&symbol.as_str()) {
@ -1647,7 +1633,7 @@ impl<'a> Parser<'a> {
kind: IncDecRecovery, kind: IncDecRecovery,
op_span: Span, op_span: Span,
) -> PResult<'a, P<Expr>> { ) -> PResult<'a, P<Expr>> {
let mut err = self.struct_span_err( let mut err = self.dcx().struct_span_err(
op_span, op_span,
format!("Rust has no {} {} operator", kind.fixity, kind.op.name()), format!("Rust has no {} {} operator", kind.fixity, kind.op.name()),
); );
@ -1843,7 +1829,7 @@ impl<'a> Parser<'a> {
_ => this_token_str, _ => this_token_str,
}, },
); );
let mut err = self.struct_span_err(sp, msg); let mut err = self.dcx().struct_span_err(sp, msg);
let label_exp = format!("expected `{token_str}`"); let label_exp = format!("expected `{token_str}`");
let sm = self.sess.source_map(); let sm = self.sess.source_map();
if !sm.is_multiline(prev_sp.until(sp)) { if !sm.is_multiline(prev_sp.until(sp)) {
@ -1978,7 +1964,7 @@ impl<'a> Parser<'a> {
self.consume_block(Delimiter::Parenthesis, ConsumeClosingDelim::No); //eat the block self.consume_block(Delimiter::Parenthesis, ConsumeClosingDelim::No); //eat the block
let hi = self.token.span; let hi = self.token.span;
self.bump(); //remove ) self.bump(); //remove )
let mut err = self.struct_span_err(lo.to(hi), "use of deprecated `try` macro"); let mut err = self.dcx().struct_span_err(lo.to(hi), "use of deprecated `try` macro");
err.note("in the 2018 edition `try` is a reserved keyword, and the `try!()` macro is deprecated"); err.note("in the 2018 edition `try` is a reserved keyword, and the `try!()` macro is deprecated");
let prefix = if is_empty { "" } else { "alternatively, " }; let prefix = if is_empty { "" } else { "alternatively, " };
if !is_empty { if !is_empty {
@ -2328,7 +2314,7 @@ impl<'a> Parser<'a> {
format!("expected expression, found {}", super::token_descr(&self.token)), format!("expected expression, found {}", super::token_descr(&self.token)),
), ),
}; };
let mut err = self.struct_span_err(span, msg); let mut err = self.dcx().struct_span_err(span, msg);
let sp = self.sess.source_map().start_point(self.token.span); let sp = self.sess.source_map().start_point(self.token.span);
if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow().get(&sp) { if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow().get(&sp) {
err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp)); err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
@ -2450,7 +2436,7 @@ impl<'a> Parser<'a> {
// We are causing this error here exclusively in case that a `const` expression // We are causing this error here exclusively in case that a `const` expression
// could be recovered from the current parser state, even if followed by more // could be recovered from the current parser state, even if followed by more
// arguments after a comma. // arguments after a comma.
let mut err = self.struct_span_err( let mut err = self.dcx().struct_span_err(
self.token.span, self.token.span,
format!("expected one of `,` or `>`, found {}", super::token_descr(&self.token)), format!("expected one of `,` or `>`, found {}", super::token_descr(&self.token)),
); );
@ -2840,7 +2826,7 @@ impl<'a> Parser<'a> {
let label = self.eat_label().expect("just checked if a label exists"); let label = self.eat_label().expect("just checked if a label exists");
self.bump(); // eat `:` self.bump(); // eat `:`
let span = label.ident.span.to(self.prev_token.span); let span = label.ident.span.to(self.prev_token.span);
let mut err = self.struct_span_err(span, "block label not supported here"); let mut err = self.dcx().struct_span_err(span, "block label not supported here");
err.span_label(span, "not supported here"); err.span_label(span, "not supported here");
err.tool_only_span_suggestion( err.tool_only_span_suggestion(
label.ident.span.until(self.token.span), label.ident.span.until(self.token.span),
@ -2875,7 +2861,7 @@ impl<'a> Parser<'a> {
err.cancel(); err.cancel();
} }
let seq_span = lo.to(self.prev_token.span); let seq_span = lo.to(self.prev_token.span);
let mut err = self.struct_span_err(comma_span, "unexpected `,` in pattern"); let mut err = self.dcx().struct_span_err(comma_span, "unexpected `,` in pattern");
if let Ok(seq_snippet) = self.span_to_snippet(seq_span) { if let Ok(seq_snippet) = self.span_to_snippet(seq_span) {
err.multipart_suggestion( err.multipart_suggestion(
format!( format!(
@ -2970,7 +2956,7 @@ impl<'a> Parser<'a> {
} }
self.bump(); self.bump();
} }
let mut err = self.struct_span_err(spans, "encountered diff marker"); let mut err = self.dcx().struct_span_err(spans, "encountered diff marker");
err.span_label(start, "after this is the code before the merge"); err.span_label(start, "after this is the code before the merge");
if let Some(middle) = middlediff3 { if let Some(middle) = middlediff3 {
err.span_label(middle, ""); err.span_label(middle, "");

View file

@ -370,7 +370,7 @@ impl<'a> Parser<'a> {
self.mk_expr(span, aopexpr) self.mk_expr(span, aopexpr)
} }
AssocOp::As | AssocOp::DotDot | AssocOp::DotDotEq => { AssocOp::As | AssocOp::DotDot | AssocOp::DotDotEq => {
self.span_bug(span, "AssocOp should have been handled by special case") self.dcx().span_bug(span, "AssocOp should have been handled by special case")
} }
}; };
@ -857,7 +857,7 @@ impl<'a> Parser<'a> {
_ => unreachable!("parse_dot_or_call_expr_with_ shouldn't produce this"), _ => unreachable!("parse_dot_or_call_expr_with_ shouldn't produce this"),
} }
); );
let mut err = self.struct_span_err(span, msg); let mut err = self.dcx().struct_span_err(span, msg);
let suggest_parens = |err: &mut Diagnostic| { let suggest_parens = |err: &mut Diagnostic| {
let suggestions = vec![ let suggestions = vec![
@ -1967,7 +1967,7 @@ impl<'a> Parser<'a> {
let token = self.token.clone(); let token = self.token.clone();
let err = |self_: &Self| { let err = |self_: &Self| {
let msg = format!("unexpected token: {}", super::token_descr(&token)); let msg = format!("unexpected token: {}", super::token_descr(&token));
self_.struct_span_err(token.span, msg) self_.dcx().struct_span_err(token.span, msg)
}; };
// On an error path, eagerly consider a lifetime to be an unclosed character lit // On an error path, eagerly consider a lifetime to be an unclosed character lit
if self.token.is_lifetime() { if self.token.is_lifetime() {

View file

@ -64,7 +64,7 @@ impl<'a> Parser<'a> {
Ok(p) => { Ok(p) => {
if let TyKind::ImplTrait(_, bounds) = &p.kind { if let TyKind::ImplTrait(_, bounds) = &p.kind {
let span = impl_span.to(self.token.span.shrink_to_lo()); let span = impl_span.to(self.token.span.shrink_to_lo());
let mut err = self.struct_span_err( let mut err = self.dcx().struct_span_err(
span, span,
"expected trait bound, found `impl Trait` type", "expected trait bound, found `impl Trait` type",
); );
@ -141,7 +141,7 @@ impl<'a> Parser<'a> {
// Parse optional const generics default value. // Parse optional const generics default value.
let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None }; let default = if self.eat(&token::Eq) { Some(self.parse_const_arg()?) } else { None };
let mut err = self.struct_span_err( let mut err = self.dcx().struct_span_err(
mistyped_const_ident.span, mistyped_const_ident.span,
format!("`const` keyword was mistyped as `{}`", mistyped_const_ident.as_str()), format!("`const` keyword was mistyped as `{}`", mistyped_const_ident.as_str()),
); );

View file

@ -63,7 +63,7 @@ impl<'a> Parser<'a> {
let token_str = super::token_descr(&self.token); let token_str = super::token_descr(&self.token);
if !self.maybe_consume_incorrect_semicolon(&items) { if !self.maybe_consume_incorrect_semicolon(&items) {
let msg = format!("expected item, found {token_str}"); let msg = format!("expected item, found {token_str}");
let mut err = self.struct_span_err(self.token.span, msg); let mut err = self.dcx().struct_span_err(self.token.span, msg);
let span = self.token.span; let span = self.token.span;
if self.is_kw_followed_by_ident(kw::Let) { if self.is_kw_followed_by_ident(kw::Let) {
err.span_label( err.span_label(
@ -484,7 +484,7 @@ impl<'a> Parser<'a> {
} else { } else {
"expected item after attributes" "expected item after attributes"
}; };
let mut err = self.struct_span_err(end.span, msg); let mut err = self.dcx().struct_span_err(end.span, msg);
if end.is_doc_comment() { if end.is_doc_comment() {
err.span_label(end.span, "this doc comment doesn't document anything"); err.span_label(end.span, "this doc comment doesn't document anything");
} else if self.token.kind == TokenKind::Semi { } else if self.token.kind == TokenKind::Semi {
@ -712,7 +712,8 @@ impl<'a> Parser<'a> {
let non_item_span = self.token.span; let non_item_span = self.token.span;
let is_let = self.token.is_keyword(kw::Let); let is_let = self.token.is_keyword(kw::Let);
let mut err = self.struct_span_err(non_item_span, "non-item in item list"); let mut err =
self.dcx().struct_span_err(non_item_span, "non-item in item list");
self.consume_block(Delimiter::Brace, ConsumeClosingDelim::Yes); self.consume_block(Delimiter::Brace, ConsumeClosingDelim::Yes);
if is_let { if is_let {
err.span_suggestion( err.span_suggestion(
@ -1617,7 +1618,7 @@ impl<'a> Parser<'a> {
} else { } else {
let token_str = super::token_descr(&self.token); let token_str = super::token_descr(&self.token);
let msg = format!("expected `where` or `{{` after union name, found {token_str}"); let msg = format!("expected `where` or `{{` after union name, found {token_str}");
let mut err = self.struct_span_err(self.token.span, msg); let mut err = self.dcx().struct_span_err(self.token.span, msg);
err.span_label(self.token.span, "expected `where` or `{` after union name"); err.span_label(self.token.span, "expected `where` or `{` after union name");
return Err(err); return Err(err);
}; };
@ -1657,7 +1658,7 @@ impl<'a> Parser<'a> {
if parsed_where { "" } else { "`where`, or " }, if parsed_where { "" } else { "`where`, or " },
token_str token_str
); );
let mut err = self.struct_span_err(self.token.span, msg); let mut err = self.dcx().struct_span_err(self.token.span, msg);
err.span_label( err.span_label(
self.token.span, self.token.span,
format!( format!(
@ -1749,7 +1750,8 @@ impl<'a> Parser<'a> {
} }
if self.eat(&token::Semi) { if self.eat(&token::Semi) {
let sp = self.prev_token.span; let sp = self.prev_token.span;
let mut err = self.struct_span_err(sp, format!("{adt_ty} fields are separated by `,`")); let mut err =
self.dcx().struct_span_err(sp, format!("{adt_ty} fields are separated by `,`"));
err.span_suggestion_short( err.span_suggestion_short(
sp, sp,
"replace `;` with `,`", "replace `;` with `,`",
@ -1788,7 +1790,7 @@ impl<'a> Parser<'a> {
} }
_ => { _ => {
let sp = self.prev_token.span.shrink_to_hi(); let sp = self.prev_token.span.shrink_to_hi();
let mut err = self.struct_span_err( let mut err = self.dcx().struct_span_err(
sp, sp,
format!("expected `,`, or `}}`, found {}", super::token_descr(&self.token)), format!("expected `,`, or `}}`, found {}", super::token_descr(&self.token)),
); );
@ -1935,7 +1937,7 @@ impl<'a> Parser<'a> {
Case::Insensitive, Case::Insensitive,
) { ) {
Ok(_) => { Ok(_) => {
let mut err = self.struct_span_err( let mut err = self.dcx().struct_span_err(
lo.to(self.prev_token.span), lo.to(self.prev_token.span),
format!("functions are not allowed in {adt_ty} definitions"), format!("functions are not allowed in {adt_ty} definitions"),
); );
@ -1954,7 +1956,7 @@ impl<'a> Parser<'a> {
} else if self.eat_keyword(kw::Struct) { } else if self.eat_keyword(kw::Struct) {
match self.parse_item_struct() { match self.parse_item_struct() {
Ok((ident, _)) => { Ok((ident, _)) => {
let mut err = self.struct_span_err( let mut err = self.dcx().struct_span_err(
lo.with_hi(ident.span.hi()), lo.with_hi(ident.span.hi()),
format!("structs are not allowed in {adt_ty} definitions"), format!("structs are not allowed in {adt_ty} definitions"),
); );
@ -2101,7 +2103,7 @@ impl<'a> Parser<'a> {
fn report_invalid_macro_expansion_item(&self, args: &DelimArgs) { fn report_invalid_macro_expansion_item(&self, args: &DelimArgs) {
let span = args.dspan.entire(); let span = args.dspan.entire();
let mut err = self.struct_span_err( let mut err = self.dcx().struct_span_err(
span, span,
"macros that expand to items must be delimited with braces or followed by a semicolon", "macros that expand to items must be delimited with braces or followed by a semicolon",
); );

View file

@ -459,7 +459,7 @@ impl<'a> Parser<'a> {
super::token_descr(&self_.token) super::token_descr(&self_.token)
); );
let mut err = self_.struct_span_err(self_.token.span, msg); let mut err = self_.dcx().struct_span_err(self_.token.span, msg);
err.span_label(self_.token.span, format!("expected {expected}")); err.span_label(self_.token.span, format!("expected {expected}"));
err err
}); });
@ -695,7 +695,7 @@ impl<'a> Parser<'a> {
let expected = Expected::to_string_or_fallback(expected); let expected = Expected::to_string_or_fallback(expected);
let msg = format!("expected {}, found {}", expected, super::token_descr(&self.token)); let msg = format!("expected {}, found {}", expected, super::token_descr(&self.token));
let mut err = self.struct_span_err(self.token.span, msg); let mut err = self.dcx().struct_span_err(self.token.span, msg);
err.span_label(self.token.span, format!("expected {expected}")); err.span_label(self.token.span, format!("expected {expected}"));
let sp = self.sess.source_map().start_point(self.token.span); let sp = self.sess.source_map().start_point(self.token.span);
@ -1029,7 +1029,7 @@ impl<'a> Parser<'a> {
} }
let token_str = super::token_descr(&self.token); let token_str = super::token_descr(&self.token);
let msg = format!("expected `}}`, found {token_str}"); let msg = format!("expected `}}`, found {token_str}");
let mut err = self.struct_span_err(self.token.span, msg); let mut err = self.dcx().struct_span_err(self.token.span, msg);
err.span_label(self.token.span, "expected `}`"); err.span_label(self.token.span, "expected `}`");
let mut comma_sp = None; let mut comma_sp = None;

View file

@ -614,7 +614,7 @@ impl<'a> Parser<'a> {
// FIXME(compiler-errors): this could be improved by suggesting lifting // FIXME(compiler-errors): this could be improved by suggesting lifting
// this up to the trait, at least before this becomes real syntax. // this up to the trait, at least before this becomes real syntax.
// e.g. `Trait<for<'a> Assoc = Ty>` -> `for<'a> Trait<Assoc = Ty>` // e.g. `Trait<for<'a> Assoc = Ty>` -> `for<'a> Trait<Assoc = Ty>`
return Err(self.struct_span_err( return Err(self.dcx().struct_span_err(
arg_span, arg_span,
"`for<...>` is not allowed on associated type bounds", "`for<...>` is not allowed on associated type bounds",
)); ));
@ -685,6 +685,7 @@ impl<'a> Parser<'a> {
let after_eq = eq.shrink_to_hi(); let after_eq = eq.shrink_to_hi();
let before_next = self.token.span.shrink_to_lo(); let before_next = self.token.span.shrink_to_lo();
let mut err = self let mut err = self
.dcx()
.struct_span_err(after_eq.to(before_next), "missing type to the right of `=`"); .struct_span_err(after_eq.to(before_next), "missing type to the right of `=`");
if matches!(self.token.kind, token::Comma | token::Gt) { if matches!(self.token.kind, token::Comma | token::Gt) {
err.span_suggestion( err.span_suggestion(
@ -783,10 +784,13 @@ impl<'a> Parser<'a> {
&& let Some(expr) = && let Some(expr) =
self.recover_unbraced_const_arg_that_can_begin_ty(snapshot) self.recover_unbraced_const_arg_that_can_begin_ty(snapshot)
{ {
return Ok(Some(self.dummy_const_arg_needs_braces( return Ok(Some(
self.struct_span_err(expr.span, "invalid const generic expression"), self.dummy_const_arg_needs_braces(
expr.span, self.dcx()
))); .struct_span_err(expr.span, "invalid const generic expression"),
expr.span,
),
));
} }
GenericArg::Type(ty) GenericArg::Type(ty)
@ -811,7 +815,7 @@ impl<'a> Parser<'a> {
match self.parse_expr_res(Restrictions::CONST_EXPR, None) { match self.parse_expr_res(Restrictions::CONST_EXPR, None) {
Ok(expr) => { Ok(expr) => {
return Ok(Some(self.dummy_const_arg_needs_braces( return Ok(Some(self.dummy_const_arg_needs_braces(
self.struct_span_err(expr.span, "invalid const generic expression"), self.dcx().struct_span_err(expr.span, "invalid const generic expression"),
expr.span, expr.span,
))); )));
} }

View file

@ -444,7 +444,7 @@ impl<'a> Parser<'a> {
msg: Cow<'static, str>, msg: Cow<'static, str>,
) -> DiagnosticBuilder<'a> { ) -> DiagnosticBuilder<'a> {
let sp = self.token.span; let sp = self.token.span;
let mut e = self.struct_span_err(sp, msg); let mut e = self.dcx().struct_span_err(sp, msg);
let do_not_suggest_help = self.token.is_keyword(kw::In) || self.token == token::Colon; let do_not_suggest_help = self.token.is_keyword(kw::In) || self.token == token::Colon;
// Check to see if the user has written something like // Check to see if the user has written something like

View file

@ -341,7 +341,7 @@ impl<'a> Parser<'a> {
} }
} else { } else {
let msg = format!("expected type, found {}", super::token_descr(&self.token)); let msg = format!("expected type, found {}", super::token_descr(&self.token));
let mut err = self.struct_span_err(self.token.span, msg); let mut err = self.dcx().struct_span_err(self.token.span, msg);
err.span_label(self.token.span, "expected type"); err.span_label(self.token.span, "expected type");
return Err(err); return Err(err);
}; };
@ -902,7 +902,7 @@ impl<'a> Parser<'a> {
} else if !self.token.is_path_start() && self.token.can_begin_type() { } else if !self.token.is_path_start() && self.token.can_begin_type() {
let ty = self.parse_ty_no_plus()?; let ty = self.parse_ty_no_plus()?;
// Instead of finding a path (a trait), we found a type. // Instead of finding a path (a trait), we found a type.
let mut err = self.struct_span_err(ty.span, "expected a trait, found type"); let mut err = self.dcx().struct_span_err(ty.span, "expected a trait, found type");
// If we can recover, try to extract a path from the type. Note // If we can recover, try to extract a path from the type. Note
// that we do not use the try operator when parsing the type because // that we do not use the try operator when parsing the type because
@ -1096,8 +1096,9 @@ impl<'a> Parser<'a> {
lifetime_defs.append(&mut generic_params); lifetime_defs.append(&mut generic_params);
let generic_args_span = generic_args.span(); let generic_args_span = generic_args.span();
let mut err = let mut err = self
self.struct_span_err(generic_args_span, "`Fn` traits cannot take lifetime parameters"); .dcx()
.struct_span_err(generic_args_span, "`Fn` traits cannot take lifetime parameters");
let snippet = format!( let snippet = format!(
"for<{}> ", "for<{}> ",
lifetimes.iter().map(|lt| lt.ident.as_str()).intersperse(", ").collect::<String>(), lifetimes.iter().map(|lt| lt.ident.as_str()).intersperse(", ").collect::<String>(),
@ -1123,7 +1124,7 @@ impl<'a> Parser<'a> {
self.bump(); self.bump();
Lifetime { ident, id: ast::DUMMY_NODE_ID } Lifetime { ident, id: ast::DUMMY_NODE_ID }
} else { } else {
self.span_bug(self.token.span, "not a lifetime") self.dcx().span_bug(self.token.span, "not a lifetime")
} }
} }