Commit dd104ef16315e2387fe94e8c43eb5a66e3dbd660 | rust

compiler/rustc_ast_lowering/src/lib.rs+2-2

...	...	@@ -50,7 +50,7 @@ use rustc_data_structures::fx::FxIndexSet;
50	50	use rustc_data_structures::sorted_map::SortedMap;
51	51	use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
52	52	use rustc_data_structures::sync::Lrc;
53		use rustc_errors::{DiagArgFromDisplay, DiagCtxt, StashKey};
	53	use rustc_errors::{DiagArgFromDisplay, DiagCtxtHandle, StashKey};
54	54	use rustc_hir::def::{DefKind, LifetimeRes, Namespace, PartialRes, PerNS, Res};
55	55	use rustc_hir::def_id::{LocalDefId, LocalDefIdMap, CRATE_DEF_ID, LOCAL_CRATE};
56	56	use rustc_hir::{self as hir};
...	...	@@ -188,7 +188,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
188	188	}
189	189	}
190	190
191		pub(crate) fn dcx(&self) -> &'hir DiagCtxt {
	191	pub(crate) fn dcx(&self) -> DiagCtxtHandle<'hir> {
192	192	self.tcx.dcx()
193	193	}
194	194	}

compiler/rustc_ast_passes/src/ast_validation.rs+3-6

...	...	@@ -12,6 +12,7 @@ use rustc_ast::visit::{walk_list, AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor}
12	12	use rustc_ast::*;
13	13	use rustc_ast_pretty::pprust::{self, State};
14	14	use rustc_data_structures::fx::FxIndexMap;
	15	use rustc_errors::DiagCtxtHandle;
15	16	use rustc_feature::Features;
16	17	use rustc_parse::validate_attr;
17	18	use rustc_session::lint::builtin::{
...	...	@@ -269,7 +270,7 @@ impl<'a> AstValidator<'a> {
269	270	}
270	271	}
271	272
272		fn dcx(&self) -> &rustc_errors::DiagCtxt {
	273	fn dcx(&self) -> DiagCtxtHandle<'a> {
273	274	self.session.dcx()
274	275	}
275	276
...	...	@@ -809,11 +810,7 @@ impl<'a> AstValidator<'a> {
809	810
810	811	/// Checks that generic parameters are in the correct order,
811	812	/// which is lifetimes, then types and then consts. (`<'a, T, const N: usize>`)
812		fn validate_generic_param_order(
813		dcx: &rustc_errors::DiagCtxt,
814		generics: &[GenericParam],
815		span: Span,
816		) {
	813	fn validate_generic_param_order(dcx: DiagCtxtHandle<'_>, generics: &[GenericParam], span: Span) {
817	814	let mut max_param: Option<ParamKindOrd> = None;
818	815	let mut out_of_order = FxIndexMap::default();
819	816	let mut param_idents = Vec::with_capacity(generics.len());

compiler/rustc_ast_passes/src/show_span.rs+3-2

...	...	@@ -8,6 +8,7 @@ use std::str::FromStr;
8	8	use rustc_ast as ast;
9	9	use rustc_ast::visit;
10	10	use rustc_ast::visit::Visitor;
	11	use rustc_errors::DiagCtxtHandle;
11	12
12	13	use crate::errors;
13	14
...	...	@@ -31,7 +32,7 @@ impl FromStr for Mode {
31	32	}
32	33
33	34	struct ShowSpanVisitor<'a> {
34		dcx: &'a rustc_errors::DiagCtxt,
	35	dcx: DiagCtxtHandle<'a>,
35	36	mode: Mode,
36	37	}
37	38
...	...	@@ -58,7 +59,7 @@ impl<'a> Visitor<'a> for ShowSpanVisitor<'a> {
58	59	}
59	60	}
60	61
61		pub fn run(dcx: &rustc_errors::DiagCtxt, mode: &str, krate: &ast::Crate) {
	62	pub fn run(dcx: DiagCtxtHandle<'_>, mode: &str, krate: &ast::Crate) {
62	63	let Ok(mode) = mode.parse() else {
63	64	return;
64	65	};

compiler/rustc_attr/src/builtin.rs+1-1

...	...	@@ -596,7 +596,7 @@ pub fn eval_condition(
596	596	features: Option<&Features>,
597	597	eval: &mut impl FnMut(Condition) -> bool,
598	598	) -> bool {
599		let dcx = &sess.psess.dcx;
	599	let dcx = sess.dcx();
600	600	match &cfg.kind {
601	601	ast::MetaItemKind::List(mis) if cfg.name_or_empty() == sym::version => {
602	602	try_gate_cfg(sym::version, cfg.span, sess, features);

compiler/rustc_attr/src/session_diagnostics.rs+4-3

...	...	@@ -1,7 +1,8 @@
1	1	use std::num::IntErrorKind;
2	2
3	3	use rustc_ast as ast;
4		use rustc_errors::{codes::*, Applicability, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level};
	4	use rustc_errors::DiagCtxtHandle;
	5	use rustc_errors::{codes::*, Applicability, Diag, Diagnostic, EmissionGuarantee, Level};
5	6	use rustc_macros::{Diagnostic, Subdiagnostic};
6	7	use rustc_span::{Span, Symbol};
7	8
...	...	@@ -49,7 +50,7 @@ pub(crate) struct UnknownMetaItem<'a> {
49	50
50	51	// Manual implementation to be able to format `expected` items correctly.
51	52	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for UnknownMetaItem<'_> {
52		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	53	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
53	54	let expected = self.expected.iter().map(\|name\| format!("`{name}`")).collect::<Vec<_>>();
54	55	Diag::new(dcx, level, fluent::attr_unknown_meta_item)
55	56	.with_span(self.span)
...	...	@@ -202,7 +203,7 @@ pub(crate) struct UnsupportedLiteral {
202	203	}
203	204
204	205	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for UnsupportedLiteral {
205		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	206	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
206	207	let mut diag = Diag::new(
207	208	dcx,
208	209	level,

compiler/rustc_borrowck/src/borrowck_errors.rs+2-2

...	...	@@ -1,13 +1,13 @@
1	1	#![allow(rustc::diagnostic_outside_of_impl)]
2	2	#![allow(rustc::untranslatable_diagnostic)]
3	3
4		use rustc_errors::{codes::*, struct_span_code_err, Diag, DiagCtxt};
	4	use rustc_errors::{codes::*, struct_span_code_err, Diag, DiagCtxtHandle};
5	5	use rustc_middle::span_bug;
6	6	use rustc_middle::ty::{self, Ty, TyCtxt};
7	7	use rustc_span::Span;
8	8
9	9	impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
10		pub fn dcx(&self) -> &'tcx DiagCtxt {
	10	pub fn dcx(&self) -> DiagCtxtHandle<'tcx> {
11	11	self.infcx.dcx()
12	12	}
13	13

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs+58-88

...	...	@@ -228,7 +228,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
228	228	seen_spans.insert(move_span);
229	229	}
230	230
231		use_spans.var_path_only_subdiag(self.dcx(), &mut err, desired_action);
	231	use_spans.var_path_only_subdiag(&mut err, desired_action);
232	232
233	233	if !is_loop_move {
234	234	err.span_label(
...	...	@@ -303,24 +303,18 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
303	303	if needs_note {
304	304	if let Some(local) = place.as_local() {
305	305	let span = self.body.local_decls[local].source_info.span;
306		err.subdiagnostic(
307		self.dcx(),
308		crate::session_diagnostics::TypeNoCopy::Label {
309		is_partial_move,
310		ty,
311		place: &note_msg,
312		span,
313		},
314		);
	306	err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
	307	is_partial_move,
	308	ty,
	309	place: &note_msg,
	310	span,
	311	});
315	312	} else {
316		err.subdiagnostic(
317		self.dcx(),
318		crate::session_diagnostics::TypeNoCopy::Note {
319		is_partial_move,
320		ty,
321		place: &note_msg,
322		},
323		);
	313	err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Note {
	314	is_partial_move,
	315	ty,
	316	place: &note_msg,
	317	});
324	318	};
325	319	}
326	320
...	...	@@ -597,7 +591,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
597	591	E0381,
598	592	"{used} binding {desc}{isnt_initialized}"
599	593	);
600		use_spans.var_path_only_subdiag(self.dcx(), &mut err, desired_action);
	594	use_spans.var_path_only_subdiag(&mut err, desired_action);
601	595
602	596	if let InitializationRequiringAction::PartialAssignment
603	597	\| InitializationRequiringAction::Assignment = desired_action
...	...	@@ -996,7 +990,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
996	990	&self,
997	991	err: &mut Diag<'_>,
998	992	ty: Ty<'tcx>,
999		expr: &'cx hir::Expr<'cx>,
	993	expr: &hir::Expr<'_>,
1000	994	) {
1001	995	let typeck_results = self.infcx.tcx.typeck(self.mir_def_id());
1002	996	let hir::ExprKind::Struct(struct_qpath, fields, Some(base)) = expr.kind else { return };
...	...	@@ -1084,8 +1078,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1084	1078	&self,
1085	1079	err: &mut Diag<'_>,
1086	1080	ty: Ty<'tcx>,
1087		mut expr: &'cx hir::Expr<'cx>,
1088		mut other_expr: Option<&'cx hir::Expr<'cx>>,
	1081	mut expr: &'tcx hir::Expr<'tcx>,
	1082	mut other_expr: Option<&'tcx hir::Expr<'tcx>>,
1089	1083	use_spans: Option<UseSpans<'tcx>>,
1090	1084	) {
1091	1085	if let hir::ExprKind::Struct(_, _, Some(_)) = expr.kind {
...	...	@@ -1410,13 +1404,9 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1410	1404	&value_msg,
1411	1405	);
1412	1406
1413		borrow_spans.var_path_only_subdiag(
1414		self.dcx(),
1415		&mut err,
1416		crate::InitializationRequiringAction::Borrow,
1417		);
	1407	borrow_spans.var_path_only_subdiag(&mut err, crate::InitializationRequiringAction::Borrow);
1418	1408
1419		move_spans.var_subdiag(self.dcx(), &mut err, None, \|kind, var_span\| {
	1409	move_spans.var_subdiag(&mut err, None, \|kind, var_span\| {
1420	1410	use crate::session_diagnostics::CaptureVarCause::*;
1421	1411	match kind {
1422	1412	hir::ClosureKind::Coroutine(_) => MoveUseInCoroutine { var_span },
...	...	@@ -1468,7 +1458,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1468	1458	borrow_span,
1469	1459	&self.describe_any_place(borrow.borrowed_place.as_ref()),
1470	1460	);
1471		borrow_spans.var_subdiag(self.dcx(), &mut err, Some(borrow.kind), \|kind, var_span\| {
	1461	borrow_spans.var_subdiag(&mut err, Some(borrow.kind), \|kind, var_span\| {
1472	1462	use crate::session_diagnostics::CaptureVarCause::*;
1473	1463	let place = &borrow.borrowed_place;
1474	1464	let desc_place = self.describe_any_place(place.as_ref());
...	...	@@ -1633,7 +1623,6 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1633	1623	"mutably borrow",
1634	1624	);
1635	1625	borrow_spans.var_subdiag(
1636		self.dcx(),
1637	1626	&mut err,
1638	1627	Some(BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture }),
1639	1628	\|kind, var_span\| {
...	...	@@ -1730,64 +1719,45 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1730	1719	};
1731	1720
1732	1721	if issued_spans == borrow_spans {
1733		borrow_spans.var_subdiag(
1734		self.dcx(),
1735		&mut err,
1736		Some(gen_borrow_kind),
1737		\|kind, var_span\| {
1738		use crate::session_diagnostics::CaptureVarCause::*;
1739		match kind {
1740		hir::ClosureKind::Coroutine(_) => BorrowUsePlaceCoroutine {
1741		place: desc_place,
1742		var_span,
1743		is_single_var: false,
1744		},
1745		hir::ClosureKind::Closure \| hir::ClosureKind::CoroutineClosure(_) => {
1746		BorrowUsePlaceClosure {
1747		place: desc_place,
1748		var_span,
1749		is_single_var: false,
1750		}
1751		}
	1722	borrow_spans.var_subdiag(&mut err, Some(gen_borrow_kind), \|kind, var_span\| {
	1723	use crate::session_diagnostics::CaptureVarCause::*;
	1724	match kind {
	1725	hir::ClosureKind::Coroutine(_) => BorrowUsePlaceCoroutine {
	1726	place: desc_place,
	1727	var_span,
	1728	is_single_var: false,
	1729	},
	1730	hir::ClosureKind::Closure \| hir::ClosureKind::CoroutineClosure(_) => {
	1731	BorrowUsePlaceClosure { place: desc_place, var_span, is_single_var: false }
1752	1732	}
1753		},
1754		);
	1733	}
	1734	});
1755	1735	} else {
1756		issued_spans.var_subdiag(
1757		self.dcx(),
1758		&mut err,
1759		Some(issued_borrow.kind),
1760		\|kind, var_span\| {
1761		use crate::session_diagnostics::CaptureVarCause::*;
1762		let borrow_place = &issued_borrow.borrowed_place;
1763		let borrow_place_desc = self.describe_any_place(borrow_place.as_ref());
1764		match kind {
1765		hir::ClosureKind::Coroutine(_) => {
1766		FirstBorrowUsePlaceCoroutine { place: borrow_place_desc, var_span }
1767		}
1768		hir::ClosureKind::Closure \| hir::ClosureKind::CoroutineClosure(_) => {
1769		FirstBorrowUsePlaceClosure { place: borrow_place_desc, var_span }
1770		}
	1736	issued_spans.var_subdiag(&mut err, Some(issued_borrow.kind), \|kind, var_span\| {
	1737	use crate::session_diagnostics::CaptureVarCause::*;
	1738	let borrow_place = &issued_borrow.borrowed_place;
	1739	let borrow_place_desc = self.describe_any_place(borrow_place.as_ref());
	1740	match kind {
	1741	hir::ClosureKind::Coroutine(_) => {
	1742	FirstBorrowUsePlaceCoroutine { place: borrow_place_desc, var_span }
1771	1743	}
1772		},
1773		);
	1744	hir::ClosureKind::Closure \| hir::ClosureKind::CoroutineClosure(_) => {
	1745	FirstBorrowUsePlaceClosure { place: borrow_place_desc, var_span }
	1746	}
	1747	}
	1748	});
1774	1749
1775		borrow_spans.var_subdiag(
1776		self.dcx(),
1777		&mut err,
1778		Some(gen_borrow_kind),
1779		\|kind, var_span\| {
1780		use crate::session_diagnostics::CaptureVarCause::*;
1781		match kind {
1782		hir::ClosureKind::Coroutine(_) => {
1783		SecondBorrowUsePlaceCoroutine { place: desc_place, var_span }
1784		}
1785		hir::ClosureKind::Closure \| hir::ClosureKind::CoroutineClosure(_) => {
1786		SecondBorrowUsePlaceClosure { place: desc_place, var_span }
1787		}
	1750	borrow_spans.var_subdiag(&mut err, Some(gen_borrow_kind), \|kind, var_span\| {
	1751	use crate::session_diagnostics::CaptureVarCause::*;
	1752	match kind {
	1753	hir::ClosureKind::Coroutine(_) => {
	1754	SecondBorrowUsePlaceCoroutine { place: desc_place, var_span }
1788	1755	}
1789		},
1790		);
	1756	hir::ClosureKind::Closure \| hir::ClosureKind::CoroutineClosure(_) => {
	1757	SecondBorrowUsePlaceClosure { place: desc_place, var_span }
	1758	}
	1759	}
	1760	});
1791	1761	}
1792	1762
1793	1763	if union_type_name != "" {
...	...	@@ -2016,7 +1986,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
2016	1986	);
2017	1987	}
2018	1988
2019		pub(crate) fn find_expr(&self, span: Span) -> Option<&hir::Expr<'_>> {
	1989	pub(crate) fn find_expr(&self, span: Span) -> Option<&'tcx hir::Expr<'tcx>> {
2020	1990	let tcx = self.infcx.tcx;
2021	1991	let body_id = tcx.hir_node(self.mir_hir_id()).body_id()?;
2022	1992	let mut expr_finder = FindExprBySpan::new(span, tcx);
...	...	@@ -2961,7 +2931,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
2961	2931	err.span_label(borrow_span, "borrowed value does not live long enough");
2962	2932	err.span_label(drop_span, format!("`{name}` dropped here while still borrowed"));
2963	2933
2964		borrow_spans.args_subdiag(self.dcx(), &mut err, \|args_span\| {
	2934	borrow_spans.args_subdiag(&mut err, \|args_span\| {
2965	2935	crate::session_diagnostics::CaptureArgLabel::Capture {
2966	2936	is_within: borrow_spans.for_coroutine(),
2967	2937	args_span,
...	...	@@ -3219,7 +3189,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
3219	3189	None,
3220	3190	);
3221	3191
3222		borrow_spans.args_subdiag(self.dcx(), &mut err, \|args_span\| {
	3192	borrow_spans.args_subdiag(&mut err, \|args_span\| {
3223	3193	crate::session_diagnostics::CaptureArgLabel::Capture {
3224	3194	is_within: borrow_spans.for_coroutine(),
3225	3195	args_span,
...	...	@@ -3680,7 +3650,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
3680	3650	"assign",
3681	3651	);
3682	3652
3683		loan_spans.var_subdiag(self.dcx(), &mut err, Some(loan.kind), \|kind, var_span\| {
	3653	loan_spans.var_subdiag(&mut err, Some(loan.kind), \|kind, var_span\| {
3684	3654	use crate::session_diagnostics::CaptureVarCause::*;
3685	3655	match kind {
3686	3656	hir::ClosureKind::Coroutine(_) => BorrowUseInCoroutine { var_span },
...	...	@@ -3698,7 +3668,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
3698	3668
3699	3669	let mut err = self.cannot_assign_to_borrowed(span, loan_span, &descr_place);
3700	3670
3701		loan_spans.var_subdiag(self.dcx(), &mut err, Some(loan.kind), \|kind, var_span\| {
	3671	loan_spans.var_subdiag(&mut err, Some(loan.kind), \|kind, var_span\| {
3702	3672	use crate::session_diagnostics::CaptureVarCause::*;
3703	3673	match kind {
3704	3674	hir::ClosureKind::Coroutine(_) => BorrowUseInCoroutine { var_span },

compiler/rustc_borrowck/src/diagnostics/mod.rs+89-145

...	...	@@ -4,8 +4,8 @@ use crate::session_diagnostics::{
4	4	CaptureArgLabel, CaptureReasonLabel, CaptureReasonNote, CaptureReasonSuggest, CaptureVarCause,
5	5	CaptureVarKind, CaptureVarPathUseCause, OnClosureNote,
6	6	};
	7	use rustc_errors::MultiSpan;
7	8	use rustc_errors::{Applicability, Diag};
8		use rustc_errors::{DiagCtxt, MultiSpan};
9	9	use rustc_hir::def::{CtorKind, Namespace};
10	10	use rustc_hir::CoroutineKind;
11	11	use rustc_hir::{self as hir, LangItem};
...	...	@@ -130,16 +130,13 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
130	130	if let ty::Closure(did, _) = self.body.local_decls[closure].ty.kind() {
131	131	let did = did.expect_local();
132	132	if let Some((span, hir_place)) = self.infcx.tcx.closure_kind_origin(did) {
133		diag.subdiagnostic(
134		self.dcx(),
135		OnClosureNote::InvokedTwice {
136		place_name: &ty::place_to_string_for_capture(
137		self.infcx.tcx,
138		hir_place,
139		),
140		span: *span,
141		},
142		);
	133	diag.subdiagnostic(OnClosureNote::InvokedTwice {
	134	place_name: &ty::place_to_string_for_capture(
	135	self.infcx.tcx,
	136	hir_place,
	137	),
	138	span: *span,
	139	});
143	140	return true;
144	141	}
145	142	}
...	...	@@ -152,13 +149,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
152	149	if let ty::Closure(did, _) = self.body.local_decls[target].ty.kind() {
153	150	let did = did.expect_local();
154	151	if let Some((span, hir_place)) = self.infcx.tcx.closure_kind_origin(did) {
155		diag.subdiagnostic(
156		self.dcx(),
157		OnClosureNote::MovedTwice {
158		place_name: &ty::place_to_string_for_capture(self.infcx.tcx, hir_place),
159		span: *span,
160		},
161		);
	152	diag.subdiagnostic(OnClosureNote::MovedTwice {
	153	place_name: &ty::place_to_string_for_capture(self.infcx.tcx, hir_place),
	154	span: *span,
	155	});
162	156	return true;
163	157	}
164	158	}
...	...	@@ -591,14 +585,9 @@ impl UseSpans<'_> {
591	585
592	586	/// Add a span label to the arguments of the closure, if it exists.
593	587	#[allow(rustc::diagnostic_outside_of_impl)]
594		pub(super) fn args_subdiag(
595		self,
596		dcx: &DiagCtxt,
597		err: &mut Diag<'_>,
598		f: impl FnOnce(Span) -> CaptureArgLabel,
599		) {
	588	pub(super) fn args_subdiag(self, err: &mut Diag<'_>, f: impl FnOnce(Span) -> CaptureArgLabel) {
600	589	if let UseSpans::ClosureUse { args_span, .. } = self {
601		err.subdiagnostic(dcx, f(args_span));
	590	err.subdiagnostic(f(args_span));
602	591	}
603	592	}
604	593
...	...	@@ -607,7 +596,6 @@ impl UseSpans<'_> {
607	596	#[allow(rustc::diagnostic_outside_of_impl)]
608	597	pub(super) fn var_path_only_subdiag(
609	598	self,
610		dcx: &DiagCtxt,
611	599	err: &mut Diag<'_>,
612	600	action: crate::InitializationRequiringAction,
613	601	) {
...	...	@@ -616,26 +604,20 @@ impl UseSpans<'_> {
616	604	if let UseSpans::ClosureUse { closure_kind, path_span, .. } = self {
617	605	match closure_kind {
618	606	hir::ClosureKind::Coroutine(_) => {
619		err.subdiagnostic(
620		dcx,
621		match action {
622		Borrow => BorrowInCoroutine { path_span },
623		MatchOn \| Use => UseInCoroutine { path_span },
624		Assignment => AssignInCoroutine { path_span },
625		PartialAssignment => AssignPartInCoroutine { path_span },
626		},
627		);
	607	err.subdiagnostic(match action {
	608	Borrow => BorrowInCoroutine { path_span },
	609	MatchOn \| Use => UseInCoroutine { path_span },
	610	Assignment => AssignInCoroutine { path_span },
	611	PartialAssignment => AssignPartInCoroutine { path_span },
	612	});
628	613	}
629	614	hir::ClosureKind::Closure \| hir::ClosureKind::CoroutineClosure(_) => {
630		err.subdiagnostic(
631		dcx,
632		match action {
633		Borrow => BorrowInClosure { path_span },
634		MatchOn \| Use => UseInClosure { path_span },
635		Assignment => AssignInClosure { path_span },
636		PartialAssignment => AssignPartInClosure { path_span },
637		},
638		);
	615	err.subdiagnostic(match action {
	616	Borrow => BorrowInClosure { path_span },
	617	MatchOn \| Use => UseInClosure { path_span },
	618	Assignment => AssignInClosure { path_span },
	619	PartialAssignment => AssignPartInClosure { path_span },
	620	});
639	621	}
640	622	}
641	623	}
...	...	@@ -645,32 +627,28 @@ impl UseSpans<'_> {
645	627	#[allow(rustc::diagnostic_outside_of_impl)]
646	628	pub(super) fn var_subdiag(
647	629	self,
648		dcx: &DiagCtxt,
649	630	err: &mut Diag<'_>,
650	631	kind: Option<rustc_middle::mir::BorrowKind>,
651	632	f: impl FnOnce(hir::ClosureKind, Span) -> CaptureVarCause,
652	633	) {
653	634	if let UseSpans::ClosureUse { closure_kind, capture_kind_span, path_span, .. } = self {
654	635	if capture_kind_span != path_span {
655		err.subdiagnostic(
656		dcx,
657		match kind {
658		Some(kd) => match kd {
659		rustc_middle::mir::BorrowKind::Shared
660		\| rustc_middle::mir::BorrowKind::Fake(_) => {
661		CaptureVarKind::Immut { kind_span: capture_kind_span }
662		}
	636	err.subdiagnostic(match kind {
	637	Some(kd) => match kd {
	638	rustc_middle::mir::BorrowKind::Shared
	639	\| rustc_middle::mir::BorrowKind::Fake(_) => {
	640	CaptureVarKind::Immut { kind_span: capture_kind_span }
	641	}
663	642
664		rustc_middle::mir::BorrowKind::Mut { .. } => {
665		CaptureVarKind::Mut { kind_span: capture_kind_span }
666		}
667		},
668		None => CaptureVarKind::Move { kind_span: capture_kind_span },
	643	rustc_middle::mir::BorrowKind::Mut { .. } => {
	644	CaptureVarKind::Mut { kind_span: capture_kind_span }
	645	}
669	646	},
670		);
	647	None => CaptureVarKind::Move { kind_span: capture_kind_span },
	648	});
671	649	};
672	650	let diag = f(closure_kind, path_span);
673		err.subdiagnostic(dcx, diag);
	651	err.subdiagnostic(diag);
674	652	}
675	653	}
676	654
...	...	@@ -1042,15 +1020,12 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1042	1020	CallKind::FnCall { fn_trait_id, self_ty }
1043	1021	if self.infcx.tcx.is_lang_item(fn_trait_id, LangItem::FnOnce) =>
1044	1022	{
1045		err.subdiagnostic(
1046		self.dcx(),
1047		CaptureReasonLabel::Call {
1048		fn_call_span,
1049		place_name: &place_name,
1050		is_partial,
1051		is_loop_message,
1052		},
1053		);
	1023	err.subdiagnostic(CaptureReasonLabel::Call {
	1024	fn_call_span,
	1025	place_name: &place_name,
	1026	is_partial,
	1027	is_loop_message,
	1028	});
1054	1029	// Check if the move occurs on a value because of a call on a closure that comes
1055	1030	// from a type parameter `F: FnOnce()`. If so, we provide a targeted `note`:
1056	1031	// ```
...	...	@@ -1119,27 +1094,20 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1119	1094	);
1120	1095	err.span_note(span, fluent::borrowck_moved_a_fn_once_in_call_call);
1121	1096	} else {
1122		err.subdiagnostic(
1123		self.dcx(),
1124		CaptureReasonNote::FnOnceMoveInCall { var_span },
1125		);
	1097	err.subdiagnostic(CaptureReasonNote::FnOnceMoveInCall { var_span });
1126	1098	}
1127	1099	}
1128	1100	CallKind::Operator { self_arg, trait_id, .. } => {
1129	1101	let self_arg = self_arg.unwrap();
1130		err.subdiagnostic(
1131		self.dcx(),
1132		CaptureReasonLabel::OperatorUse {
1133		fn_call_span,
1134		place_name: &place_name,
1135		is_partial,
1136		is_loop_message,
1137		},
1138		);
	1102	err.subdiagnostic(CaptureReasonLabel::OperatorUse {
	1103	fn_call_span,
	1104	place_name: &place_name,
	1105	is_partial,
	1106	is_loop_message,
	1107	});
1139	1108	if self.fn_self_span_reported.insert(fn_span) {
1140	1109	let lang = self.infcx.tcx.lang_items();
1141	1110	err.subdiagnostic(
1142		self.dcx(),
1143	1111	if [lang.not_trait(), lang.deref_trait(), lang.neg_trait()]
1144	1112	.contains(&Some(trait_id))
1145	1113	{
...	...	@@ -1164,14 +1132,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1164	1132	);
1165	1133
1166	1134	let func = tcx.def_path_str(method_did);
1167		err.subdiagnostic(
1168		self.dcx(),
1169		CaptureReasonNote::FuncTakeSelf {
1170		func,
1171		place_name: place_name.clone(),
1172		span: self_arg.span,
1173		},
1174		);
	1135	err.subdiagnostic(CaptureReasonNote::FuncTakeSelf {
	1136	func,
	1137	place_name: place_name.clone(),
	1138	span: self_arg.span,
	1139	});
1175	1140	}
1176	1141	let parent_did = tcx.parent(method_did);
1177	1142	let parent_self_ty =
...	...	@@ -1185,10 +1150,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1185	1150	matches!(tcx.get_diagnostic_name(def_id), Some(sym::Option \| sym::Result))
1186	1151	});
1187	1152	if is_option_or_result && maybe_reinitialized_locations_is_empty {
1188		err.subdiagnostic(
1189		self.dcx(),
1190		CaptureReasonLabel::BorrowContent { var_span },
1191		);
	1153	err.subdiagnostic(CaptureReasonLabel::BorrowContent { var_span });
1192	1154	}
1193	1155	if let Some((CallDesugaringKind::ForLoopIntoIter, _)) = desugaring {
1194	1156	let ty = moved_place.ty(self.body, tcx).ty;
...	...	@@ -1202,24 +1164,18 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1202	1164	_ => false,
1203	1165	};
1204	1166	if suggest {
1205		err.subdiagnostic(
1206		self.dcx(),
1207		CaptureReasonSuggest::IterateSlice {
1208		ty,
1209		span: move_span.shrink_to_lo(),
1210		},
1211		);
	1167	err.subdiagnostic(CaptureReasonSuggest::IterateSlice {
	1168	ty,
	1169	span: move_span.shrink_to_lo(),
	1170	});
1212	1171	}
1213	1172
1214		err.subdiagnostic(
1215		self.dcx(),
1216		CaptureReasonLabel::ImplicitCall {
1217		fn_call_span,
1218		place_name: &place_name,
1219		is_partial,
1220		is_loop_message,
1221		},
1222		);
	1173	err.subdiagnostic(CaptureReasonLabel::ImplicitCall {
	1174	fn_call_span,
	1175	place_name: &place_name,
	1176	is_partial,
	1177	is_loop_message,
	1178	});
1223	1179	// If the moved place was a `&mut` ref, then we can
1224	1180	// suggest to reborrow it where it was moved, so it
1225	1181	// will still be valid by the time we get to the usage.
...	...	@@ -1243,25 +1199,19 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1243	1199	}
1244	1200	} else {
1245	1201	if let Some((CallDesugaringKind::Await, _)) = desugaring {
1246		err.subdiagnostic(
1247		self.dcx(),
1248		CaptureReasonLabel::Await {
1249		fn_call_span,
1250		place_name: &place_name,
1251		is_partial,
1252		is_loop_message,
1253		},
1254		);
	1202	err.subdiagnostic(CaptureReasonLabel::Await {
	1203	fn_call_span,
	1204	place_name: &place_name,
	1205	is_partial,
	1206	is_loop_message,
	1207	});
1255	1208	} else {
1256		err.subdiagnostic(
1257		self.dcx(),
1258		CaptureReasonLabel::MethodCall {
1259		fn_call_span,
1260		place_name: &place_name,
1261		is_partial,
1262		is_loop_message,
1263		},
1264		);
	1209	err.subdiagnostic(CaptureReasonLabel::MethodCall {
	1210	fn_call_span,
	1211	place_name: &place_name,
	1212	is_partial,
	1213	is_loop_message,
	1214	});
1265	1215	}
1266	1216	// Erase and shadow everything that could be passed to the new infcx.
1267	1217	let ty = moved_place.ty(self.body, tcx).ty;
...	...	@@ -1276,12 +1226,9 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1276	1226	)
1277	1227	&& self.infcx.can_eq(self.param_env, ty, self_ty)
1278	1228	{
1279		err.subdiagnostic(
1280		self.dcx(),
1281		CaptureReasonSuggest::FreshReborrow {
1282		span: move_span.shrink_to_hi(),
1283		},
1284		);
	1229	err.subdiagnostic(CaptureReasonSuggest::FreshReborrow {
	1230	span: move_span.shrink_to_hi(),
	1231	});
1285	1232	has_sugg = true;
1286	1233	}
1287	1234	if let Some(clone_trait) = tcx.lang_items().clone_trait() {
...	...	@@ -1368,20 +1315,17 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
1368	1315	}
1369	1316	} else {
1370	1317	if move_span != span \|\| is_loop_message {
1371		err.subdiagnostic(
1372		self.dcx(),
1373		CaptureReasonLabel::MovedHere {
1374		move_span,
1375		is_partial,
1376		is_move_msg,
1377		is_loop_message,
1378		},
1379		);
	1318	err.subdiagnostic(CaptureReasonLabel::MovedHere {
	1319	move_span,
	1320	is_partial,
	1321	is_move_msg,
	1322	is_loop_message,
	1323	});
1380	1324	}
1381	1325	// If the move error occurs due to a loop, don't show
1382	1326	// another message for the same span
1383	1327	if !is_loop_message {
1384		move_spans.var_subdiag(self.dcx(), err, None, \|kind, var_span\| match kind {
	1328	move_spans.var_subdiag(err, None, \|kind, var_span\| match kind {
1385	1329	hir::ClosureKind::Coroutine(_) => {
1386	1330	CaptureVarCause::PartialMoveUseInCoroutine { var_span, is_partial }
1387	1331	}

compiler/rustc_borrowck/src/diagnostics/move_errors.rs+19-28

...	...	@@ -579,15 +579,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
579	579	self.suggest_cloning(err, place_ty, expr, self.find_expr(other_span), None);
580	580	}
581	581
582		err.subdiagnostic(
583		self.dcx(),
584		crate::session_diagnostics::TypeNoCopy::Label {
585		is_partial_move: false,
586		ty: place_ty,
587		place: &place_desc,
588		span,
589		},
590		);
	582	err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
	583	is_partial_move: false,
	584	ty: place_ty,
	585	place: &place_desc,
	586	span,
	587	});
591	588	} else {
592	589	binds_to.sort();
593	590	binds_to.dedup();
...	...	@@ -620,17 +617,14 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
620	617	);
621	618	}
622	619
623		err.subdiagnostic(
624		self.dcx(),
625		crate::session_diagnostics::TypeNoCopy::Label {
626		is_partial_move: false,
627		ty: place_ty,
628		place: &place_desc,
629		span: use_span,
630		},
631		);
	620	err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
	621	is_partial_move: false,
	622	ty: place_ty,
	623	place: &place_desc,
	624	span: use_span,
	625	});
632	626
633		use_spans.args_subdiag(self.dcx(), err, \|args_span\| {
	627	use_spans.args_subdiag(err, \|args_span\| {
634	628	crate::session_diagnostics::CaptureArgLabel::MoveOutPlace {
635	629	place: place_desc,
636	630	args_span,
...	...	@@ -733,15 +727,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
733	727	self.suggest_cloning(err, bind_to.ty, expr, None, None);
734	728	}
735	729
736		err.subdiagnostic(
737		self.dcx(),
738		crate::session_diagnostics::TypeNoCopy::Label {
739		is_partial_move: false,
740		ty: bind_to.ty,
741		place: place_desc,
742		span: binding_span,
743		},
744		);
	730	err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
	731	is_partial_move: false,
	732	ty: bind_to.ty,
	733	place: place_desc,
	734	span: binding_span,
	735	});
745	736	}
746	737	}
747	738

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs-1

...	...	@@ -230,7 +230,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
230	230	}
231	231	if suggest {
232	232	borrow_spans.var_subdiag(
233		self.dcx(),
234	233	&mut err,
235	234	Some(mir::BorrowKind::Mut { kind: mir::MutBorrowKind::Default }),
236	235	\|_kind, var_span\| {

compiler/rustc_borrowck/src/diagnostics/region_errors.rs+5-5

...	...	@@ -631,13 +631,13 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
631	631	let upvars_map = self.infcx.tcx.upvars_mentioned(def_id).unwrap();
632	632	let upvar_def_span = self.infcx.tcx.hir().span(def_hir);
633	633	let upvar_span = upvars_map.get(&def_hir).unwrap().span;
634		diag.subdiagnostic(self.dcx(), VarHereDenote::Defined { span: upvar_def_span });
635		diag.subdiagnostic(self.dcx(), VarHereDenote::Captured { span: upvar_span });
	634	diag.subdiagnostic(VarHereDenote::Defined { span: upvar_def_span });
	635	diag.subdiagnostic(VarHereDenote::Captured { span: upvar_span });
636	636	}
637	637	}
638	638
639	639	if let Some(fr_span) = self.give_region_a_name(*outlived_fr).unwrap().span() {
640		diag.subdiagnostic(self.dcx(), VarHereDenote::FnMutInferred { span: fr_span });
	640	diag.subdiagnostic(VarHereDenote::FnMutInferred { span: fr_span });
641	641	}
642	642
643	643	self.suggest_move_on_borrowing_closure(&mut diag);
...	...	@@ -810,7 +810,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
810	810	},
811	811	};
812	812
813		diag.subdiagnostic(self.dcx(), err_category);
	813	diag.subdiagnostic(err_category);
814	814
815	815	self.add_static_impl_trait_suggestion(&mut diag, fr, fr_name, outlived_fr);
816	816	self.suggest_adding_lifetime_params(&mut diag, fr, outlived_fr);
...	...	@@ -1008,7 +1008,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
1008	1008	ident.span,
1009	1009	"calling this method introduces the `impl`'s `'static` requirement",
1010	1010	);
1011		err.subdiagnostic(self.dcx(), RequireStaticErr::UsedImpl { multi_span });
	1011	err.subdiagnostic(RequireStaticErr::UsedImpl { multi_span });
1012	1012	err.span_suggestion_verbose(
1013	1013	span.shrink_to_hi(),
1014	1014	"consider relaxing the implicit `'static` requirement",

compiler/rustc_builtin_macros/src/asm.rs+4-4

...	...	@@ -46,7 +46,7 @@ pub fn parse_asm_args<'a>(
46	46	sp: Span,
47	47	is_global_asm: bool,
48	48	) -> PResult<'a, AsmArgs> {
49		let dcx = &p.psess.dcx;
	49	let dcx = p.dcx();
50	50
51	51	if p.token == token::Eof {
52	52	return Err(dcx.create_err(errors::AsmRequiresTemplate { span: sp }));
...	...	@@ -307,7 +307,7 @@ pub fn parse_asm_args<'a>(
307	307	fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
308	308	// Tool-only output
309	309	let full_span = if p.token.kind == token::Comma { span.to(p.token.span) } else { span };
310		p.psess.dcx.emit_err(errors::AsmOptAlreadyprovided { span, symbol, full_span });
	310	p.dcx().emit_err(errors::AsmOptAlreadyprovided { span, symbol, full_span });
311	311	}
312	312
313	313	/// Try to set the provided option in the provided `AsmArgs`.
...	...	@@ -379,7 +379,7 @@ fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a,
379	379	p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
380	380
381	381	if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
382		return Err(p.psess.dcx.create_err(errors::NonABI { span: p.token.span }));
	382	return Err(p.dcx().create_err(errors::NonABI { span: p.token.span }));
383	383	}
384	384
385	385	let mut new_abis = Vec::new();
...	...	@@ -390,7 +390,7 @@ fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a,
390	390	}
391	391	Err(opt_lit) => {
392	392	let span = opt_lit.map_or(p.token.span, \|lit\| lit.span);
393		let mut err = p.psess.dcx.struct_span_err(span, "expected string literal");
	393	let mut err = p.dcx().struct_span_err(span, "expected string literal");
394	394	err.span_label(span, "not a string literal");
395	395	return Err(err);
396	396	}

compiler/rustc_builtin_macros/src/cmdline_attrs.rs+1-1

...	...	@@ -26,7 +26,7 @@ pub fn inject(krate: &mut ast::Crate, psess: &ParseSess, attrs: &[String]) {
26	26	};
27	27	let end_span = parser.token.span;
28	28	if parser.token != token::Eof {
29		psess.dcx.emit_err(errors::InvalidCrateAttr { span: start_span.to(end_span) });
	29	psess.dcx().emit_err(errors::InvalidCrateAttr { span: start_span.to(end_span) });
30	30	continue;
31	31	}
32	32

compiler/rustc_builtin_macros/src/errors.rs+3-3

...	...	@@ -1,5 +1,5 @@
1	1	use rustc_errors::{
2		codes::*, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level, MultiSpan,
	2	codes::*, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, MultiSpan,
3	3	SingleLabelManySpans, SubdiagMessageOp, Subdiagnostic,
4	4	};
5	5	use rustc_macros::{Diagnostic, Subdiagnostic};
...	...	@@ -434,7 +434,7 @@ pub(crate) struct EnvNotDefinedWithUserMessage {
434	434	// Hand-written implementation to support custom user messages.
435	435	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for EnvNotDefinedWithUserMessage {
436	436	#[track_caller]
437		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	437	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
438	438	#[expect(
439	439	rustc::untranslatable_diagnostic,
440	440	reason = "cannot translate user-provided messages"
...	...	@@ -801,7 +801,7 @@ pub(crate) struct AsmClobberNoReg {
801	801	}
802	802
803	803	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for AsmClobberNoReg {
804		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	804	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
805	805	// eager translation as `span_labels` takes `AsRef<str>`
806	806	let lbl1 = dcx.eagerly_translate_to_string(
807	807	crate::fluent_generated::builtin_macros_asm_clobber_abi,

compiler/rustc_builtin_macros/src/proc_macro_harness.rs+3-2

...	...	@@ -3,6 +3,7 @@ use rustc_ast::ptr::P;
3	3	use rustc_ast::visit::{self, Visitor};
4	4	use rustc_ast::{self as ast, attr, NodeId};
5	5	use rustc_ast_pretty::pprust;
	6	use rustc_errors::DiagCtxtHandle;
6	7	use rustc_expand::base::{parse_macro_name_and_helper_attrs, ExtCtxt, ResolverExpand};
7	8	use rustc_expand::expand::{AstFragment, ExpansionConfig};
8	9	use rustc_feature::Features;
...	...	@@ -38,7 +39,7 @@ enum ProcMacro {
38	39	struct CollectProcMacros<'a> {
39	40	macros: Vec<ProcMacro>,
40	41	in_root: bool,
41		dcx: &'a rustc_errors::DiagCtxt,
	42	dcx: DiagCtxtHandle<'a>,
42	43	source_map: &'a SourceMap,
43	44	is_proc_macro_crate: bool,
44	45	is_test_crate: bool,
...	...	@@ -52,7 +53,7 @@ pub fn inject(
52	53	is_proc_macro_crate: bool,
53	54	has_proc_macro_decls: bool,
54	55	is_test_crate: bool,
55		dcx: &rustc_errors::DiagCtxt,
	56	dcx: DiagCtxtHandle<'_>,
56	57	) {
57	58	let ecfg = ExpansionConfig::default("proc_macro".to_string(), features);
58	59	let mut cx = ExtCtxt::new(sess, ecfg, resolver, None);

compiler/rustc_builtin_macros/src/test_harness.rs+2-1

...	...	@@ -6,6 +6,7 @@ use rustc_ast::mut_visit::*;
6	6	use rustc_ast::ptr::P;
7	7	use rustc_ast::visit::{walk_item, Visitor};
8	8	use rustc_ast::{attr, ModKind};
	9	use rustc_errors::DiagCtxtHandle;
9	10	use rustc_expand::base::{ExtCtxt, ResolverExpand};
10	11	use rustc_expand::expand::{AstFragment, ExpansionConfig};
11	12	use rustc_feature::Features;
...	...	@@ -391,7 +392,7 @@ fn get_test_name(i: &ast::Item) -> Option<Symbol> {
391	392	attr::first_attr_value_str_by_name(&i.attrs, sym::rustc_test_marker)
392	393	}
393	394
394		fn get_test_runner(dcx: &rustc_errors::DiagCtxt, krate: &ast::Crate) -> Option<ast::Path> {
	395	fn get_test_runner(dcx: DiagCtxtHandle<'_>, krate: &ast::Crate) -> Option<ast::Path> {
395	396	let test_attr = attr::find_by_name(&krate.attrs, sym::test_runner)?;
396	397	let meta_list = test_attr.meta_item_list()?;
397	398	let span = test_attr.span;

compiler/rustc_codegen_cranelift/src/concurrency_limiter.rs+2-1

...	...	@@ -1,6 +1,7 @@
1	1	use std::sync::{Arc, Condvar, Mutex};
2	2
3	3	use jobserver::HelperThread;
	4	use rustc_errors::DiagCtxtHandle;
4	5	use rustc_session::Session;
5	6
6	7	// FIXME don't panic when a worker thread panics
...	...	@@ -46,7 +47,7 @@ impl ConcurrencyLimiter {
46	47	}
47	48	}
48	49
49		pub(super) fn acquire(&self, dcx: &rustc_errors::DiagCtxt) -> ConcurrencyLimiterToken {
	50	pub(super) fn acquire(&self, dcx: DiagCtxtHandle<'_>) -> ConcurrencyLimiterToken {
50	51	let mut state = self.state.lock().unwrap();
51	52	loop {
52	53	state.assert_invariants();

compiler/rustc_codegen_gcc/src/back/lto.rs+6-5

...	...	@@ -28,7 +28,7 @@ use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput};
28	28	use rustc_codegen_ssa::traits::*;
29	29	use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind};
30	30	use rustc_data_structures::memmap::Mmap;
31		use rustc_errors::{DiagCtxt, FatalError};
	31	use rustc_errors::{DiagCtxtHandle, FatalError};
32	32	use rustc_hir::def_id::LOCAL_CRATE;
33	33	use rustc_middle::dep_graph::WorkProduct;
34	34	use rustc_middle::middle::exported_symbols::{SymbolExportInfo, SymbolExportLevel};
...	...	@@ -59,7 +59,7 @@ struct LtoData {
59	59
60	60	fn prepare_lto(
61	61	cgcx: &CodegenContext<GccCodegenBackend>,
62		dcx: &DiagCtxt,
	62	dcx: DiagCtxtHandle<'_>,
63	63	) -> Result<LtoData, FatalError> {
64	64	let export_threshold = match cgcx.lto {
65	65	// We're just doing LTO for our one crate
...	...	@@ -179,12 +179,13 @@ pub(crate) fn run_fat(
179	179	cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
180	180	) -> Result<LtoModuleCodegen<GccCodegenBackend>, FatalError> {
181	181	let dcx = cgcx.create_dcx();
182		let lto_data = prepare_lto(cgcx, &dcx)?;
	182	let dcx = dcx.handle();
	183	let lto_data = prepare_lto(cgcx, dcx)?;
183	184	/*let symbols_below_threshold =
184	185	lto_data.symbols_below_threshold.iter().map(\|c\| c.as_ptr()).collect::<Vec<_>>();*/
185	186	fat_lto(
186	187	cgcx,
187		&dcx,
	188	dcx,
188	189	modules,
189	190	cached_modules,
190	191	lto_data.upstream_modules,
...	...	@@ -195,7 +196,7 @@ pub(crate) fn run_fat(
195	196
196	197	fn fat_lto(
197	198	cgcx: &CodegenContext<GccCodegenBackend>,
198		_dcx: &DiagCtxt,
	199	_dcx: DiagCtxtHandle<'_>,
199	200	modules: Vec<FatLtoInput<GccCodegenBackend>>,
200	201	cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
201	202	mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,

compiler/rustc_codegen_gcc/src/back/write.rs+3-3

...	...	@@ -4,7 +4,7 @@ use gccjit::OutputKind;
4	4	use rustc_codegen_ssa::back::link::ensure_removed;
5	5	use rustc_codegen_ssa::back::write::{BitcodeSection, CodegenContext, EmitObj, ModuleConfig};
6	6	use rustc_codegen_ssa::{CompiledModule, ModuleCodegen};
7		use rustc_errors::DiagCtxt;
	7	use rustc_errors::DiagCtxtHandle;
8	8	use rustc_fs_util::link_or_copy;
9	9	use rustc_session::config::OutputType;
10	10	use rustc_span::fatal_error::FatalError;
...	...	@@ -15,7 +15,7 @@ use crate::{GccCodegenBackend, GccContext};
15	15
16	16	pub(crate) unsafe fn codegen(
17	17	cgcx: &CodegenContext<GccCodegenBackend>,
18		dcx: &DiagCtxt,
	18	dcx: DiagCtxtHandle<'_>,
19	19	module: ModuleCodegen<GccContext>,
20	20	config: &ModuleConfig,
21	21	) -> Result<CompiledModule, FatalError> {
...	...	@@ -166,7 +166,7 @@ pub(crate) unsafe fn codegen(
166	166
167	167	pub(crate) fn link(
168	168	_cgcx: &CodegenContext<GccCodegenBackend>,
169		_dcx: &DiagCtxt,
	169	_dcx: DiagCtxtHandle<'_>,
170	170	mut _modules: Vec<ModuleCodegen<GccContext>>,
171	171	) -> Result<ModuleCodegen<GccContext>, FatalError> {
172	172	unimplemented!();

compiler/rustc_codegen_gcc/src/errors.rs+3-3

...	...	@@ -1,4 +1,4 @@
1		use rustc_errors::{Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level};
	1	use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
2	2	use rustc_macros::{Diagnostic, Subdiagnostic};
3	3	use rustc_span::Span;
4	4
...	...	@@ -90,13 +90,13 @@ pub(crate) struct TargetFeatureDisableOrEnable<'a> {
90	90	pub(crate) struct MissingFeatures;
91	91
92	92	impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetFeatureDisableOrEnable<'_> {
93		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	93	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
94	94	let mut diag = Diag::new(dcx, level, fluent::codegen_gcc_target_feature_disable_or_enable);
95	95	if let Some(span) = self.span {
96	96	diag.span(span);
97	97	};
98	98	if let Some(missing_features) = self.missing_features {
99		diag.subdiagnostic(dcx, missing_features);
	99	diag.subdiagnostic(missing_features);
100	100	}
101	101	diag.arg("features", self.features.join(", "));
102	102	diag

compiler/rustc_codegen_gcc/src/lib.rs+9-12

...	...	@@ -16,13 +16,7 @@
16	16	#![allow(internal_features)]
17	17	#![doc(rust_logo)]
18	18	#![feature(rustdoc_internals)]
19		#![feature(
20		rustc_private,
21		decl_macro,
22		never_type,
23		trusted_len,
24		hash_raw_entry
25		)]
	19	#![feature(rustc_private, decl_macro, never_type, trusted_len, hash_raw_entry)]
26	20	#![allow(broken_intra_doc_links)]
27	21	#![recursion_limit = "256"]
28	22	#![warn(rust_2018_idioms)]
...	...	@@ -104,7 +98,7 @@ use rustc_codegen_ssa::traits::{
104	98	use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen};
105	99	use rustc_data_structures::fx::FxIndexMap;
106	100	use rustc_data_structures::sync::IntoDynSyncSend;
107		use rustc_errors::{DiagCtxt, ErrorGuaranteed};
	101	use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
108	102	use rustc_metadata::EncodedMetadata;
109	103	use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
110	104	use rustc_middle::ty::TyCtxt;
...	...	@@ -386,7 +380,7 @@ impl WriteBackendMethods for GccCodegenBackend {
386	380
387	381	unsafe fn optimize(
388	382	_cgcx: &CodegenContext<Self>,
389		_dcx: &DiagCtxt,
	383	_dcx: DiagCtxtHandle<'_>,
390	384	module: &ModuleCodegen<Self::Module>,
391	385	config: &ModuleConfig,
392	386	) -> Result<(), FatalError> {
...	...	@@ -411,14 +405,17 @@ impl WriteBackendMethods for GccCodegenBackend {
411	405
412	406	unsafe fn codegen(
413	407	cgcx: &CodegenContext<Self>,
414		dcx: &DiagCtxt,
	408	dcx: DiagCtxtHandle<'_>,
415	409	module: ModuleCodegen<Self::Module>,
416	410	config: &ModuleConfig,
417	411	) -> Result<CompiledModule, FatalError> {
418	412	back::write::codegen(cgcx, dcx, module, config)
419	413	}
420	414
421		fn prepare_thin(_module: ModuleCodegen<Self::Module>, _emit_summary: bool) -> (String, Self::ThinBuffer) {
	415	fn prepare_thin(
	416	_module: ModuleCodegen<Self::Module>,
	417	_emit_summary: bool,
	418	) -> (String, Self::ThinBuffer) {
422	419	unimplemented!();
423	420	}
424	421
...	...	@@ -428,7 +425,7 @@ impl WriteBackendMethods for GccCodegenBackend {
428	425
429	426	fn run_link(
430	427	cgcx: &CodegenContext<Self>,
431		dcx: &DiagCtxt,
	428	dcx: DiagCtxtHandle<'_>,
432	429	modules: Vec<ModuleCodegen<Self::Module>>,
433	430	) -> Result<ModuleCodegen<Self::Module>, FatalError> {
434	431	back::write::link(cgcx, dcx, modules)

compiler/rustc_codegen_llvm/src/back/lto.rs+20-17

...	...	@@ -14,7 +14,7 @@ use rustc_codegen_ssa::traits::*;
14	14	use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind};
15	15	use rustc_data_structures::fx::FxHashMap;
16	16	use rustc_data_structures::memmap::Mmap;
17		use rustc_errors::{DiagCtxt, FatalError};
	17	use rustc_errors::{DiagCtxtHandle, FatalError};
18	18	use rustc_hir::def_id::LOCAL_CRATE;
19	19	use rustc_middle::bug;
20	20	use rustc_middle::dep_graph::WorkProduct;
...	...	@@ -49,7 +49,7 @@ pub fn crate_type_allows_lto(crate_type: CrateType) -> bool {
49	49
50	50	fn prepare_lto(
51	51	cgcx: &CodegenContext<LlvmCodegenBackend>,
52		dcx: &DiagCtxt,
	52	dcx: DiagCtxtHandle<'_>,
53	53	) -> Result<(Vec<CString>, Vec<(SerializedModule<ModuleBuffer>, CString)>), FatalError> {
54	54	let export_threshold = match cgcx.lto {
55	55	// We're just doing LTO for our one crate
...	...	@@ -203,10 +203,11 @@ pub(crate) fn run_fat(
203	203	cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
204	204	) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> {
205	205	let dcx = cgcx.create_dcx();
206		let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &dcx)?;
	206	let dcx = dcx.handle();
	207	let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, dcx)?;
207	208	let symbols_below_threshold =
208	209	symbols_below_threshold.iter().map(\|c\| c.as_ptr()).collect::<Vec<_>>();
209		fat_lto(cgcx, &dcx, modules, cached_modules, upstream_modules, &symbols_below_threshold)
	210	fat_lto(cgcx, dcx, modules, cached_modules, upstream_modules, &symbols_below_threshold)
210	211	}
211	212
212	213	/// Performs thin LTO by performing necessary global analysis and returning two
...	...	@@ -218,7 +219,8 @@ pub(crate) fn run_thin(
218	219	cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
219	220	) -> Result<(Vec<LtoModuleCodegen<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
220	221	let dcx = cgcx.create_dcx();
221		let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &dcx)?;
	222	let dcx = dcx.handle();
	223	let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, dcx)?;
222	224	let symbols_below_threshold =
223	225	symbols_below_threshold.iter().map(\|c\| c.as_ptr()).collect::<Vec<_>>();
224	226	if cgcx.opts.cg.linker_plugin_lto.enabled() {
...	...	@@ -227,7 +229,7 @@ pub(crate) fn run_thin(
227	229	is deferred to the linker"
228	230	);
229	231	}
230		thin_lto(cgcx, &dcx, modules, upstream_modules, cached_modules, &symbols_below_threshold)
	232	thin_lto(cgcx, dcx, modules, upstream_modules, cached_modules, &symbols_below_threshold)
231	233	}
232	234
233	235	pub(crate) fn prepare_thin(
...	...	@@ -241,7 +243,7 @@ pub(crate) fn prepare_thin(
241	243
242	244	fn fat_lto(
243	245	cgcx: &CodegenContext<LlvmCodegenBackend>,
244		dcx: &DiagCtxt,
	246	dcx: DiagCtxtHandle<'_>,
245	247	modules: Vec<FatLtoInput<LlvmCodegenBackend>>,
246	248	cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
247	249	mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
...	...	@@ -436,7 +438,7 @@ impl Drop for Linker<'_> {
436	438	/// they all go out of scope.
437	439	fn thin_lto(
438	440	cgcx: &CodegenContext<LlvmCodegenBackend>,
439		dcx: &DiagCtxt,
	441	dcx: DiagCtxtHandle<'_>,
440	442	modules: Vec<(String, ThinBuffer)>,
441	443	serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
442	444	cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
...	...	@@ -593,7 +595,7 @@ fn thin_lto(
593	595
594	596	pub(crate) fn run_pass_manager(
595	597	cgcx: &CodegenContext<LlvmCodegenBackend>,
596		dcx: &DiagCtxt,
	598	dcx: DiagCtxtHandle<'_>,
597	599	module: &mut ModuleCodegen<ModuleLlvm>,
598	600	thin: bool,
599	601	) -> Result<(), FatalError> {
...	...	@@ -714,10 +716,11 @@ pub unsafe fn optimize_thin_module(
714	716	cgcx: &CodegenContext<LlvmCodegenBackend>,
715	717	) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> {
716	718	let dcx = cgcx.create_dcx();
	719	let dcx = dcx.handle();
717	720
718	721	let module_name = &thin_module.shared.module_names[thin_module.idx];
719	722	let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, module_name.to_str().unwrap());
720		let tm = (cgcx.tm_factory)(tm_factory_config).map_err(\|e\| write::llvm_err(&dcx, e))?;
	723	let tm = (cgcx.tm_factory)(tm_factory_config).map_err(\|e\| write::llvm_err(dcx, e))?;
721	724
722	725	// Right now the implementation we've got only works over serialized
723	726	// modules, so we create a fresh new LLVM context and parse the module
...	...	@@ -725,7 +728,7 @@ pub unsafe fn optimize_thin_module(
725	728	// crates but for locally codegened modules we may be able to reuse
726	729	// that LLVM Context and Module.
727	730	let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
728		let llmod_raw = parse_module(llcx, module_name, thin_module.data(), &dcx)? as *const _;
	731	let llmod_raw = parse_module(llcx, module_name, thin_module.data(), dcx)? as *const _;
729	732	let mut module = ModuleCodegen {
730	733	module_llvm: ModuleLlvm { llmod_raw, llcx, tm: ManuallyDrop::new(tm) },
731	734	name: thin_module.name().to_string(),
...	...	@@ -748,7 +751,7 @@ pub unsafe fn optimize_thin_module(
748	751	let _timer =
749	752	cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_rename", thin_module.name());
750	753	if !llvm::LLVMRustPrepareThinLTORename(thin_module.shared.data.0, llmod, target) {
751		return Err(write::llvm_err(&dcx, LlvmError::PrepareThinLtoModule));
	754	return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
752	755	}
753	756	save_temp_bitcode(cgcx, &module, "thin-lto-after-rename");
754	757	}
...	...	@@ -758,7 +761,7 @@ pub unsafe fn optimize_thin_module(
758	761	.prof
759	762	.generic_activity_with_arg("LLVM_thin_lto_resolve_weak", thin_module.name());
760	763	if !llvm::LLVMRustPrepareThinLTOResolveWeak(thin_module.shared.data.0, llmod) {
761		return Err(write::llvm_err(&dcx, LlvmError::PrepareThinLtoModule));
	764	return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
762	765	}
763	766	save_temp_bitcode(cgcx, &module, "thin-lto-after-resolve");
764	767	}
...	...	@@ -768,7 +771,7 @@ pub unsafe fn optimize_thin_module(
768	771	.prof
769	772	.generic_activity_with_arg("LLVM_thin_lto_internalize", thin_module.name());
770	773	if !llvm::LLVMRustPrepareThinLTOInternalize(thin_module.shared.data.0, llmod) {
771		return Err(write::llvm_err(&dcx, LlvmError::PrepareThinLtoModule));
	774	return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
772	775	}
773	776	save_temp_bitcode(cgcx, &module, "thin-lto-after-internalize");
774	777	}
...	...	@@ -777,7 +780,7 @@ pub unsafe fn optimize_thin_module(
777	780	let _timer =
778	781	cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_import", thin_module.name());
779	782	if !llvm::LLVMRustPrepareThinLTOImport(thin_module.shared.data.0, llmod, target) {
780		return Err(write::llvm_err(&dcx, LlvmError::PrepareThinLtoModule));
	783	return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
781	784	}
782	785	save_temp_bitcode(cgcx, &module, "thin-lto-after-import");
783	786	}
...	...	@@ -789,7 +792,7 @@ pub unsafe fn optimize_thin_module(
789	792	// little differently.
790	793	{
791	794	info!("running thin lto passes over {}", module.name);
792		run_pass_manager(cgcx, &dcx, &mut module, true)?;
	795	run_pass_manager(cgcx, dcx, &mut module, true)?;
793	796	save_temp_bitcode(cgcx, &module, "thin-lto-after-pm");
794	797	}
795	798	}
...	...	@@ -859,7 +862,7 @@ pub fn parse_module<'a>(
859	862	cx: &'a llvm::Context,
860	863	name: &CStr,
861	864	data: &[u8],
862		dcx: &DiagCtxt,
	865	dcx: DiagCtxtHandle<'_>,
863	866	) -> Result<&'a llvm::Module, FatalError> {
864	867	unsafe {
865	868	llvm::LLVMRustParseBitcodeForLTO(cx, data.as_ptr(), data.len(), name.as_ptr())

compiler/rustc_codegen_llvm/src/back/write.rs+10-10

...	...	@@ -26,7 +26,7 @@ use rustc_codegen_ssa::traits::*;
26	26	use rustc_codegen_ssa::{CompiledModule, ModuleCodegen};
27	27	use rustc_data_structures::profiling::SelfProfilerRef;
28	28	use rustc_data_structures::small_c_str::SmallCStr;
29		use rustc_errors::{DiagCtxt, FatalError, Level};
	29	use rustc_errors::{DiagCtxtHandle, FatalError, Level};
30	30	use rustc_fs_util::{link_or_copy, path_to_c_string};
31	31	use rustc_middle::ty::TyCtxt;
32	32	use rustc_session::config::{self, Lto, OutputType, Passes};
...	...	@@ -47,7 +47,7 @@ use std::slice;
47	47	use std::str;
48	48	use std::sync::Arc;
49	49
50		pub fn llvm_err<'a>(dcx: &rustc_errors::DiagCtxt, err: LlvmError<'a>) -> FatalError {
	50	pub fn llvm_err<'a>(dcx: DiagCtxtHandle<'_>, err: LlvmError<'a>) -> FatalError {
51	51	match llvm::last_error() {
52	52	Some(llvm_err) => dcx.emit_almost_fatal(WithLlvmError(err, llvm_err)),
53	53	None => dcx.emit_almost_fatal(err),
...	...	@@ -55,7 +55,7 @@ pub fn llvm_err<'a>(dcx: &rustc_errors::DiagCtxt, err: LlvmError<'a>) -> FatalEr
55	55	}
56	56
57	57	pub fn write_output_file<'ll>(
58		dcx: &rustc_errors::DiagCtxt,
	58	dcx: DiagCtxtHandle<'_>,
59	59	target: &'ll llvm::TargetMachine,
60	60	pm: &llvm::PassManager<'ll>,
61	61	m: &'ll llvm::Module,
...	...	@@ -331,7 +331,7 @@ pub enum CodegenDiagnosticsStage {
331	331	}
332	332
333	333	pub struct DiagnosticHandlers<'a> {
334		data: *mut (&'a CodegenContext<LlvmCodegenBackend>, &'a DiagCtxt),
	334	data: *mut (&'a CodegenContext<LlvmCodegenBackend>, DiagCtxtHandle<'a>),
335	335	llcx: &'a llvm::Context,
336	336	old_handler: Option<&'a llvm::DiagnosticHandler>,
337	337	}
...	...	@@ -339,7 +339,7 @@ pub struct DiagnosticHandlers<'a> {
339	339	impl<'a> DiagnosticHandlers<'a> {
340	340	pub fn new(
341	341	cgcx: &'a CodegenContext<LlvmCodegenBackend>,
342		dcx: &'a DiagCtxt,
	342	dcx: DiagCtxtHandle<'a>,
343	343	llcx: &'a llvm::Context,
344	344	module: &ModuleCodegen<ModuleLlvm>,
345	345	stage: CodegenDiagnosticsStage,
...	...	@@ -428,7 +428,7 @@ unsafe extern "C" fn diagnostic_handler(info: &DiagnosticInfo, user: *mut c_void
428	428	if user.is_null() {
429	429	return;
430	430	}
431		let (cgcx, dcx) = (user as const (&CodegenContext<LlvmCodegenBackend>, &DiagCtxt));
	431	let (cgcx, dcx) = (user as const (&CodegenContext<LlvmCodegenBackend>, DiagCtxtHandle<'_>));
432	432
433	433	match llvm::diagnostic::Diagnostic::unpack(info) {
434	434	llvm::diagnostic::InlineAsm(inline) => {
...	...	@@ -506,7 +506,7 @@ fn get_instr_profile_output_path(config: &ModuleConfig) -> Option<CString> {
506	506
507	507	pub(crate) unsafe fn llvm_optimize(
508	508	cgcx: &CodegenContext<LlvmCodegenBackend>,
509		dcx: &DiagCtxt,
	509	dcx: DiagCtxtHandle<'_>,
510	510	module: &ModuleCodegen<ModuleLlvm>,
511	511	config: &ModuleConfig,
512	512	opt_level: config::OptLevel,
...	...	@@ -604,7 +604,7 @@ pub(crate) unsafe fn llvm_optimize(
604	604	// Unsafe due to LLVM calls.
605	605	pub(crate) unsafe fn optimize(
606	606	cgcx: &CodegenContext<LlvmCodegenBackend>,
607		dcx: &DiagCtxt,
	607	dcx: DiagCtxtHandle<'_>,
608	608	module: &ModuleCodegen<ModuleLlvm>,
609	609	config: &ModuleConfig,
610	610	) -> Result<(), FatalError> {
...	...	@@ -637,7 +637,7 @@ pub(crate) unsafe fn optimize(
637	637
638	638	pub(crate) fn link(
639	639	cgcx: &CodegenContext<LlvmCodegenBackend>,
640		dcx: &DiagCtxt,
	640	dcx: DiagCtxtHandle<'_>,
641	641	mut modules: Vec<ModuleCodegen<ModuleLlvm>>,
642	642	) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> {
643	643	use super::lto::{Linker, ModuleBuffer};
...	...	@@ -660,7 +660,7 @@ pub(crate) fn link(
660	660
661	661	pub(crate) unsafe fn codegen(
662	662	cgcx: &CodegenContext<LlvmCodegenBackend>,
663		dcx: &DiagCtxt,
	663	dcx: DiagCtxtHandle<'_>,
664	664	module: ModuleCodegen<ModuleLlvm>,
665	665	config: &ModuleConfig,
666	666	) -> Result<CompiledModule, FatalError> {

compiler/rustc_codegen_llvm/src/errors.rs+5-5

...	...	@@ -4,7 +4,7 @@ use std::path::Path;
4	4
5	5	use crate::fluent_generated as fluent;
6	6	use rustc_data_structures::small_c_str::SmallCStr;
7		use rustc_errors::{Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level};
	7	use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
8	8	use rustc_macros::{Diagnostic, Subdiagnostic};
9	9	use rustc_span::Span;
10	10
...	...	@@ -100,7 +100,7 @@ pub(crate) struct DynamicLinkingWithLTO;
100	100	pub(crate) struct ParseTargetMachineConfig<'a>(pub LlvmError<'a>);
101	101
102	102	impl<G: EmissionGuarantee> Diagnostic<'_, G> for ParseTargetMachineConfig<'_> {
103		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	103	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
104	104	let diag: Diag<'_, G> = self.0.into_diag(dcx, level);
105	105	let (message, _) = diag.messages.first().expect("`LlvmError` with no message");
106	106	let message = dcx.eagerly_translate_to_string(message.clone(), diag.args.iter());
...	...	@@ -120,13 +120,13 @@ pub(crate) struct TargetFeatureDisableOrEnable<'a> {
120	120	pub(crate) struct MissingFeatures;
121	121
122	122	impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetFeatureDisableOrEnable<'_> {
123		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	123	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
124	124	let mut diag = Diag::new(dcx, level, fluent::codegen_llvm_target_feature_disable_or_enable);
125	125	if let Some(span) = self.span {
126	126	diag.span(span);
127	127	};
128	128	if let Some(missing_features) = self.missing_features {
129		diag.subdiagnostic(dcx, missing_features);
	129	diag.subdiagnostic(missing_features);
130	130	}
131	131	diag.arg("features", self.features.join(", "));
132	132	diag
...	...	@@ -180,7 +180,7 @@ pub enum LlvmError<'a> {
180	180	pub(crate) struct WithLlvmError<'a>(pub LlvmError<'a>, pub String);
181	181
182	182	impl<G: EmissionGuarantee> Diagnostic<'_, G> for WithLlvmError<'_> {
183		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	183	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
184	184	use LlvmError::*;
185	185	let msg_with_llvm_err = match &self.0 {
186	186	WriteOutput { .. } => fluent::codegen_llvm_write_output_with_llvm_err,

compiler/rustc_codegen_llvm/src/lib.rs+7-6

...	...	@@ -31,7 +31,7 @@ use rustc_codegen_ssa::traits::*;
31	31	use rustc_codegen_ssa::ModuleCodegen;
32	32	use rustc_codegen_ssa::{CodegenResults, CompiledModule};
33	33	use rustc_data_structures::fx::FxIndexMap;
34		use rustc_errors::{DiagCtxt, ErrorGuaranteed, FatalError};
	34	use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, FatalError};
35	35	use rustc_metadata::EncodedMetadata;
36	36	use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
37	37	use rustc_middle::ty::TyCtxt;
...	...	@@ -191,7 +191,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
191	191	}
192	192	fn run_link(
193	193	cgcx: &CodegenContext<Self>,
194		dcx: &DiagCtxt,
	194	dcx: DiagCtxtHandle<'_>,
195	195	modules: Vec<ModuleCodegen<Self::Module>>,
196	196	) -> Result<ModuleCodegen<Self::Module>, FatalError> {
197	197	back::write::link(cgcx, dcx, modules)
...	...	@@ -212,7 +212,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
212	212	}
213	213	unsafe fn optimize(
214	214	cgcx: &CodegenContext<Self>,
215		dcx: &DiagCtxt,
	215	dcx: DiagCtxtHandle<'_>,
216	216	module: &ModuleCodegen<Self::Module>,
217	217	config: &ModuleConfig,
218	218	) -> Result<(), FatalError> {
...	...	@@ -223,7 +223,8 @@ impl WriteBackendMethods for LlvmCodegenBackend {
223	223	module: &mut ModuleCodegen<Self::Module>,
224	224	) -> Result<(), FatalError> {
225	225	let dcx = cgcx.create_dcx();
226		back::lto::run_pass_manager(cgcx, &dcx, module, false)
	226	let dcx = dcx.handle();
	227	back::lto::run_pass_manager(cgcx, dcx, module, false)
227	228	}
228	229	unsafe fn optimize_thin(
229	230	cgcx: &CodegenContext<Self>,
...	...	@@ -233,7 +234,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
233	234	}
234	235	unsafe fn codegen(
235	236	cgcx: &CodegenContext<Self>,
236		dcx: &DiagCtxt,
	237	dcx: DiagCtxtHandle<'_>,
237	238	module: ModuleCodegen<Self::Module>,
238	239	config: &ModuleConfig,
239	240	) -> Result<CompiledModule, FatalError> {
...	...	@@ -441,7 +442,7 @@ impl ModuleLlvm {
441	442	cgcx: &CodegenContext<LlvmCodegenBackend>,
442	443	name: &CStr,
443	444	buffer: &[u8],
444		dcx: &DiagCtxt,
	445	dcx: DiagCtxtHandle<'_>,
445	446	) -> Result<Self, FatalError> {
446	447	unsafe {
447	448	let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);

compiler/rustc_codegen_ssa/src/back/link.rs+2-2

...	...	@@ -3,7 +3,7 @@ use rustc_ast::CRATE_NODE_ID;
3	3	use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
4	4	use rustc_data_structures::memmap::Mmap;
5	5	use rustc_data_structures::temp_dir::MaybeTempDir;
6		use rustc_errors::{DiagCtxt, ErrorGuaranteed, FatalError};
	6	use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, FatalError};
7	7	use rustc_fs_util::{fix_windows_verbatim_for_gcc, try_canonicalize};
8	8	use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
9	9	use rustc_metadata::find_native_static_library;
...	...	@@ -54,7 +54,7 @@ use std::process::{ExitStatus, Output, Stdio};
54	54	use std::{env, fmt, fs, io, mem, str};
55	55	use tracing::{debug, info, warn};
56	56
57		pub fn ensure_removed(dcx: &DiagCtxt, path: &Path) {
	57	pub fn ensure_removed(dcx: DiagCtxtHandle<'_>, path: &Path) {
58	58	if let Err(e) = fs::remove_file(path) {
59	59	if e.kind() != io::ErrorKind::NotFound {
60	60	dcx.err(format!("failed to remove {}: {}", path.display(), e));

compiler/rustc_codegen_ssa/src/back/write.rs+13-6

...	...	@@ -891,9 +891,10 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
891	891	module_config: &ModuleConfig,
892	892	) -> Result<WorkItemResult<B>, FatalError> {
893	893	let dcx = cgcx.create_dcx();
	894	let dcx = dcx.handle();
894	895
895	896	unsafe {
896		B::optimize(cgcx, &dcx, &module, module_config)?;
	897	B::optimize(cgcx, dcx, &module, module_config)?;
897	898	}
898	899
899	900	// After we've done the initial round of optimizations we need to
...	...	@@ -954,7 +955,11 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
954	955	match link_or_copy(&source_file, &output_path) {
955	956	Ok(_) => Some(output_path),
956	957	Err(error) => {
957		cgcx.create_dcx().emit_err(errors::CopyPathBuf { source_file, output_path, error });
	958	cgcx.create_dcx().handle().emit_err(errors::CopyPathBuf {
	959	source_file,
	960	output_path,
	961	error,
	962	});
958	963	None
959	964	}
960	965	}
...	...	@@ -987,7 +992,7 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
987	992	let bytecode = load_from_incr_cache(module_config.emit_bc, OutputType::Bitcode);
988	993	let object = load_from_incr_cache(should_emit_obj, OutputType::Object);
989	994	if should_emit_obj && object.is_none() {
990		cgcx.create_dcx().emit_fatal(errors::NoSavedObjectFile { cgu_name: &module.name })
	995	cgcx.create_dcx().handle().emit_fatal(errors::NoSavedObjectFile { cgu_name: &module.name })
991	996	}
992	997
993	998	WorkItemResult::Finished(CompiledModule {
...	...	@@ -1016,12 +1021,13 @@ fn finish_intra_module_work<B: ExtraBackendMethods>(
1016	1021	module_config: &ModuleConfig,
1017	1022	) -> Result<WorkItemResult<B>, FatalError> {
1018	1023	let dcx = cgcx.create_dcx();
	1024	let dcx = dcx.handle();
1019	1025
1020	1026	if !cgcx.opts.unstable_opts.combine_cgu
1021	1027	\|\| module.kind == ModuleKind::Metadata
1022	1028	\|\| module.kind == ModuleKind::Allocator
1023	1029	{
1024		let module = unsafe { B::codegen(cgcx, &dcx, module, module_config)? };
	1030	let module = unsafe { B::codegen(cgcx, dcx, module, module_config)? };
1025	1031	Ok(WorkItemResult::Finished(module))
1026	1032	} else {
1027	1033	Ok(WorkItemResult::NeedsLink(module))
...	...	@@ -1692,9 +1698,10 @@ fn start_executing_work<B: ExtraBackendMethods>(
1692	1698	if !needs_link.is_empty() {
1693	1699	assert!(compiled_modules.is_empty());
1694	1700	let dcx = cgcx.create_dcx();
1695		let module = B::run_link(&cgcx, &dcx, needs_link).map_err(\|_\| ())?;
	1701	let dcx = dcx.handle();
	1702	let module = B::run_link(&cgcx, dcx, needs_link).map_err(\|_\| ())?;
1696	1703	let module = unsafe {
1697		B::codegen(&cgcx, &dcx, module, cgcx.config(ModuleKind::Regular)).map_err(\|_\| ())?
	1704	B::codegen(&cgcx, dcx, module, cgcx.config(ModuleKind::Regular)).map_err(\|_\| ())?
1698	1705	};
1699	1706	compiled_modules.push(module);
1700	1707	}

compiler/rustc_codegen_ssa/src/errors.rs+3-3

...	...	@@ -4,7 +4,7 @@ use crate::assert_module_sources::CguReuse;
4	4	use crate::back::command::Command;
5	5	use crate::fluent_generated as fluent;
6	6	use rustc_errors::{
7		codes::*, Diag, DiagArgValue, DiagCtxt, Diagnostic, EmissionGuarantee, IntoDiagArg, Level,
	7	codes::*, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, IntoDiagArg, Level,
8	8	};
9	9	use rustc_macros::Diagnostic;
10	10	use rustc_middle::ty::layout::LayoutError;
...	...	@@ -215,7 +215,7 @@ pub enum LinkRlibError {
215	215	pub struct ThorinErrorWrapper(pub thorin::Error);
216	216
217	217	impl<G: EmissionGuarantee> Diagnostic<'_, G> for ThorinErrorWrapper {
218		fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> {
	218	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
219	219	let build = \|msg\| Diag::new(dcx, level, msg);
220	220	match self.0 {
221	221	thorin::Error::ReadInput(_) => build(fluent::codegen_ssa_thorin_read_input_failure),
...	...	@@ -348,7 +348,7 @@ pub struct LinkingFailed<'a> {
348	348	}
349	349
350	350	impl<G: EmissionGuarantee> Diagnostic<'_, G> for LinkingFailed<'_> {
351		fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> {
	351	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
352	352	let mut diag = Diag::new(dcx, level, fluent::codegen_ssa_linking_failed);
353	353	diag.arg("linker_path", format!("{}", self.linker_path.display()));
354	354	diag.arg("exit_status", format!("{}", self.exit_status));

compiler/rustc_codegen_ssa/src/traits/write.rs+4-4

...	...	@@ -2,7 +2,7 @@ use crate::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
2	2	use crate::back::write::{CodegenContext, FatLtoInput, ModuleConfig};
3	3	use crate::{CompiledModule, ModuleCodegen};
4	4
5		use rustc_errors::{DiagCtxt, FatalError};
	5	use rustc_errors::{DiagCtxtHandle, FatalError};
6	6	use rustc_middle::dep_graph::WorkProduct;
7	7
8	8	pub trait WriteBackendMethods: 'static + Sized + Clone {
...	...	@@ -16,7 +16,7 @@ pub trait WriteBackendMethods: 'static + Sized + Clone {
16	16	/// Merge all modules into main_module and returning it
17	17	fn run_link(
18	18	cgcx: &CodegenContext<Self>,
19		dcx: &DiagCtxt,
	19	dcx: DiagCtxtHandle<'_>,
20	20	modules: Vec<ModuleCodegen<Self::Module>>,
21	21	) -> Result<ModuleCodegen<Self::Module>, FatalError>;
22	22	/// Performs fat LTO by merging all modules into a single one and returning it
...	...	@@ -38,7 +38,7 @@ pub trait WriteBackendMethods: 'static + Sized + Clone {
38	38	fn print_statistics(&self);
39	39	unsafe fn optimize(
40	40	cgcx: &CodegenContext<Self>,
41		dcx: &DiagCtxt,
	41	dcx: DiagCtxtHandle<'_>,
42	42	module: &ModuleCodegen<Self::Module>,
43	43	config: &ModuleConfig,
44	44	) -> Result<(), FatalError>;
...	...	@@ -52,7 +52,7 @@ pub trait WriteBackendMethods: 'static + Sized + Clone {
52	52	) -> Result<ModuleCodegen<Self::Module>, FatalError>;
53	53	unsafe fn codegen(
54	54	cgcx: &CodegenContext<Self>,
55		dcx: &DiagCtxt,
	55	dcx: DiagCtxtHandle<'_>,
56	56	module: ModuleCodegen<Self::Module>,
57	57	config: &ModuleConfig,
58	58	) -> Result<CompiledModule, FatalError>;

compiler/rustc_const_eval/src/check_consts/mod.rs+2-2

...	...	@@ -5,7 +5,7 @@
5	5	//! it finds operations that are invalid in a certain context.
6	6
7	7	use rustc_attr as attr;
8		use rustc_errors::DiagCtxt;
	8	use rustc_errors::DiagCtxtHandle;
9	9	use rustc_hir as hir;
10	10	use rustc_hir::def_id::{DefId, LocalDefId};
11	11	use rustc_middle::bug;
...	...	@@ -46,7 +46,7 @@ impl<'mir, 'tcx> ConstCx<'mir, 'tcx> {
46	46	ConstCx { body, tcx, param_env, const_kind }
47	47	}
48	48
49		pub(crate) fn dcx(&self) -> &'tcx DiagCtxt {
	49	pub(crate) fn dcx(&self) -> DiagCtxtHandle<'tcx> {
50	50	self.tcx.dcx()
51	51	}
52	52

compiler/rustc_const_eval/src/check_consts/ops.rs+1-1

...	...	@@ -138,7 +138,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
138	138	// FIXME(effects) revisit this
139	139	if !tcx.is_const_trait_impl_raw(data.impl_def_id) {
140	140	let span = tcx.def_span(data.impl_def_id);
141		err.subdiagnostic(tcx.dcx(), errors::NonConstImplNote { span });
	141	err.subdiagnostic(errors::NonConstImplNote { span });
142	142	}
143	143	}
144	144	}

compiler/rustc_const_eval/src/errors.rs+2-2

...	...	@@ -2,7 +2,7 @@ use std::borrow::Cow;
2	2
3	3	use either::Either;
4	4	use rustc_errors::{
5		codes::*, Diag, DiagArgValue, DiagCtxt, DiagMessage, Diagnostic, EmissionGuarantee, Level,
	5	codes::*, Diag, DiagArgValue, DiagCtxtHandle, DiagMessage, Diagnostic, EmissionGuarantee, Level,
6	6	};
7	7	use rustc_hir::ConstContext;
8	8	use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
...	...	@@ -453,7 +453,7 @@ pub trait ReportErrorExt {
453	453	}
454	454	}
455	455
456		fn bad_pointer_message(msg: CheckInAllocMsg, dcx: &DiagCtxt) -> String {
	456	fn bad_pointer_message(msg: CheckInAllocMsg, dcx: DiagCtxtHandle<'_>) -> String {
457	457	use crate::fluent_generated::*;
458	458
459	459	let msg = match msg {

compiler/rustc_const_eval/src/interpret/eval_context.rs+2-2

...	...	@@ -4,7 +4,7 @@ use std::{fmt, mem};
4	4	use either::{Either, Left, Right};
5	5	use tracing::{debug, info, info_span, instrument, trace};
6	6
7		use rustc_errors::DiagCtxt;
	7	use rustc_errors::DiagCtxtHandle;
8	8	use rustc_hir::{self as hir, def_id::DefId, definitions::DefPathData};
9	9	use rustc_index::IndexVec;
10	10	use rustc_middle::mir;
...	...	@@ -474,7 +474,7 @@ pub(super) fn from_known_layout<'tcx>(
474	474	///
475	475	/// This is NOT the preferred way to render an error; use `report` from `const_eval` instead.
476	476	/// However, this is useful when error messages appear in ICEs.
477		pub fn format_interp_error<'tcx>(dcx: &DiagCtxt, e: InterpErrorInfo<'tcx>) -> String {
	477	pub fn format_interp_error<'tcx>(dcx: DiagCtxtHandle<'_>, e: InterpErrorInfo<'tcx>) -> String {
478	478	let (e, backtrace) = e.into_parts();
479	479	backtrace.print_backtrace();
480	480	// FIXME(fee1-dead), HACK: we want to use the error as title therefore we can just extract the

compiler/rustc_driver_impl/src/lib.rs+2-1

...	...	@@ -1444,6 +1444,7 @@ fn report_ice(
1444	1444	fallback_bundle,
1445	1445	));
1446	1446	let dcx = rustc_errors::DiagCtxt::new(emitter);
	1447	let dcx = dcx.handle();
1447	1448
1448	1449	// a .span_bug or .bug call has already printed what
1449	1450	// it wants to print.
...	...	@@ -1509,7 +1510,7 @@ fn report_ice(
1509	1510
1510	1511	let num_frames = if backtrace { None } else { Some(2) };
1511	1512
1512		interface::try_print_query_stack(&dcx, num_frames, file);
	1513	interface::try_print_query_stack(dcx, num_frames, file);
1513	1514
1514	1515	// We don't trust this callback not to panic itself, so run it at the end after we're sure we've
1515	1516	// printed all the relevant info.

compiler/rustc_errors/src/diagnostic.rs+11-13

...	...	@@ -1,7 +1,7 @@
1	1	use crate::snippet::Style;
2	2	use crate::{
3		CodeSuggestion, DiagCtxt, DiagMessage, ErrCode, ErrorGuaranteed, ExplicitBug, Level, MultiSpan,
4		StashKey, SubdiagMessage, Substitution, SubstitutionPart, SuggestionStyle,
	3	CodeSuggestion, DiagCtxtHandle, DiagMessage, ErrCode, ErrorGuaranteed, ExplicitBug, Level,
	4	MultiSpan, StashKey, SubdiagMessage, Substitution, SubstitutionPart, SuggestionStyle,
5	5	};
6	6	use rustc_data_structures::fx::FxIndexMap;
7	7	use rustc_error_messages::fluent_value_from_str_list_sep_by_and;
...	...	@@ -133,7 +133,7 @@ impl EmissionGuarantee for rustc_span::fatal_error::FatalError {
133	133	pub trait Diagnostic<'a, G: EmissionGuarantee = ErrorGuaranteed> {
134	134	/// Write out as a diagnostic out of `DiagCtxt`.
135	135	#[must_use]
136		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G>;
	136	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G>;
137	137	}
138	138
139	139	impl<'a, T, G> Diagnostic<'a, G> for Spanned<T>
...	...	@@ -141,7 +141,7 @@ where
141	141	T: Diagnostic<'a, G>,
142	142	G: EmissionGuarantee,
143	143	{
144		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	144	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
145	145	self.node.into_diag(dcx, level).with_span(self.span)
146	146	}
147	147	}
...	...	@@ -490,7 +490,7 @@ pub struct Subdiag {
490	490	/// the methods of `Diag` here, consider extending `DiagCtxtFlags`.
491	491	#[must_use]
492	492	pub struct Diag<'a, G: EmissionGuarantee = ErrorGuaranteed> {
493		pub dcx: &'a DiagCtxt,
	493	pub dcx: DiagCtxtHandle<'a>,
494	494
495	495	/// Why the `Option`? It is always `Some` until the `Diag` is consumed via
496	496	/// `emit`, `cancel`, etc. At that point it is consumed and replaced with
...	...	@@ -578,13 +578,13 @@ macro_rules! with_fn {
578	578	impl<'a, G: EmissionGuarantee> Diag<'a, G> {
579	579	#[rustc_lint_diagnostics]
580	580	#[track_caller]
581		pub fn new(dcx: &'a DiagCtxt, level: Level, message: impl Into<DiagMessage>) -> Self {
	581	pub fn new(dcx: DiagCtxtHandle<'a>, level: Level, message: impl Into<DiagMessage>) -> Self {
582	582	Self::new_diagnostic(dcx, DiagInner::new(level, message))
583	583	}
584	584
585	585	/// Creates a new `Diag` with an already constructed diagnostic.
586	586	#[track_caller]
587		pub(crate) fn new_diagnostic(dcx: &'a DiagCtxt, diag: DiagInner) -> Self {
	587	pub(crate) fn new_diagnostic(dcx: DiagCtxtHandle<'a>, diag: DiagInner) -> Self {
588	588	debug!("Created new diagnostic");
589	589	Self { dcx, diag: Some(Box::new(diag)), _marker: PhantomData }
590	590	}
...	...	@@ -1192,11 +1192,8 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
1192	1192	/// used in the subdiagnostic, so suitable for use with repeated messages (i.e. re-use of
1193	1193	/// interpolated variables).
1194	1194	#[rustc_lint_diagnostics]
1195		pub fn subdiagnostic(
1196		&mut self,
1197		dcx: &crate::DiagCtxt,
1198		subdiagnostic: impl Subdiagnostic,
1199		) -> &mut Self {
	1195	pub fn subdiagnostic(&mut self, subdiagnostic: impl Subdiagnostic) -> &mut Self {
	1196	let dcx = self.dcx;
1200	1197	subdiagnostic.add_to_diag_with(self, &\|diag, msg\| {
1201	1198	let args = diag.args.iter();
1202	1199	let msg = diag.subdiagnostic_message_to_diagnostic_message(msg);
...	...	@@ -1341,7 +1338,8 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
1341	1338
1342	1339	/// See `DiagCtxt::stash_diagnostic` for details.
1343	1340	pub fn stash(mut self, span: Span, key: StashKey) -> Option<ErrorGuaranteed> {
1344		self.dcx.stash_diagnostic(span, key, self.take_diag())
	1341	let diag = self.take_diag();
	1342	self.dcx.stash_diagnostic(span, key, diag)
1345	1343	}
1346	1344
1347	1345	/// Delay emission of this diagnostic as a bug.

compiler/rustc_errors/src/diagnostic_impls.rs+3-3

...	...	@@ -1,7 +1,7 @@
1	1	use crate::diagnostic::DiagLocation;
2		use crate::{fluent_generated as fluent, Subdiagnostic};
	2	use crate::{fluent_generated as fluent, DiagCtxtHandle, Subdiagnostic};
3	3	use crate::{
4		Diag, DiagArgValue, DiagCtxt, Diagnostic, EmissionGuarantee, ErrCode, IntoDiagArg, Level,
	4	Diag, DiagArgValue, Diagnostic, EmissionGuarantee, ErrCode, IntoDiagArg, Level,
5	5	SubdiagMessageOp,
6	6	};
7	7	use rustc_ast as ast;
...	...	@@ -315,7 +315,7 @@ impl IntoDiagArg for DiagSymbolList {
315	315	}
316	316
317	317	impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetDataLayoutErrors<'_> {
318		fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> {
	318	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
319	319	match self {
320	320	TargetDataLayoutErrors::InvalidAddressSpace { addr_space, err, cause } => {
321	321	Diag::new(dcx, level, fluent::errors_target_invalid_address_space)

compiler/rustc_errors/src/emitter.rs+1-1

...	...	@@ -567,7 +567,7 @@ impl Emitter for SilentEmitter {
567	567	if let Some(fatal_note) = &self.fatal_note {
568	568	diag.sub(Level::Note, fatal_note.clone(), MultiSpan::new());
569	569	}
570		self.fatal_dcx.emit_diagnostic(diag);
	570	self.fatal_dcx.handle().emit_diagnostic(diag);
571	571	}
572	572	}
573	573	}

compiler/rustc_errors/src/json/tests.rs+1-2

...	...	@@ -55,8 +55,7 @@ fn test_positions(code: &str, span: (u32, u32), expected_output: SpanTestData) {
55	55	);
56	56
57	57	let span = Span::with_root_ctxt(BytePos(span.0), BytePos(span.1));
58		let dcx = DiagCtxt::new(Box::new(je));
59		dcx.span_err(span, "foo");
	58	DiagCtxt::new(Box::new(je)).handle().span_err(span, "foo");
60	59
61	60	let bytes = output.lock().unwrap();
62	61	let actual_output = str::from_utf8(&bytes).unwrap();

compiler/rustc_errors/src/lib.rs+71-59

...	...	@@ -414,6 +414,19 @@ pub struct DiagCtxt {
414	414	inner: Lock<DiagCtxtInner>,
415	415	}
416	416
	417	#[derive(Copy, Clone)]
	418	pub struct DiagCtxtHandle<'a> {
	419	dcx: &'a DiagCtxt,
	420	}
	421
	422	impl<'a> std::ops::Deref for DiagCtxtHandle<'a> {
	423	type Target = &'a DiagCtxt;
	424
	425	fn deref(&self) -> &Self::Target {
	426	&self.dcx
	427	}
	428	}
	429
417	430	/// This inner struct exists to keep it all behind a single lock;
418	431	/// this is done to prevent possible deadlocks in a multi-threaded compiler,
419	432	/// as well as inconsistent state observation.
...	...	@@ -608,7 +621,7 @@ impl DiagCtxt {
608	621	}
609	622
610	623	pub fn make_silent(
611		&mut self,
	624	&self,
612	625	fallback_bundle: LazyFallbackBundle,
613	626	fatal_note: Option<String>,
614	627	emit_fatal_diagnostic: bool,
...	...	@@ -623,7 +636,7 @@ impl DiagCtxt {
623	636	});
624	637	}
625	638
626		fn wrap_emitter<F>(&mut self, f: F)
	639	fn wrap_emitter<F>(&self, f: F)
627	640	where
628	641	F: FnOnce(DiagCtxtInner) -> Box<DynEmitter>,
629	642	{
...	...	@@ -738,6 +751,12 @@ impl DiagCtxt {
738	751	*fulfilled_expectations = Default::default();
739	752	}
740	753
	754	pub fn handle<'a>(&'a self) -> DiagCtxtHandle<'a> {
	755	DiagCtxtHandle { dcx: self }
	756	}
	757	}
	758
	759	impl<'a> DiagCtxtHandle<'a> {
741	760	/// Stashes a diagnostic for possible later improvement in a different,
742	761	/// later stage of the compiler. Possible actions depend on the diagnostic
743	762	/// level:
...	...	@@ -745,8 +764,8 @@ impl DiagCtxt {
745	764	/// - Level::Error: immediately counted as an error that has occurred, because it
746	765	/// is guaranteed to be emitted eventually. Can be later accessed with the
747	766	/// provided `span` and `key` through
748		/// [`DiagCtxt::try_steal_modify_and_emit_err`] or
749		/// [`DiagCtxt::try_steal_replace_and_emit_err`]. These do not allow
	767	/// [`DiagCtxtHandle::try_steal_modify_and_emit_err`] or
	768	/// [`DiagCtxtHandle::try_steal_replace_and_emit_err`]. These do not allow
750	769	/// cancellation or downgrading of the error. Returns
751	770	/// `Some(ErrorGuaranteed)`.
752	771	/// - Level::DelayedBug: this does happen occasionally with errors that are
...	...	@@ -757,7 +776,7 @@ impl DiagCtxt {
757	776	/// user-facing error. Returns `Some(ErrorGuaranteed)` as is normal for
758	777	/// delayed bugs.
759	778	/// - Level::Warning and lower (i.e. !is_error()): can be accessed with the
760		/// provided `span` and `key` through [`DiagCtxt::steal_non_err()`]. This
	779	/// provided `span` and `key` through [`DiagCtxtHandle::steal_non_err()`]. This
761	780	/// allows cancelling and downgrading of the diagnostic. Returns `None`.
762	781	pub fn stash_diagnostic(
763	782	&self,
...	...	@@ -793,7 +812,7 @@ impl DiagCtxt {
793	812	/// Steal a previously stashed non-error diagnostic with the given `Span`
794	813	/// and [`StashKey`] as the key. Panics if the found diagnostic is an
795	814	/// error.
796		pub fn steal_non_err(&self, span: Span, key: StashKey) -> Option<Diag<'_, ()>> {
	815	pub fn steal_non_err(self, span: Span, key: StashKey) -> Option<Diag<'a, ()>> {
797	816	let key = (span.with_parent(None), key);
798	817	// FIXME(#120456) - is `swap_remove` correct?
799	818	let (diag, guar) = self.inner.borrow_mut().stashed_diagnostics.swap_remove(&key)?;
...	...	@@ -807,7 +826,7 @@ impl DiagCtxt {
807	826	/// no matching diagnostic is found. Panics if the found diagnostic's level
808	827	/// isn't `Level::Error`.
809	828	pub fn try_steal_modify_and_emit_err<F>(
810		&self,
	829	self,
811	830	span: Span,
812	831	key: StashKey,
813	832	mut modify_err: F,
...	...	@@ -833,7 +852,7 @@ impl DiagCtxt {
833	852	/// [`StashKey`] as the key, cancels it if found, and emits `new_err`.
834	853	/// Panics if the found diagnostic's level isn't `Level::Error`.
835	854	pub fn try_steal_replace_and_emit_err(
836		&self,
	855	self,
837	856	span: Span,
838	857	key: StashKey,
839	858	new_err: Diag<'_>,
...	...	@@ -1106,18 +1125,18 @@ impl DiagCtxt {
1106	1125	//
1107	1126	// Functions beginning with `struct_`/`create_` create a diagnostic. Other
1108	1127	// functions create and emit a diagnostic all in one go.
1109		impl DiagCtxt {
	1128	impl<'a> DiagCtxtHandle<'a> {
1110	1129	// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
1111	1130	// user-facing.
1112	1131	#[track_caller]
1113		pub fn struct_bug(&self, msg: impl Into<Cow<'static, str>>) -> Diag<'_, BugAbort> {
	1132	pub fn struct_bug(self, msg: impl Into<Cow<'static, str>>) -> Diag<'a, BugAbort> {
1114	1133	Diag::new(self, Bug, msg.into())
1115	1134	}
1116	1135
1117	1136	// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
1118	1137	// user-facing.
1119	1138	#[track_caller]
1120		pub fn bug(&self, msg: impl Into<Cow<'static, str>>) -> ! {
	1139	pub fn bug(self, msg: impl Into<Cow<'static, str>>) -> ! {
1121	1140	self.struct_bug(msg).emit()
1122	1141	}
1123	1142
...	...	@@ -1125,111 +1144,108 @@ impl DiagCtxt {
1125	1144	// user-facing.
1126	1145	#[track_caller]
1127	1146	pub fn struct_span_bug(
1128		&self,
	1147	self,
1129	1148	span: impl Into<MultiSpan>,
1130	1149	msg: impl Into<Cow<'static, str>>,
1131		) -> Diag<'_, BugAbort> {
	1150	) -> Diag<'a, BugAbort> {
1132	1151	self.struct_bug(msg).with_span(span)
1133	1152	}
1134	1153
1135	1154	// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
1136	1155	// user-facing.
1137	1156	#[track_caller]
1138		pub fn span_bug(&self, span: impl Into<MultiSpan>, msg: impl Into<Cow<'static, str>>) -> ! {
	1157	pub fn span_bug(self, span: impl Into<MultiSpan>, msg: impl Into<Cow<'static, str>>) -> ! {
1139	1158	self.struct_span_bug(span, msg.into()).emit()
1140	1159	}
1141	1160
1142	1161	#[track_caller]
1143		pub fn create_bug<'a>(&'a self, bug: impl Diagnostic<'a, BugAbort>) -> Diag<'a, BugAbort> {
	1162	pub fn create_bug(self, bug: impl Diagnostic<'a, BugAbort>) -> Diag<'a, BugAbort> {
1144	1163	bug.into_diag(self, Bug)
1145	1164	}
1146	1165
1147	1166	#[track_caller]
1148		pub fn emit_bug<'a>(&'a self, bug: impl Diagnostic<'a, BugAbort>) -> ! {
	1167	pub fn emit_bug(self, bug: impl Diagnostic<'a, BugAbort>) -> ! {
1149	1168	self.create_bug(bug).emit()
1150	1169	}
1151	1170
1152	1171	#[rustc_lint_diagnostics]
1153	1172	#[track_caller]
1154		pub fn struct_fatal(&self, msg: impl Into<DiagMessage>) -> Diag<'_, FatalAbort> {
	1173	pub fn struct_fatal(self, msg: impl Into<DiagMessage>) -> Diag<'a, FatalAbort> {
1155	1174	Diag::new(self, Fatal, msg)
1156	1175	}
1157	1176
1158	1177	#[rustc_lint_diagnostics]
1159	1178	#[track_caller]
1160		pub fn fatal(&self, msg: impl Into<DiagMessage>) -> ! {
	1179	pub fn fatal(self, msg: impl Into<DiagMessage>) -> ! {
1161	1180	self.struct_fatal(msg).emit()
1162	1181	}
1163	1182
1164	1183	#[rustc_lint_diagnostics]
1165	1184	#[track_caller]
1166	1185	pub fn struct_span_fatal(
1167		&self,
	1186	self,
1168	1187	span: impl Into<MultiSpan>,
1169	1188	msg: impl Into<DiagMessage>,
1170		) -> Diag<'_, FatalAbort> {
	1189	) -> Diag<'a, FatalAbort> {
1171	1190	self.struct_fatal(msg).with_span(span)
1172	1191	}
1173	1192
1174	1193	#[rustc_lint_diagnostics]
1175	1194	#[track_caller]
1176		pub fn span_fatal(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) -> ! {
	1195	pub fn span_fatal(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) -> ! {
1177	1196	self.struct_span_fatal(span, msg).emit()
1178	1197	}
1179	1198
1180	1199	#[track_caller]
1181		pub fn create_fatal<'a>(
1182		&'a self,
1183		fatal: impl Diagnostic<'a, FatalAbort>,
1184		) -> Diag<'a, FatalAbort> {
	1200	pub fn create_fatal(self, fatal: impl Diagnostic<'a, FatalAbort>) -> Diag<'a, FatalAbort> {
1185	1201	fatal.into_diag(self, Fatal)
1186	1202	}
1187	1203
1188	1204	#[track_caller]
1189		pub fn emit_fatal<'a>(&'a self, fatal: impl Diagnostic<'a, FatalAbort>) -> ! {
	1205	pub fn emit_fatal(self, fatal: impl Diagnostic<'a, FatalAbort>) -> ! {
1190	1206	self.create_fatal(fatal).emit()
1191	1207	}
1192	1208
1193	1209	#[track_caller]
1194		pub fn create_almost_fatal<'a>(
1195		&'a self,
	1210	pub fn create_almost_fatal(
	1211	self,
1196	1212	fatal: impl Diagnostic<'a, FatalError>,
1197	1213	) -> Diag<'a, FatalError> {
1198	1214	fatal.into_diag(self, Fatal)
1199	1215	}
1200	1216
1201	1217	#[track_caller]
1202		pub fn emit_almost_fatal<'a>(&'a self, fatal: impl Diagnostic<'a, FatalError>) -> FatalError {
	1218	pub fn emit_almost_fatal(self, fatal: impl Diagnostic<'a, FatalError>) -> FatalError {
1203	1219	self.create_almost_fatal(fatal).emit()
1204	1220	}
1205	1221
1206	1222	// FIXME: This method should be removed (every error should have an associated error code).
1207	1223	#[rustc_lint_diagnostics]
1208	1224	#[track_caller]
1209		pub fn struct_err(&self, msg: impl Into<DiagMessage>) -> Diag<'_> {
	1225	pub fn struct_err(self, msg: impl Into<DiagMessage>) -> Diag<'a> {
1210	1226	Diag::new(self, Error, msg)
1211	1227	}
1212	1228
1213	1229	#[rustc_lint_diagnostics]
1214	1230	#[track_caller]
1215		pub fn err(&self, msg: impl Into<DiagMessage>) -> ErrorGuaranteed {
	1231	pub fn err(self, msg: impl Into<DiagMessage>) -> ErrorGuaranteed {
1216	1232	self.struct_err(msg).emit()
1217	1233	}
1218	1234
1219	1235	#[rustc_lint_diagnostics]
1220	1236	#[track_caller]
1221	1237	pub fn struct_span_err(
1222		&self,
	1238	self,
1223	1239	span: impl Into<MultiSpan>,
1224	1240	msg: impl Into<DiagMessage>,
1225		) -> Diag<'_> {
	1241	) -> Diag<'a> {
1226	1242	self.struct_err(msg).with_span(span)
1227	1243	}
1228	1244
1229	1245	#[rustc_lint_diagnostics]
1230	1246	#[track_caller]
1231	1247	pub fn span_err(
1232		&self,
	1248	self,
1233	1249	span: impl Into<MultiSpan>,
1234	1250	msg: impl Into<DiagMessage>,
1235	1251	) -> ErrorGuaranteed {
...	...	@@ -1237,12 +1253,12 @@ impl DiagCtxt {
1237	1253	}
1238	1254
1239	1255	#[track_caller]
1240		pub fn create_err<'a>(&'a self, err: impl Diagnostic<'a>) -> Diag<'a> {
	1256	pub fn create_err(self, err: impl Diagnostic<'a>) -> Diag<'a> {
1241	1257	err.into_diag(self, Error)
1242	1258	}
1243	1259
1244	1260	#[track_caller]
1245		pub fn emit_err<'a>(&'a self, err: impl Diagnostic<'a>) -> ErrorGuaranteed {
	1261	pub fn emit_err(self, err: impl Diagnostic<'a>) -> ErrorGuaranteed {
1246	1262	self.create_err(err).emit()
1247	1263	}
1248	1264
...	...	@@ -1251,7 +1267,7 @@ impl DiagCtxt {
1251	1267	// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
1252	1268	// user-facing.
1253	1269	#[track_caller]
1254		pub fn delayed_bug(&self, msg: impl Into<Cow<'static, str>>) -> ErrorGuaranteed {
	1270	pub fn delayed_bug(self, msg: impl Into<Cow<'static, str>>) -> ErrorGuaranteed {
1255	1271	Diag::<ErrorGuaranteed>::new(self, DelayedBug, msg.into()).emit()
1256	1272	}
1257	1273
...	...	@@ -1264,7 +1280,7 @@ impl DiagCtxt {
1264	1280	// user-facing.
1265	1281	#[track_caller]
1266	1282	pub fn span_delayed_bug(
1267		&self,
	1283	self,
1268	1284	sp: impl Into<MultiSpan>,
1269	1285	msg: impl Into<Cow<'static, str>>,
1270	1286	) -> ErrorGuaranteed {
...	...	@@ -1273,45 +1289,45 @@ impl DiagCtxt {
1273	1289
1274	1290	#[rustc_lint_diagnostics]
1275	1291	#[track_caller]
1276		pub fn struct_warn(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> {
	1292	pub fn struct_warn(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
1277	1293	Diag::new(self, Warning, msg)
1278	1294	}
1279	1295
1280	1296	#[rustc_lint_diagnostics]
1281	1297	#[track_caller]
1282		pub fn warn(&self, msg: impl Into<DiagMessage>) {
	1298	pub fn warn(self, msg: impl Into<DiagMessage>) {
1283	1299	self.struct_warn(msg).emit()
1284	1300	}
1285	1301
1286	1302	#[rustc_lint_diagnostics]
1287	1303	#[track_caller]
1288	1304	pub fn struct_span_warn(
1289		&self,
	1305	self,
1290	1306	span: impl Into<MultiSpan>,
1291	1307	msg: impl Into<DiagMessage>,
1292		) -> Diag<'_, ()> {
	1308	) -> Diag<'a, ()> {
1293	1309	self.struct_warn(msg).with_span(span)
1294	1310	}
1295	1311
1296	1312	#[rustc_lint_diagnostics]
1297	1313	#[track_caller]
1298		pub fn span_warn(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
	1314	pub fn span_warn(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
1299	1315	self.struct_span_warn(span, msg).emit()
1300	1316	}
1301	1317
1302	1318	#[track_caller]
1303		pub fn create_warn<'a>(&'a self, warning: impl Diagnostic<'a, ()>) -> Diag<'a, ()> {
	1319	pub fn create_warn(self, warning: impl Diagnostic<'a, ()>) -> Diag<'a, ()> {
1304	1320	warning.into_diag(self, Warning)
1305	1321	}
1306	1322
1307	1323	#[track_caller]
1308		pub fn emit_warn<'a>(&'a self, warning: impl Diagnostic<'a, ()>) {
	1324	pub fn emit_warn(self, warning: impl Diagnostic<'a, ()>) {
1309	1325	self.create_warn(warning).emit()
1310	1326	}
1311	1327
1312	1328	#[rustc_lint_diagnostics]
1313	1329	#[track_caller]
1314		pub fn struct_note(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> {
	1330	pub fn struct_note(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
1315	1331	Diag::new(self, Note, msg)
1316	1332	}
1317	1333
...	...	@@ -1324,54 +1340,50 @@ impl DiagCtxt {
1324	1340	#[rustc_lint_diagnostics]
1325	1341	#[track_caller]
1326	1342	pub fn struct_span_note(
1327		&self,
	1343	self,
1328	1344	span: impl Into<MultiSpan>,
1329	1345	msg: impl Into<DiagMessage>,
1330		) -> Diag<'_, ()> {
	1346	) -> Diag<'a, ()> {
1331	1347	self.struct_note(msg).with_span(span)
1332	1348	}
1333	1349
1334	1350	#[rustc_lint_diagnostics]
1335	1351	#[track_caller]
1336		pub fn span_note(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
	1352	pub fn span_note(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
1337	1353	self.struct_span_note(span, msg).emit()
1338	1354	}
1339	1355
1340	1356	#[track_caller]
1341		pub fn create_note<'a>(&'a self, note: impl Diagnostic<'a, ()>) -> Diag<'a, ()> {
	1357	pub fn create_note(self, note: impl Diagnostic<'a, ()>) -> Diag<'a, ()> {
1342	1358	note.into_diag(self, Note)
1343	1359	}
1344	1360
1345	1361	#[track_caller]
1346		pub fn emit_note<'a>(&'a self, note: impl Diagnostic<'a, ()>) {
	1362	pub fn emit_note(self, note: impl Diagnostic<'a, ()>) {
1347	1363	self.create_note(note).emit()
1348	1364	}
1349	1365
1350	1366	#[rustc_lint_diagnostics]
1351	1367	#[track_caller]
1352		pub fn struct_help(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> {
	1368	pub fn struct_help(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
1353	1369	Diag::new(self, Help, msg)
1354	1370	}
1355	1371
1356	1372	#[rustc_lint_diagnostics]
1357	1373	#[track_caller]
1358		pub fn struct_failure_note(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> {
	1374	pub fn struct_failure_note(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
1359	1375	Diag::new(self, FailureNote, msg)
1360	1376	}
1361	1377
1362	1378	#[rustc_lint_diagnostics]
1363	1379	#[track_caller]
1364		pub fn struct_allow(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> {
	1380	pub fn struct_allow(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
1365	1381	Diag::new(self, Allow, msg)
1366	1382	}
1367	1383
1368	1384	#[rustc_lint_diagnostics]
1369	1385	#[track_caller]
1370		pub fn struct_expect(
1371		&self,
1372		msg: impl Into<DiagMessage>,
1373		id: LintExpectationId,
1374		) -> Diag<'_, ()> {
	1386	pub fn struct_expect(self, msg: impl Into<DiagMessage>, id: LintExpectationId) -> Diag<'a, ()> {
1375	1387	Diag::new(self, Expect(id), msg)
1376	1388	}
1377	1389	}

compiler/rustc_expand/src/base.rs+4-4

...	...	@@ -12,7 +12,7 @@ use rustc_ast::{self as ast, AttrVec, Attribute, HasAttrs, Item, NodeId, PatKind
12	12	use rustc_attr::{self as attr, Deprecation, Stability};
13	13	use rustc_data_structures::fx::FxIndexMap;
14	14	use rustc_data_structures::sync::{self, Lrc};
15		use rustc_errors::{DiagCtxt, ErrorGuaranteed, PResult};
	15	use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, PResult};
16	16	use rustc_feature::Features;
17	17	use rustc_lint_defs::{BufferedEarlyLint, RegisteredTools};
18	18	use rustc_parse::{parser::Parser, MACRO_ARGUMENTS};
...	...	@@ -1135,7 +1135,7 @@ impl<'a> ExtCtxt<'a> {
1135	1135	}
1136	1136	}
1137	1137
1138		pub fn dcx(&self) -> &'a DiagCtxt {
	1138	pub fn dcx(&self) -> DiagCtxtHandle<'a> {
1139	1139	self.sess.dcx()
1140	1140	}
1141	1141
...	...	@@ -1256,7 +1256,7 @@ pub fn resolve_path(sess: &Session, path: impl Into<PathBuf>, span: Span) -> PRe
1256	1256	}
1257	1257
1258	1258	pub fn parse_macro_name_and_helper_attrs(
1259		dcx: &rustc_errors::DiagCtxt,
	1259	dcx: DiagCtxtHandle<'_>,
1260	1260	attr: &Attribute,
1261	1261	macro_type: &str,
1262	1262	) -> Option<(Symbol, Vec<Symbol>)> {
...	...	@@ -1358,7 +1358,7 @@ fn pretty_printing_compatibility_hack(item: &Item, sess: &Session) {
1358	1358	if crate_matches {
1359	1359	// FIXME: make this translatable
1360	1360	#[allow(rustc::untranslatable_diagnostic)]
1361		sess.psess.dcx.emit_fatal(errors::ProcMacroBackCompat {
	1361	sess.dcx().emit_fatal(errors::ProcMacroBackCompat {
1362	1362	crate_name: "rental".to_string(),
1363	1363	fixed_version: "0.5.6".to_string(),
1364	1364	});

compiler/rustc_expand/src/mbe/diagnostics.rs+5-5

...	...	@@ -7,7 +7,7 @@ use crate::mbe::{
7	7	use rustc_ast::token::{self, Token, TokenKind};
8	8	use rustc_ast::tokenstream::TokenStream;
9	9	use rustc_ast_pretty::pprust;
10		use rustc_errors::{Applicability, Diag, DiagCtxt, DiagMessage};
	10	use rustc_errors::{Applicability, Diag, DiagMessage};
11	11	use rustc_macros::Subdiagnostic;
12	12	use rustc_parse::parser::{Parser, Recovery};
13	13	use rustc_span::source_map::SourceMap;
...	...	@@ -61,7 +61,7 @@ pub(super) fn failed_to_match_macro<'cx>(
61	61	err.span_label(cx.source_map().guess_head_span(def_span), "when calling this macro");
62	62	}
63	63
64		annotate_doc_comment(cx.sess.dcx(), &mut err, psess.source_map(), span);
	64	annotate_doc_comment(&mut err, psess.source_map(), span);
65	65
66	66	if let Some(span) = remaining_matcher.span() {
67	67	err.span_note(span, format!("while trying to match {remaining_matcher}"));
...	...	@@ -324,12 +324,12 @@ enum ExplainDocComment {
324	324	},
325	325	}
326	326
327		pub(super) fn annotate_doc_comment(dcx: &DiagCtxt, err: &mut Diag<'_>, sm: &SourceMap, span: Span) {
	327	pub(super) fn annotate_doc_comment(err: &mut Diag<'_>, sm: &SourceMap, span: Span) {
328	328	if let Ok(src) = sm.span_to_snippet(span) {
329	329	if src.starts_with("///") \|\| src.starts_with("/**") {
330		err.subdiagnostic(dcx, ExplainDocComment::Outer { span });
	330	err.subdiagnostic(ExplainDocComment::Outer { span });
331	331	} else if src.starts_with("//!") \|\| src.starts_with("/*!") {
332		err.subdiagnostic(dcx, ExplainDocComment::Inner { span });
	332	err.subdiagnostic(ExplainDocComment::Inner { span });
333	333	}
334	334	}
335	335	}

compiler/rustc_expand/src/mbe/macro_check.rs+5-5

...	...	@@ -206,7 +206,7 @@ pub(super) fn check_meta_variables(
206	206	rhses: &[TokenTree],
207	207	) -> Result<(), ErrorGuaranteed> {
208	208	if lhses.len() != rhses.len() {
209		psess.dcx.span_bug(span, "length mismatch between LHSes and RHSes")
	209	psess.dcx().span_bug(span, "length mismatch between LHSes and RHSes")
210	210	}
211	211	let mut guar = None;
212	212	for (lhs, rhs) in iter::zip(lhses, rhses) {
...	...	@@ -245,7 +245,7 @@ fn check_binders(
245	245	// MetaVar(fragment) and not as MetaVarDecl(y, fragment).
246	246	TokenTree::MetaVar(span, name) => {
247	247	if macros.is_empty() {
248		psess.dcx.span_bug(span, "unexpected MetaVar in lhs");
	248	psess.dcx().span_bug(span, "unexpected MetaVar in lhs");
249	249	}
250	250	let name = MacroRulesNormalizedIdent::new(name);
251	251	// There are 3 possibilities:
...	...	@@ -276,7 +276,7 @@ fn check_binders(
276	276	);
277	277	}
278	278	if !macros.is_empty() {
279		psess.dcx.span_bug(span, "unexpected MetaVarDecl in nested lhs");
	279	psess.dcx().span_bug(span, "unexpected MetaVarDecl in nested lhs");
280	280	}
281	281	let name = MacroRulesNormalizedIdent::new(name);
282	282	if let Some(prev_info) = get_binder_info(macros, binders, name) {
...	...	@@ -284,7 +284,7 @@ fn check_binders(
284	284	// for nested macro definitions.
285	285	*guar = Some(
286	286	psess
287		.dcx
	287	.dcx()
288	288	.emit_err(errors::DuplicateMatcherBinding { span, prev: prev_info.span }),
289	289	);
290	290	} else {
...	...	@@ -344,7 +344,7 @@ fn check_occurrences(
344	344	match *rhs {
345	345	TokenTree::Token(..) => {}
346	346	TokenTree::MetaVarDecl(span, _name, _kind) => {
347		psess.dcx.span_bug(span, "unexpected MetaVarDecl in rhs")
	347	psess.dcx().span_bug(span, "unexpected MetaVarDecl in rhs")
348	348	}
349	349	TokenTree::MetaVar(span, name) => {
350	350	let name = MacroRulesNormalizedIdent::new(name);

compiler/rustc_expand/src/mbe/macro_rules.rs+2-2

...	...	@@ -383,7 +383,7 @@ pub fn compile_declarative_macro(
383	383	};
384	384	let dummy_syn_ext = \|guar\| (mk_syn_ext(Box::new(DummyExpander(guar))), Vec::new());
385	385
386		let dcx = &sess.psess.dcx;
	386	let dcx = sess.dcx();
387	387	let lhs_nm = Ident::new(sym::lhs, def.span);
388	388	let rhs_nm = Ident::new(sym::rhs, def.span);
389	389	let tt_spec = Some(NonterminalKind::TT);
...	...	@@ -463,7 +463,7 @@ pub fn compile_declarative_macro(
463	463	let sp = token.span.substitute_dummy(def.span);
464	464	let mut err = sess.dcx().struct_span_err(sp, s);
465	465	err.span_label(sp, msg);
466		annotate_doc_comment(sess.dcx(), &mut err, sess.source_map(), sp);
	466	annotate_doc_comment(&mut err, sess.source_map(), sp);
467	467	let guar = err.emit();
468	468	return dummy_syn_ext(guar);
469	469	}

compiler/rustc_expand/src/mbe/metavar_expr.rs+15-14

...	...	@@ -42,7 +42,7 @@ impl MetaVarExpr {
42	42	let ident = parse_ident(&mut tts, psess, outer_span)?;
43	43	let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = tts.next() else {
44	44	let msg = "meta-variable expression parameter must be wrapped in parentheses";
45		return Err(psess.dcx.struct_span_err(ident.span, msg));
	45	return Err(psess.dcx().struct_span_err(ident.span, msg));
46	46	};
47	47	check_trailing_token(&mut tts, psess)?;
48	48	let mut iter = args.trees();
...	...	@@ -62,12 +62,12 @@ impl MetaVarExpr {
62	62	break;
63	63	}
64	64	if !try_eat_comma(&mut iter) {
65		return Err(psess.dcx.struct_span_err(outer_span, "expected comma"));
	65	return Err(psess.dcx().struct_span_err(outer_span, "expected comma"));
66	66	}
67	67	}
68	68	if result.len() < 2 {
69	69	return Err(psess
70		.dcx
	70	.dcx()
71	71	.struct_span_err(ident.span, "`concat` must have at least two elements"));
72	72	}
73	73	MetaVarExpr::Concat(result.into())
...	...	@@ -81,7 +81,7 @@ impl MetaVarExpr {
81	81	"len" => MetaVarExpr::Len(parse_depth(&mut iter, psess, ident.span)?),
82	82	_ => {
83	83	let err_msg = "unrecognized meta-variable expression";
84		let mut err = psess.dcx.struct_span_err(ident.span, err_msg);
	84	let mut err = psess.dcx().struct_span_err(ident.span, err_msg);
85	85	err.span_suggestion(
86	86	ident.span,
87	87	"supported expressions are count, ignore, index and len",
...	...	@@ -120,7 +120,7 @@ fn check_trailing_token<'psess>(
120	120	) -> PResult<'psess, ()> {
121	121	if let Some(tt) = iter.next() {
122	122	let mut diag = psess
123		.dcx
	123	.dcx()
124	124	.struct_span_err(tt.span(), format!("unexpected token: {}", pprust::tt_to_string(tt)));
125	125	diag.span_note(tt.span(), "meta-variable expression must not have trailing tokens");
126	126	Err(diag)
...	...	@@ -139,7 +139,7 @@ fn parse_count<'psess>(
139	139	let ident = parse_ident(iter, psess, span)?;
140	140	let depth = if try_eat_comma(iter) {
141	141	if iter.look_ahead(0).is_none() {
142		return Err(psess.dcx.struct_span_err(
	142	return Err(psess.dcx().struct_span_err(
143	143	span,
144	144	"`count` followed by a comma must have an associated index indicating its depth",
145	145	));
...	...	@@ -160,7 +160,7 @@ fn parse_depth<'psess>(
160	160	let Some(tt) = iter.next() else { return Ok(0) };
161	161	let TokenTree::Token(token::Token { kind: token::TokenKind::Literal(lit), .. }, _) = tt else {
162	162	return Err(psess
163		.dcx
	163	.dcx()
164	164	.struct_span_err(span, "meta-variable expression depth must be a literal"));
165	165	};
166	166	if let Ok(lit_kind) = LitKind::from_token_lit(*lit)
...	...	@@ -170,7 +170,7 @@ fn parse_depth<'psess>(
170	170	Ok(n_usize)
171	171	} else {
172	172	let msg = "only unsuffixes integer literals are supported in meta-variable expressions";
173		Err(psess.dcx.struct_span_err(span, msg))
	173	Err(psess.dcx().struct_span_err(span, msg))
174	174	}
175	175	}
176	176
...	...	@@ -181,20 +181,21 @@ fn parse_ident<'psess>(
181	181	fallback_span: Span,
182	182	) -> PResult<'psess, Ident> {
183	183	let Some(tt) = iter.next() else {
184		return Err(psess.dcx.struct_span_err(fallback_span, "expected identifier"));
	184	return Err(psess.dcx().struct_span_err(fallback_span, "expected identifier"));
185	185	};
186	186	let TokenTree::Token(token, _) = tt else {
187		return Err(psess.dcx.struct_span_err(tt.span(), "expected identifier"));
	187	return Err(psess.dcx().struct_span_err(tt.span(), "expected identifier"));
188	188	};
189	189	if let Some((elem, is_raw)) = token.ident() {
190	190	if let IdentIsRaw::Yes = is_raw {
191		return Err(psess.dcx.struct_span_err(elem.span, RAW_IDENT_ERR));
	191	return Err(psess.dcx().struct_span_err(elem.span, RAW_IDENT_ERR));
192	192	}
193	193	return Ok(elem);
194	194	}
195	195	let token_str = pprust::token_to_string(token);
196		let mut err =
197		psess.dcx.struct_span_err(token.span, format!("expected identifier, found `{token_str}`"));
	196	let mut err = psess
	197	.dcx()
	198	.struct_span_err(token.span, format!("expected identifier, found `{token_str}`"));
198	199	err.span_suggestion(
199	200	token.span,
200	201	format!("try removing `{token_str}`"),
...	...	@@ -236,7 +237,7 @@ fn eat_dollar<'psess>(
236	237	let _ = iter.next();
237	238	return Ok(());
238	239	}
239		Err(psess.dcx.struct_span_err(
	240	Err(psess.dcx().struct_span_err(
240	241	span,
241	242	"meta-variables within meta-variable expressions must be referenced using a dollar sign",
242	243	))

compiler/rustc_expand/src/mbe/transcribe.rs+7-7

...	...	@@ -10,7 +10,7 @@ use rustc_ast::token::IdentIsRaw;
10	10	use rustc_ast::token::{self, Delimiter, Token, TokenKind};
11	11	use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
12	12	use rustc_data_structures::fx::FxHashMap;
13		use rustc_errors::{pluralize, Diag, DiagCtxt, PResult};
	13	use rustc_errors::{pluralize, Diag, DiagCtxtHandle, PResult};
14	14	use rustc_parse::parser::ParseNtResult;
15	15	use rustc_session::parse::ParseSess;
16	16	use rustc_span::hygiene::{LocalExpnId, Transparency};
...	...	@@ -141,7 +141,7 @@ pub(super) fn transcribe<'a>(
141	141	let mut result_stack = Vec::new();
142	142	let mut marker = Marker(expand_id, transparency, Default::default());
143	143
144		let dcx = &psess.dcx;
	144	let dcx = psess.dcx();
145	145	loop {
146	146	// Look at the last frame on the stack.
147	147	// If it still has a TokenTree we have not looked at yet, use that tree.
...	...	@@ -571,7 +571,7 @@ fn lockstep_iter_size(
571	571	/// * `[ $( ${count(foo, 1)} ),* ]` will return an error because `${count(foo, 1)}` is
572	572	/// declared inside a single repetition and the index `1` implies two nested repetitions.
573	573	fn count_repetitions<'a>(
574		dcx: &'a DiagCtxt,
	574	dcx: DiagCtxtHandle<'a>,
575	575	depth_user: usize,
576	576	mut matched: &NamedMatch,
577	577	repeats: &[(usize, usize)],
...	...	@@ -632,7 +632,7 @@ fn count_repetitions<'a>(
632	632
633	633	/// Returns a `NamedMatch` item declared on the LHS given an arbitrary [Ident]
634	634	fn matched_from_ident<'ctx, 'interp, 'rslt>(
635		dcx: &'ctx DiagCtxt,
	635	dcx: DiagCtxtHandle<'ctx>,
636	636	ident: Ident,
637	637	interp: &'interp FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
638	638	) -> PResult<'ctx, &'rslt NamedMatch>
...	...	@@ -646,7 +646,7 @@ where
646	646
647	647	/// Used by meta-variable expressions when an user input is out of the actual declared bounds. For
648	648	/// example, index(999999) in an repetition of only three elements.
649		fn out_of_bounds_err<'a>(dcx: &'a DiagCtxt, max: usize, span: Span, ty: &str) -> Diag<'a> {
	649	fn out_of_bounds_err<'a>(dcx: DiagCtxtHandle<'a>, max: usize, span: Span, ty: &str) -> Diag<'a> {
650	650	let msg = if max == 0 {
651	651	format!(
652	652	"meta-variable expression `{ty}` with depth parameter \
...	...	@@ -662,7 +662,7 @@ fn out_of_bounds_err<'a>(dcx: &'a DiagCtxt, max: usize, span: Span, ty: &str) ->
662	662	}
663	663
664	664	fn transcribe_metavar_expr<'a>(
665		dcx: &'a DiagCtxt,
	665	dcx: DiagCtxtHandle<'a>,
666	666	expr: &MetaVarExpr,
667	667	interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
668	668	marker: &mut Marker,
...	...	@@ -730,7 +730,7 @@ fn transcribe_metavar_expr<'a>(
730	730
731	731	/// Extracts an identifier that can be originated from a `$var:ident` variable or from a token tree.
732	732	fn extract_ident<'a>(
733		dcx: &'a DiagCtxt,
	733	dcx: DiagCtxtHandle<'a>,
734	734	ident: Ident,
735	735	interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
736	736	) -> PResult<'a, String> {

compiler/rustc_expand/src/proc_macro_server.rs+1-1

...	...	@@ -522,7 +522,7 @@ impl server::FreeFunctions for Rustc<'_, '_> {
522	522	fn emit_diagnostic(&mut self, diagnostic: Diagnostic<Self::Span>) {
523	523	let message = rustc_errors::DiagMessage::from(diagnostic.message);
524	524	let mut diag: Diag<'_, ()> =
525		Diag::new(&self.psess().dcx, diagnostic.level.to_internal(), message);
	525	Diag::new(self.psess().dcx(), diagnostic.level.to_internal(), message);
526	526	diag.span(MultiSpan::from_spans(diagnostic.spans));
527	527	for child in diagnostic.children {
528	528	// This message comes from another diagnostic, and we are just reconstructing the

compiler/rustc_hir_analysis/src/check/errs.rs+1-1

...	...	@@ -63,7 +63,7 @@ fn handle_static_mut_ref(
63	63	} else {
64	64	(errors::StaticMutRefSugg::Shared { span, var }, "shared")
65	65	};
66		tcx.sess.psess.dcx.emit_err(errors::StaticMutRef { span, sugg, shared });
	66	tcx.dcx().emit_err(errors::StaticMutRef { span, sugg, shared });
67	67	} else {
68	68	let (sugg, shared) = if mutable == Mutability::Mut {
69	69	(errors::RefOfMutStaticSugg::Mut { span, var }, "mutable")

compiler/rustc_hir_analysis/src/coherence/orphan.rs+28-46

...	...	@@ -403,74 +403,56 @@ fn emit_orphan_check_error<'tcx>(
403	403	match *ty.kind() {
404	404	ty::Slice(_) => {
405	405	if is_foreign {
406		diag.subdiagnostic(
407		tcx.dcx(),
408		errors::OnlyCurrentTraitsForeign { span },
409		);
	406	diag.subdiagnostic(errors::OnlyCurrentTraitsForeign { span });
410	407	} else {
411		diag.subdiagnostic(
412		tcx.dcx(),
413		errors::OnlyCurrentTraitsName { span, name: "slices" },
414		);
	408	diag.subdiagnostic(errors::OnlyCurrentTraitsName {
	409	span,
	410	name: "slices",
	411	});
415	412	}
416	413	}
417	414	ty::Array(..) => {
418	415	if is_foreign {
419		diag.subdiagnostic(
420		tcx.dcx(),
421		errors::OnlyCurrentTraitsForeign { span },
422		);
	416	diag.subdiagnostic(errors::OnlyCurrentTraitsForeign { span });
423	417	} else {
424		diag.subdiagnostic(
425		tcx.dcx(),
426		errors::OnlyCurrentTraitsName { span, name: "arrays" },
427		);
	418	diag.subdiagnostic(errors::OnlyCurrentTraitsName {
	419	span,
	420	name: "arrays",
	421	});
428	422	}
429	423	}
430	424	ty::Tuple(..) => {
431	425	if is_foreign {
432		diag.subdiagnostic(
433		tcx.dcx(),
434		errors::OnlyCurrentTraitsForeign { span },
435		);
	426	diag.subdiagnostic(errors::OnlyCurrentTraitsForeign { span });
436	427	} else {
437		diag.subdiagnostic(
438		tcx.dcx(),
439		errors::OnlyCurrentTraitsName { span, name: "tuples" },
440		);
	428	diag.subdiagnostic(errors::OnlyCurrentTraitsName {
	429	span,
	430	name: "tuples",
	431	});
441	432	}
442	433	}
443	434	ty::Alias(ty::Opaque, ..) => {
444		diag.subdiagnostic(tcx.dcx(), errors::OnlyCurrentTraitsOpaque { span });
	435	diag.subdiagnostic(errors::OnlyCurrentTraitsOpaque { span });
445	436	}
446	437	ty::RawPtr(ptr_ty, mutbl) => {
447	438	if !trait_ref.self_ty().has_param() {
448		diag.subdiagnostic(
449		tcx.dcx(),
450		errors::OnlyCurrentTraitsPointerSugg {
451		wrapper_span: impl_.self_ty.span,
452		struct_span: item.span.shrink_to_lo(),
453		mut_key: mutbl.prefix_str(),
454		ptr_ty,
455		},
456		);
	439	diag.subdiagnostic(errors::OnlyCurrentTraitsPointerSugg {
	440	wrapper_span: impl_.self_ty.span,
	441	struct_span: item.span.shrink_to_lo(),
	442	mut_key: mutbl.prefix_str(),
	443	ptr_ty,
	444	});
457	445	}
458		diag.subdiagnostic(
459		tcx.dcx(),
460		errors::OnlyCurrentTraitsPointer { span, pointer: ty },
461		);
	446	diag.subdiagnostic(errors::OnlyCurrentTraitsPointer { span, pointer: ty });
462	447	}
463	448	ty::Adt(adt_def, _) => {
464		diag.subdiagnostic(
465		tcx.dcx(),
466		errors::OnlyCurrentTraitsAdt {
467		span,
468		name: tcx.def_path_str(adt_def.did()),
469		},
470		);
	449	diag.subdiagnostic(errors::OnlyCurrentTraitsAdt {
	450	span,
	451	name: tcx.def_path_str(adt_def.did()),
	452	});
471	453	}
472	454	_ => {
473		diag.subdiagnostic(tcx.dcx(), errors::OnlyCurrentTraitsTy { span, ty });
	455	diag.subdiagnostic(errors::OnlyCurrentTraitsTy { span, ty });
474	456	}
475	457	}
476	458	}

compiler/rustc_hir_analysis/src/errors.rs+2-2

...	...	@@ -2,7 +2,7 @@
2	2
3	3	use crate::fluent_generated as fluent;
4	4	use rustc_errors::{
5		codes::*, Applicability, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level, MultiSpan,
	5	codes::*, Applicability, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, MultiSpan,
6	6	};
7	7	use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
8	8	use rustc_middle::ty::Ty;
...	...	@@ -424,7 +424,7 @@ pub struct MissingTypeParams {
424	424	// Manual implementation of `Diagnostic` to be able to call `span_to_snippet`.
425	425	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for MissingTypeParams {
426	426	#[track_caller]
427		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	427	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
428	428	let mut err = Diag::new(dcx, level, fluent::hir_analysis_missing_type_params);
429	429	err.span(self.span);
430	430	err.code(E0393);

compiler/rustc_hir_typeck/src/_match.rs+1-1

...	...	@@ -246,7 +246,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
246	246
247	247	let semi = expr.span.shrink_to_hi().with_hi(semi_span.hi());
248	248	let sugg = crate::errors::RemoveSemiForCoerce { expr: expr.span, ret, semi };
249		diag.subdiagnostic(self.dcx(), sugg);
	249	diag.subdiagnostic(sugg);
250	250	}
251	251
252	252	/// When the previously checked expression (the scrutinee) diverges,

compiler/rustc_hir_typeck/src/cast.rs+9-15

...	...	@@ -1005,25 +1005,19 @@ impl<'a, 'tcx> CastCheck<'tcx> {
1005	1005	if let Some((deref_ty, _)) = derefed {
1006	1006	// Give a note about what the expr derefs to.
1007	1007	if deref_ty != self.expr_ty.peel_refs() {
1008		err.subdiagnostic(
1009		fcx.dcx(),
1010		errors::DerefImplsIsEmpty {
1011		span: self.expr_span,
1012		deref_ty: fcx.ty_to_string(deref_ty),
1013		},
1014		);
	1008	err.subdiagnostic(errors::DerefImplsIsEmpty {
	1009	span: self.expr_span,
	1010	deref_ty: fcx.ty_to_string(deref_ty),
	1011	});
1015	1012	}
1016	1013
1017	1014	// Create a multipart suggestion: add `!` and `.is_empty()` in
1018	1015	// place of the cast.
1019		err.subdiagnostic(
1020		fcx.dcx(),
1021		errors::UseIsEmpty {
1022		lo: self.expr_span.shrink_to_lo(),
1023		hi: self.span.with_lo(self.expr_span.hi()),
1024		expr_ty: fcx.ty_to_string(self.expr_ty),
1025		},
1026		);
	1016	err.subdiagnostic(errors::UseIsEmpty {
	1017	lo: self.expr_span.shrink_to_lo(),
	1018	hi: self.span.with_lo(self.expr_span.hi()),
	1019	expr_ty: fcx.ty_to_string(self.expr_ty),
	1020	});
1027	1021	}
1028	1022	}
1029	1023	}

compiler/rustc_hir_typeck/src/coercion.rs+5-11

...	...	@@ -1782,20 +1782,14 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
1782	1782	}
1783	1783
1784	1784	let rpid_def_span = fcx.tcx.def_span(rpit_def_id);
1785		err.subdiagnostic(
1786		fcx.tcx.dcx(),
1787		SuggestBoxingForReturnImplTrait::ChangeReturnType {
1788		start_sp: rpid_def_span.with_hi(rpid_def_span.lo() + BytePos(4)),
1789		end_sp: rpid_def_span.shrink_to_hi(),
1790		},
1791		);
	1785	err.subdiagnostic(SuggestBoxingForReturnImplTrait::ChangeReturnType {
	1786	start_sp: rpid_def_span.with_hi(rpid_def_span.lo() + BytePos(4)),
	1787	end_sp: rpid_def_span.shrink_to_hi(),
	1788	});
1792	1789
1793	1790	let (starts, ends) =
1794	1791	arm_spans.map(\|span\| (span.shrink_to_lo(), span.shrink_to_hi())).unzip();
1795		err.subdiagnostic(
1796		fcx.tcx.dcx(),
1797		SuggestBoxingForReturnImplTrait::BoxReturnExpr { starts, ends },
1798		);
	1792	err.subdiagnostic(SuggestBoxingForReturnImplTrait::BoxReturnExpr { starts, ends });
1799	1793	}
1800	1794
1801	1795	fn report_return_mismatched_types<'a>(

compiler/rustc_hir_typeck/src/expr.rs+2-5

...	...	@@ -384,7 +384,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
384	384	if let Some(sp) =
385	385	tcx.sess.psess.ambiguous_block_expr_parse.borrow().get(&sp)
386	386	{
387		err.subdiagnostic(self.dcx(), ExprParenthesesNeeded::surrounding(*sp));
	387	err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
388	388	}
389	389	oprnd_t = Ty::new_error(tcx, err.emit());
390	390	}
...	...	@@ -2018,10 +2018,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
2018	2018	.shrink_to_hi()
2019	2019	.to(range_end.span);
2020	2020
2021		err.subdiagnostic(
2022		self.dcx(),
2023		TypeMismatchFruTypo { expr_span: range_start.span, fru_span, expr },
2024		);
	2021	err.subdiagnostic(TypeMismatchFruTypo { expr_span: range_start.span, fru_span, expr });
2025	2022
2026	2023	// Suppress any range expr type mismatches
2027	2024	self.dcx().try_steal_replace_and_emit_err(

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs+1-1

...	...	@@ -1435,7 +1435,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
1435	1435	{
1436	1436	// The user provided `ptr::null()`, but the function expects
1437	1437	// `ptr::null_mut()`.
1438		err.subdiagnostic(self.dcx(), SuggestPtrNullMut { span: arg.span });
	1438	err.subdiagnostic(SuggestPtrNullMut { span: arg.span });
1439	1439	}
1440	1440	}
1441	1441

compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs+3-4

...	...	@@ -5,14 +5,13 @@ mod checks;
5	5	mod inspect_obligations;
6	6	mod suggestions;
7	7
8		use rustc_errors::ErrorGuaranteed;
	8	use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
9	9
10	10	use crate::coercion::DynamicCoerceMany;
11	11	use crate::fallback::DivergingFallbackBehavior;
12	12	use crate::fn_ctxt::checks::DivergingBlockBehavior;
13	13	use crate::{CoroutineTypes, Diverges, EnclosingBreakables, TypeckRootCtxt};
14	14	use hir::def_id::CRATE_DEF_ID;
15		use rustc_errors::DiagCtxt;
16	15	use rustc_hir as hir;
17	16	use rustc_hir::def_id::{DefId, LocalDefId};
18	17	use rustc_hir_analysis::hir_ty_lowering::{HirTyLowerer, RegionInferReason};
...	...	@@ -145,8 +144,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
145	144	}
146	145	}
147	146
148		pub(crate) fn dcx(&self) -> &'tcx DiagCtxt {
149		self.tcx.dcx()
	147	pub(crate) fn dcx(&self) -> DiagCtxtHandle<'tcx> {
	148	self.infcx.dcx()
150	149	}
151	150
152	151	pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs+40-58

...	...	@@ -460,16 +460,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
460	460	// but those checks need to be a bit more delicate and the benefit is diminishing.
461	461	if self.can_eq(self.param_env, found_ty_inner, peeled) && error_tys_equate_as_ref {
462	462	let sugg = prefix_wrap(".as_ref()");
463		err.subdiagnostic(
464		self.dcx(),
465		errors::SuggestConvertViaMethod {
466		span: expr.span.shrink_to_hi(),
467		sugg,
468		expected,
469		found,
470		borrow_removal_span,
471		},
472		);
	463	err.subdiagnostic(errors::SuggestConvertViaMethod {
	464	span: expr.span.shrink_to_hi(),
	465	sugg,
	466	expected,
	467	found,
	468	borrow_removal_span,
	469	});
473	470	return true;
474	471	} else if let Some((deref_ty, _)) =
475	472	self.autoderef(expr.span, found_ty_inner).silence_errors().nth(1)
...	...	@@ -477,16 +474,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
477	474	&& error_tys_equate_as_ref
478	475	{
479	476	let sugg = prefix_wrap(".as_deref()");
480		err.subdiagnostic(
481		self.dcx(),
482		errors::SuggestConvertViaMethod {
483		span: expr.span.shrink_to_hi(),
484		sugg,
485		expected,
486		found,
487		borrow_removal_span,
488		},
489		);
	477	err.subdiagnostic(errors::SuggestConvertViaMethod {
	478	span: expr.span.shrink_to_hi(),
	479	sugg,
	480	expected,
	481	found,
	482	borrow_removal_span,
	483	});
490	484	return true;
491	485	} else if let ty::Adt(adt, _) = found_ty_inner.peel_refs().kind()
492	486	&& self.tcx.is_lang_item(adt.did(), LangItem::String)
...	...	@@ -573,7 +567,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
573	567	end: span.shrink_to_hi(),
574	568	},
575	569	};
576		err.subdiagnostic(self.dcx(), suggest_boxing);
	570	err.subdiagnostic(suggest_boxing);
577	571
578	572	true
579	573	} else {
...	...	@@ -814,28 +808,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
814	808	match &fn_decl.output {
815	809	&hir::FnRetTy::DefaultReturn(span) if expected.is_unit() && !can_suggest => {
816	810	// `fn main()` must return `()`, do not suggest changing return type
817		err.subdiagnostic(self.dcx(), errors::ExpectedReturnTypeLabel::Unit { span });
	811	err.subdiagnostic(errors::ExpectedReturnTypeLabel::Unit { span });
818	812	return true;
819	813	}
820	814	&hir::FnRetTy::DefaultReturn(span) if expected.is_unit() => {
821	815	if let Some(found) = found.make_suggestable(self.tcx, false, None) {
822		err.subdiagnostic(
823		self.dcx(),
824		errors::AddReturnTypeSuggestion::Add { span, found: found.to_string() },
825		);
	816	err.subdiagnostic(errors::AddReturnTypeSuggestion::Add {
	817	span,
	818	found: found.to_string(),
	819	});
826	820	return true;
827	821	} else if let Some(sugg) = suggest_impl_trait(self, self.param_env, found) {
828		err.subdiagnostic(
829		self.dcx(),
830		errors::AddReturnTypeSuggestion::Add { span, found: sugg },
831		);
	822	err.subdiagnostic(errors::AddReturnTypeSuggestion::Add { span, found: sugg });
832	823	return true;
833	824	} else {
834	825	// FIXME: if `found` could be `impl Iterator` we should suggest that.
835		err.subdiagnostic(
836		self.dcx(),
837		errors::AddReturnTypeSuggestion::MissingHere { span },
838		);
	826	err.subdiagnostic(errors::AddReturnTypeSuggestion::MissingHere { span });
839	827	return true;
840	828	}
841	829	}
...	...	@@ -856,19 +844,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
856	844	debug!(?found);
857	845	if found.is_suggestable(self.tcx, false) {
858	846	if ty.span.is_empty() {
859		err.subdiagnostic(
860		self.dcx(),
861		errors::AddReturnTypeSuggestion::Add {
862		span: ty.span,
863		found: found.to_string(),
864		},
865		);
	847	err.subdiagnostic(errors::AddReturnTypeSuggestion::Add {
	848	span: ty.span,
	849	found: found.to_string(),
	850	});
866	851	return true;
867	852	} else {
868		err.subdiagnostic(
869		self.dcx(),
870		errors::ExpectedReturnTypeLabel::Other { span: ty.span, expected },
871		);
	853	err.subdiagnostic(errors::ExpectedReturnTypeLabel::Other {
	854	span: ty.span,
	855	expected,
	856	});
872	857	}
873	858	}
874	859	} else {
...	...	@@ -883,10 +868,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
883	868	let ty = self.normalize(hir_ty.span, ty);
884	869	let ty = self.tcx.instantiate_bound_regions_with_erased(ty);
885	870	if self.can_coerce(expected, ty) {
886		err.subdiagnostic(
887		self.dcx(),
888		errors::ExpectedReturnTypeLabel::Other { span: hir_ty.span, expected },
889		);
	871	err.subdiagnostic(errors::ExpectedReturnTypeLabel::Other {
	872	span: hir_ty.span,
	873	expected,
	874	});
890	875	self.try_suggest_return_impl_trait(err, expected, found, fn_id);
891	876	self.note_caller_chooses_ty_for_ty_param(err, expected, found);
892	877	return true;
...	...	@@ -905,13 +890,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
905	890	found: Ty<'tcx>,
906	891	) {
907	892	if let ty::Param(expected_ty_as_param) = expected.kind() {
908		diag.subdiagnostic(
909		self.dcx(),
910		errors::NoteCallerChoosesTyForTyParam {
911		ty_param_name: expected_ty_as_param.name,
912		found_ty: found,
913		},
914		);
	893	diag.subdiagnostic(errors::NoteCallerChoosesTyForTyParam {
	894	ty_param_name: expected_ty_as_param.name,
	895	found_ty: found,
	896	});
915	897	}
916	898	}
917	899
...	...	@@ -1136,7 +1118,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
1136	1118	let sp = self.tcx.sess.source_map().start_point(expr.span).with_parent(None);
1137	1119	if let Some(sp) = self.tcx.sess.psess.ambiguous_block_expr_parse.borrow().get(&sp) {
1138	1120	// `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }`
1139		err.subdiagnostic(self.dcx(), ExprParenthesesNeeded::surrounding(*sp));
	1121	err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
1140	1122	true
1141	1123	} else {
1142	1124	false
...	...	@@ -1250,7 +1232,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
1250	1232	} else {
1251	1233	return false;
1252	1234	};
1253		diag.subdiagnostic(self.dcx(), subdiag);
	1235	diag.subdiagnostic(subdiag);
1254	1236	return true;
1255	1237	}
1256	1238	}

compiler/rustc_hir_typeck/src/method/suggest.rs+12-15

...	...	@@ -3729,22 +3729,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
3729	3729	if impls_trait(trait_info.def_id) {
3730	3730	self.suggest_valid_traits(err, item_name, vec![trait_info.def_id], false);
3731	3731	} else {
3732		err.subdiagnostic(
3733		self.dcx(),
3734		CandidateTraitNote {
3735		span: self.tcx.def_span(trait_info.def_id),
3736		trait_name: self.tcx.def_path_str(trait_info.def_id),
3737		item_name,
3738		action_or_ty: if trait_missing_method {
3739		"NONE".to_string()
3740		} else {
3741		param_type.map_or_else(
3742		\|\| "implement".to_string(), // FIXME: it might only need to be imported into scope, not implemented.
3743		\|p\| p.to_string(),
3744		)
3745		},
	3732	err.subdiagnostic(CandidateTraitNote {
	3733	span: self.tcx.def_span(trait_info.def_id),
	3734	trait_name: self.tcx.def_path_str(trait_info.def_id),
	3735	item_name,
	3736	action_or_ty: if trait_missing_method {
	3737	"NONE".to_string()
	3738	} else {
	3739	param_type.map_or_else(
	3740	\|\| "implement".to_string(), // FIXME: it might only need to be imported into scope, not implemented.
	3741	\|p\| p.to_string(),
	3742	)
3746	3743	},
3747		);
	3744	});
3748	3745	}
3749	3746	}
3750	3747	trait_infos => {

compiler/rustc_hir_typeck/src/op.rs+1-1

...	...	@@ -820,7 +820,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
820	820	// If the previous expression was a block expression, suggest parentheses
821	821	// (turning this into a binary subtraction operation instead.)
822	822	// for example, `{2} - 2` -> `({2}) - 2` (see src\test\ui\parser\expr-as-stmt.rs)
823		err.subdiagnostic(self.dcx(), ExprParenthesesNeeded::surrounding(*sp));
	823	err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
824	824	} else {
825	825	match actual.kind() {
826	826	Uint(_) if op == hir::UnOp::Neg => {

compiler/rustc_infer/src/infer/error_reporting/mod.rs+6-6

...	...	@@ -61,8 +61,8 @@ use crate::traits::{
61	61	use crate::infer::relate::{self, RelateResult, TypeRelation};
62	62	use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
63	63	use rustc_errors::{
64		codes::*, pluralize, struct_span_code_err, Applicability, Diag, DiagCtxt, DiagStyledString,
65		ErrorGuaranteed, IntoDiagArg, StringPart,
	64	codes::*, pluralize, struct_span_code_err, Applicability, Diag, DiagCtxtHandle,
	65	DiagStyledString, ErrorGuaranteed, IntoDiagArg, StringPart,
66	66	};
67	67	use rustc_hir::def::DefKind;
68	68	use rustc_hir::def_id::{DefId, LocalDefId};
...	...	@@ -139,8 +139,8 @@ pub struct TypeErrCtxt<'a, 'tcx> {
139	139	}
140	140
141	141	impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
142		pub fn dcx(&self) -> &'tcx DiagCtxt {
143		self.infcx.tcx.dcx()
	142	pub fn dcx(&self) -> DiagCtxtHandle<'tcx> {
	143	self.infcx.dcx()
144	144	}
145	145
146	146	/// This is just to avoid a potential footgun of accidentally
...	...	@@ -892,7 +892,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
892	892	arm_ty,
893	893	arm_span,
894	894	) {
895		err.subdiagnostic(self.dcx(), subdiag);
	895	err.subdiagnostic(subdiag);
896	896	}
897	897	}
898	898	},
...	...	@@ -918,7 +918,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
918	918	else_ty,
919	919	else_span,
920	920	) {
921		err.subdiagnostic(self.dcx(), subdiag);
	921	err.subdiagnostic(subdiag);
922	922	}
923	923	}
924	924	ObligationCauseCode::LetElse => {

compiler/rustc_infer/src/infer/error_reporting/note.rs+1-1

...	...	@@ -369,7 +369,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
369	369	trait_predicates: trait_predicates.join(", "),
370	370	}
371	371	};
372		err.subdiagnostic(self.dcx(), suggestion);
	372	err.subdiagnostic(suggestion);
373	373	}
374	374
375	375	pub(super) fn report_placeholder_failure(

compiler/rustc_infer/src/infer/error_reporting/suggest.rs+14-15

...	...	@@ -121,7 +121,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
121	121	span_low: cause.span.shrink_to_lo(),
122	122	span_high: cause.span.shrink_to_hi(),
123	123	};
124		diag.subdiagnostic(self.dcx(), sugg);
	124	diag.subdiagnostic(sugg);
125	125	}
126	126	_ => {
127	127	// More than one matching variant.
...	...	@@ -130,7 +130,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
130	130	cause_span: cause.span,
131	131	compatible_variants,
132	132	};
133		diag.subdiagnostic(self.dcx(), sugg);
	133	diag.subdiagnostic(sugg);
134	134	}
135	135	}
136	136	}
...	...	@@ -202,10 +202,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
202	202	},
203	203	(_, Some(ty)) if self.same_type_modulo_infer(exp_found.expected, ty) => {
204	204	// FIXME: Seems like we can't have a suggestion and a note with different spans in a single subdiagnostic
205		diag.subdiagnostic(
206		self.dcx(),
207		ConsiderAddingAwait::FutureSugg { span: exp_span.shrink_to_hi() },
208		);
	205	diag.subdiagnostic(ConsiderAddingAwait::FutureSugg {
	206	span: exp_span.shrink_to_hi(),
	207	});
209	208	Some(ConsiderAddingAwait::FutureSuggNote { span: exp_span })
210	209	}
211	210	(Some(ty), _) if self.same_type_modulo_infer(ty, exp_found.found) => match cause.code()
...	...	@@ -233,7 +232,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
233	232	_ => None,
234	233	};
235	234	if let Some(subdiag) = subdiag {
236		diag.subdiagnostic(self.dcx(), subdiag);
	235	diag.subdiagnostic(subdiag);
237	236	}
238	237	}
239	238
...	...	@@ -269,7 +268,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
269	268	} else {
270	269	return;
271	270	};
272		diag.subdiagnostic(self.dcx(), suggestion);
	271	diag.subdiagnostic(suggestion);
273	272	}
274	273	}
275	274	}
...	...	@@ -401,15 +400,15 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
401	400	(true, false) => FunctionPointerSuggestion::UseRef { span, fn_name },
402	401	(false, true) => FunctionPointerSuggestion::RemoveRef { span, fn_name },
403	402	(true, true) => {
404		diag.subdiagnostic(self.dcx(), FnItemsAreDistinct);
	403	diag.subdiagnostic(FnItemsAreDistinct);
405	404	FunctionPointerSuggestion::CastRef { span, fn_name, sig: *sig }
406	405	}
407	406	(false, false) => {
408		diag.subdiagnostic(self.dcx(), FnItemsAreDistinct);
	407	diag.subdiagnostic(FnItemsAreDistinct);
409	408	FunctionPointerSuggestion::Cast { span, fn_name, sig: *sig }
410	409	}
411	410	};
412		diag.subdiagnostic(self.dcx(), sugg);
	411	diag.subdiagnostic(sugg);
413	412	}
414	413	(ty::FnDef(did1, args1), ty::FnDef(did2, args2)) => {
415	414	let expected_sig =
...	...	@@ -418,7 +417,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
418	417	&(self.normalize_fn_sig)(self.tcx.fn_sig(*did2).instantiate(self.tcx, args2));
419	418
420	419	if self.same_type_modulo_infer(expected_sig, found_sig) {
421		diag.subdiagnostic(self.dcx(), FnUniqTypes);
	420	diag.subdiagnostic(FnUniqTypes);
422	421	}
423	422
424	423	if !self.same_type_modulo_infer(found_sig, expected_sig)
...	...	@@ -447,7 +446,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
447	446	}
448	447	};
449	448
450		diag.subdiagnostic(self.dcx(), sug);
	449	diag.subdiagnostic(sug);
451	450	}
452	451	(ty::FnDef(did, args), ty::FnPtr(sig)) => {
453	452	let expected_sig =
...	...	@@ -466,7 +465,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
466	465	format!("{fn_name} as {found_sig}")
467	466	};
468	467
469		diag.subdiagnostic(self.dcx(), FnConsiderCasting { casting });
	468	diag.subdiagnostic(FnConsiderCasting { casting });
470	469	}
471	470	_ => {
472	471	return;
...	...	@@ -889,7 +888,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
889	888	let diag = self.consider_returning_binding_diag(blk, expected_ty);
890	889	match diag {
891	890	Some(diag) => {
892		err.subdiagnostic(self.dcx(), diag);
	891	err.subdiagnostic(diag);
893	892	true
894	893	}
895	894	None => false,

compiler/rustc_infer/src/infer/mod.rs+3-2

...	...	@@ -4,6 +4,7 @@ pub use lexical_region_resolve::RegionResolutionError;
4	4	pub use relate::combine::CombineFields;
5	5	pub use relate::combine::PredicateEmittingRelation;
6	6	pub use relate::StructurallyRelateAliases;
	7	use rustc_errors::DiagCtxtHandle;
7	8	pub use rustc_macros::{TypeFoldable, TypeVisitable};
8	9	pub use rustc_middle::ty::IntVarValue;
9	10	pub use BoundRegionConversionTime::*;
...	...	@@ -23,7 +24,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
23	24	use rustc_data_structures::sync::Lrc;
24	25	use rustc_data_structures::undo_log::Rollback;
25	26	use rustc_data_structures::unify as ut;
26		use rustc_errors::{Diag, DiagCtxt, ErrorGuaranteed};
	27	use rustc_errors::{Diag, ErrorGuaranteed};
27	28	use rustc_hir::def_id::{DefId, LocalDefId};
28	29	use rustc_macros::extension;
29	30	use rustc_middle::infer::canonical::{Canonical, CanonicalVarValues};
...	...	@@ -826,7 +827,7 @@ impl<'tcx> InferOk<'tcx, ()> {
826	827	}
827	828
828	829	impl<'tcx> InferCtxt<'tcx> {
829		pub fn dcx(&self) -> &'tcx DiagCtxt {
	830	pub fn dcx(&self) -> DiagCtxtHandle<'tcx> {
830	831	self.tcx.dcx()
831	832	}
832	833

compiler/rustc_interface/src/interface.rs+6-6

...	...	@@ -9,7 +9,7 @@ use rustc_data_structures::jobserver;
9	9	use rustc_data_structures::stable_hasher::StableHasher;
10	10	use rustc_data_structures::sync::Lrc;
11	11	use rustc_errors::registry::Registry;
12		use rustc_errors::{DiagCtxt, ErrorGuaranteed};
	12	use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
13	13	use rustc_lint::LintStore;
14	14	use rustc_middle::ty;
15	15	use rustc_middle::ty::CurrentGcx;
...	...	@@ -46,7 +46,7 @@ pub struct Compiler {
46	46	}
47	47
48	48	/// Converts strings provided as `--cfg [cfgspec]` into a `Cfg`.
49		pub(crate) fn parse_cfg(dcx: &DiagCtxt, cfgs: Vec<String>) -> Cfg {
	49	pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
50	50	cfgs.into_iter()
51	51	.map(\|s\| {
52	52	let psess = ParseSess::with_silent_emitter(
...	...	@@ -105,7 +105,7 @@ pub(crate) fn parse_cfg(dcx: &DiagCtxt, cfgs: Vec<String>) -> Cfg {
105	105	}
106	106
107	107	/// Converts strings provided as `--check-cfg [specs]` into a `CheckCfg`.
108		pub(crate) fn parse_check_cfg(dcx: &DiagCtxt, specs: Vec<String>) -> CheckCfg {
	108	pub(crate) fn parse_check_cfg(dcx: DiagCtxtHandle<'_>, specs: Vec<String>) -> CheckCfg {
109	109	// If any --check-cfg is passed then exhaustive_values and exhaustive_names
110	110	// are enabled by default.
111	111	let exhaustive_names = !specs.is_empty();
...	...	@@ -451,12 +451,12 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
451	451
452	452	codegen_backend.init(&sess);
453	453
454		let cfg = parse_cfg(&sess.dcx(), config.crate_cfg);
	454	let cfg = parse_cfg(sess.dcx(), config.crate_cfg);
455	455	let mut cfg = config::build_configuration(&sess, cfg);
456	456	util::add_configuration(&mut cfg, &mut sess, &*codegen_backend);
457	457	sess.psess.config = cfg;
458	458
459		let mut check_cfg = parse_check_cfg(&sess.dcx(), config.crate_check_cfg);
	459	let mut check_cfg = parse_check_cfg(sess.dcx(), config.crate_check_cfg);
460	460	check_cfg.fill_well_known(&sess.target);
461	461	sess.psess.check_config = check_cfg;
462	462
...	...	@@ -529,7 +529,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
529	529	}
530	530
531	531	pub fn try_print_query_stack(
532		dcx: &DiagCtxt,
	532	dcx: DiagCtxtHandle<'_>,
533	533	num_frames: Option<usize>,
534	534	file: Option<std::fs::File>,
535	535	) {

compiler/rustc_interface/src/tests.rs+1-1

...	...	@@ -70,7 +70,7 @@ where
70	70	Arc::default(),
71	71	Default::default(),
72	72	);
73		let cfg = parse_cfg(&sess.dcx(), matches.opt_strs("cfg"));
	73	let cfg = parse_cfg(sess.dcx(), matches.opt_strs("cfg"));
74	74	let cfg = build_configuration(&sess, cfg);
75	75	f(sess, cfg)
76	76	});

compiler/rustc_lint/src/lints.rs+3-3

...	...	@@ -1405,7 +1405,7 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
1405	1405	diag.note(fluent::lint_macro_to_change);
1406	1406	}
1407	1407	if let Some(cargo_update) = cargo_update {
1408		diag.subdiagnostic(&diag.dcx, cargo_update);
	1408	diag.subdiagnostic(cargo_update);
1409	1409	}
1410	1410
1411	1411	if has_trait {
...	...	@@ -1471,7 +1471,7 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
1471	1471	diag.note(fluent::lint_non_local_definitions_deprecation);
1472	1472
1473	1473	if let Some(cargo_update) = cargo_update {
1474		diag.subdiagnostic(&diag.dcx, cargo_update);
	1474	diag.subdiagnostic(cargo_update);
1475	1475	}
1476	1476	}
1477	1477	}
...	...	@@ -1957,7 +1957,7 @@ impl<'a> LintDiagnostic<'a, ()> for UnusedDef<'_, '_> {
1957	1957	diag.note(note.to_string());
1958	1958	}
1959	1959	if let Some(sugg) = self.suggestion {
1960		diag.subdiagnostic(diag.dcx, sugg);
	1960	diag.subdiagnostic(sugg);
1961	1961	}
1962	1962	}
1963	1963	}

compiler/rustc_macros/src/diagnostics/diagnostic.rs+1-1

...	...	@@ -78,7 +78,7 @@ impl<'a> DiagnosticDerive<'a> {
78	78	#[track_caller]
79	79	fn into_diag(
80	80	self,
81		dcx: &'_sess rustc_errors::DiagCtxt,
	81	dcx: rustc_errors::DiagCtxtHandle<'_sess>,
82	82	level: rustc_errors::Level
83	83	) -> rustc_errors::Diag<'_sess, G> {
84	84	#implementation

compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs+1-1

...	...	@@ -335,7 +335,7 @@ impl DiagnosticDeriveVariantBuilder {
335	335	}
336	336	}
337	337	(Meta::Path(_), "subdiagnostic") => {
338		return Ok(quote! { diag.subdiagnostic(diag.dcx, #binding); });
	338	return Ok(quote! { diag.subdiagnostic(#binding); });
339	339	}
340	340	_ => (),
341	341	}

compiler/rustc_metadata/src/creader.rs+3-3

...	...	@@ -10,7 +10,7 @@ use rustc_data_structures::fx::FxHashSet;
10	10	use rustc_data_structures::owned_slice::OwnedSlice;
11	11	use rustc_data_structures::svh::Svh;
12	12	use rustc_data_structures::sync::{self, FreezeReadGuard, FreezeWriteGuard};
13		use rustc_errors::DiagCtxt;
	13	use rustc_errors::DiagCtxtHandle;
14	14	use rustc_expand::base::SyntaxExtension;
15	15	use rustc_fs_util::try_canonicalize;
16	16	use rustc_hir::def_id::{CrateNum, LocalDefId, StableCrateId, LOCAL_CRATE};
...	...	@@ -91,8 +91,8 @@ impl<'a, 'tcx> std::ops::Deref for CrateLoader<'a, 'tcx> {
91	91	}
92	92
93	93	impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
94		fn dcx(&self) -> &'tcx DiagCtxt {
95		&self.tcx.dcx()
	94	fn dcx(&self) -> DiagCtxtHandle<'tcx> {
	95	self.tcx.dcx()
96	96	}
97	97	}
98	98

compiler/rustc_metadata/src/errors.rs+4-4

...	...	@@ -3,7 +3,7 @@ use std::{
3	3	path::{Path, PathBuf},
4	4	};
5	5
6		use rustc_errors::{codes::*, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level};
	6	use rustc_errors::{codes::*, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
7	7	use rustc_macros::{Diagnostic, Subdiagnostic};
8	8	use rustc_span::{sym, Span, Symbol};
9	9	use rustc_target::spec::{PanicStrategy, TargetTriple};
...	...	@@ -503,7 +503,7 @@ pub(crate) struct MultipleCandidates {
503	503	}
504	504
505	505	impl<G: EmissionGuarantee> Diagnostic<'_, G> for MultipleCandidates {
506		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	506	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
507	507	let mut diag = Diag::new(dcx, level, fluent::metadata_multiple_candidates);
508	508	diag.arg("crate_name", self.crate_name);
509	509	diag.arg("flavor", self.flavor);
...	...	@@ -602,7 +602,7 @@ pub struct InvalidMetadataFiles {
602	602
603	603	impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidMetadataFiles {
604	604	#[track_caller]
605		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	605	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
606	606	let mut diag = Diag::new(dcx, level, fluent::metadata_invalid_meta_files);
607	607	diag.arg("crate_name", self.crate_name);
608	608	diag.arg("add_info", self.add_info);
...	...	@@ -631,7 +631,7 @@ pub struct CannotFindCrate {
631	631
632	632	impl<G: EmissionGuarantee> Diagnostic<'_, G> for CannotFindCrate {
633	633	#[track_caller]
634		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	634	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
635	635	let mut diag = Diag::new(dcx, level, fluent::metadata_cannot_find_crate);
636	636	diag.arg("crate_name", self.crate_name);
637	637	diag.arg("current_crate", self.current_crate);

compiler/rustc_middle/src/macros.rs+4-4

...	...	@@ -4,10 +4,10 @@
4	4	///
5	5	/// If you have a span available, you should use [`span_bug`] instead.
6	6	///
7		/// If the bug should only be emitted when compilation didn't fail, [`DiagCtxt::span_delayed_bug`]
	7	/// If the bug should only be emitted when compilation didn't fail, [`DiagCtxtHandle::span_delayed_bug`]
8	8	/// may be useful.
9	9	///
10		/// [`DiagCtxt::span_delayed_bug`]: rustc_errors::DiagCtxt::span_delayed_bug
	10	/// [`DiagCtxtHandle::span_delayed_bug`]: rustc_errors::DiagCtxtHandle::span_delayed_bug
11	11	/// [`span_bug`]: crate::span_bug
12	12	#[macro_export]
13	13	macro_rules! bug {
...	...	@@ -30,10 +30,10 @@ macro_rules! bug {
30	30	/// at the code the compiler was compiling when it ICEd. This is the preferred way to trigger
31	31	/// ICEs.
32	32	///
33		/// If the bug should only be emitted when compilation didn't fail, [`DiagCtxt::span_delayed_bug`]
	33	/// If the bug should only be emitted when compilation didn't fail, [`DiagCtxtHandle::span_delayed_bug`]
34	34	/// may be useful.
35	35	///
36		/// [`DiagCtxt::span_delayed_bug`]: rustc_errors::DiagCtxt::span_delayed_bug
	36	/// [`DiagCtxtHandle::span_delayed_bug`]: rustc_errors::DiagCtxtHandle::span_delayed_bug
37	37	#[macro_export]
38	38	macro_rules! span_bug {
39	39	($span:expr, $msg:expr) => (

compiler/rustc_middle/src/middle/stability.rs+1-1

...	...	@@ -176,7 +176,7 @@ impl<'a, G: EmissionGuarantee> rustc_errors::LintDiagnostic<'a, G> for Deprecate
176	176	diag.arg("has_note", false);
177	177	}
178	178	if let Some(sub) = self.sub {
179		diag.subdiagnostic(diag.dcx, sub);
	179	diag.subdiagnostic(sub);
180	180	}
181	181	}
182	182	}

compiler/rustc_middle/src/ty/context.rs+4-2

...	...	@@ -47,7 +47,9 @@ use rustc_data_structures::sync::{self, FreezeReadGuard, Lock, Lrc, RwLock, Work
47	47	#[cfg(parallel_compiler)]
48	48	use rustc_data_structures::sync::{DynSend, DynSync};
49	49	use rustc_data_structures::unord::UnordSet;
50		use rustc_errors::{Applicability, Diag, DiagCtxt, ErrorGuaranteed, LintDiagnostic, MultiSpan};
	50	use rustc_errors::{
	51	Applicability, Diag, DiagCtxtHandle, ErrorGuaranteed, LintDiagnostic, MultiSpan,
	52	};
51	53	use rustc_hir as hir;
52	54	use rustc_hir::def::DefKind;
53	55	use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
...	...	@@ -1415,7 +1417,7 @@ impl<'tcx> TyCtxt<'tcx> {
1415	1417	)
1416	1418	}
1417	1419
1418		pub fn dcx(self) -> &'tcx DiagCtxt {
	1420	pub fn dcx(self) -> DiagCtxtHandle<'tcx> {
1419	1421	self.sess.dcx()
1420	1422	}
1421	1423	}

compiler/rustc_middle/src/ty/layout.rs+2-2

...	...	@@ -5,7 +5,7 @@ use crate::ty::normalize_erasing_regions::NormalizationError;
5	5	use crate::ty::{self, CoroutineArgsExt, Ty, TyCtxt, TypeVisitableExt};
6	6	use rustc_error_messages::DiagMessage;
7	7	use rustc_errors::{
8		Diag, DiagArgValue, DiagCtxt, Diagnostic, EmissionGuarantee, IntoDiagArg, Level,
	8	Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, IntoDiagArg, Level,
9	9	};
10	10	use rustc_hir as hir;
11	11	use rustc_hir::def_id::DefId;
...	...	@@ -1256,7 +1256,7 @@ pub enum FnAbiError<'tcx> {
1256	1256	}
1257	1257
1258	1258	impl<'a, 'b, G: EmissionGuarantee> Diagnostic<'a, G> for FnAbiError<'b> {
1259		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	1259	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
1260	1260	match self {
1261	1261	Self::Layout(e) => e.into_diagnostic().into_diag(dcx, level),
1262	1262	Self::AdjustForForeignAbi(call::AdjustForForeignAbiError::Unsupported {

compiler/rustc_mir_build/src/errors.rs+3-3

...	...	@@ -1,9 +1,9 @@
1	1	use crate::fluent_generated as fluent;
2		use rustc_errors::DiagArgValue;
3	2	use rustc_errors::{
4		codes::*, Applicability, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level, MultiSpan,
	3	codes::*, Applicability, Diag, Diagnostic, EmissionGuarantee, Level, MultiSpan,
5	4	SubdiagMessageOp, Subdiagnostic,
6	5	};
	6	use rustc_errors::{DiagArgValue, DiagCtxtHandle};
7	7	use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
8	8	use rustc_middle::ty::{self, Ty};
9	9	use rustc_pattern_analysis::{errors::Uncovered, rustc::RustcPatCtxt};
...	...	@@ -492,7 +492,7 @@ pub(crate) struct NonExhaustivePatternsTypeNotEmpty<'p, 'tcx, 'm> {
492	492	}
493	493
494	494	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for NonExhaustivePatternsTypeNotEmpty<'_, '_, '_> {
495		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'_, G> {
	495	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'_, G> {
496	496	let mut diag =
497	497	Diag::new(dcx, level, fluent::mir_build_non_exhaustive_patterns_type_not_empty);
498	498	diag.span(self.scrut_span);

compiler/rustc_mir_build/src/thir/pattern/check_match.rs+1-1

...	...	@@ -1137,7 +1137,7 @@ fn report_non_exhaustive_match<'p, 'tcx>(
1137	1137
1138	1138	let all_arms_have_guards = arms.iter().all(\|arm_id\| thir[*arm_id].guard.is_some());
1139	1139	if !is_empty_match && all_arms_have_guards {
1140		err.subdiagnostic(cx.tcx.dcx(), NonExhaustiveMatchAllArmsGuarded);
	1140	err.subdiagnostic(NonExhaustiveMatchAllArmsGuarded);
1141	1141	}
1142	1142	if let Some((span, sugg)) = suggestion {
1143	1143	err.span_suggestion_verbose(span, msg, sugg, Applicability::HasPlaceholders);

compiler/rustc_mir_transform/src/errors.rs+1-1

...	...	@@ -104,7 +104,7 @@ impl<'a> LintDiagnostic<'a, ()> for MustNotSupend<'_, '_> {
104	104	diag.primary_message(fluent::mir_transform_must_not_suspend);
105	105	diag.span_label(self.yield_sp, fluent::_subdiag::label);
106	106	if let Some(reason) = self.reason {
107		diag.subdiagnostic(diag.dcx, reason);
	107	diag.subdiagnostic(reason);
108	108	}
109	109	diag.span_help(self.src_sp, fluent::_subdiag::help);
110	110	diag.arg("pre", self.pre);

compiler/rustc_monomorphize/src/errors.rs+2-2

...	...	@@ -1,7 +1,7 @@
1	1	use std::path::PathBuf;
2	2
3	3	use crate::fluent_generated as fluent;
4		use rustc_errors::{Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level};
	4	use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
5	5	use rustc_macros::{Diagnostic, LintDiagnostic};
6	6	use rustc_span::{Span, Symbol};
7	7
...	...	@@ -48,7 +48,7 @@ pub struct UnusedGenericParamsHint {
48	48
49	49	impl<G: EmissionGuarantee> Diagnostic<'_, G> for UnusedGenericParamsHint {
50	50	#[track_caller]
51		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	51	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
52	52	let mut diag = Diag::new(dcx, level, fluent::monomorphize_unused_generic_params);
53	53	diag.span(self.span);
54	54	for (span, name) in self.param_spans.into_iter().zip(self.param_names) {

compiler/rustc_parse/src/errors.rs+3-3

...	...	@@ -3,7 +3,7 @@ use std::borrow::Cow;
3	3	use rustc_ast::token::Token;
4	4	use rustc_ast::{Path, Visibility};
5	5	use rustc_errors::{
6		codes::*, Applicability, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level,
	6	codes::*, Applicability, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
7	7	SubdiagMessageOp, Subdiagnostic,
8	8	};
9	9	use rustc_macros::{Diagnostic, Subdiagnostic};
...	...	@@ -1052,7 +1052,7 @@ pub(crate) struct ExpectedIdentifier {
1052	1052
1053	1053	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for ExpectedIdentifier {
1054	1054	#[track_caller]
1055		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	1055	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
1056	1056	let token_descr = TokenDescription::from_token(&self.token);
1057	1057
1058	1058	let mut diag = Diag::new(
...	...	@@ -1112,7 +1112,7 @@ pub(crate) struct ExpectedSemi {
1112	1112
1113	1113	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for ExpectedSemi {
1114	1114	#[track_caller]
1115		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	1115	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
1116	1116	let token_descr = TokenDescription::from_token(&self.token);
1117	1117
1118	1118	let mut diag = Diag::new(

compiler/rustc_parse/src/lexer/mod.rs+6-7

...	...	@@ -7,7 +7,7 @@ use rustc_ast::ast::{self, AttrStyle};
7	7	use rustc_ast::token::{self, CommentKind, Delimiter, IdentIsRaw, Token, TokenKind};
8	8	use rustc_ast::tokenstream::TokenStream;
9	9	use rustc_ast::util::unicode::contains_text_flow_control_chars;
10		use rustc_errors::{codes::*, Applicability, Diag, DiagCtxt, StashKey};
	10	use rustc_errors::{codes::*, Applicability, Diag, DiagCtxtHandle, StashKey};
11	11	use rustc_lexer::unescape::{self, EscapeError, Mode};
12	12	use rustc_lexer::{Base, DocStyle, RawStrError};
13	13	use rustc_lexer::{Cursor, LiteralKind};
...	...	@@ -113,8 +113,8 @@ struct StringReader<'psess, 'src> {
113	113	}
114	114
115	115	impl<'psess, 'src> StringReader<'psess, 'src> {
116		fn dcx(&self) -> &'psess DiagCtxt {
117		&self.psess.dcx
	116	fn dcx(&self) -> DiagCtxtHandle<'psess> {
	117	self.psess.dcx()
118	118	}
119	119
120	120	fn mk_sp(&self, lo: BytePos, hi: BytePos) -> Span {
...	...	@@ -248,8 +248,8 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
248	248	let suffix = if suffix_start < self.pos {
249	249	let string = self.str_from(suffix_start);
250	250	if string == "_" {
251		self.psess
252		.dcx
	251	self
	252	.dcx()
253	253	.emit_err(errors::UnderscoreLiteralSuffix { span: self.mk_sp(suffix_start, self.pos) });
254	254	None
255	255	} else {
...	...	@@ -597,8 +597,7 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
597	597	}
598	598
599	599	fn report_non_started_raw_string(&self, start: BytePos, bad_char: char) -> ! {
600		self.psess
601		.dcx
	600	self.dcx()
602	601	.struct_span_fatal(
603	602	self.mk_sp(start, self.pos),
604	603	format!(

compiler/rustc_parse/src/lexer/tokentrees.rs+2-2

...	...	@@ -71,7 +71,7 @@ impl<'psess, 'src> TokenTreesReader<'psess, 'src> {
71	71
72	72	fn eof_err(&mut self) -> PErr<'psess> {
73	73	let msg = "this file contains an unclosed delimiter";
74		let mut err = self.string_reader.psess.dcx.struct_span_err(self.token.span, msg);
	74	let mut err = self.string_reader.dcx().struct_span_err(self.token.span, msg);
75	75	for &(_, sp) in &self.diag_info.open_braces {
76	76	err.span_label(sp, "unclosed delimiter");
77	77	self.diag_info.unmatched_delims.push(UnmatchedDelim {
...	...	@@ -290,7 +290,7 @@ impl<'psess, 'src> TokenTreesReader<'psess, 'src> {
290	290	// An unexpected closing delimiter (i.e., there is no matching opening delimiter).
291	291	let token_str = token_to_string(&self.token);
292	292	let msg = format!("unexpected closing delimiter: `{token_str}`");
293		let mut err = self.string_reader.psess.dcx.struct_span_err(self.token.span, msg);
	293	let mut err = self.string_reader.dcx().struct_span_err(self.token.span, msg);
294	294
295	295	report_suspicious_mismatch_block(
296	296	&mut err,

compiler/rustc_parse/src/lexer/unescape_error_reporting.rs+2-2

...	...	@@ -3,7 +3,7 @@
3	3	use std::iter::once;
4	4	use std::ops::Range;
5	5
6		use rustc_errors::{Applicability, DiagCtxt, ErrorGuaranteed};
	6	use rustc_errors::{Applicability, DiagCtxtHandle, ErrorGuaranteed};
7	7	use rustc_lexer::unescape::{EscapeError, Mode};
8	8	use rustc_span::{BytePos, Span};
9	9	use tracing::debug;
...	...	@@ -11,7 +11,7 @@ use tracing::debug;
11	11	use crate::errors::{MoreThanOneCharNote, MoreThanOneCharSugg, NoBraceUnicodeSub, UnescapeError};
12	12
13	13	pub(crate) fn emit_unescape_error(
14		dcx: &DiagCtxt,
	14	dcx: DiagCtxtHandle<'_>,
15	15	// interior part of the literal, between quotes
16	16	lit: &str,
17	17	// full span of the literal, including quotes and any prefix

compiler/rustc_parse/src/lexer/unicode_chars.rs+1-1

...	...	@@ -351,7 +351,7 @@ pub(super) fn check_for_substitution(
351	351
352	352	let Some((_, ascii_name, token)) = ASCII_ARRAY.iter().find(\|&&(s, _, _)\| s == ascii_str) else {
353	353	let msg = format!("substitution character not found for '{ch}'");
354		reader.psess.dcx.span_bug(span, msg);
	354	reader.dcx().span_bug(span, msg);
355	355	};
356	356
357	357	// special help suggestion for "directed" double quotes

compiler/rustc_parse/src/lib.rs+3-3

...	...	@@ -73,7 +73,7 @@ pub fn new_parser_from_file<'a>(
73	73	) -> Result<Parser<'a>, Vec<Diag<'a>>> {
74	74	let source_file = psess.source_map().load_file(path).unwrap_or_else(\|e\| {
75	75	let msg = format!("couldn't read {}: {}", path.display(), e);
76		let mut err = psess.dcx.struct_fatal(msg);
	76	let mut err = psess.dcx().struct_fatal(msg);
77	77	if let Some(sp) = sp {
78	78	err.span(sp);
79	79	}
...	...	@@ -115,7 +115,7 @@ fn source_file_to_stream<'psess>(
115	115	override_span: Option<Span>,
116	116	) -> Result<TokenStream, Vec<Diag<'psess>>> {
117	117	let src = source_file.src.as_ref().unwrap_or_else(\|\| {
118		psess.dcx.bug(format!(
	118	psess.dcx().bug(format!(
119	119	"cannot lex `source_file` without source: {}",
120	120	psess.source_map().filename_for_diagnostics(&source_file.name)
121	121	));
...	...	@@ -179,7 +179,7 @@ pub fn parse_cfg_attr(
179	179	}
180	180	}
181	181	_ => {
182		psess.dcx.emit_err(errors::MalformedCfgAttr {
	182	psess.dcx().emit_err(errors::MalformedCfgAttr {
183	183	span: attr.span,
184	184	sugg: CFG_ATTR_GRAMMAR_HELP,
185	185	});

compiler/rustc_parse/src/parser/attr_wrapper.rs+1-1

...	...	@@ -41,7 +41,7 @@ impl AttrWrapper {
41	41	}
42	42
43	43	pub(crate) fn take_for_recovery(self, psess: &ParseSess) -> AttrVec {
44		psess.dcx.span_delayed_bug(
	44	psess.dcx().span_delayed_bug(
45	45	self.attrs.get(0).map(\|attr\| attr.span).unwrap_or(DUMMY_SP),
46	46	"AttrVec is taken for recovery but no error is produced",
47	47	);

compiler/rustc_parse/src/parser/diagnostics.rs+5-5

...	...	@@ -34,7 +34,7 @@ use rustc_ast::{
34	34	use rustc_ast_pretty::pprust;
35	35	use rustc_data_structures::fx::FxHashSet;
36	36	use rustc_errors::{
37		pluralize, Applicability, Diag, DiagCtxt, ErrorGuaranteed, FatalError, PErr, PResult,
	37	pluralize, Applicability, Diag, DiagCtxtHandle, ErrorGuaranteed, FatalError, PErr, PResult,
38	38	Subdiagnostic,
39	39	};
40	40	use rustc_session::errors::ExprParenthesesNeeded;
...	...	@@ -240,8 +240,8 @@ impl<'a> DerefMut for SnapshotParser<'a> {
240	240	}
241	241
242	242	impl<'a> Parser<'a> {
243		pub fn dcx(&self) -> &'a DiagCtxt {
244		&self.psess.dcx
	243	pub fn dcx(&self) -> DiagCtxtHandle<'a> {
	244	self.psess.dcx()
245	245	}
246	246
247	247	/// Replace `self` with `snapshot.parser`.
...	...	@@ -666,7 +666,7 @@ impl<'a> Parser<'a> {
666	666	{
667	667	err.note("you may be trying to write a c-string literal");
668	668	err.note("c-string literals require Rust 2021 or later");
669		err.subdiagnostic(self.dcx(), HelpUseLatestEdition::new());
	669	err.subdiagnostic(HelpUseLatestEdition::new());
670	670	}
671	671
672	672	// `pub` may be used for an item or `pub(crate)`
...	...	@@ -2357,7 +2357,7 @@ impl<'a> Parser<'a> {
2357	2357	let mut err = self.dcx().struct_span_err(span, msg);
2358	2358	let sp = self.psess.source_map().start_point(self.token.span);
2359	2359	if let Some(sp) = self.psess.ambiguous_block_expr_parse.borrow().get(&sp) {
2360		err.subdiagnostic(self.dcx(), ExprParenthesesNeeded::surrounding(*sp));
	2360	err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
2361	2361	}
2362	2362	err.span_label(span, "expected expression");
2363	2363

compiler/rustc_parse/src/parser/expr.rs+1-1

...	...	@@ -1461,7 +1461,7 @@ impl<'a> Parser<'a> {
1461	1461	// If the input is something like `if a { 1 } else { 2 } \| if a { 3 } else { 4 }`
1462	1462	// then suggest parens around the lhs.
1463	1463	if let Some(sp) = this.psess.ambiguous_block_expr_parse.borrow().get(&lo) {
1464		err.subdiagnostic(this.dcx(), ExprParenthesesNeeded::surrounding(*sp));
	1464	err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
1465	1465	}
1466	1466	err
1467	1467	})

compiler/rustc_parse/src/parser/item.rs+5-8

...	...	@@ -1966,7 +1966,7 @@ impl<'a> Parser<'a> {
1966	1966	if self.token.kind == token::Not {
1967	1967	if let Err(mut err) = self.unexpected() {
1968	1968	// Encounter the macro invocation
1969		err.subdiagnostic(self.dcx(), MacroExpandsToAdtField { adt_ty });
	1969	err.subdiagnostic(MacroExpandsToAdtField { adt_ty });
1970	1970	return Err(err);
1971	1971	}
1972	1972	}
...	...	@@ -2382,13 +2382,10 @@ impl<'a> Parser<'a> {
2382	2382	.into_iter()
2383	2383	.any(\|s\| self.prev_token.is_ident_named(s));
2384	2384
2385		err.subdiagnostic(
2386		self.dcx(),
2387		errors::FnTraitMissingParen {
2388		span: self.prev_token.span,
2389		machine_applicable,
2390		},
2391		);
	2385	err.subdiagnostic(errors::FnTraitMissingParen {
	2386	span: self.prev_token.span,
	2387	machine_applicable,
	2388	});
2392	2389	}
2393	2390	return Err(err);
2394	2391	}

compiler/rustc_parse/src/parser/mod.rs+1-1

...	...	@@ -1596,7 +1596,7 @@ pub(crate) fn make_unclosed_delims_error(
1596	1596	if let Some(sp) = unmatched.unclosed_span {
1597	1597	spans.push(sp);
1598	1598	};
1599		let err = psess.dcx.create_err(MismatchedClosingDelimiter {
	1599	let err = psess.dcx().create_err(MismatchedClosingDelimiter {
1600	1600	spans,
1601	1601	delimiter: pprust::token_kind_to_string(&token::CloseDelim(found_delim)).to_string(),
1602	1602	unmatched: unmatched.found_span,

compiler/rustc_parse/src/parser/pat.rs+1-1

...	...	@@ -851,7 +851,7 @@ impl<'a> Parser<'a> {
851	851
852	852	let sp = self.psess.source_map().start_point(self.token.span);
853	853	if let Some(sp) = self.psess.ambiguous_block_expr_parse.borrow().get(&sp) {
854		err.subdiagnostic(self.dcx(), ExprParenthesesNeeded::surrounding(*sp));
	854	err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
855	855	}
856	856
857	857	Err(err)

compiler/rustc_parse/src/parser/tests.rs+3-3

...	...	@@ -61,7 +61,7 @@ where
61	61	{
62	62	let mut p = string_to_parser(&psess, s);
63	63	let x = f(&mut p).unwrap();
64		p.psess.dcx.abort_if_errors();
	64	p.dcx().abort_if_errors();
65	65	x
66	66	}
67	67
...	...	@@ -193,7 +193,7 @@ impl<T: Write> Write for Shared<T> {
193	193	#[allow(rustc::untranslatable_diagnostic)] // no translation needed for tests
194	194	fn test_harness(file_text: &str, span_labels: Vec<SpanLabel>, expected_output: &str) {
195	195	create_default_session_globals_then(\|\| {
196		let (handler, source_map, output) = create_test_handler();
	196	let (dcx, source_map, output) = create_test_handler();
197	197	source_map.new_source_file(Path::new("test.rs").to_owned().into(), file_text.to_owned());
198	198
199	199	let primary_span = make_span(&file_text, &span_labels[0].start, &span_labels[0].end);
...	...	@@ -205,7 +205,7 @@ fn test_harness(file_text: &str, span_labels: Vec<SpanLabel>, expected_output: &
205	205	println!("text: {:?}", source_map.span_to_snippet(span));
206	206	}
207	207
208		handler.span_err(msp, "foo");
	208	dcx.handle().span_err(msp, "foo");
209	209
210	210	assert!(
211	211	expected_output.chars().next() == Some('\n'),

compiler/rustc_parse/src/validate_attr.rs+5-5

...	...	@@ -65,7 +65,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
65	65	let res = match res {
66	66	Ok(lit) => {
67	67	if token_lit.suffix.is_some() {
68		let mut err = psess.dcx.struct_span_err(
	68	let mut err = psess.dcx().struct_span_err(
69	69	expr.span,
70	70	"suffixed literals are not allowed in attributes",
71	71	);
...	...	@@ -98,7 +98,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
98	98	// the error because an earlier error will have already
99	99	// been reported.
100	100	let msg = "attribute value must be a literal";
101		let mut err = psess.dcx.struct_span_err(expr.span, msg);
	101	let mut err = psess.dcx().struct_span_err(expr.span, msg);
102	102	if let ast::ExprKind::Err(_) = expr.kind {
103	103	err.downgrade_to_delayed_bug();
104	104	}
...	...	@@ -114,7 +114,7 @@ fn check_meta_bad_delim(psess: &ParseSess, span: DelimSpan, delim: Delimiter) {
114	114	if let Delimiter::Parenthesis = delim {
115	115	return;
116	116	}
117		psess.dcx.emit_err(errors::MetaBadDelim {
	117	psess.dcx().emit_err(errors::MetaBadDelim {
118	118	span: span.entire(),
119	119	sugg: errors::MetaBadDelimSugg { open: span.open, close: span.close },
120	120	});
...	...	@@ -124,7 +124,7 @@ pub(super) fn check_cfg_attr_bad_delim(psess: &ParseSess, span: DelimSpan, delim
124	124	if let Delimiter::Parenthesis = delim {
125	125	return;
126	126	}
127		psess.dcx.emit_err(errors::CfgAttrBadDelim {
	127	psess.dcx().emit_err(errors::CfgAttrBadDelim {
128	128	span: span.entire(),
129	129	sugg: errors::MetaBadDelimSugg { open: span.open, close: span.close },
130	130	});
...	...	@@ -191,7 +191,7 @@ fn emit_malformed_attribute(
191	191	} else {
192	192	suggestions.sort();
193	193	psess
194		.dcx
	194	.dcx()
195	195	.struct_span_err(span, error_msg)
196	196	.with_span_suggestions(
197	197	span,

compiler/rustc_passes/src/check_attr.rs+3-3

...	...	@@ -8,8 +8,8 @@ use crate::{errors, fluent_generated as fluent};
8	8	use rustc_ast::{ast, AttrKind, AttrStyle, Attribute, LitKind};
9	9	use rustc_ast::{MetaItemKind, MetaItemLit, NestedMetaItem};
10	10	use rustc_data_structures::fx::FxHashMap;
11		use rustc_errors::StashKey;
12		use rustc_errors::{Applicability, DiagCtxt, IntoDiagArg, MultiSpan};
	11	use rustc_errors::{Applicability, IntoDiagArg, MultiSpan};
	12	use rustc_errors::{DiagCtxtHandle, StashKey};
13	13	use rustc_feature::{
14	14	is_unsafe_attr, AttributeDuplicates, AttributeType, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP,
15	15	};
...	...	@@ -99,7 +99,7 @@ struct CheckAttrVisitor<'tcx> {
99	99	}
100	100
101	101	impl<'tcx> CheckAttrVisitor<'tcx> {
102		fn dcx(&self) -> &'tcx DiagCtxt {
	102	fn dcx(&self) -> DiagCtxtHandle<'tcx> {
103	103	self.tcx.dcx()
104	104	}
105	105

compiler/rustc_passes/src/errors.rs+7-7

...	...	@@ -6,8 +6,8 @@ use std::{
6	6	use crate::fluent_generated as fluent;
7	7	use rustc_ast::{ast, Label};
8	8	use rustc_errors::{
9		codes::*, Applicability, Diag, DiagCtxt, DiagSymbolList, Diagnostic, EmissionGuarantee, Level,
10		MultiSpan, SubdiagMessageOp, Subdiagnostic,
	9	codes::*, Applicability, Diag, DiagCtxtHandle, DiagSymbolList, Diagnostic, EmissionGuarantee,
	10	Level, MultiSpan, SubdiagMessageOp, Subdiagnostic,
11	11	};
12	12	use rustc_hir::{self as hir, ExprKind, Target};
13	13	use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
...	...	@@ -880,7 +880,7 @@ pub struct ItemFollowingInnerAttr {
880	880
881	881	impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidAttrAtCrateLevel {
882	882	#[track_caller]
883		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	883	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
884	884	let mut diag = Diag::new(dcx, level, fluent::passes_invalid_attr_at_crate_level);
885	885	diag.span(self.span);
886	886	diag.arg("name", self.name);
...	...	@@ -1030,7 +1030,7 @@ pub struct BreakNonLoop<'a> {
1030	1030
1031	1031	impl<'a, G: EmissionGuarantee> Diagnostic<'_, G> for BreakNonLoop<'a> {
1032	1032	#[track_caller]
1033		fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> {
	1033	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
1034	1034	let mut diag = Diag::new(dcx, level, fluent::passes_break_non_loop);
1035	1035	diag.span(self.span);
1036	1036	diag.code(E0571);
...	...	@@ -1176,7 +1176,7 @@ pub struct NakedFunctionsAsmBlock {
1176	1176
1177	1177	impl<G: EmissionGuarantee> Diagnostic<'_, G> for NakedFunctionsAsmBlock {
1178	1178	#[track_caller]
1179		fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> {
	1179	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
1180	1180	let mut diag = Diag::new(dcx, level, fluent::passes_naked_functions_asm_block);
1181	1181	diag.span(self.span);
1182	1182	diag.code(E0787);
...	...	@@ -1264,7 +1264,7 @@ pub struct NoMainErr {
1264	1264
1265	1265	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for NoMainErr {
1266	1266	#[track_caller]
1267		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	1267	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
1268	1268	let mut diag = Diag::new(dcx, level, fluent::passes_no_main_function);
1269	1269	diag.span(DUMMY_SP);
1270	1270	diag.code(E0601);
...	...	@@ -1322,7 +1322,7 @@ pub struct DuplicateLangItem {
1322	1322
1323	1323	impl<G: EmissionGuarantee> Diagnostic<'_, G> for DuplicateLangItem {
1324	1324	#[track_caller]
1325		fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> {
	1325	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
1326	1326	let mut diag = Diag::new(
1327	1327	dcx,
1328	1328	level,

compiler/rustc_query_system/src/query/job.rs+2-2

...	...	@@ -4,7 +4,7 @@ use crate::query::plumbing::CycleError;
4	4	use crate::query::DepKind;
5	5	use crate::query::{QueryContext, QueryStackFrame};
6	6	use rustc_data_structures::fx::FxHashMap;
7		use rustc_errors::{Diag, DiagCtxt};
	7	use rustc_errors::{Diag, DiagCtxtHandle};
8	8	use rustc_hir::def::DefKind;
9	9	use rustc_session::Session;
10	10	use rustc_span::Span;
...	...	@@ -600,7 +600,7 @@ pub fn report_cycle<'a>(
600	600	pub fn print_query_stack<Qcx: QueryContext>(
601	601	qcx: Qcx,
602	602	mut current_query: Option<QueryJobId>,
603		dcx: &DiagCtxt,
	603	dcx: DiagCtxtHandle<'_>,
604	604	num_frames: Option<usize>,
605	605	mut file: Option<std::fs::File>,
606	606	) -> usize {

compiler/rustc_resolve/src/diagnostics.rs+33-43

...	...	@@ -6,7 +6,7 @@ use rustc_ast::{MetaItemKind, NestedMetaItem};
6	6	use rustc_ast_pretty::pprust;
7	7	use rustc_data_structures::fx::FxHashSet;
8	8	use rustc_errors::{
9		codes::*, report_ambiguity_error, struct_span_code_err, Applicability, Diag, DiagCtxt,
	9	codes::*, report_ambiguity_error, struct_span_code_err, Applicability, Diag, DiagCtxtHandle,
10	10	ErrorGuaranteed, MultiSpan, SuggestionStyle,
11	11	};
12	12	use rustc_feature::BUILTIN_ATTRIBUTES;
...	...	@@ -120,7 +120,7 @@ fn reduce_impl_span_to_impl_keyword(sm: &SourceMap, impl_span: Span) -> Span {
120	120	}
121	121
122	122	impl<'a, 'tcx> Resolver<'a, 'tcx> {
123		pub(crate) fn dcx(&self) -> &'tcx DiagCtxt {
	123	pub(crate) fn dcx(&self) -> DiagCtxtHandle<'tcx> {
124	124	self.tcx.dcx()
125	125	}
126	126
...	...	@@ -334,12 +334,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
334	334	Some((import, _, true)) if should_remove_import && !import.is_glob() => {
335	335	// Simple case - remove the entire import. Due to the above match arm, this can
336	336	// only be a single use so just remove it entirely.
337		err.subdiagnostic(
338		self.tcx.dcx(),
339		errors::ToolOnlyRemoveUnnecessaryImport {
340		span: import.use_span_with_attributes,
341		},
342		);
	337	err.subdiagnostic(errors::ToolOnlyRemoveUnnecessaryImport {
	338	span: import.use_span_with_attributes,
	339	});
343	340	}
344	341	Some((import, span, _)) => {
345	342	self.add_suggestion_for_rename_of_use(&mut err, name, import, span);
...	...	@@ -405,12 +402,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
405	402	}
406	403
407	404	if let Some(suggestion) = suggestion {
408		err.subdiagnostic(
409		self.dcx(),
410		ChangeImportBindingSuggestion { span: binding_span, suggestion },
411		);
	405	err.subdiagnostic(ChangeImportBindingSuggestion { span: binding_span, suggestion });
412	406	} else {
413		err.subdiagnostic(self.dcx(), ChangeImportBinding { span: binding_span });
	407	err.subdiagnostic(ChangeImportBinding { span: binding_span });
414	408	}
415	409	}
416	410
...	...	@@ -458,20 +452,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
458	452	// previous imports.
459	453	if found_closing_brace {
460	454	if let Some(span) = extend_span_to_previous_binding(self.tcx.sess, span) {
461		err.subdiagnostic(self.dcx(), errors::ToolOnlyRemoveUnnecessaryImport { span });
	455	err.subdiagnostic(errors::ToolOnlyRemoveUnnecessaryImport { span });
462	456	} else {
463	457	// Remove the entire line if we cannot extend the span back, this indicates an
464	458	// `issue_52891::{self}` case.
465		err.subdiagnostic(
466		self.dcx(),
467		errors::RemoveUnnecessaryImport { span: import.use_span_with_attributes },
468		);
	459	err.subdiagnostic(errors::RemoveUnnecessaryImport {
	460	span: import.use_span_with_attributes,
	461	});
469	462	}
470	463
471	464	return;
472	465	}
473	466
474		err.subdiagnostic(self.dcx(), errors::RemoveUnnecessaryImport { span });
	467	err.subdiagnostic(errors::RemoveUnnecessaryImport { span });
475	468	}
476	469
477	470	pub(crate) fn lint_if_path_starts_with_module(
...	...	@@ -682,10 +675,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
682	675	.dcx()
683	676	.create_err(errors::VariableIsNotBoundInAllPatterns { multispan: msp, name });
684	677	for sp in target_sp {
685		err.subdiagnostic(self.dcx(), errors::PatternDoesntBindName { span: sp, name });
	678	err.subdiagnostic(errors::PatternDoesntBindName { span: sp, name });
686	679	}
687	680	for sp in origin_sp {
688		err.subdiagnostic(self.dcx(), errors::VariableNotInAllPatterns { span: sp });
	681	err.subdiagnostic(errors::VariableNotInAllPatterns { span: sp });
689	682	}
690	683	if could_be_path {
691	684	let import_suggestions = self.lookup_import_candidates(
...	...	@@ -1446,12 +1439,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1446	1439	);
1447	1440
1448	1441	if macro_kind == MacroKind::Bang && ident.name == sym::macro_rules {
1449		err.subdiagnostic(self.dcx(), MaybeMissingMacroRulesName { span: ident.span });
	1442	err.subdiagnostic(MaybeMissingMacroRulesName { span: ident.span });
1450	1443	return;
1451	1444	}
1452	1445
1453	1446	if macro_kind == MacroKind::Derive && (ident.name == sym::Send \|\| ident.name == sym::Sync) {
1454		err.subdiagnostic(self.dcx(), ExplicitUnsafeTraits { span: ident.span, ident });
	1447	err.subdiagnostic(ExplicitUnsafeTraits { span: ident.span, ident });
1455	1448	return;
1456	1449	}
1457	1450
...	...	@@ -1467,14 +1460,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1467	1460	let scope = self.local_macro_def_scopes[&def_id];
1468	1461	let parent_nearest = parent_scope.module.nearest_parent_mod();
1469	1462	if Some(parent_nearest) == scope.opt_def_id() {
1470		err.subdiagnostic(self.dcx(), MacroDefinedLater { span: unused_ident.span });
1471		err.subdiagnostic(self.dcx(), MacroSuggMovePosition { span: ident.span, ident });
	1463	err.subdiagnostic(MacroDefinedLater { span: unused_ident.span });
	1464	err.subdiagnostic(MacroSuggMovePosition { span: ident.span, ident });
1472	1465	return;
1473	1466	}
1474	1467	}
1475	1468
1476	1469	if self.macro_names.contains(&ident.normalize_to_macros_2_0()) {
1477		err.subdiagnostic(self.dcx(), AddedMacroUse);
	1470	err.subdiagnostic(AddedMacroUse);
1478	1471	return;
1479	1472	}
1480	1473
...	...	@@ -1484,13 +1477,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1484	1477	let span = self.def_span(def_id);
1485	1478	let source_map = self.tcx.sess.source_map();
1486	1479	let head_span = source_map.guess_head_span(span);
1487		err.subdiagnostic(
1488		self.dcx(),
1489		ConsiderAddingADerive {
1490		span: head_span.shrink_to_lo(),
1491		suggestion: "#[derive(Default)]\n".to_string(),
1492		},
1493		);
	1480	err.subdiagnostic(ConsiderAddingADerive {
	1481	span: head_span.shrink_to_lo(),
	1482	suggestion: "#[derive(Default)]\n".to_string(),
	1483	});
1494	1484	}
1495	1485	for ns in [Namespace::MacroNS, Namespace::TypeNS, Namespace::ValueNS] {
1496	1486	if let Ok(binding) = self.early_resolve_ident_in_lexical_scope(
...	...	@@ -1533,7 +1523,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1533	1523	imported_ident: ident,
1534	1524	imported_ident_desc: &desc,
1535	1525	};
1536		err.subdiagnostic(self.tcx.dcx(), note);
	1526	err.subdiagnostic(note);
1537	1527	// Silence the 'unused import' warning we might get,
1538	1528	// since this diagnostic already covers that import.
1539	1529	self.record_use(ident, binding, Used::Other);
...	...	@@ -1544,7 +1534,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1544	1534	imported_ident: ident,
1545	1535	imported_ident_desc: &desc,
1546	1536	};
1547		err.subdiagnostic(self.tcx.dcx(), note);
	1537	err.subdiagnostic(note);
1548	1538	return;
1549	1539	}
1550	1540	}
...	...	@@ -1599,7 +1589,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1599	1589	}
1600	1590	};
1601	1591	did_label_def_span = true;
1602		err.subdiagnostic(self.tcx.dcx(), label);
	1592	err.subdiagnostic(label);
1603	1593	}
1604	1594
1605	1595	let (span, msg, sugg) = if let SuggestionTarget::SimilarlyNamed = suggestion.target
...	...	@@ -1790,7 +1780,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1790	1780	outer_ident_descr: this_res.descr(),
1791	1781	outer_ident,
1792	1782	};
1793		err.subdiagnostic(self.tcx.dcx(), label);
	1783	err.subdiagnostic(label);
1794	1784	}
1795	1785	}
1796	1786
...	...	@@ -1805,14 +1795,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1805	1795	non_exhaustive = Some(attr.span);
1806	1796	} else if let Some(span) = ctor_fields_span {
1807	1797	let label = errors::ConstructorPrivateIfAnyFieldPrivate { span };
1808		err.subdiagnostic(self.tcx.dcx(), label);
	1798	err.subdiagnostic(label);
1809	1799	if let Res::Def(_, d) = res
1810	1800	&& let Some(fields) = self.field_visibility_spans.get(&d)
1811	1801	{
1812	1802	let spans = fields.iter().map(\|span\| *span).collect();
1813	1803	let sugg =
1814	1804	errors::ConsiderMakingTheFieldPublic { spans, number_of_fields: fields.len() };
1815		err.subdiagnostic(self.tcx.dcx(), sugg);
	1805	err.subdiagnostic(sugg);
1816	1806	}
1817	1807	}
1818	1808
...	...	@@ -1921,7 +1911,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1921	1911	first,
1922	1912	dots: next_binding.is_some(),
1923	1913	};
1924		err.subdiagnostic(self.tcx.dcx(), note);
	1914	err.subdiagnostic(note);
1925	1915	}
1926	1916	// We prioritize shorter paths, non-core imports and direct imports over the alternatives.
1927	1917	sugg_paths.sort_by_key(\|(p, reexport)\| (p.len(), p[0] == "core", *reexport));
...	...	@@ -1940,7 +1930,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1940	1930	} else {
1941	1931	errors::ImportIdent::Directly { span: dedup_span, ident, path }
1942	1932	};
1943		err.subdiagnostic(self.tcx.dcx(), sugg);
	1933	err.subdiagnostic(sugg);
1944	1934	break;
1945	1935	}
1946	1936
...	...	@@ -2521,14 +2511,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
2521	2511	}
2522	2512
2523	2513	let note = errors::FoundItemConfigureOut { span: name.span };
2524		err.subdiagnostic(self.tcx.dcx(), note);
	2514	err.subdiagnostic(note);
2525	2515
2526	2516	if let MetaItemKind::List(nested) = &cfg.kind
2527	2517	&& let NestedMetaItem::MetaItem(meta_item) = &nested[0]
2528	2518	&& let MetaItemKind::NameValue(feature_name) = &meta_item.kind
2529	2519	{
2530	2520	let note = errors::ItemWasBehindFeature { feature: feature_name.symbol };
2531		err.subdiagnostic(self.tcx.dcx(), note);
	2521	err.subdiagnostic(note);
2532	2522	}
2533	2523	}
2534	2524	}

compiler/rustc_resolve/src/imports.rs+2-2

...	...	@@ -1294,12 +1294,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
1294	1294	// exclude decl_macro
1295	1295	if self.get_macro_by_def_id(def_id).macro_rules =>
1296	1296	{
1297		err.subdiagnostic(self.dcx(), ConsiderAddingMacroExport {
	1297	err.subdiagnostic( ConsiderAddingMacroExport {
1298	1298	span: binding.span,
1299	1299	});
1300	1300	}
1301	1301	_ => {
1302		err.subdiagnostic(self.dcx(), ConsiderMarkingAsPub {
	1302	err.subdiagnostic( ConsiderMarkingAsPub {
1303	1303	span: import.span,
1304	1304	ident,
1305	1305	});

compiler/rustc_resolve/src/late/diagnostics.rs+9-15

...	...	@@ -1109,14 +1109,11 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
1109	1109	Side::Start => (segment.ident.span.between(range.span), " @ ".into()),
1110	1110	Side::End => (range.span.to(segment.ident.span), format!("{} @ ..", segment.ident)),
1111	1111	};
1112		err.subdiagnostic(
1113		self.r.dcx(),
1114		errors::UnexpectedResUseAtOpInSlicePatWithRangeSugg {
1115		span,
1116		ident: segment.ident,
1117		snippet,
1118		},
1119		);
	1112	err.subdiagnostic(errors::UnexpectedResUseAtOpInSlicePatWithRangeSugg {
	1113	span,
	1114	ident: segment.ident,
	1115	snippet,
	1116	});
1120	1117	}
1121	1118
1122	1119	enum Side {
...	...	@@ -1208,13 +1205,10 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
1208	1205	});
1209	1206
1210	1207	if let Some(param) = param {
1211		err.subdiagnostic(
1212		self.r.dcx(),
1213		errors::UnexpectedResChangeTyToConstParamSugg {
1214		span: param.shrink_to_lo(),
1215		applicability,
1216		},
1217		);
	1208	err.subdiagnostic(errors::UnexpectedResChangeTyToConstParamSugg {
	1209	span: param.shrink_to_lo(),
	1210	applicability,
	1211	});
1218	1212	}
1219	1213	}
1220	1214

compiler/rustc_session/src/errors.rs+4-4

...	...	@@ -3,8 +3,8 @@ use std::num::NonZero;
3	3	use rustc_ast::token;
4	4	use rustc_ast::util::literal::LitError;
5	5	use rustc_errors::{
6		codes::*, Diag, DiagCtxt, DiagMessage, Diagnostic, EmissionGuarantee, ErrorGuaranteed, Level,
7		MultiSpan,
	6	codes::*, Diag, DiagCtxtHandle, DiagMessage, Diagnostic, EmissionGuarantee, ErrorGuaranteed,
	7	Level, MultiSpan,
8	8	};
9	9	use rustc_macros::{Diagnostic, Subdiagnostic};
10	10	use rustc_span::{Span, Symbol};
...	...	@@ -19,7 +19,7 @@ pub(crate) struct FeatureGateError {
19	19
20	20	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for FeatureGateError {
21	21	#[track_caller]
22		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	22	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
23	23	Diag::new(dcx, level, self.explain).with_span(self.span).with_code(E0658)
24	24	}
25	25	}
...	...	@@ -401,7 +401,7 @@ pub fn report_lit_error(
401	401	valid.then(\|\| format!("0{}{}", base_char.to_ascii_lowercase(), &suffix[1..]))
402	402	}
403	403
404		let dcx = &psess.dcx;
	404	let dcx = psess.dcx();
405	405	match err {
406	406	LitError::InvalidSuffix(suffix) => {
407	407	dcx.emit_err(InvalidLiteralSuffix { span, kind: lit.kind.descr(), suffix })

compiler/rustc_session/src/parse.rs+16-12

...	...	@@ -15,8 +15,8 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
15	15	use rustc_data_structures::sync::{AppendOnlyVec, Lock, Lrc};
16	16	use rustc_errors::emitter::{stderr_destination, HumanEmitter, SilentEmitter};
17	17	use rustc_errors::{
18		fallback_fluent_bundle, ColorConfig, Diag, DiagCtxt, DiagMessage, EmissionGuarantee, MultiSpan,
19		StashKey,
	18	fallback_fluent_bundle, ColorConfig, Diag, DiagCtxt, DiagCtxtHandle, DiagMessage,
	19	EmissionGuarantee, MultiSpan, StashKey,
20	20	};
21	21	use rustc_feature::{find_feature_issue, GateIssue, UnstableFeatures};
22	22	use rustc_span::edition::Edition;
...	...	@@ -106,12 +106,12 @@ pub fn feature_err_issue(
106	106
107	107	// Cancel an earlier warning for this same error, if it exists.
108	108	if let Some(span) = span.primary_span() {
109		if let Some(err) = sess.psess.dcx.steal_non_err(span, StashKey::EarlySyntaxWarning) {
	109	if let Some(err) = sess.dcx().steal_non_err(span, StashKey::EarlySyntaxWarning) {
110	110	err.cancel()
111	111	}
112	112	}
113	113
114		let mut err = sess.psess.dcx.create_err(FeatureGateError { span, explain: explain.into() });
	114	let mut err = sess.dcx().create_err(FeatureGateError { span, explain: explain.into() });
115	115	add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None);
116	116	err
117	117	}
...	...	@@ -140,7 +140,7 @@ pub fn feature_warn_issue(
140	140	issue: GateIssue,
141	141	explain: &'static str,
142	142	) {
143		let mut err = sess.psess.dcx.struct_span_warn(span, explain);
	143	let mut err = sess.dcx().struct_span_warn(span, explain);
144	144	add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None);
145	145
146	146	// Decorate this as a future-incompatibility lint as in rustc_middle::lint::lint_level
...	...	@@ -178,30 +178,30 @@ pub fn add_feature_diagnostics_for_issue<G: EmissionGuarantee>(
178	178	inject_span: Option<Span>,
179	179	) {
180	180	if let Some(n) = find_feature_issue(feature, issue) {
181		err.subdiagnostic(sess.dcx(), FeatureDiagnosticForIssue { n });
	181	err.subdiagnostic(FeatureDiagnosticForIssue { n });
182	182	}
183	183
184	184	// #23973: do not suggest `#![feature(...)]` if we are in beta/stable
185	185	if sess.psess.unstable_features.is_nightly_build() {
186	186	if feature_from_cli {
187		err.subdiagnostic(sess.dcx(), CliFeatureDiagnosticHelp { feature });
	187	err.subdiagnostic(CliFeatureDiagnosticHelp { feature });
188	188	} else if let Some(span) = inject_span {
189		err.subdiagnostic(sess.dcx(), FeatureDiagnosticSuggestion { feature, span });
	189	err.subdiagnostic(FeatureDiagnosticSuggestion { feature, span });
190	190	} else {
191		err.subdiagnostic(sess.dcx(), FeatureDiagnosticHelp { feature });
	191	err.subdiagnostic(FeatureDiagnosticHelp { feature });
192	192	}
193	193
194	194	if sess.opts.unstable_opts.ui_testing {
195		err.subdiagnostic(sess.dcx(), SuggestUpgradeCompiler::ui_testing());
	195	err.subdiagnostic(SuggestUpgradeCompiler::ui_testing());
196	196	} else if let Some(suggestion) = SuggestUpgradeCompiler::new() {
197		err.subdiagnostic(sess.dcx(), suggestion);
	197	err.subdiagnostic(suggestion);
198	198	}
199	199	}
200	200	}
201	201
202	202	/// Info about a parsing session.
203	203	pub struct ParseSess {
204		pub dcx: DiagCtxt,
	204	dcx: DiagCtxt,
205	205	pub unstable_features: UnstableFeatures,
206	206	pub config: Cfg,
207	207	pub check_config: CheckCfg,
...	...	@@ -326,4 +326,8 @@ impl ParseSess {
326	326	// AppendOnlyVec, so we resort to this scheme.
327	327	self.proc_macro_quoted_spans.iter_enumerated()
328	328	}
	329
	330	pub fn dcx(&self) -> DiagCtxtHandle<'_> {
	331	self.dcx.handle()
	332	}
329	333	}

compiler/rustc_session/src/session.rs+13-13

...	...	@@ -22,8 +22,8 @@ use rustc_errors::emitter::{stderr_destination, DynEmitter, HumanEmitter, HumanR
22	22	use rustc_errors::json::JsonEmitter;
23	23	use rustc_errors::registry::Registry;
24	24	use rustc_errors::{
25		codes::*, fallback_fluent_bundle, Diag, DiagCtxt, DiagMessage, Diagnostic, ErrorGuaranteed,
26		FatalAbort, FluentBundle, LazyFallbackBundle, TerminalUrl,
	25	codes::*, fallback_fluent_bundle, Diag, DiagCtxt, DiagCtxtHandle, DiagMessage, Diagnostic,
	26	ErrorGuaranteed, FatalAbort, FluentBundle, LazyFallbackBundle, TerminalUrl,
27	27	};
28	28	use rustc_macros::HashStable_Generic;
29	29	pub use rustc_span::def_id::StableCrateId;
...	...	@@ -328,8 +328,8 @@ impl Session {
328	328	}
329	329
330	330	#[inline]
331		pub fn dcx(&self) -> &DiagCtxt {
332		&self.psess.dcx
	331	pub fn dcx(&self) -> DiagCtxtHandle<'_> {
	332	self.psess.dcx()
333	333	}
334	334
335	335	#[inline]
...	...	@@ -1070,7 +1070,7 @@ pub fn build_session(
1070	1070	match profiler {
1071	1071	Ok(profiler) => Some(Arc::new(profiler)),
1072	1072	Err(e) => {
1073		dcx.emit_warn(errors::FailedToCreateProfiler { err: e.to_string() });
	1073	dcx.handle().emit_warn(errors::FailedToCreateProfiler { err: e.to_string() });
1074	1074	None
1075	1075	}
1076	1076	}
...	...	@@ -1371,7 +1371,7 @@ impl EarlyDiagCtxt {
1371	1371	/// format. Any errors prior to that will cause an abort and all stashed diagnostics of the
1372	1372	/// previous dcx will be emitted.
1373	1373	pub fn abort_if_error_and_set_error_format(&mut self, output: ErrorOutputType) {
1374		self.dcx.abort_if_errors();
	1374	self.dcx.handle().abort_if_errors();
1375	1375
1376	1376	let emitter = mk_emitter(output);
1377	1377	self.dcx = DiagCtxt::new(emitter);
...	...	@@ -1380,44 +1380,44 @@ impl EarlyDiagCtxt {
1380	1380	#[allow(rustc::untranslatable_diagnostic)]
1381	1381	#[allow(rustc::diagnostic_outside_of_impl)]
1382	1382	pub fn early_note(&self, msg: impl Into<DiagMessage>) {
1383		self.dcx.note(msg)
	1383	self.dcx.handle().note(msg)
1384	1384	}
1385	1385
1386	1386	#[allow(rustc::untranslatable_diagnostic)]
1387	1387	#[allow(rustc::diagnostic_outside_of_impl)]
1388	1388	pub fn early_help(&self, msg: impl Into<DiagMessage>) {
1389		self.dcx.struct_help(msg).emit()
	1389	self.dcx.handle().struct_help(msg).emit()
1390	1390	}
1391	1391
1392	1392	#[allow(rustc::untranslatable_diagnostic)]
1393	1393	#[allow(rustc::diagnostic_outside_of_impl)]
1394	1394	#[must_use = "ErrorGuaranteed must be returned from `run_compiler` in order to exit with a non-zero status code"]
1395	1395	pub fn early_err(&self, msg: impl Into<DiagMessage>) -> ErrorGuaranteed {
1396		self.dcx.err(msg)
	1396	self.dcx.handle().err(msg)
1397	1397	}
1398	1398
1399	1399	#[allow(rustc::untranslatable_diagnostic)]
1400	1400	#[allow(rustc::diagnostic_outside_of_impl)]
1401	1401	pub fn early_fatal(&self, msg: impl Into<DiagMessage>) -> ! {
1402		self.dcx.fatal(msg)
	1402	self.dcx.handle().fatal(msg)
1403	1403	}
1404	1404
1405	1405	#[allow(rustc::untranslatable_diagnostic)]
1406	1406	#[allow(rustc::diagnostic_outside_of_impl)]
1407	1407	pub fn early_struct_fatal(&self, msg: impl Into<DiagMessage>) -> Diag<'_, FatalAbort> {
1408		self.dcx.struct_fatal(msg)
	1408	self.dcx.handle().struct_fatal(msg)
1409	1409	}
1410	1410
1411	1411	#[allow(rustc::untranslatable_diagnostic)]
1412	1412	#[allow(rustc::diagnostic_outside_of_impl)]
1413	1413	pub fn early_warn(&self, msg: impl Into<DiagMessage>) {
1414		self.dcx.warn(msg)
	1414	self.dcx.handle().warn(msg)
1415	1415	}
1416	1416
1417	1417	#[allow(rustc::untranslatable_diagnostic)]
1418	1418	#[allow(rustc::diagnostic_outside_of_impl)]
1419	1419	pub fn early_struct_warn(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> {
1420		self.dcx.struct_warn(msg)
	1420	self.dcx.handle().struct_warn(msg)
1421	1421	}
1422	1422	}
1423	1423

compiler/rustc_symbol_mangling/src/errors.rs+2-2

...	...	@@ -1,6 +1,6 @@
1	1	//! Errors emitted by symbol_mangling.
2	2
3		use rustc_errors::{Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level};
	3	use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
4	4	use rustc_span::Span;
5	5	use std::fmt;
6	6
...	...	@@ -14,7 +14,7 @@ pub struct TestOutput {
14	14	// natural language, and (b) it's only used in tests. So we construct it
15	15	// manually and avoid the fluent machinery.
16	16	impl<G: EmissionGuarantee> Diagnostic<'_, G> for TestOutput {
17		fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> {
	17	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
18	18	let TestOutput { span, kind, content } = self;
19	19
20	20	#[allow(rustc::untranslatable_diagnostic)]

compiler/rustc_trait_selection/src/errors.rs+2-2

...	...	@@ -1,6 +1,6 @@
1	1	use crate::fluent_generated as fluent;
2	2	use rustc_errors::{
3		codes::*, Applicability, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level,
	3	codes::*, Applicability, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
4	4	SubdiagMessageOp, Subdiagnostic,
5	5	};
6	6	use rustc_macros::{Diagnostic, Subdiagnostic};
...	...	@@ -59,7 +59,7 @@ pub struct NegativePositiveConflict<'tcx> {
59	59
60	60	impl<G: EmissionGuarantee> Diagnostic<'_, G> for NegativePositiveConflict<'_> {
61	61	#[track_caller]
62		fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> {
	62	fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
63	63	let mut diag = Diag::new(dcx, level, fluent::trait_selection_negative_positive_conflict);
64	64	diag.arg("trait_desc", self.trait_desc.print_only_trait_path().to_string());
65	65	diag.arg("self_desc", self.self_ty.map_or_else(\|\| "none".to_string(), \|ty\| ty.to_string()));

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs+2-5

...	...	@@ -4705,14 +4705,11 @@ fn hint_missing_borrow<'tcx>(
4705	4705	}
4706	4706
4707	4707	if !to_borrow.is_empty() {
4708		err.subdiagnostic(infcx.dcx(), errors::AdjustSignatureBorrow::Borrow { to_borrow });
	4708	err.subdiagnostic(errors::AdjustSignatureBorrow::Borrow { to_borrow });
4709	4709	}
4710	4710
4711	4711	if !remove_borrow.is_empty() {
4712		err.subdiagnostic(
4713		infcx.dcx(),
4714		errors::AdjustSignatureBorrow::RemoveBorrow { remove_borrow },
4715		);
	4712	err.subdiagnostic(errors::AdjustSignatureBorrow::RemoveBorrow { remove_borrow });
4716	4713	}
4717	4714	}
4718	4715

src/librustdoc/config.rs+9-7

...	...	@@ -8,6 +8,7 @@ use std::path::PathBuf;
8	8	use std::str::FromStr;
9	9
10	10	use rustc_data_structures::fx::FxHashMap;
	11	use rustc_errors::DiagCtxtHandle;
11	12	use rustc_session::config::{
12	13	self, parse_crate_types_from_list, parse_externs, parse_target_triple, CrateType,
13	14	};
...	...	@@ -383,9 +384,10 @@ impl Options {
383	384	};
384	385
385	386	let dcx = new_dcx(error_format, None, diagnostic_width, &unstable_opts);
	387	let dcx = dcx.handle();
386	388
387	389	// check for deprecated options
388		check_deprecated_options(matches, &dcx);
	390	check_deprecated_options(matches, dcx);
389	391
390	392	if matches.opt_strs("passes") == ["list"] {
391	393	println!("Available passes for running rustdoc:");
...	...	@@ -458,7 +460,7 @@ impl Options {
458	460	println!("rustdoc: [check-theme] Starting tests! (Ignoring all other arguments)");
459	461	for theme_file in to_check.iter() {
460	462	print!(" - Checking \"{theme_file}\"...");
461		let (success, differences) = theme::test_theme_against(theme_file, &paths, &dcx);
	463	let (success, differences) = theme::test_theme_against(theme_file, &paths, dcx);
462	464	if !differences.is_empty() \|\| !success {
463	465	println!(" FAILED");
464	466	errors += 1;
...	...	@@ -603,7 +605,7 @@ impl Options {
603	605	.with_help("arguments to --theme must have a .css extension")
604	606	.emit();
605	607	}
606		let (success, ret) = theme::test_theme_against(&theme_file, &paths, &dcx);
	608	let (success, ret) = theme::test_theme_against(&theme_file, &paths, dcx);
607	609	if !success {
608	610	dcx.fatal(format!("error loading theme file: \"{theme_s}\""));
609	611	} else if !ret.is_empty() {
...	...	@@ -630,7 +632,7 @@ impl Options {
630	632	&matches.opt_strs("markdown-before-content"),
631	633	&matches.opt_strs("markdown-after-content"),
632	634	nightly_options::match_is_nightly_build(matches),
633		&dcx,
	635	dcx,
634	636	&mut id_map,
635	637	edition,
636	638	&None,
...	...	@@ -741,9 +743,9 @@ impl Options {
741	743	);
742	744	}
743	745
744		let scrape_examples_options = ScrapeExamplesOptions::new(matches, &dcx);
	746	let scrape_examples_options = ScrapeExamplesOptions::new(matches, dcx);
745	747	let with_examples = matches.opt_strs("with-examples");
746		let call_locations = crate::scrape_examples::load_call_locations(with_examples, &dcx);
	748	let call_locations = crate::scrape_examples::load_call_locations(with_examples, dcx);
747	749
748	750	let unstable_features =
749	751	rustc_feature::UnstableFeatures::from_environment(crate_name.as_deref());
...	...	@@ -847,7 +849,7 @@ fn parse_remap_path_prefix(
847	849	}
848	850
849	851	/// Prints deprecation warnings for deprecated options
850		fn check_deprecated_options(matches: &getopts::Matches, dcx: &rustc_errors::DiagCtxt) {
	852	fn check_deprecated_options(matches: &getopts::Matches, dcx: DiagCtxtHandle<'_>) {
851	853	let deprecated_flags = [];
852	854
853	855	for &flag in deprecated_flags.iter() {

src/librustdoc/core.rs+2-2

...	...	@@ -3,7 +3,7 @@ use rustc_data_structures::sync::Lrc;
3	3	use rustc_data_structures::unord::UnordSet;
4	4	use rustc_errors::emitter::{stderr_destination, DynEmitter, HumanEmitter};
5	5	use rustc_errors::json::JsonEmitter;
6		use rustc_errors::{codes::*, ErrorGuaranteed, TerminalUrl};
	6	use rustc_errors::{codes::*, DiagCtxtHandle, ErrorGuaranteed, TerminalUrl};
7	7	use rustc_feature::UnstableFeatures;
8	8	use rustc_hir::def::Res;
9	9	use rustc_hir::def_id::{DefId, DefIdMap, DefIdSet, LocalDefId};
...	...	@@ -379,7 +379,7 @@ pub(crate) fn run_global_ctxt(
379	379	);
380	380	}
381	381
382		fn report_deprecated_attr(name: &str, dcx: &rustc_errors::DiagCtxt, sp: Span) {
	382	fn report_deprecated_attr(name: &str, dcx: DiagCtxtHandle<'_>, sp: Span) {
383	383	let mut msg =
384	384	dcx.struct_span_warn(sp, format!("the `#![doc({name})]` attribute is deprecated"));
385	385	msg.note(

src/librustdoc/doctest.rs+2-5

...	...	@@ -7,7 +7,7 @@ pub(crate) use markdown::test as test_markdown;
7	7
8	8	use rustc_ast as ast;
9	9	use rustc_data_structures::fx::{FxHashMap, FxHashSet};
10		use rustc_errors::{ColorConfig, ErrorGuaranteed, FatalError};
	10	use rustc_errors::{ColorConfig, DiagCtxtHandle, ErrorGuaranteed, FatalError};
11	11	use rustc_hir::def_id::LOCAL_CRATE;
12	12	use rustc_hir::CRATE_HIR_ID;
13	13	use rustc_interface::interface;
...	...	@@ -90,10 +90,7 @@ fn get_doctest_dir() -> io::Result<TempDir> {
90	90	TempFileBuilder::new().prefix("rustdoctest").tempdir()
91	91	}
92	92
93		pub(crate) fn run(
94		dcx: &rustc_errors::DiagCtxt,
95		options: RustdocOptions,
96		) -> Result<(), ErrorGuaranteed> {
	93	pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<(), ErrorGuaranteed> {
97	94	let invalid_codeblock_attributes_name = crate::lint::INVALID_CODEBLOCK_ATTRIBUTES.name;
98	95
99	96	// See core::create_config for what's going on here.

src/librustdoc/doctest/make.rs+1-1

...	...	@@ -229,7 +229,7 @@ fn check_for_main_and_extern_crate(
229	229	// dcx. Any errors in the tests will be reported when the test file is compiled,
230	230	// Note that we still need to cancel the errors above otherwise `Diag` will panic on
231	231	// drop.
232		psess.dcx.reset_err_count();
	232	psess.dcx().reset_err_count();
233	233
234	234	(found_main, found_extern_crate, found_macro)
235	235	})

src/librustdoc/externalfiles.rs+4-3

...	...	@@ -1,4 +1,5 @@
1	1	use crate::html::markdown::{ErrorCodes, HeadingOffset, IdMap, Markdown, Playground};
	2	use rustc_errors::DiagCtxtHandle;
2	3	use rustc_span::edition::Edition;
3	4	use std::fs;
4	5	use std::path::Path;
...	...	@@ -27,7 +28,7 @@ impl ExternalHtml {
27	28	md_before_content: &[String],
28	29	md_after_content: &[String],
29	30	nightly_build: bool,
30		dcx: &rustc_errors::DiagCtxt,
	31	dcx: DiagCtxtHandle<'_>,
31	32	id_map: &mut IdMap,
32	33	edition: Edition,
33	34	playground: &Option<Playground>,
...	...	@@ -75,7 +76,7 @@ pub(crate) enum LoadStringError {
75	76
76	77	pub(crate) fn load_string<P: AsRef<Path>>(
77	78	file_path: P,
78		dcx: &rustc_errors::DiagCtxt,
	79	dcx: DiagCtxtHandle<'_>,
79	80	) -> Result<String, LoadStringError> {
80	81	let file_path = file_path.as_ref();
81	82	let contents = match fs::read(file_path) {
...	...	@@ -98,7 +99,7 @@ pub(crate) fn load_string<P: AsRef<Path>>(
98	99	}
99	100	}
100	101
101		fn load_external_files(names: &[String], dcx: &rustc_errors::DiagCtxt) -> Option<String> {
	102	fn load_external_files(names: &[String], dcx: DiagCtxtHandle<'_>) -> Option<String> {
102	103	let mut out = String::new();
103	104	for name in names {
104	105	let Ok(s) = load_string(name, dcx) else { return None };

src/librustdoc/lib.rs+7-6

...	...	@@ -77,7 +77,7 @@ use std::io::{self, IsTerminal};
77	77	use std::process;
78	78	use std::sync::{atomic::AtomicBool, Arc};
79	79
80		use rustc_errors::{ErrorGuaranteed, FatalError};
	80	use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, FatalError};
81	81	use rustc_interface::interface;
82	82	use rustc_middle::ty::TyCtxt;
83	83	use rustc_session::config::{make_crate_type_option, ErrorOutputType, RustcOptGroup};
...	...	@@ -670,7 +670,7 @@ fn usage(argv0: &str) {
670	670	/// A result type used by several functions under `main()`.
671	671	type MainResult = Result<(), ErrorGuaranteed>;
672	672
673		pub(crate) fn wrap_return(dcx: &rustc_errors::DiagCtxt, res: Result<(), String>) -> MainResult {
	673	pub(crate) fn wrap_return(dcx: DiagCtxtHandle<'_>, res: Result<(), String>) -> MainResult {
674	674	match res {
675	675	Ok(()) => dcx.has_errors().map_or(Ok(()), Err),
676	676	Err(err) => Err(dcx.err(err)),
...	...	@@ -732,12 +732,13 @@ fn main_args(
732	732	None => return Ok(()),
733	733	};
734	734
735		let diag =
	735	let dcx =
736	736	core::new_dcx(options.error_format, None, options.diagnostic_width, &options.unstable_opts);
	737	let dcx = dcx.handle();
737	738
738	739	match (options.should_test, options.markdown_input()) {
739		(true, Some(_)) => return wrap_return(&diag, doctest::test_markdown(options)),
740		(true, None) => return doctest::run(&diag, options),
	740	(true, Some(_)) => return wrap_return(dcx, doctest::test_markdown(options)),
	741	(true, None) => return doctest::run(dcx, options),
741	742	(false, Some(input)) => {
742	743	let input = input.to_owned();
743	744	let edition = options.edition;
...	...	@@ -747,7 +748,7 @@ fn main_args(
747	748	// requires session globals and a thread pool, so we use
748	749	// `run_compiler`.
749	750	return wrap_return(
750		&diag,
	751	dcx,
751	752	interface::run_compiler(config, \|_compiler\| {
752	753	markdown::render(&input, render_options, edition)
753	754	}),

src/librustdoc/scrape_examples.rs+3-2

...	...	@@ -7,6 +7,7 @@ use crate::formats::renderer::FormatRenderer;
7	7	use crate::html::render::Context;
8	8
9	9	use rustc_data_structures::fx::FxHashMap;
	10	use rustc_errors::DiagCtxtHandle;
10	11	use rustc_hir::{
11	12	self as hir,
12	13	intravisit::{self, Visitor},
...	...	@@ -38,7 +39,7 @@ pub(crate) struct ScrapeExamplesOptions {
38	39	}
39	40
40	41	impl ScrapeExamplesOptions {
41		pub(crate) fn new(matches: &getopts::Matches, dcx: &rustc_errors::DiagCtxt) -> Option<Self> {
	42	pub(crate) fn new(matches: &getopts::Matches, dcx: DiagCtxtHandle<'_>) -> Option<Self> {
42	43	let output_path = matches.opt_str("scrape-examples-output-path");
43	44	let target_crates = matches.opt_strs("scrape-examples-target-crate");
44	45	let scrape_tests = matches.opt_present("scrape-tests");
...	...	@@ -336,7 +337,7 @@ pub(crate) fn run(
336	337	// options.
337	338	pub(crate) fn load_call_locations(
338	339	with_examples: Vec<String>,
339		dcx: &rustc_errors::DiagCtxt,
	340	dcx: DiagCtxtHandle<'_>,
340	341	) -> AllCallLocations {
341	342	let mut all_calls: AllCallLocations = FxHashMap::default();
342	343	for path in with_examples {

src/librustdoc/theme.rs+2-2

...	...	@@ -5,7 +5,7 @@ use std::iter::Peekable;
5	5	use std::path::Path;
6	6	use std::str::Chars;
7	7
8		use rustc_errors::DiagCtxt;
	8	use rustc_errors::DiagCtxtHandle;
9	9
10	10	#[cfg(test)]
11	11	mod tests;
...	...	@@ -236,7 +236,7 @@ pub(crate) fn get_differences(
236	236	pub(crate) fn test_theme_against<P: AsRef<Path>>(
237	237	f: &P,
238	238	origin: &FxHashMap<String, CssPath>,
239		dcx: &DiagCtxt,
	239	dcx: DiagCtxtHandle<'_>,
240	240	) -> (bool, Vec<String>) {
241	241	let against = match fs::read_to_string(f)
242	242	.map_err(\|e\| e.to_string())

src/tools/clippy/src/driver.rs+2-2

...	...	@@ -180,12 +180,12 @@ pub fn main() {
180	180
181	181	rustc_driver::init_rustc_env_logger(&early_dcx);
182	182
183		let using_internal_features = rustc_driver::install_ice_hook(BUG_REPORT_URL, \|handler\| {
	183	let using_internal_features = rustc_driver::install_ice_hook(BUG_REPORT_URL, \|dcx\| {
184	184	// FIXME: this macro calls unwrap internally but is called in a panicking context! It's not
185	185	// as simple as moving the call from the hook to main, because `install_ice_hook` doesn't
186	186	// accept a generic closure.
187	187	let version_info = rustc_tools_util::get_version_info!();
188		handler.note(format!("Clippy version: {version_info}"));
	188	dcx.handle().note(format!("Clippy version: {version_info}"));
189	189	});
190	190
191	191	exit(rustc_driver::catch_with_exit_code(move \|\| {

src/tools/miri/src/diagnostics.rs+1-1

...	...	@@ -566,7 +566,7 @@ pub fn report_msg<'tcx>(
566	566	let is_local = machine.is_local(frame_info);
567	567	// No span for non-local frames and the first frame (which is the error site).
568	568	if is_local && idx > 0 {
569		err.subdiagnostic(err.dcx, frame_info.as_note(machine.tcx));
	569	err.subdiagnostic(frame_info.as_note(machine.tcx));
570	570	} else {
571	571	let sm = sess.source_map();
572	572	let span = sm.span_to_embeddable_string(frame_info.span);

src/tools/rustfmt/src/parse/macros/cfg_if.rs+1-1

...	...	@@ -67,7 +67,7 @@ fn parse_cfg_if_inner<'a>(
67	67	Ok(None) => continue,
68	68	Err(err) => {
69	69	err.cancel();
70		parser.psess.dcx.reset_err_count();
	70	parser.psess.dcx().reset_err_count();
71	71	return Err(
72	72	"Expected item inside cfg_if block, but failed to parse it as an item",
73	73	);

src/tools/rustfmt/src/parse/macros/lazy_static.rs+3-3

...	...	@@ -16,8 +16,8 @@ pub(crate) fn parse_lazy_static(
16	16	($method:ident $(,)* $($arg:expr),* $(,)*) => {
17	17	match parser.$method($($arg,)*) {
18	18	Ok(val) => {
19		if parser.psess.dcx.has_errors().is_some() {
20		parser.psess.dcx.reset_err_count();
	19	if parser.psess.dcx().has_errors().is_some() {
	20	parser.psess.dcx().reset_err_count();
21	21	return None;
22	22	} else {
23	23	val
...	...	@@ -25,7 +25,7 @@ pub(crate) fn parse_lazy_static(
25	25	}
26	26	Err(err) => {
27	27	err.cancel();
28		parser.psess.dcx.reset_err_count();
	28	parser.psess.dcx().reset_err_count();
29	29	return None;
30	30	}
31	31	}

src/tools/rustfmt/src/parse/macros/mod.rs+3-3

...	...	@@ -29,8 +29,8 @@ fn parse_macro_arg<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
29	29	if Parser::nonterminal_may_begin_with($nt_kind, &cloned_parser.token) {
30	30	match $try_parse(&mut cloned_parser) {
31	31	Ok(x) => {
32		if parser.psess.dcx.has_errors().is_some() {
33		parser.psess.dcx.reset_err_count();
	32	if parser.psess.dcx().has_errors().is_some() {
	33	parser.psess.dcx().reset_err_count();
34	34	} else {
35	35	// Parsing succeeded.
36	36	*parser = cloned_parser;
...	...	@@ -39,7 +39,7 @@ fn parse_macro_arg<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
39	39	}
40	40	Err(e) => {
41	41	e.cancel();
42		parser.psess.dcx.reset_err_count();
	42	parser.psess.dcx().reset_err_count();
43	43	}
44	44	}
45	45	}

src/tools/rustfmt/src/parse/session.rs+5-3

...	...	@@ -210,7 +210,9 @@ impl ParseSess {
210	210	rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(),
211	211	false,
212	212	);
213		self.raw_psess.dcx.make_silent(fallback_bundle, None, false);
	213	self.raw_psess
	214	.dcx()
	215	.make_silent(fallback_bundle, None, false);
214	216	}
215	217
216	218	pub(crate) fn span_to_filename(&self, span: Span) -> FileName {
...	...	@@ -286,11 +288,11 @@ impl ParseSess {
286	288	}
287	289
288	290	pub(super) fn has_errors(&self) -> bool {
289		self.raw_psess.dcx.has_errors().is_some()
	291	self.raw_psess.dcx().has_errors().is_some()
290	292	}
291	293
292	294	pub(super) fn reset_errors(&self) {
293		self.raw_psess.dcx.reset_err_count();
	295	self.raw_psess.dcx().reset_err_count();
294	296	}
295	297	}
296	298

tests/ui-fulldeps/internal-lints/diagnostics.rs+7-7

...	...	@@ -14,8 +14,8 @@ extern crate rustc_session;
14	14	extern crate rustc_span;
15	15
16	16	use rustc_errors::{
17		Diag, DiagCtxt, DiagInner, DiagMessage, Diagnostic, EmissionGuarantee, Level, LintDiagnostic,
18		SubdiagMessageOp, SubdiagMessage, Subdiagnostic,
	17	Diag, DiagCtxtHandle, DiagInner, DiagMessage, Diagnostic, EmissionGuarantee, Level,
	18	LintDiagnostic, SubdiagMessage, SubdiagMessageOp, Subdiagnostic,
19	19	};
20	20	use rustc_macros::{Diagnostic, Subdiagnostic};
21	21	use rustc_span::Span;
...	...	@@ -39,7 +39,7 @@ struct Note {
39	39	pub struct UntranslatableInDiagnostic;
40	40
41	41	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for UntranslatableInDiagnostic {
42		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	42	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
43	43	Diag::new(dcx, level, "untranslatable diagnostic")
44	44	//~^ ERROR diagnostics should be created using translatable messages
45	45	}
...	...	@@ -48,7 +48,7 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for UntranslatableInDiagnostic
48	48	pub struct TranslatableInDiagnostic;
49	49
50	50	impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for TranslatableInDiagnostic {
51		fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> {
	51	fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
52	52	Diag::new(dcx, level, crate::fluent_generated::no_crate_example)
53	53	}
54	54	}
...	...	@@ -81,7 +81,7 @@ impl Subdiagnostic for TranslatableInAddtoDiag {
81	81	pub struct UntranslatableInLintDiagnostic;
82	82
83	83	impl<'a> LintDiagnostic<'a, ()> for UntranslatableInLintDiagnostic {
84		fn decorate_lint<'b, >(self, diag: &'b mut Diag<'a, ()>) {
	84	fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, ()>) {
85	85	diag.note("untranslatable diagnostic");
86	86	//~^ ERROR diagnostics should be created using translatable messages
87	87	}
...	...	@@ -95,7 +95,7 @@ impl<'a> LintDiagnostic<'a, ()> for TranslatableInLintDiagnostic {
95	95	}
96	96	}
97	97
98		pub fn make_diagnostics<'a>(dcx: &'a DiagCtxt) {
	98	pub fn make_diagnostics<'a>(dcx: DiagCtxtHandle<'a>) {
99	99	let _diag = dcx.struct_err(crate::fluent_generated::no_crate_example);
100	100	//~^ ERROR diagnostics should only be created in `Diagnostic`/`Subdiagnostic`/`LintDiagnostic` impls
101	101
...	...	@@ -107,7 +107,7 @@ pub fn make_diagnostics<'a>(dcx: &'a DiagCtxt) {
107	107	// Check that `rustc_lint_diagnostics`-annotated functions aren't themselves linted for
108	108	// `diagnostic_outside_of_impl`.
109	109	#[rustc_lint_diagnostics]
110		pub fn skipped_because_of_annotation<'a>(dcx: &'a DiagCtxt) {
	110	pub fn skipped_because_of_annotation<'a>(dcx: DiagCtxtHandle<'a>) {
111	111	#[allow(rustc::untranslatable_diagnostic)]
112	112	let _diag = dcx.struct_err("untranslatable diagnostic"); // okay!
113	113	}

author	bors <bors@rust-lang.org> 2024-06-18 16:49:19 UTC
committer	bors <bors@rust-lang.org> 2024-06-18 16:49:19 UTC
log	dd104ef16315e2387fe94e8c43eb5a66e3dbd660
tree	bc7569f842f9454815433b814d6cdf846f91948b
parent	8814b926f49bc5780753ed9533853679a1181357
parent	3f34196839730cfb5b241667cfcc9b94599ea0c1

Auto merge of #126623 - oli-obk:do_not_count_errors, r=davidtwco