Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit cda4736

Browse files
borsbors
committed
Auto merge of rust-lang#119063 - nnethercote:dcx, r=compiler-errors
Consistent `Handler` naming This PR implements the renaming described in rust-lang/compiler-team#699. r? `@compiler-errors`
2 parents 8681e07 + 1e831e3 commit cda4736

File tree

145 files changed

+1296
-1392
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

145 files changed

+1296
-1392
lines changed

‎compiler/rustc_ast_lowering/src/path.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -139,7 +139,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
139139

140140
// We should've returned in the for loop above.
141141

142-
self.tcx.sess.diagnostic().span_bug(
142+
self.tcx.sess.dcx().span_bug(
143143
p.span,
144144
format!(
145145
"lower_qpath: no final extension segment in {}..{}",

‎compiler/rustc_ast_passes/src/ast_validation.rs‎

Lines changed: 41 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -220,8 +220,8 @@ impl<'a> AstValidator<'a> {
220220
}
221221
}
222222

223-
fn err_handler(&self) -> &rustc_errors::Handler {
224-
self.session.diagnostic()
223+
fn dcx(&self) -> &rustc_errors::DiagCtxt {
224+
self.session.dcx()
225225
}
226226

227227
fn check_lifetime(&self, ident: Ident) {
@@ -269,7 +269,7 @@ impl<'a> AstValidator<'a> {
269269
) {
270270
return;
271271
}
272-
self.err_handler().emit_err(errors::InvalidUnnamedFieldTy { span, ty_span: ty.span });
272+
self.dcx().emit_err(errors::InvalidUnnamedFieldTy { span, ty_span: ty.span });
273273
}
274274

275275
fn deny_anon_struct_or_union(&self, ty: &Ty) {
@@ -278,15 +278,14 @@ impl<'a> AstValidator<'a> {
278278
TyKind::AnonUnion(..) => "union",
279279
_ => return,
280280
};
281-
self.err_handler()
282-
.emit_err(errors::AnonStructOrUnionNotAllowed { struct_or_union, span: ty.span });
281+
self.dcx().emit_err(errors::AnonStructOrUnionNotAllowed { struct_or_union, span: ty.span });
283282
}
284283

285284
fn deny_unnamed_field(&self, field: &FieldDef) {
286285
if let Some(ident) = field.ident
287286
&& ident.name == kw::Underscore
288287
{
289-
self.err_handler()
288+
self.dcx()
290289
.emit_err(errors::InvalidUnnamedField { span: field.span, ident_span: ident.span });
291290
}
292291
}
@@ -392,7 +391,7 @@ impl<'a> AstValidator<'a> {
392391
[b0] => b0.span(),
393392
[b0, .., bl] => b0.span().to(bl.span()),
394393
};
395-
self.err_handler().emit_err(errors::BoundInContext { span, ctx });
394+
self.dcx().emit_err(errors::BoundInContext { span, ctx });
396395
}
397396

398397
fn check_foreign_ty_genericless(
@@ -402,7 +401,7 @@ impl<'a> AstValidator<'a> {
402401
after_where_clause: &TyAliasWhereClause,
403402
) {
404403
let cannot_have = |span, descr, remove_descr| {
405-
self.err_handler().emit_err(errors::ExternTypesCannotHave {
404+
self.dcx().emit_err(errors::ExternTypesCannotHave {
406405
span,
407406
descr,
408407
remove_descr,
@@ -428,7 +427,7 @@ impl<'a> AstValidator<'a> {
428427
let Some(body) = body else {
429428
return;
430429
};
431-
self.err_handler().emit_err(errors::BodyInExtern {
430+
self.dcx().emit_err(errors::BodyInExtern {
432431
span: ident.span,
433432
body,
434433
block: self.current_extern_span(),
@@ -441,7 +440,7 @@ impl<'a> AstValidator<'a> {
441440
let Some(body) = body else {
442441
return;
443442
};
444-
self.err_handler().emit_err(errors::FnBodyInExtern {
443+
self.dcx().emit_err(errors::FnBodyInExtern {
445444
span: ident.span,
446445
body: body.span,
447446
block: self.current_extern_span(),
@@ -455,7 +454,7 @@ impl<'a> AstValidator<'a> {
455454
/// An `fn` in `extern { ... }` cannot have qualifiers, e.g. `async fn`.
456455
fn check_foreign_fn_headerless(&self, ident: Ident, span: Span, header: FnHeader) {
457456
if header.has_qualifiers() {
458-
self.err_handler().emit_err(errors::FnQualifierInExtern {
457+
self.dcx().emit_err(errors::FnQualifierInExtern {
459458
span: ident.span,
460459
block: self.current_extern_span(),
461460
sugg_span: span.until(ident.span.shrink_to_lo()),
@@ -466,7 +465,7 @@ impl<'a> AstValidator<'a> {
466465
/// An item in `extern { ... }` cannot use non-ascii identifier.
467466
fn check_foreign_item_ascii_only(&self, ident: Ident) {
468467
if !ident.as_str().is_ascii() {
469-
self.err_handler().emit_err(errors::ExternItemAscii {
468+
self.dcx().emit_err(errors::ExternItemAscii {
470469
span: ident.span,
471470
block: self.current_extern_span(),
472471
});
@@ -495,7 +494,7 @@ impl<'a> AstValidator<'a> {
495494
if let Const::Yes(const_span) = header.constness {
496495
let mut spans = variadic_spans.clone();
497496
spans.push(const_span);
498-
self.err_handler().emit_err(errors::ConstAndCVariadic {
497+
self.dcx().emit_err(errors::ConstAndCVariadic {
499498
spans,
500499
const_span,
501500
variadic_spans: variadic_spans.clone(),
@@ -517,14 +516,14 @@ impl<'a> AstValidator<'a> {
517516
_ => {}
518517
};
519518

520-
self.err_handler().emit_err(errors::BadCVariadic { span: variadic_spans });
519+
self.dcx().emit_err(errors::BadCVariadic { span: variadic_spans });
521520
}
522521

523522
fn check_item_named(&self, ident: Ident, kind: &str) {
524523
if ident.name != kw::Underscore {
525524
return;
526525
}
527-
self.err_handler().emit_err(errors::ItemUnderscore { span: ident.span, kind });
526+
self.dcx().emit_err(errors::ItemUnderscore { span: ident.span, kind });
528527
}
529528

530529
fn check_nomangle_item_asciionly(&self, ident: Ident, item_span: Span) {
@@ -615,7 +614,7 @@ impl<'a> AstValidator<'a> {
615614
let args_len = arg_spans.len();
616615
let constraint_len = constraint_spans.len();
617616
// ...and then error:
618-
self.err_handler().emit_err(errors::ArgsBeforeConstraint {
617+
self.dcx().emit_err(errors::ArgsBeforeConstraint {
619618
arg_spans: arg_spans.clone(),
620619
constraints: constraint_spans[0],
621620
args: *arg_spans.iter().last().unwrap(),
@@ -667,7 +666,7 @@ impl<'a> AstValidator<'a> {
667666
}
668667

669668
if !bounds.iter().any(|b| matches!(b, GenericBound::Trait(..))) {
670-
self.err_handler().emit_err(errors::AtLeastOneTrait { span: ty.span });
669+
self.dcx().emit_err(errors::AtLeastOneTrait { span: ty.span });
671670
}
672671
}
673672
_ => {}
@@ -697,7 +696,7 @@ impl<'a> AstValidator<'a> {
697696
/// Checks that generic parameters are in the correct order,
698697
/// which is lifetimes, then types and then consts. (`<'a, T, const N: usize>`)
699698
fn validate_generic_param_order(
700-
handler: &rustc_errors::Handler,
699+
dcx: &rustc_errors::DiagCtxt,
701700
generics: &[GenericParam],
702701
span: Span,
703702
) {
@@ -760,7 +759,7 @@ fn validate_generic_param_order(
760759
ordered_params += ">";
761760

762761
for (param_ord, (max_param, spans)) in &out_of_order {
763-
handler.emit_err(errors::OutOfOrderParams {
762+
dcx.emit_err(errors::OutOfOrderParams {
764763
spans: spans.clone(),
765764
sugg_span: span,
766765
param_ord,
@@ -823,7 +822,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
823822
errors::VisibilityNotPermittedNote::TraitImpl,
824823
);
825824
if let TyKind::Err = self_ty.kind {
826-
this.err_handler().emit_err(errors::ObsoleteAuto { span: item.span });
825+
this.dcx().emit_err(errors::ObsoleteAuto { span: item.span });
827826
}
828827
if let (&Unsafe::Yes(span), &ImplPolarity::Negative(sp)) = (unsafety, polarity)
829828
{
@@ -871,21 +870,21 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
871870
errors::VisibilityNotPermittedNote::IndividualImplItems,
872871
);
873872
if let &Unsafe::Yes(span) = unsafety {
874-
self.err_handler().emit_err(errors::InherentImplCannotUnsafe {
873+
self.dcx().emit_err(errors::InherentImplCannotUnsafe {
875874
span: self_ty.span,
876875
annotation_span: span,
877876
annotation: "unsafe",
878877
self_ty: self_ty.span,
879878
});
880879
}
881880
if let &ImplPolarity::Negative(span) = polarity {
882-
self.err_handler().emit_err(error(span, "negative", false));
881+
self.dcx().emit_err(error(span, "negative", false));
883882
}
884883
if let &Defaultness::Default(def_span) = defaultness {
885-
self.err_handler().emit_err(error(def_span, "`default`", true));
884+
self.dcx().emit_err(error(def_span, "`default`", true));
886885
}
887886
if let &Const::Yes(span) = constness {
888-
self.err_handler().emit_err(error(span, "`const`", true));
887+
self.dcx().emit_err(error(span, "`const`", true));
889888
}
890889

891890
self.visit_vis(&item.vis);
@@ -937,7 +936,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
937936
errors::VisibilityNotPermittedNote::IndividualForeignItems,
938937
);
939938
if let &Unsafe::Yes(span) = unsafety {
940-
self.err_handler().emit_err(errors::UnsafeItem { span, kind: "extern block" });
939+
self.dcx().emit_err(errors::UnsafeItem { span, kind: "extern block" });
941940
}
942941
if abi.is_none() {
943942
self.maybe_lint_missing_abi(item.span, item.id);
@@ -988,7 +987,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
988987
}
989988
ItemKind::Mod(unsafety, mod_kind) => {
990989
if let &Unsafe::Yes(span) = unsafety {
991-
self.err_handler().emit_err(errors::UnsafeItem { span, kind: "module" });
990+
self.dcx().emit_err(errors::UnsafeItem { span, kind: "module" });
992991
}
993992
// Ensure that `path` attributes on modules are recorded as used (cf. issue #35584).
994993
if !matches!(mod_kind, ModKind::Loaded(_, Inline::Yes, _))
@@ -1011,7 +1010,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
10111010
},
10121011
ItemKind::Union(vdata, generics) => {
10131012
if vdata.fields().is_empty() {
1014-
self.err_handler().emit_err(errors::FieldlessUnion { span: item.span });
1013+
self.dcx().emit_err(errors::FieldlessUnion { span: item.span });
10151014
}
10161015
match vdata {
10171016
VariantData::Struct(fields, ..) => {
@@ -1053,10 +1052,10 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
10531052

10541053
if self.features.lazy_type_alias {
10551054
if let Err(err) = self.check_type_alias_where_clause_location(ty_alias) {
1056-
self.err_handler().emit_err(err);
1055+
self.dcx().emit_err(err);
10571056
}
10581057
} else if where_clauses.1.0 {
1059-
self.err_handler().emit_err(errors::WhereClauseAfterTypeAlias {
1058+
self.dcx().emit_err(errors::WhereClauseAfterTypeAlias {
10601059
span: where_clauses.1.1,
10611060
help: self.session.is_nightly_build().then_some(()),
10621061
});
@@ -1141,14 +1140,14 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
11411140
}
11421141
GenericParamKind::Type { .. } | GenericParamKind::Const { .. } => {
11431142
if let Some(span) = prev_param_default {
1144-
self.err_handler().emit_err(errors::GenericDefaultTrailing { span });
1143+
self.dcx().emit_err(errors::GenericDefaultTrailing { span });
11451144
break;
11461145
}
11471146
}
11481147
}
11491148
}
11501149

1151-
validate_generic_param_order(self.err_handler(), &generics.params, generics.span);
1150+
validate_generic_param_order(self.dcx(), &generics.params, generics.span);
11521151

11531152
for predicate in &generics.where_clause.predicates {
11541153
if let WherePredicate::EqPredicate(predicate) = predicate {
@@ -1169,7 +1168,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
11691168
match bound {
11701169
GenericBound::Trait(t, _) => {
11711170
if !t.bound_generic_params.is_empty() {
1172-
self.err_handler()
1171+
self.dcx()
11731172
.emit_err(errors::NestedLifetimes { span: t.span });
11741173
}
11751174
}
@@ -1195,13 +1194,13 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
11951194
if let GenericBound::Trait(poly, modify) = bound {
11961195
match (ctxt, modify) {
11971196
(BoundKind::SuperTraits, TraitBoundModifier::Maybe) => {
1198-
self.err_handler().emit_err(errors::OptionalTraitSupertrait {
1197+
self.dcx().emit_err(errors::OptionalTraitSupertrait {
11991198
span: poly.span,
12001199
path_str: pprust::path_to_string(&poly.trait_ref.path),
12011200
});
12021201
}
12031202
(BoundKind::TraitObject, TraitBoundModifier::Maybe) => {
1204-
self.err_handler().emit_err(errors::OptionalTraitObject { span: poly.span });
1203+
self.dcx().emit_err(errors::OptionalTraitObject { span: poly.span });
12051204
}
12061205
(_, &TraitBoundModifier::MaybeConst(span))
12071206
if let Some(reason) = &self.disallow_tilde_const =>
@@ -1224,16 +1223,16 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
12241223
}
12251224
DisallowTildeConstContext::Item => errors::TildeConstReason::Item,
12261225
};
1227-
self.err_handler().emit_err(errors::TildeConstDisallowed { span, reason });
1226+
self.dcx().emit_err(errors::TildeConstDisallowed { span, reason });
12281227
}
12291228
(_, TraitBoundModifier::MaybeConstMaybe) => {
1230-
self.err_handler().emit_err(errors::OptionalConstExclusive {
1229+
self.dcx().emit_err(errors::OptionalConstExclusive {
12311230
span: bound.span(),
12321231
modifier: "?",
12331232
});
12341233
}
12351234
(_, TraitBoundModifier::MaybeConstNegative) => {
1236-
self.err_handler().emit_err(errors::OptionalConstExclusive {
1235+
self.dcx().emit_err(errors::OptionalConstExclusive {
12371236
span: bound.span(),
12381237
modifier: "!",
12391238
});
@@ -1249,7 +1248,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
12491248
{
12501249
for arg in &args.args {
12511250
if let ast::AngleBracketedArg::Constraint(constraint) = arg {
1252-
self.err_handler()
1251+
self.dcx()
12531252
.emit_err(errors::ConstraintOnNegativeBound { span: constraint.span });
12541253
}
12551254
}
@@ -1281,7 +1280,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
12811280
| CoroutineKind::AsyncGen { span: aspan, .. } => aspan,
12821281
};
12831282
// FIXME(gen_blocks): Report a different error for `const gen`
1284-
self.err_handler().emit_err(errors::ConstAndAsync {
1283+
self.dcx().emit_err(errors::ConstAndAsync {
12851284
spans: vec![cspan, aspan],
12861285
cspan,
12871286
aspan,
@@ -1321,10 +1320,8 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
13211320
}
13221321
} else {
13231322
match ctxt {
1324-
FnCtxt::Foreign => {
1325-
self.err_handler().emit_err(errors::PatternInForeign { span })
1326-
}
1327-
_ => self.err_handler().emit_err(errors::PatternInBodiless { span }),
1323+
FnCtxt::Foreign => self.dcx().emit_err(errors::PatternInForeign { span }),
1324+
_ => self.dcx().emit_err(errors::PatternInBodiless { span }),
13281325
};
13291326
}
13301327
});
@@ -1523,7 +1520,7 @@ fn deny_equality_constraints(
15231520
}
15241521
}
15251522
}
1526-
this.err_handler().emit_err(err);
1523+
this.dcx().emit_err(err);
15271524
}
15281525

15291526
pub fn check_crate(

‎compiler/rustc_ast_passes/src/feature_gate.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -102,7 +102,7 @@ impl<'a> PostExpansionVisitor<'a> {
102102
}
103103
Err(abi::AbiDisabled::Unrecognized) => {
104104
if self.sess.opts.pretty.map_or(true, |ppm| ppm.needs_hir()) {
105-
self.sess.diagnostic().span_delayed_bug(
105+
self.sess.dcx().span_delayed_bug(
106106
span,
107107
format!(
108108
"unrecognized ABI not caught in lowering: {}",
@@ -654,7 +654,7 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
654654
if all_stable {
655655
err.sugg = Some(attr.span);
656656
}
657-
sess.diagnostic().emit_err(err);
657+
sess.dcx().emit_err(err);
658658
}
659659
}
660660
}

0 commit comments

Comments
 (0)