Skip to content

Commit 73bac45

Browse files
nnethercotennethercote
committed
Rename Parser::span_diagnostic as Parser::dcx.
1 parent 09af8a6 commit 73bac45

File tree

8 files changed

+40
-42
lines changed

8 files changed

+40
-42
lines changed

‎compiler/rustc_parse/src/parser/attr.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ impl<'a> Parser<'a> {
5555
} else if let token::DocComment(comment_kind, attr_style, data) = self.token.kind {
5656
if attr_style != ast::AttrStyle::Outer {
5757
let span = self.token.span;
58-
let mut err = self.diagnostic().struct_span_err_with_code(
58+
let mut err = self.dcx().struct_span_err_with_code(
5959
span,
6060
fluent::parse_inner_doc_comment_not_permitted,
6161
error_code!(E0753),
@@ -417,7 +417,7 @@ impl<'a> Parser<'a> {
417417
}
418418

419419
Err(InvalidMetaItem { span: self.token.span, token: self.token.clone() }
420-
.into_diagnostic(self.diagnostic()))
420+
.into_diagnostic(self.dcx()))
421421
}
422422
}
423423

‎compiler/rustc_parse/src/parser/attr_wrapper.rs‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -266,8 +266,7 @@ impl<'a> Parser<'a> {
266266
if let Some(attr_range) = self.capture_state.inner_attr_ranges.remove(&inner_attr.id) {
267267
inner_attr_replace_ranges.push(attr_range);
268268
} else {
269-
self.diagnostic()
270-
.span_delayed_bug(inner_attr.span, "Missing token range for attribute");
269+
self.dcx().span_delayed_bug(inner_attr.span, "Missing token range for attribute");
271270
}
272271
}
273272

‎compiler/rustc_parse/src/parser/diagnostics.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -246,14 +246,14 @@ impl<'a> Parser<'a> {
246246
sp: S,
247247
m: impl Into<DiagnosticMessage>,
248248
) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
249-
self.diagnostic().struct_span_err(sp, m)
249+
self.dcx().struct_span_err(sp, m)
250250
}
251251

252252
pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: impl Into<DiagnosticMessage>) -> ! {
253-
self.diagnostic().span_bug(sp, msg)
253+
self.dcx().span_bug(sp, msg)
254254
}
255255

256-
pub(super) fn diagnostic(&self) -> &'a DiagCtxt {
256+
pub(super) fn dcx(&self) -> &'a DiagCtxt {
257257
&self.sess.dcx
258258
}
259259

@@ -284,7 +284,7 @@ impl<'a> Parser<'a> {
284284
span: self.prev_token.span,
285285
missing_comma: None,
286286
}
287-
.into_diagnostic(self.diagnostic()));
287+
.into_diagnostic(self.dcx()));
288288
}
289289

290290
let valid_follow = &[
@@ -347,7 +347,7 @@ impl<'a> Parser<'a> {
347347
suggest_remove_comma,
348348
help_cannot_start_number,
349349
};
350-
let mut err = err.into_diagnostic(self.diagnostic());
350+
let mut err = err.into_diagnostic(self.dcx());
351351

352352
// if the token we have is a `<`
353353
// it *might* be a misplaced generic
@@ -1410,7 +1410,7 @@ impl<'a> Parser<'a> {
14101410
// Not entirely sure now, but we bubble the error up with the
14111411
// suggestion.
14121412
self.restore_snapshot(snapshot);
1413-
Err(err.into_diagnostic(self.diagnostic()))
1413+
Err(err.into_diagnostic(self.dcx()))
14141414
}
14151415
}
14161416
} else if token::OpenDelim(Delimiter::Parenthesis) == self.token.kind {
@@ -1425,7 +1425,7 @@ impl<'a> Parser<'a> {
14251425
}
14261426
// Consume the fn call arguments.
14271427
match self.consume_fn_args() {
1428-
Err(()) => Err(err.into_diagnostic(self.diagnostic())),
1428+
Err(()) => Err(err.into_diagnostic(self.dcx())),
14291429
Ok(()) => {
14301430
self.sess.emit_err(err);
14311431
// FIXME: actually check that the two expressions in the binop are
@@ -1451,7 +1451,7 @@ impl<'a> Parser<'a> {
14511451
mk_err_expr(self, inner_op.span.to(self.prev_token.span))
14521452
} else {
14531453
// These cases cause too many knock-down errors, bail out (#61329).
1454-
Err(err.into_diagnostic(self.diagnostic()))
1454+
Err(err.into_diagnostic(self.dcx()))
14551455
}
14561456
};
14571457
}
@@ -2539,7 +2539,7 @@ impl<'a> Parser<'a> {
25392539
Ok(Some(GenericArg::Const(self.parse_const_arg()?)))
25402540
} else {
25412541
let after_kw_const = self.token.span;
2542-
self.recover_const_arg(after_kw_const, err.into_diagnostic(self.diagnostic())).map(Some)
2542+
self.recover_const_arg(after_kw_const, err.into_diagnostic(self.dcx())).map(Some)
25432543
}
25442544
}
25452545

@@ -2897,7 +2897,7 @@ impl<'a> Parser<'a> {
28972897
span: path.span.shrink_to_hi(),
28982898
between: between_span,
28992899
}
2900-
.into_diagnostic(self.diagnostic()));
2900+
.into_diagnostic(self.dcx()));
29012901
}
29022902
}
29032903
}

‎compiler/rustc_parse/src/parser/expr.rs‎

Lines changed: 10 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1269,7 +1269,7 @@ impl<'a> Parser<'a> {
12691269
.collect(),
12701270
},
12711271
}
1272-
.into_diagnostic(self.diagnostic());
1272+
.into_diagnostic(self.dcx());
12731273
replacement_err.emit();
12741274

12751275
let old_err = mem::replace(err, replacement_err);
@@ -1693,8 +1693,7 @@ impl<'a> Parser<'a> {
16931693
mk_lit_char: impl FnOnce(Symbol, Span) -> L,
16941694
err: impl FnOnce(&Self) -> DiagnosticBuilder<'a, ErrorGuaranteed>,
16951695
) -> L {
1696-
if let Some(mut diag) =
1697-
self.diagnostic().steal_diagnostic(lifetime.span, StashKey::LifetimeIsChar)
1696+
if let Some(mut diag) = self.dcx().steal_diagnostic(lifetime.span, StashKey::LifetimeIsChar)
16981697
{
16991698
diag.span_suggestion_verbose(
17001699
lifetime.span.shrink_to_hi(),
@@ -1884,8 +1883,8 @@ impl<'a> Parser<'a> {
18841883
self.bump(); // `#`
18851884

18861885
let Some((ident, false)) = self.token.ident() else {
1887-
let err = errors::ExpectedBuiltinIdent { span: self.token.span }
1888-
.into_diagnostic(self.diagnostic());
1886+
let err =
1887+
errors::ExpectedBuiltinIdent { span: self.token.span }.into_diagnostic(self.dcx());
18891888
return Err(err);
18901889
};
18911890
self.sess.gated_spans.gate(sym::builtin_syntax, ident.span);
@@ -1896,7 +1895,7 @@ impl<'a> Parser<'a> {
18961895
Ok(res)
18971896
} else {
18981897
let err = errors::UnknownBuiltinConstruct { span: lo.to(ident.span), name: ident.name }
1899-
.into_diagnostic(self.diagnostic());
1898+
.into_diagnostic(self.dcx());
19001899
return Err(err);
19011900
};
19021901
self.expect(&TokenKind::CloseDelim(Delimiter::Parenthesis))?;
@@ -1960,7 +1959,7 @@ impl<'a> Parser<'a> {
19601959
&& matches!(e.kind, ExprKind::Err)
19611960
{
19621961
let mut err = errors::InvalidInterpolatedExpression { span: self.token.span }
1963-
.into_diagnostic(self.diagnostic());
1962+
.into_diagnostic(self.dcx());
19641963
err.downgrade_to_delayed_bug();
19651964
return Err(err);
19661965
}
@@ -2172,7 +2171,7 @@ impl<'a> Parser<'a> {
21722171
return Err(errors::MissingSemicolonBeforeArray {
21732172
open_delim: open_delim_span,
21742173
semicolon: prev_span.shrink_to_hi(),
2175-
}.into_diagnostic(self.diagnostic()));
2174+
}.into_diagnostic(self.dcx()));
21762175
}
21772176
Ok(_) => (),
21782177
Err(err) => err.cancel(),
@@ -2320,7 +2319,7 @@ impl<'a> Parser<'a> {
23202319
if self.check_keyword(kw::Async) {
23212320
let move_async_span = self.token.span.with_lo(self.prev_token.span.data().lo);
23222321
Err(errors::AsyncMoveOrderIncorrect { span: move_async_span }
2323-
.into_diagnostic(self.diagnostic()))
2322+
.into_diagnostic(self.dcx()))
23242323
} else {
23252324
Ok(CaptureBy::Value { move_kw: move_kw_span })
23262325
}
@@ -2510,7 +2509,7 @@ impl<'a> Parser<'a> {
25102509
};
25112510
if self.prev_token.kind == token::BinOp(token::Or) {
25122511
// This was part of a closure, the that part of the parser recover.
2513-
return Err(err.into_diagnostic(self.diagnostic()));
2512+
return Err(err.into_diagnostic(self.dcx()));
25142513
} else {
25152514
Some(self.sess.emit_err(err))
25162515
}
@@ -3194,8 +3193,7 @@ impl<'a> Parser<'a> {
31943193
fn parse_try_block(&mut self, span_lo: Span) -> PResult<'a, P<Expr>> {
31953194
let (attrs, body) = self.parse_inner_attrs_and_block()?;
31963195
if self.eat_keyword(kw::Catch) {
3197-
Err(errors::CatchAfterTry { span: self.prev_token.span }
3198-
.into_diagnostic(self.diagnostic()))
3196+
Err(errors::CatchAfterTry { span: self.prev_token.span }.into_diagnostic(self.dcx()))
31993197
} else {
32003198
let span = span_lo.to(body.span);
32013199
self.sess.gated_spans.gate(sym::try_blocks, span);

‎compiler/rustc_parse/src/parser/item.rs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -438,7 +438,7 @@ impl<'a> Parser<'a> {
438438
None
439439
};
440440

441-
if let Some(err) = err { Err(err.into_diagnostic(self.diagnostic())) } else { Ok(()) }
441+
if let Some(err) = err { Err(err.into_diagnostic(self.dcx())) } else { Ok(()) }
442442
}
443443

444444
fn parse_item_builtin(&mut self) -> PResult<'a, Option<ItemInfo>> {
@@ -759,7 +759,7 @@ impl<'a> Parser<'a> {
759759
if self.look_ahead(1, |tok| tok == &token::CloseDelim(Delimiter::Brace)) {
760760
// FIXME: merge with `DocCommentDoesNotDocumentAnything` (E0585)
761761
struct_span_err!(
762-
self.diagnostic(),
762+
self.dcx(),
763763
self.token.span,
764764
E0584,
765765
"found a documentation comment that doesn't document anything",
@@ -1374,7 +1374,7 @@ impl<'a> Parser<'a> {
13741374

13751375
let span = self.prev_token.span.shrink_to_hi();
13761376
let err: DiagnosticBuilder<'_, ErrorGuaranteed> =
1377-
errors::MissingConstType { span, colon, kind }.into_diagnostic(self.diagnostic());
1377+
errors::MissingConstType { span, colon, kind }.into_diagnostic(self.dcx());
13781378
err.stash(span, StashKey::ItemNoType);
13791379

13801380
// The user intended that the type be inferred,
@@ -1391,7 +1391,7 @@ impl<'a> Parser<'a> {
13911391
self.bump();
13921392
self.sess.emit_err(err);
13931393
} else {
1394-
return Err(err.into_diagnostic(self.diagnostic()));
1394+
return Err(err.into_diagnostic(self.dcx()));
13951395
}
13961396
}
13971397

@@ -1591,7 +1591,7 @@ impl<'a> Parser<'a> {
15911591
} else {
15921592
let err =
15931593
errors::UnexpectedTokenAfterStructName::new(self.token.span, self.token.clone());
1594-
return Err(err.into_diagnostic(self.diagnostic()));
1594+
return Err(err.into_diagnostic(self.dcx()));
15951595
};
15961596

15971597
Ok((class_name, ItemKind::Struct(vdata, generics)))
@@ -1787,7 +1787,7 @@ impl<'a> Parser<'a> {
17871787
let sp = previous_span.shrink_to_hi();
17881788
err.missing_comma = Some(sp);
17891789
}
1790-
return Err(err.into_diagnostic(self.diagnostic()));
1790+
return Err(err.into_diagnostic(self.dcx()));
17911791
}
17921792
}
17931793
_ => {
@@ -1837,7 +1837,7 @@ impl<'a> Parser<'a> {
18371837
// Make sure an error was emitted (either by recovering an angle bracket,
18381838
// or by finding an identifier as the next token), since we're
18391839
// going to continue parsing
1840-
assert!(self.diagnostic().has_errors().is_some());
1840+
assert!(self.dcx().has_errors().is_some());
18411841
} else {
18421842
return Err(err);
18431843
}

‎compiler/rustc_parse/src/parser/nonterminal.rs‎

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -114,8 +114,9 @@ impl<'a> Parser<'a> {
114114
NonterminalKind::Item => match self.parse_item(ForceCollect::Yes)? {
115115
Some(item) => NtItem(item),
116116
None => {
117-
return Err(UnexpectedNonterminal::Item(self.token.span)
118-
.into_diagnostic(self.diagnostic()));
117+
return Err(
118+
UnexpectedNonterminal::Item(self.token.span).into_diagnostic(self.dcx())
119+
);
119120
}
120121
},
121122
NonterminalKind::Block => {
@@ -127,7 +128,7 @@ impl<'a> Parser<'a> {
127128
Some(s) => NtStmt(P(s)),
128129
None => {
129130
return Err(UnexpectedNonterminal::Statement(self.token.span)
130-
.into_diagnostic(self.diagnostic()));
131+
.into_diagnostic(self.dcx()));
131132
}
132133
},
133134
NonterminalKind::PatParam { .. } | NonterminalKind::PatWithOr => {
@@ -163,7 +164,7 @@ impl<'a> Parser<'a> {
163164
span: self.token.span,
164165
token: self.token.clone(),
165166
}
166-
.into_diagnostic(self.diagnostic()));
167+
.into_diagnostic(self.dcx()));
167168
}
168169
NonterminalKind::Path => {
169170
NtPath(P(self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?))
@@ -181,7 +182,7 @@ impl<'a> Parser<'a> {
181182
span: self.token.span,
182183
token: self.token.clone(),
183184
}
184-
.into_diagnostic(self.diagnostic()));
185+
.into_diagnostic(self.dcx()));
185186
}
186187
}
187188
};

‎compiler/rustc_parse/src/parser/pat.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -873,7 +873,7 @@ impl<'a> Parser<'a> {
873873
// will direct us over to `parse_enum_variant()`.
874874
if self.token == token::OpenDelim(Delimiter::Parenthesis) {
875875
return Err(EnumPatternInsteadOfIdentifier { span: self.prev_token.span }
876-
.into_diagnostic(self.diagnostic()));
876+
.into_diagnostic(self.dcx()));
877877
}
878878

879879
Ok(PatKind::Ident(binding_annotation, ident, sub))
@@ -987,7 +987,7 @@ impl<'a> Parser<'a> {
987987
// check that a comma comes after every field
988988
if !ate_comma {
989989
let mut err = ExpectedCommaAfterPatternField { span: self.token.span }
990-
.into_diagnostic(self.diagnostic());
990+
.into_diagnostic(self.dcx());
991991
if let Some(mut delayed) = delayed_err {
992992
delayed.emit();
993993
}

‎compiler/rustc_parse/src/parser/path.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,7 @@ impl<'a> Parser<'a> {
123123

124124
self.bump(); // colon
125125

126-
self.diagnostic()
126+
self.dcx()
127127
.struct_span_err(
128128
self.prev_token.span,
129129
"found single colon before projection in qualified path",
@@ -326,7 +326,7 @@ impl<'a> Parser<'a> {
326326
.is_nightly_build()
327327
.then_some(()),
328328
}
329-
.into_diagnostic(self.diagnostic());
329+
.into_diagnostic(self.dcx());
330330
}
331331
// Attempt to find places where a missing `>` might belong.
332332
else if let Some(arg) = args

0 commit comments

Comments
 (0)