bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Remove Parser methods that duplicate DiagCtxt methods.

Browse source
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
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_parse/src/lexer/tokentrees.rs
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)
in_cond = false;
} 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,
"found a `{` in the middle of a let-chain",
);

6
compiler/rustc_parse/src/parser/attr.rs
View file

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

38
compiler/rustc_parse/src/parser/diagnostics.rs
View file

@ -34,8 +34,8 @@ use rustc_ast::{
use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{
pluralize, AddToDiagnostic, Applicability, DiagCtxt, Diagnostic, DiagnosticBuilder,
DiagnosticMessage, FatalError, MultiSpan, PResult,
pluralize, AddToDiagnostic, Applicability, DiagCtxt, Diagnostic, DiagnosticBuilder, FatalError,
PResult,
};
use rustc_session::errors::ExprParenthesesNeeded;
use rustc_span::source_map::Spanned;
@ -239,21 +239,7 @@ impl<'a> DerefMut for SnapshotParser<'a> {
}
impl<'a> Parser<'a> {
#[rustc_lint_diagnostics]
#[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 {
pub fn dcx(&self) -> &'a DiagCtxt {
&self.sess.dcx
}
@ -610,7 +596,7 @@ impl<'a> Parser<'a> {
};
self.last_unexpected_token_span = Some(self.token.span);
// 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 ["def", "fun", "func", "function"].contains(&symbol.as_str()) {
@ -1647,7 +1633,7 @@ impl<'a> Parser<'a> {
kind: IncDecRecovery,
op_span: Span,
) -> PResult<'a, P<Expr>> {
let mut err = self.struct_span_err(
let mut err = self.dcx().struct_span_err(
op_span,
format!("Rust has no {} {} operator", kind.fixity, kind.op.name()),
);
@ -1843,7 +1829,7 @@ impl<'a> Parser<'a> {
_ => 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 sm = self.sess.source_map();
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
let hi = self.token.span;
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");
let prefix = if is_empty { "" } else { "alternatively, " };
if !is_empty {
@ -2328,7 +2314,7 @@ impl<'a> Parser<'a> {
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);
if let Some(sp) = self.sess.ambiguous_block_expr_parse.borrow().get(&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
// could be recovered from the current parser state, even if followed by more
// arguments after a comma.
let mut err = self.struct_span_err(
let mut err = self.dcx().struct_span_err(
self.token.span,
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");
self.bump(); // eat `:`
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.tool_only_span_suggestion(
label.ident.span.until(self.token.span),
@ -2875,7 +2861,7 @@ impl<'a> Parser<'a> {
err.cancel();
}
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) {
err.multipart_suggestion(
format!(
@ -2970,7 +2956,7 @@ impl<'a> Parser<'a> {
}
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");
if let Some(middle) = middlediff3 {
err.span_label(middle, "");

6
compiler/rustc_parse/src/parser/expr.rs
View file

@ -370,7 +370,7 @@ impl<'a> Parser<'a> {
self.mk_expr(span, aopexpr)
}
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"),
}
);
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 suggestions = vec![
@ -1967,7 +1967,7 @@ impl<'a> Parser<'a> {
let token = self.token.clone();
let err = |self_: &Self| {
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
if self.token.is_lifetime() {

4
compiler/rustc_parse/src/parser/generics.rs
View file

@ -64,7 +64,7 @@ impl<'a> Parser<'a> {
Ok(p) => {
if let TyKind::ImplTrait(_, bounds) = &p.kind {
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,
"expected trait bound, found `impl Trait` type",
);
@ -141,7 +141,7 @@ impl<'a> Parser<'a> {
// Parse optional const generics default value.
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,
format!("`const` keyword was mistyped as `{}`", mistyped_const_ident.as_str()),
);

22
compiler/rustc_parse/src/parser/item.rs
View file

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

6
compiler/rustc_parse/src/parser/pat.rs
View file

@ -459,7 +459,7 @@ impl<'a> Parser<'a> {
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
});
@ -695,7 +695,7 @@ impl<'a> Parser<'a> {
let expected = Expected::to_string_or_fallback(expected);
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}"));
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 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 `}`");
let mut comma_sp = None;

16
compiler/rustc_parse/src/parser/path.rs
View file

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

2
compiler/rustc_parse/src/parser/stmt.rs
View file

@ -444,7 +444,7 @@ impl<'a> Parser<'a> {
msg: Cow<'static, str>,
) -> DiagnosticBuilder<'a> {
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;
// Check to see if the user has written something like

11
compiler/rustc_parse/src/parser/ty.rs
View file

@ -341,7 +341,7 @@ impl<'a> Parser<'a> {
}
} else {
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");
return Err(err);
};
@ -902,7 +902,7 @@ impl<'a> Parser<'a> {
} else if !self.token.is_path_start() && self.token.can_begin_type() {
let ty = self.parse_ty_no_plus()?;
// 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
// 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);
let generic_args_span = generic_args.span();
let mut err =
self.struct_span_err(generic_args_span, "`Fn` traits cannot take lifetime parameters");
let mut err = self
.dcx()
.struct_span_err(generic_args_span, "`Fn` traits cannot take lifetime parameters");
let snippet = format!(
"for<{}> ",
lifetimes.iter().map(|lt| lt.ident.as_str()).intersperse(", ").collect::<String>(),
@ -1123,7 +1124,7 @@ impl<'a> Parser<'a> {
self.bump();
Lifetime { ident, id: ast::DUMMY_NODE_ID }
} else {
self.span_bug(self.token.span, "not a lifetime")
self.dcx().span_bug(self.token.span, "not a lifetime")
}
}