mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source 
Replace all `&DiagCtxt` with a `DiagCtxtHandle<'_>` wrapper type

r? `@davidtwco`

This paves the way for tracking more state (e.g. error tainting) in the diagnostic context handle

Basically I will add a field to the `DiagCtxtHandle` that refers back to the `InferCtxt`'s (and others) `Option<ErrorHandled>`, allowing us to immediately taint these contexts when emitting an error and not needing manual tainting anymore (which is easy to forget and we don't do in general anyway)
This commit is contained in:
bors 2024-06-18 16:49:19 +00:00
commit dd104ef163
118 changed files with 773 additions and 915 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
compiler/rustc_ast_lowering/src/lib.rs
View file

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

9
compiler/rustc_ast_passes/src/ast_validation.rs
View file

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

5
compiler/rustc_ast_passes/src/show_span.rs
View file

@ -8,6 +8,7 @@ use std::str::FromStr;
use rustc_ast as ast; use rustc_ast as ast;
use rustc_ast::visit; use rustc_ast::visit;
use rustc_ast::visit::Visitor; use rustc_ast::visit::Visitor;
use rustc_errors::DiagCtxtHandle;
use crate::errors; use crate::errors;
@ -31,7 +32,7 @@ impl FromStr for Mode {
} }
struct ShowSpanVisitor<'a> { struct ShowSpanVisitor<'a> {
dcx: &'a rustc_errors::DiagCtxt, dcx: DiagCtxtHandle<'a>,
mode: Mode, mode: Mode,
} }
@ -58,7 +59,7 @@ impl<'a> Visitor<'a> for ShowSpanVisitor<'a> {
} }
} }
pub fn run(dcx: &rustc_errors::DiagCtxt, mode: &str, krate: &ast::Crate) { pub fn run(dcx: DiagCtxtHandle<'_>, mode: &str, krate: &ast::Crate) {
let Ok(mode) = mode.parse() else { let Ok(mode) = mode.parse() else {
return; return;
}; };

2
compiler/rustc_attr/src/builtin.rs
View file

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

7
compiler/rustc_attr/src/session_diagnostics.rs
View file

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

4
compiler/rustc_borrowck/src/borrowck_errors.rs
View file

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

146
compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
View file

@ -228,7 +228,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
seen_spans.insert(move_span); seen_spans.insert(move_span);
} }
use_spans.var_path_only_subdiag(self.dcx(), &mut err, desired_action); use_spans.var_path_only_subdiag(&mut err, desired_action);
if !is_loop_move { if !is_loop_move {
err.span_label( err.span_label(
@ -303,24 +303,18 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
if needs_note { if needs_note {
if let Some(local) = place.as_local() { if let Some(local) = place.as_local() {
let span = self.body.local_decls[local].source_info.span; let span = self.body.local_decls[local].source_info.span;
err.subdiagnostic( err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
self.dcx(), is_partial_move,
crate::session_diagnostics::TypeNoCopy::Label { ty,
is_partial_move, place: &note_msg,
ty, span,
place: &note_msg, });
span,
},
);
} else { } else {
err.subdiagnostic( err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Note {
self.dcx(), is_partial_move,
crate::session_diagnostics::TypeNoCopy::Note { ty,
is_partial_move, place: &note_msg,
ty, });
place: &note_msg,
},
);
}; };
} }
@ -597,7 +591,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
E0381, E0381,
"{used} binding {desc}{isnt_initialized}" "{used} binding {desc}{isnt_initialized}"
); );
use_spans.var_path_only_subdiag(self.dcx(), &mut err, desired_action); use_spans.var_path_only_subdiag(&mut err, desired_action);
if let InitializationRequiringAction::PartialAssignment if let InitializationRequiringAction::PartialAssignment
| InitializationRequiringAction::Assignment = desired_action | InitializationRequiringAction::Assignment = desired_action
@ -996,7 +990,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
&self, &self,
err: &mut Diag<'_>, err: &mut Diag<'_>,
ty: Ty<'tcx>, ty: Ty<'tcx>,
expr: &'cx hir::Expr<'cx>, expr: &hir::Expr<'_>,
) { ) {
let typeck_results = self.infcx.tcx.typeck(self.mir_def_id()); let typeck_results = self.infcx.tcx.typeck(self.mir_def_id());
let hir::ExprKind::Struct(struct_qpath, fields, Some(base)) = expr.kind else { return }; let hir::ExprKind::Struct(struct_qpath, fields, Some(base)) = expr.kind else { return };
@ -1084,8 +1078,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
&self, &self,
err: &mut Diag<'_>, err: &mut Diag<'_>,
ty: Ty<'tcx>, ty: Ty<'tcx>,
mut expr: &'cx hir::Expr<'cx>, mut expr: &'tcx hir::Expr<'tcx>,
mut other_expr: Option<&'cx hir::Expr<'cx>>, mut other_expr: Option<&'tcx hir::Expr<'tcx>>,
use_spans: Option<UseSpans<'tcx>>, use_spans: Option<UseSpans<'tcx>>,
) { ) {
if let hir::ExprKind::Struct(_, _, Some(_)) = expr.kind { if let hir::ExprKind::Struct(_, _, Some(_)) = expr.kind {
@ -1410,13 +1404,9 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
&value_msg, &value_msg,
); );
borrow_spans.var_path_only_subdiag( borrow_spans.var_path_only_subdiag(&mut err, crate::InitializationRequiringAction::Borrow);
self.dcx(),
&mut err,
crate::InitializationRequiringAction::Borrow,
);
move_spans.var_subdiag(self.dcx(), &mut err, None, |kind, var_span| { move_spans.var_subdiag(&mut err, None, |kind, var_span| {
use crate::session_diagnostics::CaptureVarCause::*; use crate::session_diagnostics::CaptureVarCause::*;
match kind { match kind {
hir::ClosureKind::Coroutine(_) => MoveUseInCoroutine { var_span }, hir::ClosureKind::Coroutine(_) => MoveUseInCoroutine { var_span },
@ -1468,7 +1458,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
borrow_span, borrow_span,
&self.describe_any_place(borrow.borrowed_place.as_ref()), &self.describe_any_place(borrow.borrowed_place.as_ref()),
); );
borrow_spans.var_subdiag(self.dcx(), &mut err, Some(borrow.kind), |kind, var_span| { borrow_spans.var_subdiag(&mut err, Some(borrow.kind), |kind, var_span| {
use crate::session_diagnostics::CaptureVarCause::*; use crate::session_diagnostics::CaptureVarCause::*;
let place = &borrow.borrowed_place; let place = &borrow.borrowed_place;
let desc_place = self.describe_any_place(place.as_ref()); let desc_place = self.describe_any_place(place.as_ref());
@ -1633,7 +1623,6 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
"mutably borrow", "mutably borrow",
); );
borrow_spans.var_subdiag( borrow_spans.var_subdiag(
self.dcx(),
&mut err, &mut err,
Some(BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture }), Some(BorrowKind::Mut { kind: MutBorrowKind::ClosureCapture }),
|kind, var_span| { |kind, var_span| {
@ -1730,64 +1719,45 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
}; };
if issued_spans == borrow_spans { if issued_spans == borrow_spans {
borrow_spans.var_subdiag( borrow_spans.var_subdiag(&mut err, Some(gen_borrow_kind), |kind, var_span| {
self.dcx(), use crate::session_diagnostics::CaptureVarCause::*;
&mut err, match kind {
Some(gen_borrow_kind), hir::ClosureKind::Coroutine(_) => BorrowUsePlaceCoroutine {
|kind, var_span| { place: desc_place,
use crate::session_diagnostics::CaptureVarCause::*; var_span,
match kind { is_single_var: false,
hir::ClosureKind::Coroutine(_) => BorrowUsePlaceCoroutine { },
place: desc_place, hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
var_span, BorrowUsePlaceClosure { place: desc_place, var_span, is_single_var: false }
is_single_var: false,
},
hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
BorrowUsePlaceClosure {
place: desc_place,
var_span,
is_single_var: false,
}
}
} }
}, }
); });
} else { } else {
issued_spans.var_subdiag( issued_spans.var_subdiag(&mut err, Some(issued_borrow.kind), |kind, var_span| {
self.dcx(), use crate::session_diagnostics::CaptureVarCause::*;
&mut err, let borrow_place = &issued_borrow.borrowed_place;
Some(issued_borrow.kind), let borrow_place_desc = self.describe_any_place(borrow_place.as_ref());
|kind, var_span| { match kind {
use crate::session_diagnostics::CaptureVarCause::*; hir::ClosureKind::Coroutine(_) => {
let borrow_place = &issued_borrow.borrowed_place; FirstBorrowUsePlaceCoroutine { place: borrow_place_desc, var_span }
let borrow_place_desc = self.describe_any_place(borrow_place.as_ref());
match kind {
hir::ClosureKind::Coroutine(_) => {
FirstBorrowUsePlaceCoroutine { place: borrow_place_desc, var_span }
}
hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
FirstBorrowUsePlaceClosure { place: borrow_place_desc, var_span }
}
} }
}, hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
); FirstBorrowUsePlaceClosure { place: borrow_place_desc, var_span }
}
}
});
borrow_spans.var_subdiag( borrow_spans.var_subdiag(&mut err, Some(gen_borrow_kind), |kind, var_span| {
self.dcx(), use crate::session_diagnostics::CaptureVarCause::*;
&mut err, match kind {
Some(gen_borrow_kind), hir::ClosureKind::Coroutine(_) => {
|kind, var_span| { SecondBorrowUsePlaceCoroutine { place: desc_place, var_span }
use crate::session_diagnostics::CaptureVarCause::*;
match kind {
hir::ClosureKind::Coroutine(_) => {
SecondBorrowUsePlaceCoroutine { place: desc_place, var_span }
}
hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
SecondBorrowUsePlaceClosure { place: desc_place, var_span }
}
} }
}, hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
); SecondBorrowUsePlaceClosure { place: desc_place, var_span }
}
}
});
} }
if union_type_name != "" { if union_type_name != "" {
@ -2016,7 +1986,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
); );
} }
pub(crate) fn find_expr(&self, span: Span) -> Option<&hir::Expr<'_>> { pub(crate) fn find_expr(&self, span: Span) -> Option<&'tcx hir::Expr<'tcx>> {
let tcx = self.infcx.tcx; let tcx = self.infcx.tcx;
let body_id = tcx.hir_node(self.mir_hir_id()).body_id()?; let body_id = tcx.hir_node(self.mir_hir_id()).body_id()?;
let mut expr_finder = FindExprBySpan::new(span, tcx); let mut expr_finder = FindExprBySpan::new(span, tcx);
@ -2961,7 +2931,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
err.span_label(borrow_span, "borrowed value does not live long enough"); err.span_label(borrow_span, "borrowed value does not live long enough");
err.span_label(drop_span, format!("`{name}` dropped here while still borrowed")); err.span_label(drop_span, format!("`{name}` dropped here while still borrowed"));
borrow_spans.args_subdiag(self.dcx(), &mut err, |args_span| { borrow_spans.args_subdiag(&mut err, |args_span| {
crate::session_diagnostics::CaptureArgLabel::Capture { crate::session_diagnostics::CaptureArgLabel::Capture {
is_within: borrow_spans.for_coroutine(), is_within: borrow_spans.for_coroutine(),
args_span, args_span,
@ -3219,7 +3189,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
None, None,
); );
borrow_spans.args_subdiag(self.dcx(), &mut err, |args_span| { borrow_spans.args_subdiag(&mut err, |args_span| {
crate::session_diagnostics::CaptureArgLabel::Capture { crate::session_diagnostics::CaptureArgLabel::Capture {
is_within: borrow_spans.for_coroutine(), is_within: borrow_spans.for_coroutine(),
args_span, args_span,
@ -3680,7 +3650,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
"assign", "assign",
); );
loan_spans.var_subdiag(self.dcx(), &mut err, Some(loan.kind), |kind, var_span| { loan_spans.var_subdiag(&mut err, Some(loan.kind), |kind, var_span| {
use crate::session_diagnostics::CaptureVarCause::*; use crate::session_diagnostics::CaptureVarCause::*;
match kind { match kind {
hir::ClosureKind::Coroutine(_) => BorrowUseInCoroutine { var_span }, hir::ClosureKind::Coroutine(_) => BorrowUseInCoroutine { var_span },
@ -3698,7 +3668,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
let mut err = self.cannot_assign_to_borrowed(span, loan_span, &descr_place); let mut err = self.cannot_assign_to_borrowed(span, loan_span, &descr_place);
loan_spans.var_subdiag(self.dcx(), &mut err, Some(loan.kind), |kind, var_span| { loan_spans.var_subdiag(&mut err, Some(loan.kind), |kind, var_span| {
use crate::session_diagnostics::CaptureVarCause::*; use crate::session_diagnostics::CaptureVarCause::*;
match kind { match kind {
hir::ClosureKind::Coroutine(_) => BorrowUseInCoroutine { var_span }, hir::ClosureKind::Coroutine(_) => BorrowUseInCoroutine { var_span },

234
compiler/rustc_borrowck/src/diagnostics/mod.rs
View file

@ -4,8 +4,8 @@ use crate::session_diagnostics::{
CaptureArgLabel, CaptureReasonLabel, CaptureReasonNote, CaptureReasonSuggest, CaptureVarCause, CaptureArgLabel, CaptureReasonLabel, CaptureReasonNote, CaptureReasonSuggest, CaptureVarCause,
CaptureVarKind, CaptureVarPathUseCause, OnClosureNote, CaptureVarKind, CaptureVarPathUseCause, OnClosureNote,
}; };
use rustc_errors::MultiSpan;
use rustc_errors::{Applicability, Diag}; use rustc_errors::{Applicability, Diag};
use rustc_errors::{DiagCtxt, MultiSpan};
use rustc_hir::def::{CtorKind, Namespace}; use rustc_hir::def::{CtorKind, Namespace};
use rustc_hir::CoroutineKind; use rustc_hir::CoroutineKind;
use rustc_hir::{self as hir, LangItem}; use rustc_hir::{self as hir, LangItem};
@ -130,16 +130,13 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
if let ty::Closure(did, _) = self.body.local_decls[closure].ty.kind() { if let ty::Closure(did, _) = self.body.local_decls[closure].ty.kind() {
let did = did.expect_local(); let did = did.expect_local();
if let Some((span, hir_place)) = self.infcx.tcx.closure_kind_origin(did) { if let Some((span, hir_place)) = self.infcx.tcx.closure_kind_origin(did) {
diag.subdiagnostic( diag.subdiagnostic(OnClosureNote::InvokedTwice {
self.dcx(), place_name: &ty::place_to_string_for_capture(
OnClosureNote::InvokedTwice { self.infcx.tcx,
place_name: &ty::place_to_string_for_capture( hir_place,
self.infcx.tcx, ),
hir_place, span: *span,
), });
span: *span,
},
);
return true; return true;
} }
} }
@ -152,13 +149,10 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
if let ty::Closure(did, _) = self.body.local_decls[target].ty.kind() { if let ty::Closure(did, _) = self.body.local_decls[target].ty.kind() {
let did = did.expect_local(); let did = did.expect_local();
if let Some((span, hir_place)) = self.infcx.tcx.closure_kind_origin(did) { if let Some((span, hir_place)) = self.infcx.tcx.closure_kind_origin(did) {
diag.subdiagnostic( diag.subdiagnostic(OnClosureNote::MovedTwice {
self.dcx(), place_name: &ty::place_to_string_for_capture(self.infcx.tcx, hir_place),
OnClosureNote::MovedTwice { span: *span,
place_name: &ty::place_to_string_for_capture(self.infcx.tcx, hir_place), });
span: *span,
},
);
return true; return true;
} }
} }
@ -591,14 +585,9 @@ impl UseSpans<'_> {
/// Add a span label to the arguments of the closure, if it exists. /// Add a span label to the arguments of the closure, if it exists.
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub(super) fn args_subdiag( pub(super) fn args_subdiag(self, err: &mut Diag<'_>, f: impl FnOnce(Span) -> CaptureArgLabel) {
self,
dcx: &DiagCtxt,
err: &mut Diag<'_>,
f: impl FnOnce(Span) -> CaptureArgLabel,
) {
if let UseSpans::ClosureUse { args_span, .. } = self { if let UseSpans::ClosureUse { args_span, .. } = self {
err.subdiagnostic(dcx, f(args_span)); err.subdiagnostic(f(args_span));
} }
} }
@ -607,7 +596,6 @@ impl UseSpans<'_> {
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub(super) fn var_path_only_subdiag( pub(super) fn var_path_only_subdiag(
self, self,
dcx: &DiagCtxt,
err: &mut Diag<'_>, err: &mut Diag<'_>,
action: crate::InitializationRequiringAction, action: crate::InitializationRequiringAction,
) { ) {
@ -616,26 +604,20 @@ impl UseSpans<'_> {
if let UseSpans::ClosureUse { closure_kind, path_span, .. } = self { if let UseSpans::ClosureUse { closure_kind, path_span, .. } = self {
match closure_kind { match closure_kind {
hir::ClosureKind::Coroutine(_) => { hir::ClosureKind::Coroutine(_) => {
err.subdiagnostic( err.subdiagnostic(match action {
dcx, Borrow => BorrowInCoroutine { path_span },
match action { MatchOn | Use => UseInCoroutine { path_span },
Borrow => BorrowInCoroutine { path_span }, Assignment => AssignInCoroutine { path_span },
MatchOn | Use => UseInCoroutine { path_span }, PartialAssignment => AssignPartInCoroutine { path_span },
Assignment => AssignInCoroutine { path_span }, });
PartialAssignment => AssignPartInCoroutine { path_span },
},
);
} }
hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => { hir::ClosureKind::Closure | hir::ClosureKind::CoroutineClosure(_) => {
err.subdiagnostic( err.subdiagnostic(match action {
dcx, Borrow => BorrowInClosure { path_span },
match action { MatchOn | Use => UseInClosure { path_span },
Borrow => BorrowInClosure { path_span }, Assignment => AssignInClosure { path_span },
MatchOn | Use => UseInClosure { path_span }, PartialAssignment => AssignPartInClosure { path_span },
Assignment => AssignInClosure { path_span }, });
PartialAssignment => AssignPartInClosure { path_span },
},
);
} }
} }
} }
@ -645,32 +627,28 @@ impl UseSpans<'_> {
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub(super) fn var_subdiag( pub(super) fn var_subdiag(
self, self,
dcx: &DiagCtxt,
err: &mut Diag<'_>, err: &mut Diag<'_>,
kind: Option<rustc_middle::mir::BorrowKind>, kind: Option<rustc_middle::mir::BorrowKind>,
f: impl FnOnce(hir::ClosureKind, Span) -> CaptureVarCause, f: impl FnOnce(hir::ClosureKind, Span) -> CaptureVarCause,
) { ) {
if let UseSpans::ClosureUse { closure_kind, capture_kind_span, path_span, .. } = self { if let UseSpans::ClosureUse { closure_kind, capture_kind_span, path_span, .. } = self {
if capture_kind_span != path_span { if capture_kind_span != path_span {
err.subdiagnostic( err.subdiagnostic(match kind {
dcx, Some(kd) => match kd {
match kind { rustc_middle::mir::BorrowKind::Shared
Some(kd) => match kd { | rustc_middle::mir::BorrowKind::Fake(_) => {
rustc_middle::mir::BorrowKind::Shared CaptureVarKind::Immut { kind_span: capture_kind_span }
| rustc_middle::mir::BorrowKind::Fake(_) => { }
CaptureVarKind::Immut { kind_span: capture_kind_span }
}
rustc_middle::mir::BorrowKind::Mut { .. } => { rustc_middle::mir::BorrowKind::Mut { .. } => {
CaptureVarKind::Mut { kind_span: capture_kind_span } CaptureVarKind::Mut { kind_span: capture_kind_span }
} }
},
None => CaptureVarKind::Move { kind_span: capture_kind_span },
}, },
); None => CaptureVarKind::Move { kind_span: capture_kind_span },
});
}; };
let diag = f(closure_kind, path_span); let diag = f(closure_kind, path_span);
err.subdiagnostic(dcx, diag); err.subdiagnostic(diag);
} }
} }
@ -1042,15 +1020,12 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
CallKind::FnCall { fn_trait_id, self_ty } CallKind::FnCall { fn_trait_id, self_ty }
if self.infcx.tcx.is_lang_item(fn_trait_id, LangItem::FnOnce) => if self.infcx.tcx.is_lang_item(fn_trait_id, LangItem::FnOnce) =>
{ {
err.subdiagnostic( err.subdiagnostic(CaptureReasonLabel::Call {
self.dcx(), fn_call_span,
CaptureReasonLabel::Call { place_name: &place_name,
fn_call_span, is_partial,
place_name: &place_name, is_loop_message,
is_partial, });
is_loop_message,
},
);
// Check if the move occurs on a value because of a call on a closure that comes // Check if the move occurs on a value because of a call on a closure that comes
// from a type parameter `F: FnOnce()`. If so, we provide a targeted `note`: // from a type parameter `F: FnOnce()`. If so, we provide a targeted `note`:
// ``` // ```
@ -1119,27 +1094,20 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
); );
err.span_note(span, fluent::borrowck_moved_a_fn_once_in_call_call); err.span_note(span, fluent::borrowck_moved_a_fn_once_in_call_call);
} else { } else {
err.subdiagnostic( err.subdiagnostic(CaptureReasonNote::FnOnceMoveInCall { var_span });
self.dcx(),
CaptureReasonNote::FnOnceMoveInCall { var_span },
);
} }
} }
CallKind::Operator { self_arg, trait_id, .. } => { CallKind::Operator { self_arg, trait_id, .. } => {
let self_arg = self_arg.unwrap(); let self_arg = self_arg.unwrap();
err.subdiagnostic( err.subdiagnostic(CaptureReasonLabel::OperatorUse {
self.dcx(), fn_call_span,
CaptureReasonLabel::OperatorUse { place_name: &place_name,
fn_call_span, is_partial,
place_name: &place_name, is_loop_message,
is_partial, });
is_loop_message,
},
);
if self.fn_self_span_reported.insert(fn_span) { if self.fn_self_span_reported.insert(fn_span) {
let lang = self.infcx.tcx.lang_items(); let lang = self.infcx.tcx.lang_items();
err.subdiagnostic( err.subdiagnostic(
self.dcx(),
if [lang.not_trait(), lang.deref_trait(), lang.neg_trait()] if [lang.not_trait(), lang.deref_trait(), lang.neg_trait()]
.contains(&Some(trait_id)) .contains(&Some(trait_id))
{ {
@ -1164,14 +1132,11 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
); );
let func = tcx.def_path_str(method_did); let func = tcx.def_path_str(method_did);
err.subdiagnostic( err.subdiagnostic(CaptureReasonNote::FuncTakeSelf {
self.dcx(), func,
CaptureReasonNote::FuncTakeSelf { place_name: place_name.clone(),
func, span: self_arg.span,
place_name: place_name.clone(), });
span: self_arg.span,
},
);
} }
let parent_did = tcx.parent(method_did); let parent_did = tcx.parent(method_did);
let parent_self_ty = let parent_self_ty =
@ -1185,10 +1150,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
matches!(tcx.get_diagnostic_name(def_id), Some(sym::Option | sym::Result)) matches!(tcx.get_diagnostic_name(def_id), Some(sym::Option | sym::Result))
}); });
if is_option_or_result && maybe_reinitialized_locations_is_empty { if is_option_or_result && maybe_reinitialized_locations_is_empty {
err.subdiagnostic( err.subdiagnostic(CaptureReasonLabel::BorrowContent { var_span });
self.dcx(),
CaptureReasonLabel::BorrowContent { var_span },
);
} }
if let Some((CallDesugaringKind::ForLoopIntoIter, _)) = desugaring { if let Some((CallDesugaringKind::ForLoopIntoIter, _)) = desugaring {
let ty = moved_place.ty(self.body, tcx).ty; let ty = moved_place.ty(self.body, tcx).ty;
@ -1202,24 +1164,18 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
_ => false, _ => false,
}; };
if suggest { if suggest {
err.subdiagnostic( err.subdiagnostic(CaptureReasonSuggest::IterateSlice {
self.dcx(), ty,
CaptureReasonSuggest::IterateSlice { span: move_span.shrink_to_lo(),
ty, });
span: move_span.shrink_to_lo(),
},
);
} }
err.subdiagnostic( err.subdiagnostic(CaptureReasonLabel::ImplicitCall {
self.dcx(), fn_call_span,
CaptureReasonLabel::ImplicitCall { place_name: &place_name,
fn_call_span, is_partial,
place_name: &place_name, is_loop_message,
is_partial, });
is_loop_message,
},
);
// If the moved place was a `&mut` ref, then we can // If the moved place was a `&mut` ref, then we can
// suggest to reborrow it where it was moved, so it // suggest to reborrow it where it was moved, so it
// will still be valid by the time we get to the usage. // will still be valid by the time we get to the usage.
@ -1243,25 +1199,19 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
} }
} else { } else {
if let Some((CallDesugaringKind::Await, _)) = desugaring { if let Some((CallDesugaringKind::Await, _)) = desugaring {
err.subdiagnostic( err.subdiagnostic(CaptureReasonLabel::Await {
self.dcx(), fn_call_span,
CaptureReasonLabel::Await { place_name: &place_name,
fn_call_span, is_partial,
place_name: &place_name, is_loop_message,
is_partial, });
is_loop_message,
},
);
} else { } else {
err.subdiagnostic( err.subdiagnostic(CaptureReasonLabel::MethodCall {
self.dcx(), fn_call_span,
CaptureReasonLabel::MethodCall { place_name: &place_name,
fn_call_span, is_partial,
place_name: &place_name, is_loop_message,
is_partial, });
is_loop_message,
},
);
} }
// Erase and shadow everything that could be passed to the new infcx. // Erase and shadow everything that could be passed to the new infcx.
let ty = moved_place.ty(self.body, tcx).ty; let ty = moved_place.ty(self.body, tcx).ty;
@ -1276,12 +1226,9 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
) )
&& self.infcx.can_eq(self.param_env, ty, self_ty) && self.infcx.can_eq(self.param_env, ty, self_ty)
{ {
err.subdiagnostic( err.subdiagnostic(CaptureReasonSuggest::FreshReborrow {
self.dcx(), span: move_span.shrink_to_hi(),
CaptureReasonSuggest::FreshReborrow { });
span: move_span.shrink_to_hi(),
},
);
has_sugg = true; has_sugg = true;
} }
if let Some(clone_trait) = tcx.lang_items().clone_trait() { if let Some(clone_trait) = tcx.lang_items().clone_trait() {
@ -1368,20 +1315,17 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
} }
} else { } else {
if move_span != span || is_loop_message { if move_span != span || is_loop_message {
err.subdiagnostic( err.subdiagnostic(CaptureReasonLabel::MovedHere {
self.dcx(), move_span,
CaptureReasonLabel::MovedHere { is_partial,
move_span, is_move_msg,
is_partial, is_loop_message,
is_move_msg, });
is_loop_message,
},
);
} }
// If the move error occurs due to a loop, don't show // If the move error occurs due to a loop, don't show
// another message for the same span // another message for the same span
if !is_loop_message { if !is_loop_message {
move_spans.var_subdiag(self.dcx(), err, None, |kind, var_span| match kind { move_spans.var_subdiag(err, None, |kind, var_span| match kind {
hir::ClosureKind::Coroutine(_) => { hir::ClosureKind::Coroutine(_) => {
CaptureVarCause::PartialMoveUseInCoroutine { var_span, is_partial } CaptureVarCause::PartialMoveUseInCoroutine { var_span, is_partial }
} }

47
compiler/rustc_borrowck/src/diagnostics/move_errors.rs
View file

@ -579,15 +579,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
self.suggest_cloning(err, place_ty, expr, self.find_expr(other_span), None); self.suggest_cloning(err, place_ty, expr, self.find_expr(other_span), None);
} }
err.subdiagnostic( err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
self.dcx(), is_partial_move: false,
crate::session_diagnostics::TypeNoCopy::Label { ty: place_ty,
is_partial_move: false, place: &place_desc,
ty: place_ty, span,
place: &place_desc, });
span,
},
);
} else { } else {
binds_to.sort(); binds_to.sort();
binds_to.dedup(); binds_to.dedup();
@ -620,17 +617,14 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
); );
} }
err.subdiagnostic( err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
self.dcx(), is_partial_move: false,
crate::session_diagnostics::TypeNoCopy::Label { ty: place_ty,
is_partial_move: false, place: &place_desc,
ty: place_ty, span: use_span,
place: &place_desc, });
span: use_span,
},
);
use_spans.args_subdiag(self.dcx(), err, |args_span| { use_spans.args_subdiag(err, |args_span| {
crate::session_diagnostics::CaptureArgLabel::MoveOutPlace { crate::session_diagnostics::CaptureArgLabel::MoveOutPlace {
place: place_desc, place: place_desc,
args_span, args_span,
@ -733,15 +727,12 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
self.suggest_cloning(err, bind_to.ty, expr, None, None); self.suggest_cloning(err, bind_to.ty, expr, None, None);
} }
err.subdiagnostic( err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
self.dcx(), is_partial_move: false,
crate::session_diagnostics::TypeNoCopy::Label { ty: bind_to.ty,
is_partial_move: false, place: place_desc,
ty: bind_to.ty, span: binding_span,
place: place_desc, });
span: binding_span,
},
);
} }
} }

1
compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
View file

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

10
compiler/rustc_borrowck/src/diagnostics/region_errors.rs
View file

@ -631,13 +631,13 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
let upvars_map = self.infcx.tcx.upvars_mentioned(def_id).unwrap(); let upvars_map = self.infcx.tcx.upvars_mentioned(def_id).unwrap();
let upvar_def_span = self.infcx.tcx.hir().span(def_hir); let upvar_def_span = self.infcx.tcx.hir().span(def_hir);
let upvar_span = upvars_map.get(&def_hir).unwrap().span; let upvar_span = upvars_map.get(&def_hir).unwrap().span;
diag.subdiagnostic(self.dcx(), VarHereDenote::Defined { span: upvar_def_span }); diag.subdiagnostic(VarHereDenote::Defined { span: upvar_def_span });
diag.subdiagnostic(self.dcx(), VarHereDenote::Captured { span: upvar_span }); diag.subdiagnostic(VarHereDenote::Captured { span: upvar_span });
} }
} }
if let Some(fr_span) = self.give_region_a_name(*outlived_fr).unwrap().span() { if let Some(fr_span) = self.give_region_a_name(*outlived_fr).unwrap().span() {
diag.subdiagnostic(self.dcx(), VarHereDenote::FnMutInferred { span: fr_span }); diag.subdiagnostic(VarHereDenote::FnMutInferred { span: fr_span });
} }
self.suggest_move_on_borrowing_closure(&mut diag); self.suggest_move_on_borrowing_closure(&mut diag);
@ -810,7 +810,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
}, },
}; };
diag.subdiagnostic(self.dcx(), err_category); diag.subdiagnostic(err_category);
self.add_static_impl_trait_suggestion(&mut diag, *fr, fr_name, *outlived_fr); self.add_static_impl_trait_suggestion(&mut diag, *fr, fr_name, *outlived_fr);
self.suggest_adding_lifetime_params(&mut diag, *fr, *outlived_fr); self.suggest_adding_lifetime_params(&mut diag, *fr, *outlived_fr);
@ -1008,7 +1008,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
ident.span, ident.span,
"calling this method introduces the `impl`'s `'static` requirement", "calling this method introduces the `impl`'s `'static` requirement",
); );
err.subdiagnostic(self.dcx(), RequireStaticErr::UsedImpl { multi_span }); err.subdiagnostic(RequireStaticErr::UsedImpl { multi_span });
err.span_suggestion_verbose( err.span_suggestion_verbose(
span.shrink_to_hi(), span.shrink_to_hi(),
"consider relaxing the implicit `'static` requirement", "consider relaxing the implicit `'static` requirement",

8
compiler/rustc_builtin_macros/src/asm.rs
View file

@ -46,7 +46,7 @@ pub fn parse_asm_args<'a>(
sp: Span, sp: Span,
is_global_asm: bool, is_global_asm: bool,
) -> PResult<'a, AsmArgs> { ) -> PResult<'a, AsmArgs> {
let dcx = &p.psess.dcx; let dcx = p.dcx();
if p.token == token::Eof { if p.token == token::Eof {
return Err(dcx.create_err(errors::AsmRequiresTemplate { span: sp })); return Err(dcx.create_err(errors::AsmRequiresTemplate { span: sp }));
@ -307,7 +307,7 @@ pub fn parse_asm_args<'a>(
fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) { fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
// Tool-only output // Tool-only output
let full_span = if p.token.kind == token::Comma { span.to(p.token.span) } else { span }; let full_span = if p.token.kind == token::Comma { span.to(p.token.span) } else { span };
p.psess.dcx.emit_err(errors::AsmOptAlreadyprovided { span, symbol, full_span }); p.dcx().emit_err(errors::AsmOptAlreadyprovided { span, symbol, full_span });
} }
/// Try to set the provided option in the provided `AsmArgs`. /// 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,
p.expect(&token::OpenDelim(Delimiter::Parenthesis))?; p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) { if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
return Err(p.psess.dcx.create_err(errors::NonABI { span: p.token.span })); return Err(p.dcx().create_err(errors::NonABI { span: p.token.span }));
} }
let mut new_abis = Vec::new(); let mut new_abis = Vec::new();
@ -390,7 +390,7 @@ fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a,
} }
Err(opt_lit) => { Err(opt_lit) => {
let span = opt_lit.map_or(p.token.span, |lit| lit.span); let span = opt_lit.map_or(p.token.span, |lit| lit.span);
let mut err = p.psess.dcx.struct_span_err(span, "expected string literal"); let mut err = p.dcx().struct_span_err(span, "expected string literal");
err.span_label(span, "not a string literal"); err.span_label(span, "not a string literal");
return Err(err); return Err(err);
} }

2
compiler/rustc_builtin_macros/src/cmdline_attrs.rs
View file

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

6
compiler/rustc_builtin_macros/src/errors.rs
View file

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

5
compiler/rustc_builtin_macros/src/proc_macro_harness.rs
View file

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

3
compiler/rustc_builtin_macros/src/test_harness.rs
View file

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

3
compiler/rustc_codegen_cranelift/src/concurrency_limiter.rs
View file

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

11
compiler/rustc_codegen_gcc/src/back/lto.rs
View file

@ -28,7 +28,7 @@ use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput};
use rustc_codegen_ssa::traits::*; use rustc_codegen_ssa::traits::*;
use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind}; use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind};
use rustc_data_structures::memmap::Mmap; use rustc_data_structures::memmap::Mmap;
use rustc_errors::{DiagCtxt, FatalError}; use rustc_errors::{DiagCtxtHandle, FatalError};
use rustc_hir::def_id::LOCAL_CRATE; use rustc_hir::def_id::LOCAL_CRATE;
use rustc_middle::dep_graph::WorkProduct; use rustc_middle::dep_graph::WorkProduct;
use rustc_middle::middle::exported_symbols::{SymbolExportInfo, SymbolExportLevel}; use rustc_middle::middle::exported_symbols::{SymbolExportInfo, SymbolExportLevel};
@ -59,7 +59,7 @@ struct LtoData {
fn prepare_lto( fn prepare_lto(
cgcx: &CodegenContext<GccCodegenBackend>, cgcx: &CodegenContext<GccCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
) -> Result<LtoData, FatalError> { ) -> Result<LtoData, FatalError> {
let export_threshold = match cgcx.lto { let export_threshold = match cgcx.lto {
// We're just doing LTO for our one crate // We're just doing LTO for our one crate
@ -179,12 +179,13 @@ pub(crate) fn run_fat(
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
) -> Result<LtoModuleCodegen<GccCodegenBackend>, FatalError> { ) -> Result<LtoModuleCodegen<GccCodegenBackend>, FatalError> {
let dcx = cgcx.create_dcx(); let dcx = cgcx.create_dcx();
let lto_data = prepare_lto(cgcx, &dcx)?; let dcx = dcx.handle();
let lto_data = prepare_lto(cgcx, dcx)?;
/*let symbols_below_threshold = /*let symbols_below_threshold =
lto_data.symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();*/ lto_data.symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();*/
fat_lto( fat_lto(
cgcx, cgcx,
&dcx, dcx,
modules, modules,
cached_modules, cached_modules,
lto_data.upstream_modules, lto_data.upstream_modules,
@ -195,7 +196,7 @@ pub(crate) fn run_fat(
fn fat_lto( fn fat_lto(
cgcx: &CodegenContext<GccCodegenBackend>, cgcx: &CodegenContext<GccCodegenBackend>,
_dcx: &DiagCtxt, _dcx: DiagCtxtHandle<'_>,
modules: Vec<FatLtoInput<GccCodegenBackend>>, modules: Vec<FatLtoInput<GccCodegenBackend>>,
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>, mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,

6
compiler/rustc_codegen_gcc/src/back/write.rs
View file

@ -4,7 +4,7 @@ use gccjit::OutputKind;
use rustc_codegen_ssa::back::link::ensure_removed; use rustc_codegen_ssa::back::link::ensure_removed;
use rustc_codegen_ssa::back::write::{BitcodeSection, CodegenContext, EmitObj, ModuleConfig}; use rustc_codegen_ssa::back::write::{BitcodeSection, CodegenContext, EmitObj, ModuleConfig};
use rustc_codegen_ssa::{CompiledModule, ModuleCodegen}; use rustc_codegen_ssa::{CompiledModule, ModuleCodegen};
use rustc_errors::DiagCtxt; use rustc_errors::DiagCtxtHandle;
use rustc_fs_util::link_or_copy; use rustc_fs_util::link_or_copy;
use rustc_session::config::OutputType; use rustc_session::config::OutputType;
use rustc_span::fatal_error::FatalError; use rustc_span::fatal_error::FatalError;
@ -15,7 +15,7 @@ use crate::{GccCodegenBackend, GccContext};
pub(crate) unsafe fn codegen( pub(crate) unsafe fn codegen(
cgcx: &CodegenContext<GccCodegenBackend>, cgcx: &CodegenContext<GccCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: ModuleCodegen<GccContext>, module: ModuleCodegen<GccContext>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<CompiledModule, FatalError> { ) -> Result<CompiledModule, FatalError> {
@ -166,7 +166,7 @@ pub(crate) unsafe fn codegen(
pub(crate) fn link( pub(crate) fn link(
_cgcx: &CodegenContext<GccCodegenBackend>, _cgcx: &CodegenContext<GccCodegenBackend>,
_dcx: &DiagCtxt, _dcx: DiagCtxtHandle<'_>,
mut _modules: Vec<ModuleCodegen<GccContext>>, mut _modules: Vec<ModuleCodegen<GccContext>>,
) -> Result<ModuleCodegen<GccContext>, FatalError> { ) -> Result<ModuleCodegen<GccContext>, FatalError> {
unimplemented!(); unimplemented!();

6
compiler/rustc_codegen_gcc/src/errors.rs
View file

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

21
compiler/rustc_codegen_gcc/src/lib.rs
View file

@ -16,13 +16,7 @@
#![allow(internal_features)] #![allow(internal_features)]
#![doc(rust_logo)] #![doc(rust_logo)]
#![feature(rustdoc_internals)] #![feature(rustdoc_internals)]
#![feature( #![feature(rustc_private, decl_macro, never_type, trusted_len, hash_raw_entry)]
rustc_private,
decl_macro,
never_type,
trusted_len,
hash_raw_entry
)]
#![allow(broken_intra_doc_links)] #![allow(broken_intra_doc_links)]
#![recursion_limit = "256"] #![recursion_limit = "256"]
#![warn(rust_2018_idioms)] #![warn(rust_2018_idioms)]
@ -104,7 +98,7 @@ use rustc_codegen_ssa::traits::{
use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen}; use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen};
use rustc_data_structures::fx::FxIndexMap; use rustc_data_structures::fx::FxIndexMap;
use rustc_data_structures::sync::IntoDynSyncSend; use rustc_data_structures::sync::IntoDynSyncSend;
use rustc_errors::{DiagCtxt, ErrorGuaranteed}; use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
use rustc_metadata::EncodedMetadata; use rustc_metadata::EncodedMetadata;
use rustc_middle::dep_graph::{WorkProduct, WorkProductId}; use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
@ -386,7 +380,7 @@ impl WriteBackendMethods for GccCodegenBackend {
unsafe fn optimize( unsafe fn optimize(
_cgcx: &CodegenContext<Self>, _cgcx: &CodegenContext<Self>,
_dcx: &DiagCtxt, _dcx: DiagCtxtHandle<'_>,
module: &ModuleCodegen<Self::Module>, module: &ModuleCodegen<Self::Module>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<(), FatalError> { ) -> Result<(), FatalError> {
@ -411,14 +405,17 @@ impl WriteBackendMethods for GccCodegenBackend {
unsafe fn codegen( unsafe fn codegen(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: ModuleCodegen<Self::Module>, module: ModuleCodegen<Self::Module>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<CompiledModule, FatalError> { ) -> Result<CompiledModule, FatalError> {
back::write::codegen(cgcx, dcx, module, config) back::write::codegen(cgcx, dcx, module, config)
} }
fn prepare_thin(_module: ModuleCodegen<Self::Module>, _emit_summary: bool) -> (String, Self::ThinBuffer) { fn prepare_thin(
_module: ModuleCodegen<Self::Module>,
_emit_summary: bool,
) -> (String, Self::ThinBuffer) {
unimplemented!(); unimplemented!();
} }
@ -428,7 +425,7 @@ impl WriteBackendMethods for GccCodegenBackend {
fn run_link( fn run_link(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
modules: Vec<ModuleCodegen<Self::Module>>, modules: Vec<ModuleCodegen<Self::Module>>,
) -> Result<ModuleCodegen<Self::Module>, FatalError> { ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
back::write::link(cgcx, dcx, modules) back::write::link(cgcx, dcx, modules)

37
compiler/rustc_codegen_llvm/src/back/lto.rs
View file

@ -14,7 +14,7 @@ use rustc_codegen_ssa::traits::*;
use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind}; use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind};
use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::memmap::Mmap; use rustc_data_structures::memmap::Mmap;
use rustc_errors::{DiagCtxt, FatalError}; use rustc_errors::{DiagCtxtHandle, FatalError};
use rustc_hir::def_id::LOCAL_CRATE; use rustc_hir::def_id::LOCAL_CRATE;
use rustc_middle::bug; use rustc_middle::bug;
use rustc_middle::dep_graph::WorkProduct; use rustc_middle::dep_graph::WorkProduct;
@ -49,7 +49,7 @@ pub fn crate_type_allows_lto(crate_type: CrateType) -> bool {
fn prepare_lto( fn prepare_lto(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
) -> Result<(Vec<CString>, Vec<(SerializedModule<ModuleBuffer>, CString)>), FatalError> { ) -> Result<(Vec<CString>, Vec<(SerializedModule<ModuleBuffer>, CString)>), FatalError> {
let export_threshold = match cgcx.lto { let export_threshold = match cgcx.lto {
// We're just doing LTO for our one crate // We're just doing LTO for our one crate
@ -203,10 +203,11 @@ pub(crate) fn run_fat(
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> { ) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> {
let dcx = cgcx.create_dcx(); let dcx = cgcx.create_dcx();
let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &dcx)?; let dcx = dcx.handle();
let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, dcx)?;
let symbols_below_threshold = let symbols_below_threshold =
symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>(); symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();
fat_lto(cgcx, &dcx, modules, cached_modules, upstream_modules, &symbols_below_threshold) fat_lto(cgcx, dcx, modules, cached_modules, upstream_modules, &symbols_below_threshold)
} }
/// Performs thin LTO by performing necessary global analysis and returning two /// Performs thin LTO by performing necessary global analysis and returning two
@ -218,7 +219,8 @@ pub(crate) fn run_thin(
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
) -> Result<(Vec<LtoModuleCodegen<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> { ) -> Result<(Vec<LtoModuleCodegen<LlvmCodegenBackend>>, Vec<WorkProduct>), FatalError> {
let dcx = cgcx.create_dcx(); let dcx = cgcx.create_dcx();
let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &dcx)?; let dcx = dcx.handle();
let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, dcx)?;
let symbols_below_threshold = let symbols_below_threshold =
symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>(); symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::<Vec<_>>();
if cgcx.opts.cg.linker_plugin_lto.enabled() { if cgcx.opts.cg.linker_plugin_lto.enabled() {
@ -227,7 +229,7 @@ pub(crate) fn run_thin(
is deferred to the linker" is deferred to the linker"
); );
} }
thin_lto(cgcx, &dcx, modules, upstream_modules, cached_modules, &symbols_below_threshold) thin_lto(cgcx, dcx, modules, upstream_modules, cached_modules, &symbols_below_threshold)
} }
pub(crate) fn prepare_thin( pub(crate) fn prepare_thin(
@ -241,7 +243,7 @@ pub(crate) fn prepare_thin(
fn fat_lto( fn fat_lto(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
modules: Vec<FatLtoInput<LlvmCodegenBackend>>, modules: Vec<FatLtoInput<LlvmCodegenBackend>>,
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>, mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
@ -436,7 +438,7 @@ impl Drop for Linker<'_> {
/// they all go out of scope. /// they all go out of scope.
fn thin_lto( fn thin_lto(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
modules: Vec<(String, ThinBuffer)>, modules: Vec<(String, ThinBuffer)>,
serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>, serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
@ -593,7 +595,7 @@ fn thin_lto(
pub(crate) fn run_pass_manager( pub(crate) fn run_pass_manager(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: &mut ModuleCodegen<ModuleLlvm>, module: &mut ModuleCodegen<ModuleLlvm>,
thin: bool, thin: bool,
) -> Result<(), FatalError> { ) -> Result<(), FatalError> {
@ -714,10 +716,11 @@ pub unsafe fn optimize_thin_module(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> { ) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> {
let dcx = cgcx.create_dcx(); let dcx = cgcx.create_dcx();
let dcx = dcx.handle();
let module_name = &thin_module.shared.module_names[thin_module.idx]; let module_name = &thin_module.shared.module_names[thin_module.idx];
let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, module_name.to_str().unwrap()); let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, module_name.to_str().unwrap());
let tm = (cgcx.tm_factory)(tm_factory_config).map_err(|e| write::llvm_err(&dcx, e))?; let tm = (cgcx.tm_factory)(tm_factory_config).map_err(|e| write::llvm_err(dcx, e))?;
// Right now the implementation we've got only works over serialized // Right now the implementation we've got only works over serialized
// modules, so we create a fresh new LLVM context and parse the module // modules, so we create a fresh new LLVM context and parse the module
@ -725,7 +728,7 @@ pub unsafe fn optimize_thin_module(
// crates but for locally codegened modules we may be able to reuse // crates but for locally codegened modules we may be able to reuse
// that LLVM Context and Module. // that LLVM Context and Module.
let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names); let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
let llmod_raw = parse_module(llcx, module_name, thin_module.data(), &dcx)? as *const _; let llmod_raw = parse_module(llcx, module_name, thin_module.data(), dcx)? as *const _;
let mut module = ModuleCodegen { let mut module = ModuleCodegen {
module_llvm: ModuleLlvm { llmod_raw, llcx, tm: ManuallyDrop::new(tm) }, module_llvm: ModuleLlvm { llmod_raw, llcx, tm: ManuallyDrop::new(tm) },
name: thin_module.name().to_string(), name: thin_module.name().to_string(),
@ -748,7 +751,7 @@ pub unsafe fn optimize_thin_module(
let _timer = let _timer =
cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_rename", thin_module.name()); cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_rename", thin_module.name());
if !llvm::LLVMRustPrepareThinLTORename(thin_module.shared.data.0, llmod, target) { if !llvm::LLVMRustPrepareThinLTORename(thin_module.shared.data.0, llmod, target) {
return Err(write::llvm_err(&dcx, LlvmError::PrepareThinLtoModule)); return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
} }
save_temp_bitcode(cgcx, &module, "thin-lto-after-rename"); save_temp_bitcode(cgcx, &module, "thin-lto-after-rename");
} }
@ -758,7 +761,7 @@ pub unsafe fn optimize_thin_module(
.prof .prof
.generic_activity_with_arg("LLVM_thin_lto_resolve_weak", thin_module.name()); .generic_activity_with_arg("LLVM_thin_lto_resolve_weak", thin_module.name());
if !llvm::LLVMRustPrepareThinLTOResolveWeak(thin_module.shared.data.0, llmod) { if !llvm::LLVMRustPrepareThinLTOResolveWeak(thin_module.shared.data.0, llmod) {
return Err(write::llvm_err(&dcx, LlvmError::PrepareThinLtoModule)); return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
} }
save_temp_bitcode(cgcx, &module, "thin-lto-after-resolve"); save_temp_bitcode(cgcx, &module, "thin-lto-after-resolve");
} }
@ -768,7 +771,7 @@ pub unsafe fn optimize_thin_module(
.prof .prof
.generic_activity_with_arg("LLVM_thin_lto_internalize", thin_module.name()); .generic_activity_with_arg("LLVM_thin_lto_internalize", thin_module.name());
if !llvm::LLVMRustPrepareThinLTOInternalize(thin_module.shared.data.0, llmod) { if !llvm::LLVMRustPrepareThinLTOInternalize(thin_module.shared.data.0, llmod) {
return Err(write::llvm_err(&dcx, LlvmError::PrepareThinLtoModule)); return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
} }
save_temp_bitcode(cgcx, &module, "thin-lto-after-internalize"); save_temp_bitcode(cgcx, &module, "thin-lto-after-internalize");
} }
@ -777,7 +780,7 @@ pub unsafe fn optimize_thin_module(
let _timer = let _timer =
cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_import", thin_module.name()); cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_import", thin_module.name());
if !llvm::LLVMRustPrepareThinLTOImport(thin_module.shared.data.0, llmod, target) { if !llvm::LLVMRustPrepareThinLTOImport(thin_module.shared.data.0, llmod, target) {
return Err(write::llvm_err(&dcx, LlvmError::PrepareThinLtoModule)); return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
} }
save_temp_bitcode(cgcx, &module, "thin-lto-after-import"); save_temp_bitcode(cgcx, &module, "thin-lto-after-import");
} }
@ -789,7 +792,7 @@ pub unsafe fn optimize_thin_module(
// little differently. // little differently.
{ {
info!("running thin lto passes over {}", module.name); info!("running thin lto passes over {}", module.name);
run_pass_manager(cgcx, &dcx, &mut module, true)?; run_pass_manager(cgcx, dcx, &mut module, true)?;
save_temp_bitcode(cgcx, &module, "thin-lto-after-pm"); save_temp_bitcode(cgcx, &module, "thin-lto-after-pm");
} }
} }
@ -859,7 +862,7 @@ pub fn parse_module<'a>(
cx: &'a llvm::Context, cx: &'a llvm::Context,
name: &CStr, name: &CStr,
data: &[u8], data: &[u8],
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
) -> Result<&'a llvm::Module, FatalError> { ) -> Result<&'a llvm::Module, FatalError> {
unsafe { unsafe {
llvm::LLVMRustParseBitcodeForLTO(cx, data.as_ptr(), data.len(), name.as_ptr()) llvm::LLVMRustParseBitcodeForLTO(cx, data.as_ptr(), data.len(), name.as_ptr())

20
compiler/rustc_codegen_llvm/src/back/write.rs
View file

@ -26,7 +26,7 @@ use rustc_codegen_ssa::traits::*;
use rustc_codegen_ssa::{CompiledModule, ModuleCodegen}; use rustc_codegen_ssa::{CompiledModule, ModuleCodegen};
use rustc_data_structures::profiling::SelfProfilerRef; use rustc_data_structures::profiling::SelfProfilerRef;
use rustc_data_structures::small_c_str::SmallCStr; use rustc_data_structures::small_c_str::SmallCStr;
use rustc_errors::{DiagCtxt, FatalError, Level}; use rustc_errors::{DiagCtxtHandle, FatalError, Level};
use rustc_fs_util::{link_or_copy, path_to_c_string}; use rustc_fs_util::{link_or_copy, path_to_c_string};
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
use rustc_session::config::{self, Lto, OutputType, Passes}; use rustc_session::config::{self, Lto, OutputType, Passes};
@ -47,7 +47,7 @@ use std::slice;
use std::str; use std::str;
use std::sync::Arc; use std::sync::Arc;
pub fn llvm_err<'a>(dcx: &rustc_errors::DiagCtxt, err: LlvmError<'a>) -> FatalError { pub fn llvm_err<'a>(dcx: DiagCtxtHandle<'_>, err: LlvmError<'a>) -> FatalError {
match llvm::last_error() { match llvm::last_error() {
Some(llvm_err) => dcx.emit_almost_fatal(WithLlvmError(err, llvm_err)), Some(llvm_err) => dcx.emit_almost_fatal(WithLlvmError(err, llvm_err)),
None => dcx.emit_almost_fatal(err), None => dcx.emit_almost_fatal(err),
@ -55,7 +55,7 @@ pub fn llvm_err<'a>(dcx: &rustc_errors::DiagCtxt, err: LlvmError<'a>) -> FatalEr
} }
pub fn write_output_file<'ll>( pub fn write_output_file<'ll>(
dcx: &rustc_errors::DiagCtxt, dcx: DiagCtxtHandle<'_>,
target: &'ll llvm::TargetMachine, target: &'ll llvm::TargetMachine,
pm: &llvm::PassManager<'ll>, pm: &llvm::PassManager<'ll>,
m: &'ll llvm::Module, m: &'ll llvm::Module,
@ -331,7 +331,7 @@ pub enum CodegenDiagnosticsStage {
} }
pub struct DiagnosticHandlers<'a> { pub struct DiagnosticHandlers<'a> {
data: *mut (&'a CodegenContext<LlvmCodegenBackend>, &'a DiagCtxt), data: *mut (&'a CodegenContext<LlvmCodegenBackend>, DiagCtxtHandle<'a>),
llcx: &'a llvm::Context, llcx: &'a llvm::Context,
old_handler: Option<&'a llvm::DiagnosticHandler>, old_handler: Option<&'a llvm::DiagnosticHandler>,
} }
@ -339,7 +339,7 @@ pub struct DiagnosticHandlers<'a> {
impl<'a> DiagnosticHandlers<'a> { impl<'a> DiagnosticHandlers<'a> {
pub fn new( pub fn new(
cgcx: &'a CodegenContext<LlvmCodegenBackend>, cgcx: &'a CodegenContext<LlvmCodegenBackend>,
dcx: &'a DiagCtxt, dcx: DiagCtxtHandle<'a>,
llcx: &'a llvm::Context, llcx: &'a llvm::Context,
module: &ModuleCodegen<ModuleLlvm>, module: &ModuleCodegen<ModuleLlvm>,
stage: CodegenDiagnosticsStage, stage: CodegenDiagnosticsStage,
@ -428,7 +428,7 @@ unsafe extern "C" fn diagnostic_handler(info: &DiagnosticInfo, user: *mut c_void
if user.is_null() { if user.is_null() {
return; return;
} }
let (cgcx, dcx) = *(user as *const (&CodegenContext<LlvmCodegenBackend>, &DiagCtxt)); let (cgcx, dcx) = *(user as *const (&CodegenContext<LlvmCodegenBackend>, DiagCtxtHandle<'_>));
match llvm::diagnostic::Diagnostic::unpack(info) { match llvm::diagnostic::Diagnostic::unpack(info) {
llvm::diagnostic::InlineAsm(inline) => { llvm::diagnostic::InlineAsm(inline) => {
@ -506,7 +506,7 @@ fn get_instr_profile_output_path(config: &ModuleConfig) -> Option<CString> {
pub(crate) unsafe fn llvm_optimize( pub(crate) unsafe fn llvm_optimize(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: &ModuleCodegen<ModuleLlvm>, module: &ModuleCodegen<ModuleLlvm>,
config: &ModuleConfig, config: &ModuleConfig,
opt_level: config::OptLevel, opt_level: config::OptLevel,
@ -604,7 +604,7 @@ pub(crate) unsafe fn llvm_optimize(
// Unsafe due to LLVM calls. // Unsafe due to LLVM calls.
pub(crate) unsafe fn optimize( pub(crate) unsafe fn optimize(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: &ModuleCodegen<ModuleLlvm>, module: &ModuleCodegen<ModuleLlvm>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<(), FatalError> { ) -> Result<(), FatalError> {
@ -637,7 +637,7 @@ pub(crate) unsafe fn optimize(
pub(crate) fn link( pub(crate) fn link(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
mut modules: Vec<ModuleCodegen<ModuleLlvm>>, mut modules: Vec<ModuleCodegen<ModuleLlvm>>,
) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> { ) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> {
use super::lto::{Linker, ModuleBuffer}; use super::lto::{Linker, ModuleBuffer};
@ -660,7 +660,7 @@ pub(crate) fn link(
pub(crate) unsafe fn codegen( pub(crate) unsafe fn codegen(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: ModuleCodegen<ModuleLlvm>, module: ModuleCodegen<ModuleLlvm>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<CompiledModule, FatalError> { ) -> Result<CompiledModule, FatalError> {

10
compiler/rustc_codegen_llvm/src/errors.rs
View file

@ -4,7 +4,7 @@ use std::path::Path;
use crate::fluent_generated as fluent; use crate::fluent_generated as fluent;
use rustc_data_structures::small_c_str::SmallCStr; use rustc_data_structures::small_c_str::SmallCStr;
use rustc_errors::{Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level}; use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_macros::{Diagnostic, Subdiagnostic};
use rustc_span::Span; use rustc_span::Span;
@ -100,7 +100,7 @@ pub(crate) struct DynamicLinkingWithLTO;
pub(crate) struct ParseTargetMachineConfig<'a>(pub LlvmError<'a>); pub(crate) struct ParseTargetMachineConfig<'a>(pub LlvmError<'a>);
impl<G: EmissionGuarantee> Diagnostic<'_, G> for ParseTargetMachineConfig<'_> { impl<G: EmissionGuarantee> Diagnostic<'_, G> for ParseTargetMachineConfig<'_> {
fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let diag: Diag<'_, G> = self.0.into_diag(dcx, level); let diag: Diag<'_, G> = self.0.into_diag(dcx, level);
let (message, _) = diag.messages.first().expect("`LlvmError` with no message"); let (message, _) = diag.messages.first().expect("`LlvmError` with no message");
let message = dcx.eagerly_translate_to_string(message.clone(), diag.args.iter()); let message = dcx.eagerly_translate_to_string(message.clone(), diag.args.iter());
@ -120,13 +120,13 @@ pub(crate) struct TargetFeatureDisableOrEnable<'a> {
pub(crate) struct MissingFeatures; pub(crate) struct MissingFeatures;
impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetFeatureDisableOrEnable<'_> { impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetFeatureDisableOrEnable<'_> {
fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let mut diag = Diag::new(dcx, level, fluent::codegen_llvm_target_feature_disable_or_enable); let mut diag = Diag::new(dcx, level, fluent::codegen_llvm_target_feature_disable_or_enable);
if let Some(span) = self.span { if let Some(span) = self.span {
diag.span(span); diag.span(span);
}; };
if let Some(missing_features) = self.missing_features { if let Some(missing_features) = self.missing_features {
diag.subdiagnostic(dcx, missing_features); diag.subdiagnostic(missing_features);
} }
diag.arg("features", self.features.join(", ")); diag.arg("features", self.features.join(", "));
diag diag
@ -180,7 +180,7 @@ pub enum LlvmError<'a> {
pub(crate) struct WithLlvmError<'a>(pub LlvmError<'a>, pub String); pub(crate) struct WithLlvmError<'a>(pub LlvmError<'a>, pub String);
impl<G: EmissionGuarantee> Diagnostic<'_, G> for WithLlvmError<'_> { impl<G: EmissionGuarantee> Diagnostic<'_, G> for WithLlvmError<'_> {
fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
use LlvmError::*; use LlvmError::*;
let msg_with_llvm_err = match &self.0 { let msg_with_llvm_err = match &self.0 {
WriteOutput { .. } => fluent::codegen_llvm_write_output_with_llvm_err, WriteOutput { .. } => fluent::codegen_llvm_write_output_with_llvm_err,

13
compiler/rustc_codegen_llvm/src/lib.rs
View file

@ -31,7 +31,7 @@ use rustc_codegen_ssa::traits::*;
use rustc_codegen_ssa::ModuleCodegen; use rustc_codegen_ssa::ModuleCodegen;
use rustc_codegen_ssa::{CodegenResults, CompiledModule}; use rustc_codegen_ssa::{CodegenResults, CompiledModule};
use rustc_data_structures::fx::FxIndexMap; use rustc_data_structures::fx::FxIndexMap;
use rustc_errors::{DiagCtxt, ErrorGuaranteed, FatalError}; use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, FatalError};
use rustc_metadata::EncodedMetadata; use rustc_metadata::EncodedMetadata;
use rustc_middle::dep_graph::{WorkProduct, WorkProductId}; use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
@ -191,7 +191,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
} }
fn run_link( fn run_link(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
modules: Vec<ModuleCodegen<Self::Module>>, modules: Vec<ModuleCodegen<Self::Module>>,
) -> Result<ModuleCodegen<Self::Module>, FatalError> { ) -> Result<ModuleCodegen<Self::Module>, FatalError> {
back::write::link(cgcx, dcx, modules) back::write::link(cgcx, dcx, modules)
@ -212,7 +212,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
} }
unsafe fn optimize( unsafe fn optimize(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: &ModuleCodegen<Self::Module>, module: &ModuleCodegen<Self::Module>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<(), FatalError> { ) -> Result<(), FatalError> {
@ -223,7 +223,8 @@ impl WriteBackendMethods for LlvmCodegenBackend {
module: &mut ModuleCodegen<Self::Module>, module: &mut ModuleCodegen<Self::Module>,
) -> Result<(), FatalError> { ) -> Result<(), FatalError> {
let dcx = cgcx.create_dcx(); let dcx = cgcx.create_dcx();
back::lto::run_pass_manager(cgcx, &dcx, module, false) let dcx = dcx.handle();
back::lto::run_pass_manager(cgcx, dcx, module, false)
} }
unsafe fn optimize_thin( unsafe fn optimize_thin(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
@ -233,7 +234,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
} }
unsafe fn codegen( unsafe fn codegen(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: ModuleCodegen<Self::Module>, module: ModuleCodegen<Self::Module>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<CompiledModule, FatalError> { ) -> Result<CompiledModule, FatalError> {
@ -441,7 +442,7 @@ impl ModuleLlvm {
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
name: &CStr, name: &CStr,
buffer: &[u8], buffer: &[u8],
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
) -> Result<Self, FatalError> { ) -> Result<Self, FatalError> {
unsafe { unsafe {
let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names); let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);

4
compiler/rustc_codegen_ssa/src/back/link.rs
View file

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

19
compiler/rustc_codegen_ssa/src/back/write.rs
View file

@ -891,9 +891,10 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
module_config: &ModuleConfig, module_config: &ModuleConfig,
) -> Result<WorkItemResult<B>, FatalError> { ) -> Result<WorkItemResult<B>, FatalError> {
let dcx = cgcx.create_dcx(); let dcx = cgcx.create_dcx();
let dcx = dcx.handle();
unsafe { unsafe {
B::optimize(cgcx, &dcx, &module, module_config)?; B::optimize(cgcx, dcx, &module, module_config)?;
} }
// After we've done the initial round of optimizations we need to // 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>(
match link_or_copy(&source_file, &output_path) { match link_or_copy(&source_file, &output_path) {
Ok(_) => Some(output_path), Ok(_) => Some(output_path),
Err(error) => { Err(error) => {
cgcx.create_dcx().emit_err(errors::CopyPathBuf { source_file, output_path, error }); cgcx.create_dcx().handle().emit_err(errors::CopyPathBuf {
source_file,
output_path,
error,
});
None None
} }
} }
@ -987,7 +992,7 @@ fn execute_copy_from_cache_work_item<B: ExtraBackendMethods>(
let bytecode = load_from_incr_cache(module_config.emit_bc, OutputType::Bitcode); let bytecode = load_from_incr_cache(module_config.emit_bc, OutputType::Bitcode);
let object = load_from_incr_cache(should_emit_obj, OutputType::Object); let object = load_from_incr_cache(should_emit_obj, OutputType::Object);
if should_emit_obj && object.is_none() { if should_emit_obj && object.is_none() {
cgcx.create_dcx().emit_fatal(errors::NoSavedObjectFile { cgu_name: &module.name }) cgcx.create_dcx().handle().emit_fatal(errors::NoSavedObjectFile { cgu_name: &module.name })
} }
WorkItemResult::Finished(CompiledModule { WorkItemResult::Finished(CompiledModule {
@ -1016,12 +1021,13 @@ fn finish_intra_module_work<B: ExtraBackendMethods>(
module_config: &ModuleConfig, module_config: &ModuleConfig,
) -> Result<WorkItemResult<B>, FatalError> { ) -> Result<WorkItemResult<B>, FatalError> {
let dcx = cgcx.create_dcx(); let dcx = cgcx.create_dcx();
let dcx = dcx.handle();
if !cgcx.opts.unstable_opts.combine_cgu if !cgcx.opts.unstable_opts.combine_cgu
|| module.kind == ModuleKind::Metadata || module.kind == ModuleKind::Metadata
|| module.kind == ModuleKind::Allocator || module.kind == ModuleKind::Allocator
{ {
let module = unsafe { B::codegen(cgcx, &dcx, module, module_config)? }; let module = unsafe { B::codegen(cgcx, dcx, module, module_config)? };
Ok(WorkItemResult::Finished(module)) Ok(WorkItemResult::Finished(module))
} else { } else {
Ok(WorkItemResult::NeedsLink(module)) Ok(WorkItemResult::NeedsLink(module))
@ -1692,9 +1698,10 @@ fn start_executing_work<B: ExtraBackendMethods>(
if !needs_link.is_empty() { if !needs_link.is_empty() {
assert!(compiled_modules.is_empty()); assert!(compiled_modules.is_empty());
let dcx = cgcx.create_dcx(); let dcx = cgcx.create_dcx();
let module = B::run_link(&cgcx, &dcx, needs_link).map_err(|_| ())?; let dcx = dcx.handle();
let module = B::run_link(&cgcx, dcx, needs_link).map_err(|_| ())?;
let module = unsafe { let module = unsafe {
B::codegen(&cgcx, &dcx, module, cgcx.config(ModuleKind::Regular)).map_err(|_| ())? B::codegen(&cgcx, dcx, module, cgcx.config(ModuleKind::Regular)).map_err(|_| ())?
}; };
compiled_modules.push(module); compiled_modules.push(module);
} }

6
compiler/rustc_codegen_ssa/src/errors.rs
View file

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

8
compiler/rustc_codegen_ssa/src/traits/write.rs
View file

@ -2,7 +2,7 @@ use crate::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
use crate::back::write::{CodegenContext, FatLtoInput, ModuleConfig}; use crate::back::write::{CodegenContext, FatLtoInput, ModuleConfig};
use crate::{CompiledModule, ModuleCodegen}; use crate::{CompiledModule, ModuleCodegen};
use rustc_errors::{DiagCtxt, FatalError}; use rustc_errors::{DiagCtxtHandle, FatalError};
use rustc_middle::dep_graph::WorkProduct; use rustc_middle::dep_graph::WorkProduct;
pub trait WriteBackendMethods: 'static + Sized + Clone { pub trait WriteBackendMethods: 'static + Sized + Clone {
@ -16,7 +16,7 @@ pub trait WriteBackendMethods: 'static + Sized + Clone {
/// Merge all modules into main_module and returning it /// Merge all modules into main_module and returning it
fn run_link( fn run_link(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
modules: Vec<ModuleCodegen<Self::Module>>, modules: Vec<ModuleCodegen<Self::Module>>,
) -> Result<ModuleCodegen<Self::Module>, FatalError>; ) -> Result<ModuleCodegen<Self::Module>, FatalError>;
/// Performs fat LTO by merging all modules into a single one and returning it /// Performs fat LTO by merging all modules into a single one and returning it
@ -38,7 +38,7 @@ pub trait WriteBackendMethods: 'static + Sized + Clone {
fn print_statistics(&self); fn print_statistics(&self);
unsafe fn optimize( unsafe fn optimize(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: &ModuleCodegen<Self::Module>, module: &ModuleCodegen<Self::Module>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<(), FatalError>; ) -> Result<(), FatalError>;
@ -52,7 +52,7 @@ pub trait WriteBackendMethods: 'static + Sized + Clone {
) -> Result<ModuleCodegen<Self::Module>, FatalError>; ) -> Result<ModuleCodegen<Self::Module>, FatalError>;
unsafe fn codegen( unsafe fn codegen(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
module: ModuleCodegen<Self::Module>, module: ModuleCodegen<Self::Module>,
config: &ModuleConfig, config: &ModuleConfig,
) -> Result<CompiledModule, FatalError>; ) -> Result<CompiledModule, FatalError>;

4
compiler/rustc_const_eval/src/check_consts/mod.rs
View file

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

2
compiler/rustc_const_eval/src/check_consts/ops.rs
View file

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

4
compiler/rustc_const_eval/src/errors.rs
View file

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

4
compiler/rustc_const_eval/src/interpret/eval_context.rs
View file

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

3
compiler/rustc_driver_impl/src/lib.rs
View file

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

24
compiler/rustc_errors/src/diagnostic.rs
View file

@ -1,7 +1,7 @@
use crate::snippet::Style; use crate::snippet::Style;
use crate::{ use crate::{
CodeSuggestion, DiagCtxt, DiagMessage, ErrCode, ErrorGuaranteed, ExplicitBug, Level, MultiSpan, CodeSuggestion, DiagCtxtHandle, DiagMessage, ErrCode, ErrorGuaranteed, ExplicitBug, Level,
StashKey, SubdiagMessage, Substitution, SubstitutionPart, SuggestionStyle, MultiSpan, StashKey, SubdiagMessage, Substitution, SubstitutionPart, SuggestionStyle,
}; };
use rustc_data_structures::fx::FxIndexMap; use rustc_data_structures::fx::FxIndexMap;
use rustc_error_messages::fluent_value_from_str_list_sep_by_and; use rustc_error_messages::fluent_value_from_str_list_sep_by_and;
@ -133,7 +133,7 @@ impl EmissionGuarantee for rustc_span::fatal_error::FatalError {
pub trait Diagnostic<'a, G: EmissionGuarantee = ErrorGuaranteed> { pub trait Diagnostic<'a, G: EmissionGuarantee = ErrorGuaranteed> {
/// Write out as a diagnostic out of `DiagCtxt`. /// Write out as a diagnostic out of `DiagCtxt`.
#[must_use] #[must_use]
fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G>; fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G>;
} }
impl<'a, T, G> Diagnostic<'a, G> for Spanned<T> impl<'a, T, G> Diagnostic<'a, G> for Spanned<T>
@ -141,7 +141,7 @@ where
T: Diagnostic<'a, G>, T: Diagnostic<'a, G>,
G: EmissionGuarantee, G: EmissionGuarantee,
{ {
fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> { fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
self.node.into_diag(dcx, level).with_span(self.span) self.node.into_diag(dcx, level).with_span(self.span)
} }
} }
@ -490,7 +490,7 @@ pub struct Subdiag {
/// the methods of `Diag` here, consider extending `DiagCtxtFlags`. /// the methods of `Diag` here, consider extending `DiagCtxtFlags`.
#[must_use] #[must_use]
pub struct Diag<'a, G: EmissionGuarantee = ErrorGuaranteed> { pub struct Diag<'a, G: EmissionGuarantee = ErrorGuaranteed> {
pub dcx: &'a DiagCtxt, pub dcx: DiagCtxtHandle<'a>,
/// Why the `Option`? It is always `Some` until the `Diag` is consumed via /// Why the `Option`? It is always `Some` until the `Diag` is consumed via
/// `emit`, `cancel`, etc. At that point it is consumed and replaced with /// `emit`, `cancel`, etc. At that point it is consumed and replaced with
@ -578,13 +578,13 @@ macro_rules! with_fn {
impl<'a, G: EmissionGuarantee> Diag<'a, G> { impl<'a, G: EmissionGuarantee> Diag<'a, G> {
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn new(dcx: &'a DiagCtxt, level: Level, message: impl Into<DiagMessage>) -> Self { pub fn new(dcx: DiagCtxtHandle<'a>, level: Level, message: impl Into<DiagMessage>) -> Self {
Self::new_diagnostic(dcx, DiagInner::new(level, message)) Self::new_diagnostic(dcx, DiagInner::new(level, message))
} }
/// Creates a new `Diag` with an already constructed diagnostic. /// Creates a new `Diag` with an already constructed diagnostic.
#[track_caller] #[track_caller]
pub(crate) fn new_diagnostic(dcx: &'a DiagCtxt, diag: DiagInner) -> Self { pub(crate) fn new_diagnostic(dcx: DiagCtxtHandle<'a>, diag: DiagInner) -> Self {
debug!("Created new diagnostic"); debug!("Created new diagnostic");
Self { dcx, diag: Some(Box::new(diag)), _marker: PhantomData } Self { dcx, diag: Some(Box::new(diag)), _marker: PhantomData }
} }
@ -1192,11 +1192,8 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
/// used in the subdiagnostic, so suitable for use with repeated messages (i.e. re-use of /// used in the subdiagnostic, so suitable for use with repeated messages (i.e. re-use of
/// interpolated variables). /// interpolated variables).
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
pub fn subdiagnostic( pub fn subdiagnostic(&mut self, subdiagnostic: impl Subdiagnostic) -> &mut Self {
&mut self, let dcx = self.dcx;
dcx: &crate::DiagCtxt,
subdiagnostic: impl Subdiagnostic,
) -> &mut Self {
subdiagnostic.add_to_diag_with(self, &|diag, msg| { subdiagnostic.add_to_diag_with(self, &|diag, msg| {
let args = diag.args.iter(); let args = diag.args.iter();
let msg = diag.subdiagnostic_message_to_diagnostic_message(msg); let msg = diag.subdiagnostic_message_to_diagnostic_message(msg);
@ -1341,7 +1338,8 @@ impl<'a, G: EmissionGuarantee> Diag<'a, G> {
/// See `DiagCtxt::stash_diagnostic` for details. /// See `DiagCtxt::stash_diagnostic` for details.
pub fn stash(mut self, span: Span, key: StashKey) -> Option<ErrorGuaranteed> { pub fn stash(mut self, span: Span, key: StashKey) -> Option<ErrorGuaranteed> {
self.dcx.stash_diagnostic(span, key, self.take_diag()) let diag = self.take_diag();
self.dcx.stash_diagnostic(span, key, diag)
} }
/// Delay emission of this diagnostic as a bug. /// Delay emission of this diagnostic as a bug.

6
compiler/rustc_errors/src/diagnostic_impls.rs
View file

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

2
compiler/rustc_errors/src/emitter.rs
View file

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

3
compiler/rustc_errors/src/json/tests.rs
View file

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

130
compiler/rustc_errors/src/lib.rs
View file

@ -414,6 +414,19 @@ pub struct DiagCtxt {
inner: Lock<DiagCtxtInner>, inner: Lock<DiagCtxtInner>,
} }
#[derive(Copy, Clone)]
pub struct DiagCtxtHandle<'a> {
dcx: &'a DiagCtxt,
}
impl<'a> std::ops::Deref for DiagCtxtHandle<'a> {
type Target = &'a DiagCtxt;
fn deref(&self) -> &Self::Target {
&self.dcx
}
}
/// This inner struct exists to keep it all behind a single lock; /// This inner struct exists to keep it all behind a single lock;
/// this is done to prevent possible deadlocks in a multi-threaded compiler, /// this is done to prevent possible deadlocks in a multi-threaded compiler,
/// as well as inconsistent state observation. /// as well as inconsistent state observation.
@ -608,7 +621,7 @@ impl DiagCtxt {
} }
pub fn make_silent( pub fn make_silent(
&mut self, &self,
fallback_bundle: LazyFallbackBundle, fallback_bundle: LazyFallbackBundle,
fatal_note: Option<String>, fatal_note: Option<String>,
emit_fatal_diagnostic: bool, emit_fatal_diagnostic: bool,
@ -623,7 +636,7 @@ impl DiagCtxt {
}); });
} }
fn wrap_emitter<F>(&mut self, f: F) fn wrap_emitter<F>(&self, f: F)
where where
F: FnOnce(DiagCtxtInner) -> Box<DynEmitter>, F: FnOnce(DiagCtxtInner) -> Box<DynEmitter>,
{ {
@ -738,6 +751,12 @@ impl DiagCtxt {
*fulfilled_expectations = Default::default(); *fulfilled_expectations = Default::default();
} }
pub fn handle<'a>(&'a self) -> DiagCtxtHandle<'a> {
DiagCtxtHandle { dcx: self }
}
}
impl<'a> DiagCtxtHandle<'a> {
/// Stashes a diagnostic for possible later improvement in a different, /// Stashes a diagnostic for possible later improvement in a different,
/// later stage of the compiler. Possible actions depend on the diagnostic /// later stage of the compiler. Possible actions depend on the diagnostic
/// level: /// level:
@ -745,8 +764,8 @@ impl DiagCtxt {
/// - Level::Error: immediately counted as an error that has occurred, because it /// - Level::Error: immediately counted as an error that has occurred, because it
/// is guaranteed to be emitted eventually. Can be later accessed with the /// is guaranteed to be emitted eventually. Can be later accessed with the
/// provided `span` and `key` through /// provided `span` and `key` through
/// [`DiagCtxt::try_steal_modify_and_emit_err`] or /// [`DiagCtxtHandle::try_steal_modify_and_emit_err`] or
/// [`DiagCtxt::try_steal_replace_and_emit_err`]. These do not allow /// [`DiagCtxtHandle::try_steal_replace_and_emit_err`]. These do not allow
/// cancellation or downgrading of the error. Returns /// cancellation or downgrading of the error. Returns
/// `Some(ErrorGuaranteed)`. /// `Some(ErrorGuaranteed)`.
/// - Level::DelayedBug: this does happen occasionally with errors that are /// - Level::DelayedBug: this does happen occasionally with errors that are
@ -757,7 +776,7 @@ impl DiagCtxt {
/// user-facing error. Returns `Some(ErrorGuaranteed)` as is normal for /// user-facing error. Returns `Some(ErrorGuaranteed)` as is normal for
/// delayed bugs. /// delayed bugs.
/// - Level::Warning and lower (i.e. !is_error()): can be accessed with the /// - Level::Warning and lower (i.e. !is_error()): can be accessed with the
/// provided `span` and `key` through [`DiagCtxt::steal_non_err()`]. This /// provided `span` and `key` through [`DiagCtxtHandle::steal_non_err()`]. This
/// allows cancelling and downgrading of the diagnostic. Returns `None`. /// allows cancelling and downgrading of the diagnostic. Returns `None`.
pub fn stash_diagnostic( pub fn stash_diagnostic(
&self, &self,
@ -793,7 +812,7 @@ impl DiagCtxt {
/// Steal a previously stashed non-error diagnostic with the given `Span` /// Steal a previously stashed non-error diagnostic with the given `Span`
/// and [`StashKey`] as the key. Panics if the found diagnostic is an /// and [`StashKey`] as the key. Panics if the found diagnostic is an
/// error. /// error.
pub fn steal_non_err(&self, span: Span, key: StashKey) -> Option<Diag<'_, ()>> { pub fn steal_non_err(self, span: Span, key: StashKey) -> Option<Diag<'a, ()>> {
let key = (span.with_parent(None), key); let key = (span.with_parent(None), key);
// FIXME(#120456) - is `swap_remove` correct? // FIXME(#120456) - is `swap_remove` correct?
let (diag, guar) = self.inner.borrow_mut().stashed_diagnostics.swap_remove(&key)?; let (diag, guar) = self.inner.borrow_mut().stashed_diagnostics.swap_remove(&key)?;
@ -807,7 +826,7 @@ impl DiagCtxt {
/// no matching diagnostic is found. Panics if the found diagnostic's level /// no matching diagnostic is found. Panics if the found diagnostic's level
/// isn't `Level::Error`. /// isn't `Level::Error`.
pub fn try_steal_modify_and_emit_err<F>( pub fn try_steal_modify_and_emit_err<F>(
&self, self,
span: Span, span: Span,
key: StashKey, key: StashKey,
mut modify_err: F, mut modify_err: F,
@ -833,7 +852,7 @@ impl DiagCtxt {
/// [`StashKey`] as the key, cancels it if found, and emits `new_err`. /// [`StashKey`] as the key, cancels it if found, and emits `new_err`.
/// Panics if the found diagnostic's level isn't `Level::Error`. /// Panics if the found diagnostic's level isn't `Level::Error`.
pub fn try_steal_replace_and_emit_err( pub fn try_steal_replace_and_emit_err(
&self, self,
span: Span, span: Span,
key: StashKey, key: StashKey,
new_err: Diag<'_>, new_err: Diag<'_>,
@ -1106,18 +1125,18 @@ impl DiagCtxt {
// //
// Functions beginning with `struct_`/`create_` create a diagnostic. Other // Functions beginning with `struct_`/`create_` create a diagnostic. Other
// functions create and emit a diagnostic all in one go. // functions create and emit a diagnostic all in one go.
impl DiagCtxt { impl<'a> DiagCtxtHandle<'a> {
// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't // No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
// user-facing. // user-facing.
#[track_caller] #[track_caller]
pub fn struct_bug(&self, msg: impl Into<Cow<'static, str>>) -> Diag<'_, BugAbort> { pub fn struct_bug(self, msg: impl Into<Cow<'static, str>>) -> Diag<'a, BugAbort> {
Diag::new(self, Bug, msg.into()) Diag::new(self, Bug, msg.into())
} }
// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't // No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
// user-facing. // user-facing.
#[track_caller] #[track_caller]
pub fn bug(&self, msg: impl Into<Cow<'static, str>>) -> ! { pub fn bug(self, msg: impl Into<Cow<'static, str>>) -> ! {
self.struct_bug(msg).emit() self.struct_bug(msg).emit()
} }
@ -1125,111 +1144,108 @@ impl DiagCtxt {
// user-facing. // user-facing.
#[track_caller] #[track_caller]
pub fn struct_span_bug( pub fn struct_span_bug(
&self, self,
span: impl Into<MultiSpan>, span: impl Into<MultiSpan>,
msg: impl Into<Cow<'static, str>>, msg: impl Into<Cow<'static, str>>,
) -> Diag<'_, BugAbort> { ) -> Diag<'a, BugAbort> {
self.struct_bug(msg).with_span(span) self.struct_bug(msg).with_span(span)
} }
// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't // No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
// user-facing. // user-facing.
#[track_caller] #[track_caller]
pub fn span_bug(&self, span: impl Into<MultiSpan>, msg: impl Into<Cow<'static, str>>) -> ! { pub fn span_bug(self, span: impl Into<MultiSpan>, msg: impl Into<Cow<'static, str>>) -> ! {
self.struct_span_bug(span, msg.into()).emit() self.struct_span_bug(span, msg.into()).emit()
} }
#[track_caller] #[track_caller]
pub fn create_bug<'a>(&'a self, bug: impl Diagnostic<'a, BugAbort>) -> Diag<'a, BugAbort> { pub fn create_bug(self, bug: impl Diagnostic<'a, BugAbort>) -> Diag<'a, BugAbort> {
bug.into_diag(self, Bug) bug.into_diag(self, Bug)
} }
#[track_caller] #[track_caller]
pub fn emit_bug<'a>(&'a self, bug: impl Diagnostic<'a, BugAbort>) -> ! { pub fn emit_bug(self, bug: impl Diagnostic<'a, BugAbort>) -> ! {
self.create_bug(bug).emit() self.create_bug(bug).emit()
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_fatal(&self, msg: impl Into<DiagMessage>) -> Diag<'_, FatalAbort> { pub fn struct_fatal(self, msg: impl Into<DiagMessage>) -> Diag<'a, FatalAbort> {
Diag::new(self, Fatal, msg) Diag::new(self, Fatal, msg)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn fatal(&self, msg: impl Into<DiagMessage>) -> ! { pub fn fatal(self, msg: impl Into<DiagMessage>) -> ! {
self.struct_fatal(msg).emit() self.struct_fatal(msg).emit()
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_span_fatal( pub fn struct_span_fatal(
&self, self,
span: impl Into<MultiSpan>, span: impl Into<MultiSpan>,
msg: impl Into<DiagMessage>, msg: impl Into<DiagMessage>,
) -> Diag<'_, FatalAbort> { ) -> Diag<'a, FatalAbort> {
self.struct_fatal(msg).with_span(span) self.struct_fatal(msg).with_span(span)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn span_fatal(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) -> ! { pub fn span_fatal(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) -> ! {
self.struct_span_fatal(span, msg).emit() self.struct_span_fatal(span, msg).emit()
} }
#[track_caller] #[track_caller]
pub fn create_fatal<'a>( pub fn create_fatal(self, fatal: impl Diagnostic<'a, FatalAbort>) -> Diag<'a, FatalAbort> {
&'a self,
fatal: impl Diagnostic<'a, FatalAbort>,
) -> Diag<'a, FatalAbort> {
fatal.into_diag(self, Fatal) fatal.into_diag(self, Fatal)
} }
#[track_caller] #[track_caller]
pub fn emit_fatal<'a>(&'a self, fatal: impl Diagnostic<'a, FatalAbort>) -> ! { pub fn emit_fatal(self, fatal: impl Diagnostic<'a, FatalAbort>) -> ! {
self.create_fatal(fatal).emit() self.create_fatal(fatal).emit()
} }
#[track_caller] #[track_caller]
pub fn create_almost_fatal<'a>( pub fn create_almost_fatal(
&'a self, self,
fatal: impl Diagnostic<'a, FatalError>, fatal: impl Diagnostic<'a, FatalError>,
) -> Diag<'a, FatalError> { ) -> Diag<'a, FatalError> {
fatal.into_diag(self, Fatal) fatal.into_diag(self, Fatal)
} }
#[track_caller] #[track_caller]
pub fn emit_almost_fatal<'a>(&'a self, fatal: impl Diagnostic<'a, FatalError>) -> FatalError { pub fn emit_almost_fatal(self, fatal: impl Diagnostic<'a, FatalError>) -> FatalError {
self.create_almost_fatal(fatal).emit() self.create_almost_fatal(fatal).emit()
} }
// FIXME: This method should be removed (every error should have an associated error code). // FIXME: This method should be removed (every error should have an associated error code).
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_err(&self, msg: impl Into<DiagMessage>) -> Diag<'_> { pub fn struct_err(self, msg: impl Into<DiagMessage>) -> Diag<'a> {
Diag::new(self, Error, msg) Diag::new(self, Error, msg)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn err(&self, msg: impl Into<DiagMessage>) -> ErrorGuaranteed { pub fn err(self, msg: impl Into<DiagMessage>) -> ErrorGuaranteed {
self.struct_err(msg).emit() self.struct_err(msg).emit()
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_span_err( pub fn struct_span_err(
&self, self,
span: impl Into<MultiSpan>, span: impl Into<MultiSpan>,
msg: impl Into<DiagMessage>, msg: impl Into<DiagMessage>,
) -> Diag<'_> { ) -> Diag<'a> {
self.struct_err(msg).with_span(span) self.struct_err(msg).with_span(span)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn span_err( pub fn span_err(
&self, self,
span: impl Into<MultiSpan>, span: impl Into<MultiSpan>,
msg: impl Into<DiagMessage>, msg: impl Into<DiagMessage>,
) -> ErrorGuaranteed { ) -> ErrorGuaranteed {
@ -1237,12 +1253,12 @@ impl DiagCtxt {
} }
#[track_caller] #[track_caller]
pub fn create_err<'a>(&'a self, err: impl Diagnostic<'a>) -> Diag<'a> { pub fn create_err(self, err: impl Diagnostic<'a>) -> Diag<'a> {
err.into_diag(self, Error) err.into_diag(self, Error)
} }
#[track_caller] #[track_caller]
pub fn emit_err<'a>(&'a self, err: impl Diagnostic<'a>) -> ErrorGuaranteed { pub fn emit_err(self, err: impl Diagnostic<'a>) -> ErrorGuaranteed {
self.create_err(err).emit() self.create_err(err).emit()
} }
@ -1251,7 +1267,7 @@ impl DiagCtxt {
// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't // No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
// user-facing. // user-facing.
#[track_caller] #[track_caller]
pub fn delayed_bug(&self, msg: impl Into<Cow<'static, str>>) -> ErrorGuaranteed { pub fn delayed_bug(self, msg: impl Into<Cow<'static, str>>) -> ErrorGuaranteed {
Diag::<ErrorGuaranteed>::new(self, DelayedBug, msg.into()).emit() Diag::<ErrorGuaranteed>::new(self, DelayedBug, msg.into()).emit()
} }
@ -1264,7 +1280,7 @@ impl DiagCtxt {
// user-facing. // user-facing.
#[track_caller] #[track_caller]
pub fn span_delayed_bug( pub fn span_delayed_bug(
&self, self,
sp: impl Into<MultiSpan>, sp: impl Into<MultiSpan>,
msg: impl Into<Cow<'static, str>>, msg: impl Into<Cow<'static, str>>,
) -> ErrorGuaranteed { ) -> ErrorGuaranteed {
@ -1273,45 +1289,45 @@ impl DiagCtxt {
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_warn(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> { pub fn struct_warn(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
Diag::new(self, Warning, msg) Diag::new(self, Warning, msg)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn warn(&self, msg: impl Into<DiagMessage>) { pub fn warn(self, msg: impl Into<DiagMessage>) {
self.struct_warn(msg).emit() self.struct_warn(msg).emit()
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_span_warn( pub fn struct_span_warn(
&self, self,
span: impl Into<MultiSpan>, span: impl Into<MultiSpan>,
msg: impl Into<DiagMessage>, msg: impl Into<DiagMessage>,
) -> Diag<'_, ()> { ) -> Diag<'a, ()> {
self.struct_warn(msg).with_span(span) self.struct_warn(msg).with_span(span)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn span_warn(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) { pub fn span_warn(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
self.struct_span_warn(span, msg).emit() self.struct_span_warn(span, msg).emit()
} }
#[track_caller] #[track_caller]
pub fn create_warn<'a>(&'a self, warning: impl Diagnostic<'a, ()>) -> Diag<'a, ()> { pub fn create_warn(self, warning: impl Diagnostic<'a, ()>) -> Diag<'a, ()> {
warning.into_diag(self, Warning) warning.into_diag(self, Warning)
} }
#[track_caller] #[track_caller]
pub fn emit_warn<'a>(&'a self, warning: impl Diagnostic<'a, ()>) { pub fn emit_warn(self, warning: impl Diagnostic<'a, ()>) {
self.create_warn(warning).emit() self.create_warn(warning).emit()
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_note(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> { pub fn struct_note(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
Diag::new(self, Note, msg) Diag::new(self, Note, msg)
} }
@ -1324,54 +1340,50 @@ impl DiagCtxt {
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_span_note( pub fn struct_span_note(
&self, self,
span: impl Into<MultiSpan>, span: impl Into<MultiSpan>,
msg: impl Into<DiagMessage>, msg: impl Into<DiagMessage>,
) -> Diag<'_, ()> { ) -> Diag<'a, ()> {
self.struct_note(msg).with_span(span) self.struct_note(msg).with_span(span)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn span_note(&self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) { pub fn span_note(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
self.struct_span_note(span, msg).emit() self.struct_span_note(span, msg).emit()
} }
#[track_caller] #[track_caller]
pub fn create_note<'a>(&'a self, note: impl Diagnostic<'a, ()>) -> Diag<'a, ()> { pub fn create_note(self, note: impl Diagnostic<'a, ()>) -> Diag<'a, ()> {
note.into_diag(self, Note) note.into_diag(self, Note)
} }
#[track_caller] #[track_caller]
pub fn emit_note<'a>(&'a self, note: impl Diagnostic<'a, ()>) { pub fn emit_note(self, note: impl Diagnostic<'a, ()>) {
self.create_note(note).emit() self.create_note(note).emit()
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_help(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> { pub fn struct_help(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
Diag::new(self, Help, msg) Diag::new(self, Help, msg)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_failure_note(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> { pub fn struct_failure_note(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
Diag::new(self, FailureNote, msg) Diag::new(self, FailureNote, msg)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_allow(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> { pub fn struct_allow(self, msg: impl Into<DiagMessage>) -> Diag<'a, ()> {
Diag::new(self, Allow, msg) Diag::new(self, Allow, msg)
} }
#[rustc_lint_diagnostics] #[rustc_lint_diagnostics]
#[track_caller] #[track_caller]
pub fn struct_expect( pub fn struct_expect(self, msg: impl Into<DiagMessage>, id: LintExpectationId) -> Diag<'a, ()> {
&self,
msg: impl Into<DiagMessage>,
id: LintExpectationId,
) -> Diag<'_, ()> {
Diag::new(self, Expect(id), msg) Diag::new(self, Expect(id), msg)
} }
} }

8
compiler/rustc_expand/src/base.rs
View file

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

10
compiler/rustc_expand/src/mbe/diagnostics.rs
View file

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

10
compiler/rustc_expand/src/mbe/macro_check.rs
View file

@ -206,7 +206,7 @@ pub(super) fn check_meta_variables(
rhses: &[TokenTree], rhses: &[TokenTree],
) -> Result<(), ErrorGuaranteed> { ) -> Result<(), ErrorGuaranteed> {
if lhses.len() != rhses.len() { if lhses.len() != rhses.len() {
psess.dcx.span_bug(span, "length mismatch between LHSes and RHSes") psess.dcx().span_bug(span, "length mismatch between LHSes and RHSes")
} }
let mut guar = None; let mut guar = None;
for (lhs, rhs) in iter::zip(lhses, rhses) { for (lhs, rhs) in iter::zip(lhses, rhses) {
@ -245,7 +245,7 @@ fn check_binders(
// MetaVar(fragment) and not as MetaVarDecl(y, fragment). // MetaVar(fragment) and not as MetaVarDecl(y, fragment).
TokenTree::MetaVar(span, name) => { TokenTree::MetaVar(span, name) => {
if macros.is_empty() { if macros.is_empty() {
psess.dcx.span_bug(span, "unexpected MetaVar in lhs"); psess.dcx().span_bug(span, "unexpected MetaVar in lhs");
} }
let name = MacroRulesNormalizedIdent::new(name); let name = MacroRulesNormalizedIdent::new(name);
// There are 3 possibilities: // There are 3 possibilities:
@ -276,7 +276,7 @@ fn check_binders(
); );
} }
if !macros.is_empty() { if !macros.is_empty() {
psess.dcx.span_bug(span, "unexpected MetaVarDecl in nested lhs"); psess.dcx().span_bug(span, "unexpected MetaVarDecl in nested lhs");
} }
let name = MacroRulesNormalizedIdent::new(name); let name = MacroRulesNormalizedIdent::new(name);
if let Some(prev_info) = get_binder_info(macros, binders, name) { if let Some(prev_info) = get_binder_info(macros, binders, name) {
@ -284,7 +284,7 @@ fn check_binders(
// for nested macro definitions. // for nested macro definitions.
*guar = Some( *guar = Some(
psess psess
.dcx .dcx()
.emit_err(errors::DuplicateMatcherBinding { span, prev: prev_info.span }), .emit_err(errors::DuplicateMatcherBinding { span, prev: prev_info.span }),
); );
} else { } else {
@ -344,7 +344,7 @@ fn check_occurrences(
match *rhs { match *rhs {
TokenTree::Token(..) => {} TokenTree::Token(..) => {}
TokenTree::MetaVarDecl(span, _name, _kind) => { TokenTree::MetaVarDecl(span, _name, _kind) => {
psess.dcx.span_bug(span, "unexpected MetaVarDecl in rhs") psess.dcx().span_bug(span, "unexpected MetaVarDecl in rhs")
} }
TokenTree::MetaVar(span, name) => { TokenTree::MetaVar(span, name) => {
let name = MacroRulesNormalizedIdent::new(name); let name = MacroRulesNormalizedIdent::new(name);

4
compiler/rustc_expand/src/mbe/macro_rules.rs
View file

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

29
compiler/rustc_expand/src/mbe/metavar_expr.rs
View file

@ -42,7 +42,7 @@ impl MetaVarExpr {
let ident = parse_ident(&mut tts, psess, outer_span)?; let ident = parse_ident(&mut tts, psess, outer_span)?;
let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = tts.next() else { let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = tts.next() else {
let msg = "meta-variable expression parameter must be wrapped in parentheses"; let msg = "meta-variable expression parameter must be wrapped in parentheses";
return Err(psess.dcx.struct_span_err(ident.span, msg)); return Err(psess.dcx().struct_span_err(ident.span, msg));
}; };
check_trailing_token(&mut tts, psess)?; check_trailing_token(&mut tts, psess)?;
let mut iter = args.trees(); let mut iter = args.trees();
@ -62,12 +62,12 @@ impl MetaVarExpr {
break; break;
} }
if !try_eat_comma(&mut iter) { if !try_eat_comma(&mut iter) {
return Err(psess.dcx.struct_span_err(outer_span, "expected comma")); return Err(psess.dcx().struct_span_err(outer_span, "expected comma"));
} }
} }
if result.len() < 2 { if result.len() < 2 {
return Err(psess return Err(psess
.dcx .dcx()
.struct_span_err(ident.span, "`concat` must have at least two elements")); .struct_span_err(ident.span, "`concat` must have at least two elements"));
} }
MetaVarExpr::Concat(result.into()) MetaVarExpr::Concat(result.into())
@ -81,7 +81,7 @@ impl MetaVarExpr {
"len" => MetaVarExpr::Len(parse_depth(&mut iter, psess, ident.span)?), "len" => MetaVarExpr::Len(parse_depth(&mut iter, psess, ident.span)?),
_ => { _ => {
let err_msg = "unrecognized meta-variable expression"; let err_msg = "unrecognized meta-variable expression";
let mut err = psess.dcx.struct_span_err(ident.span, err_msg); let mut err = psess.dcx().struct_span_err(ident.span, err_msg);
err.span_suggestion( err.span_suggestion(
ident.span, ident.span,
"supported expressions are count, ignore, index and len", "supported expressions are count, ignore, index and len",
@ -120,7 +120,7 @@ fn check_trailing_token<'psess>(
) -> PResult<'psess, ()> { ) -> PResult<'psess, ()> {
if let Some(tt) = iter.next() { if let Some(tt) = iter.next() {
let mut diag = psess let mut diag = psess
.dcx .dcx()
.struct_span_err(tt.span(), format!("unexpected token: {}", pprust::tt_to_string(tt))); .struct_span_err(tt.span(), format!("unexpected token: {}", pprust::tt_to_string(tt)));
diag.span_note(tt.span(), "meta-variable expression must not have trailing tokens"); diag.span_note(tt.span(), "meta-variable expression must not have trailing tokens");
Err(diag) Err(diag)
@ -139,7 +139,7 @@ fn parse_count<'psess>(
let ident = parse_ident(iter, psess, span)?; let ident = parse_ident(iter, psess, span)?;
let depth = if try_eat_comma(iter) { let depth = if try_eat_comma(iter) {
if iter.look_ahead(0).is_none() { if iter.look_ahead(0).is_none() {
return Err(psess.dcx.struct_span_err( return Err(psess.dcx().struct_span_err(
span, span,
"`count` followed by a comma must have an associated index indicating its depth", "`count` followed by a comma must have an associated index indicating its depth",
)); ));
@ -160,7 +160,7 @@ fn parse_depth<'psess>(
let Some(tt) = iter.next() else { return Ok(0) }; let Some(tt) = iter.next() else { return Ok(0) };
let TokenTree::Token(token::Token { kind: token::TokenKind::Literal(lit), .. }, _) = tt else { let TokenTree::Token(token::Token { kind: token::TokenKind::Literal(lit), .. }, _) = tt else {
return Err(psess return Err(psess
.dcx .dcx()
.struct_span_err(span, "meta-variable expression depth must be a literal")); .struct_span_err(span, "meta-variable expression depth must be a literal"));
}; };
if let Ok(lit_kind) = LitKind::from_token_lit(*lit) if let Ok(lit_kind) = LitKind::from_token_lit(*lit)
@ -170,7 +170,7 @@ fn parse_depth<'psess>(
Ok(n_usize) Ok(n_usize)
} else { } else {
let msg = "only unsuffixes integer literals are supported in meta-variable expressions"; let msg = "only unsuffixes integer literals are supported in meta-variable expressions";
Err(psess.dcx.struct_span_err(span, msg)) Err(psess.dcx().struct_span_err(span, msg))
} }
} }
@ -181,20 +181,21 @@ fn parse_ident<'psess>(
fallback_span: Span, fallback_span: Span,
) -> PResult<'psess, Ident> { ) -> PResult<'psess, Ident> {
let Some(tt) = iter.next() else { let Some(tt) = iter.next() else {
return Err(psess.dcx.struct_span_err(fallback_span, "expected identifier")); return Err(psess.dcx().struct_span_err(fallback_span, "expected identifier"));
}; };
let TokenTree::Token(token, _) = tt else { let TokenTree::Token(token, _) = tt else {
return Err(psess.dcx.struct_span_err(tt.span(), "expected identifier")); return Err(psess.dcx().struct_span_err(tt.span(), "expected identifier"));
}; };
if let Some((elem, is_raw)) = token.ident() { if let Some((elem, is_raw)) = token.ident() {
if let IdentIsRaw::Yes = is_raw { if let IdentIsRaw::Yes = is_raw {
return Err(psess.dcx.struct_span_err(elem.span, RAW_IDENT_ERR)); return Err(psess.dcx().struct_span_err(elem.span, RAW_IDENT_ERR));
} }
return Ok(elem); return Ok(elem);
} }
let token_str = pprust::token_to_string(token); let token_str = pprust::token_to_string(token);
let mut err = let mut err = psess
psess.dcx.struct_span_err(token.span, format!("expected identifier, found `{token_str}`")); .dcx()
.struct_span_err(token.span, format!("expected identifier, found `{token_str}`"));
err.span_suggestion( err.span_suggestion(
token.span, token.span,
format!("try removing `{token_str}`"), format!("try removing `{token_str}`"),
@ -236,7 +237,7 @@ fn eat_dollar<'psess>(
let _ = iter.next(); let _ = iter.next();
return Ok(()); return Ok(());
} }
Err(psess.dcx.struct_span_err( Err(psess.dcx().struct_span_err(
span, span,
"meta-variables within meta-variable expressions must be referenced using a dollar sign", "meta-variables within meta-variable expressions must be referenced using a dollar sign",
)) ))

14
compiler/rustc_expand/src/mbe/transcribe.rs
View file

@ -10,7 +10,7 @@ use rustc_ast::token::IdentIsRaw;
use rustc_ast::token::{self, Delimiter, Token, TokenKind}; use rustc_ast::token::{self, Delimiter, Token, TokenKind};
use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree}; use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::fx::FxHashMap;
use rustc_errors::{pluralize, Diag, DiagCtxt, PResult}; use rustc_errors::{pluralize, Diag, DiagCtxtHandle, PResult};
use rustc_parse::parser::ParseNtResult; use rustc_parse::parser::ParseNtResult;
use rustc_session::parse::ParseSess; use rustc_session::parse::ParseSess;
use rustc_span::hygiene::{LocalExpnId, Transparency}; use rustc_span::hygiene::{LocalExpnId, Transparency};
@ -141,7 +141,7 @@ pub(super) fn transcribe<'a>(
let mut result_stack = Vec::new(); let mut result_stack = Vec::new();
let mut marker = Marker(expand_id, transparency, Default::default()); let mut marker = Marker(expand_id, transparency, Default::default());
let dcx = &psess.dcx; let dcx = psess.dcx();
loop { loop {
// Look at the last frame on the stack. // Look at the last frame on the stack.
// If it still has a TokenTree we have not looked at yet, use that tree. // If it still has a TokenTree we have not looked at yet, use that tree.
@ -571,7 +571,7 @@ fn lockstep_iter_size(
/// * `[ $( ${count(foo, 1)} ),* ]` will return an error because `${count(foo, 1)}` is /// * `[ $( ${count(foo, 1)} ),* ]` will return an error because `${count(foo, 1)}` is
/// declared inside a single repetition and the index `1` implies two nested repetitions. /// declared inside a single repetition and the index `1` implies two nested repetitions.
fn count_repetitions<'a>( fn count_repetitions<'a>(
dcx: &'a DiagCtxt, dcx: DiagCtxtHandle<'a>,
depth_user: usize, depth_user: usize,
mut matched: &NamedMatch, mut matched: &NamedMatch,
repeats: &[(usize, usize)], repeats: &[(usize, usize)],
@ -632,7 +632,7 @@ fn count_repetitions<'a>(
/// Returns a `NamedMatch` item declared on the LHS given an arbitrary [Ident] /// Returns a `NamedMatch` item declared on the LHS given an arbitrary [Ident]
fn matched_from_ident<'ctx, 'interp, 'rslt>( fn matched_from_ident<'ctx, 'interp, 'rslt>(
dcx: &'ctx DiagCtxt, dcx: DiagCtxtHandle<'ctx>,
ident: Ident, ident: Ident,
interp: &'interp FxHashMap<MacroRulesNormalizedIdent, NamedMatch>, interp: &'interp FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
) -> PResult<'ctx, &'rslt NamedMatch> ) -> PResult<'ctx, &'rslt NamedMatch>
@ -646,7 +646,7 @@ where
/// Used by meta-variable expressions when an user input is out of the actual declared bounds. For /// Used by meta-variable expressions when an user input is out of the actual declared bounds. For
/// example, index(999999) in an repetition of only three elements. /// example, index(999999) in an repetition of only three elements.
fn out_of_bounds_err<'a>(dcx: &'a DiagCtxt, max: usize, span: Span, ty: &str) -> Diag<'a> { fn out_of_bounds_err<'a>(dcx: DiagCtxtHandle<'a>, max: usize, span: Span, ty: &str) -> Diag<'a> {
let msg = if max == 0 { let msg = if max == 0 {
format!( format!(
"meta-variable expression `{ty}` with depth parameter \ "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) ->
} }
fn transcribe_metavar_expr<'a>( fn transcribe_metavar_expr<'a>(
dcx: &'a DiagCtxt, dcx: DiagCtxtHandle<'a>,
expr: &MetaVarExpr, expr: &MetaVarExpr,
interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>, interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
marker: &mut Marker, marker: &mut Marker,
@ -730,7 +730,7 @@ fn transcribe_metavar_expr<'a>(
/// Extracts an identifier that can be originated from a `$var:ident` variable or from a token tree. /// Extracts an identifier that can be originated from a `$var:ident` variable or from a token tree.
fn extract_ident<'a>( fn extract_ident<'a>(
dcx: &'a DiagCtxt, dcx: DiagCtxtHandle<'a>,
ident: Ident, ident: Ident,
interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>, interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
) -> PResult<'a, String> { ) -> PResult<'a, String> {

2
compiler/rustc_expand/src/proc_macro_server.rs
View file

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

2
compiler/rustc_hir_analysis/src/check/errs.rs
View file

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

74
compiler/rustc_hir_analysis/src/coherence/orphan.rs
View file

@ -403,74 +403,56 @@ fn emit_orphan_check_error<'tcx>(
match *ty.kind() { match *ty.kind() {
ty::Slice(_) => { ty::Slice(_) => {
if is_foreign { if is_foreign {
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsForeign { span });
tcx.dcx(),
errors::OnlyCurrentTraitsForeign { span },
);
} else { } else {
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsName {
tcx.dcx(), span,
errors::OnlyCurrentTraitsName { span, name: "slices" }, name: "slices",
); });
} }
} }
ty::Array(..) => { ty::Array(..) => {
if is_foreign { if is_foreign {
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsForeign { span });
tcx.dcx(),
errors::OnlyCurrentTraitsForeign { span },
);
} else { } else {
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsName {
tcx.dcx(), span,
errors::OnlyCurrentTraitsName { span, name: "arrays" }, name: "arrays",
); });
} }
} }
ty::Tuple(..) => { ty::Tuple(..) => {
if is_foreign { if is_foreign {
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsForeign { span });
tcx.dcx(),
errors::OnlyCurrentTraitsForeign { span },
);
} else { } else {
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsName {
tcx.dcx(), span,
errors::OnlyCurrentTraitsName { span, name: "tuples" }, name: "tuples",
); });
} }
} }
ty::Alias(ty::Opaque, ..) => { ty::Alias(ty::Opaque, ..) => {
diag.subdiagnostic(tcx.dcx(), errors::OnlyCurrentTraitsOpaque { span }); diag.subdiagnostic(errors::OnlyCurrentTraitsOpaque { span });
} }
ty::RawPtr(ptr_ty, mutbl) => { ty::RawPtr(ptr_ty, mutbl) => {
if !trait_ref.self_ty().has_param() { if !trait_ref.self_ty().has_param() {
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsPointerSugg {
tcx.dcx(), wrapper_span: impl_.self_ty.span,
errors::OnlyCurrentTraitsPointerSugg { struct_span: item.span.shrink_to_lo(),
wrapper_span: impl_.self_ty.span, mut_key: mutbl.prefix_str(),
struct_span: item.span.shrink_to_lo(), ptr_ty,
mut_key: mutbl.prefix_str(), });
ptr_ty,
},
);
} }
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsPointer { span, pointer: ty });
tcx.dcx(),
errors::OnlyCurrentTraitsPointer { span, pointer: ty },
);
} }
ty::Adt(adt_def, _) => { ty::Adt(adt_def, _) => {
diag.subdiagnostic( diag.subdiagnostic(errors::OnlyCurrentTraitsAdt {
tcx.dcx(), span,
errors::OnlyCurrentTraitsAdt { name: tcx.def_path_str(adt_def.did()),
span, });
name: tcx.def_path_str(adt_def.did()),
},
);
} }
_ => { _ => {
diag.subdiagnostic(tcx.dcx(), errors::OnlyCurrentTraitsTy { span, ty }); diag.subdiagnostic(errors::OnlyCurrentTraitsTy { span, ty });
} }
} }
} }

4
compiler/rustc_hir_analysis/src/errors.rs
View file

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

2
compiler/rustc_hir_typeck/src/_match.rs
View file

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

24
compiler/rustc_hir_typeck/src/cast.rs
View file

@ -1005,25 +1005,19 @@ impl<'a, 'tcx> CastCheck<'tcx> {
if let Some((deref_ty, _)) = derefed { if let Some((deref_ty, _)) = derefed {
// Give a note about what the expr derefs to. // Give a note about what the expr derefs to.
if deref_ty != self.expr_ty.peel_refs() { if deref_ty != self.expr_ty.peel_refs() {
err.subdiagnostic( err.subdiagnostic(errors::DerefImplsIsEmpty {
fcx.dcx(), span: self.expr_span,
errors::DerefImplsIsEmpty { deref_ty: fcx.ty_to_string(deref_ty),
span: self.expr_span, });
deref_ty: fcx.ty_to_string(deref_ty),
},
);
} }
// Create a multipart suggestion: add `!` and `.is_empty()` in // Create a multipart suggestion: add `!` and `.is_empty()` in
// place of the cast. // place of the cast.
err.subdiagnostic( err.subdiagnostic(errors::UseIsEmpty {
fcx.dcx(), lo: self.expr_span.shrink_to_lo(),
errors::UseIsEmpty { hi: self.span.with_lo(self.expr_span.hi()),
lo: self.expr_span.shrink_to_lo(), expr_ty: fcx.ty_to_string(self.expr_ty),
hi: self.span.with_lo(self.expr_span.hi()), });
expr_ty: fcx.ty_to_string(self.expr_ty),
},
);
} }
} }
} }

16
compiler/rustc_hir_typeck/src/coercion.rs
View file

@ -1782,20 +1782,14 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
} }
let rpid_def_span = fcx.tcx.def_span(rpit_def_id); let rpid_def_span = fcx.tcx.def_span(rpit_def_id);
err.subdiagnostic( err.subdiagnostic(SuggestBoxingForReturnImplTrait::ChangeReturnType {
fcx.tcx.dcx(), start_sp: rpid_def_span.with_hi(rpid_def_span.lo() + BytePos(4)),
SuggestBoxingForReturnImplTrait::ChangeReturnType { end_sp: rpid_def_span.shrink_to_hi(),
start_sp: rpid_def_span.with_hi(rpid_def_span.lo() + BytePos(4)), });
end_sp: rpid_def_span.shrink_to_hi(),
},
);
let (starts, ends) = let (starts, ends) =
arm_spans.map(|span| (span.shrink_to_lo(), span.shrink_to_hi())).unzip(); arm_spans.map(|span| (span.shrink_to_lo(), span.shrink_to_hi())).unzip();
err.subdiagnostic( err.subdiagnostic(SuggestBoxingForReturnImplTrait::BoxReturnExpr { starts, ends });
fcx.tcx.dcx(),
SuggestBoxingForReturnImplTrait::BoxReturnExpr { starts, ends },
);
} }
fn report_return_mismatched_types<'a>( fn report_return_mismatched_types<'a>(

7
compiler/rustc_hir_typeck/src/expr.rs
View file

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

2
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View file

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

7
compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
View file

@ -5,14 +5,13 @@ mod checks;
mod inspect_obligations; mod inspect_obligations;
mod suggestions; mod suggestions;
use rustc_errors::ErrorGuaranteed; use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
use crate::coercion::DynamicCoerceMany; use crate::coercion::DynamicCoerceMany;
use crate::fallback::DivergingFallbackBehavior; use crate::fallback::DivergingFallbackBehavior;
use crate::fn_ctxt::checks::DivergingBlockBehavior; use crate::fn_ctxt::checks::DivergingBlockBehavior;
use crate::{CoroutineTypes, Diverges, EnclosingBreakables, TypeckRootCtxt}; use crate::{CoroutineTypes, Diverges, EnclosingBreakables, TypeckRootCtxt};
use hir::def_id::CRATE_DEF_ID; use hir::def_id::CRATE_DEF_ID;
use rustc_errors::DiagCtxt;
use rustc_hir as hir; use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir_analysis::hir_ty_lowering::{HirTyLowerer, RegionInferReason}; use rustc_hir_analysis::hir_ty_lowering::{HirTyLowerer, RegionInferReason};
@ -145,8 +144,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} }
} }
pub(crate) fn dcx(&self) -> &'tcx DiagCtxt { pub(crate) fn dcx(&self) -> DiagCtxtHandle<'tcx> {
self.tcx.dcx() self.infcx.dcx()
} }
pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> { pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {

98
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View file

@ -460,16 +460,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// but those checks need to be a bit more delicate and the benefit is diminishing. // but those checks need to be a bit more delicate and the benefit is diminishing.
if self.can_eq(self.param_env, found_ty_inner, peeled) && error_tys_equate_as_ref { if self.can_eq(self.param_env, found_ty_inner, peeled) && error_tys_equate_as_ref {
let sugg = prefix_wrap(".as_ref()"); let sugg = prefix_wrap(".as_ref()");
err.subdiagnostic( err.subdiagnostic(errors::SuggestConvertViaMethod {
self.dcx(), span: expr.span.shrink_to_hi(),
errors::SuggestConvertViaMethod { sugg,
span: expr.span.shrink_to_hi(), expected,
sugg, found,
expected, borrow_removal_span,
found, });
borrow_removal_span,
},
);
return true; return true;
} else if let Some((deref_ty, _)) = } else if let Some((deref_ty, _)) =
self.autoderef(expr.span, found_ty_inner).silence_errors().nth(1) self.autoderef(expr.span, found_ty_inner).silence_errors().nth(1)
@ -477,16 +474,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
&& error_tys_equate_as_ref && error_tys_equate_as_ref
{ {
let sugg = prefix_wrap(".as_deref()"); let sugg = prefix_wrap(".as_deref()");
err.subdiagnostic( err.subdiagnostic(errors::SuggestConvertViaMethod {
self.dcx(), span: expr.span.shrink_to_hi(),
errors::SuggestConvertViaMethod { sugg,
span: expr.span.shrink_to_hi(), expected,
sugg, found,
expected, borrow_removal_span,
found, });
borrow_removal_span,
},
);
return true; return true;
} else if let ty::Adt(adt, _) = found_ty_inner.peel_refs().kind() } else if let ty::Adt(adt, _) = found_ty_inner.peel_refs().kind()
&& self.tcx.is_lang_item(adt.did(), LangItem::String) && self.tcx.is_lang_item(adt.did(), LangItem::String)
@ -573,7 +567,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
end: span.shrink_to_hi(), end: span.shrink_to_hi(),
}, },
}; };
err.subdiagnostic(self.dcx(), suggest_boxing); err.subdiagnostic(suggest_boxing);
true true
} else { } else {
@ -814,28 +808,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
match &fn_decl.output { match &fn_decl.output {
&hir::FnRetTy::DefaultReturn(span) if expected.is_unit() && !can_suggest => { &hir::FnRetTy::DefaultReturn(span) if expected.is_unit() && !can_suggest => {
// `fn main()` must return `()`, do not suggest changing return type // `fn main()` must return `()`, do not suggest changing return type
err.subdiagnostic(self.dcx(), errors::ExpectedReturnTypeLabel::Unit { span }); err.subdiagnostic(errors::ExpectedReturnTypeLabel::Unit { span });
return true; return true;
} }
&hir::FnRetTy::DefaultReturn(span) if expected.is_unit() => { &hir::FnRetTy::DefaultReturn(span) if expected.is_unit() => {
if let Some(found) = found.make_suggestable(self.tcx, false, None) { if let Some(found) = found.make_suggestable(self.tcx, false, None) {
err.subdiagnostic( err.subdiagnostic(errors::AddReturnTypeSuggestion::Add {
self.dcx(), span,
errors::AddReturnTypeSuggestion::Add { span, found: found.to_string() }, found: found.to_string(),
); });
return true; return true;
} else if let Some(sugg) = suggest_impl_trait(self, self.param_env, found) { } else if let Some(sugg) = suggest_impl_trait(self, self.param_env, found) {
err.subdiagnostic( err.subdiagnostic(errors::AddReturnTypeSuggestion::Add { span, found: sugg });
self.dcx(),
errors::AddReturnTypeSuggestion::Add { span, found: sugg },
);
return true; return true;
} else { } else {
// FIXME: if `found` could be `impl Iterator` we should suggest that. // FIXME: if `found` could be `impl Iterator` we should suggest that.
err.subdiagnostic( err.subdiagnostic(errors::AddReturnTypeSuggestion::MissingHere { span });
self.dcx(),
errors::AddReturnTypeSuggestion::MissingHere { span },
);
return true; return true;
} }
} }
@ -856,19 +844,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
debug!(?found); debug!(?found);
if found.is_suggestable(self.tcx, false) { if found.is_suggestable(self.tcx, false) {
if ty.span.is_empty() { if ty.span.is_empty() {
err.subdiagnostic( err.subdiagnostic(errors::AddReturnTypeSuggestion::Add {
self.dcx(), span: ty.span,
errors::AddReturnTypeSuggestion::Add { found: found.to_string(),
span: ty.span, });
found: found.to_string(),
},
);
return true; return true;
} else { } else {
err.subdiagnostic( err.subdiagnostic(errors::ExpectedReturnTypeLabel::Other {
self.dcx(), span: ty.span,
errors::ExpectedReturnTypeLabel::Other { span: ty.span, expected }, expected,
); });
} }
} }
} else { } else {
@ -883,10 +868,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let ty = self.normalize(hir_ty.span, ty); let ty = self.normalize(hir_ty.span, ty);
let ty = self.tcx.instantiate_bound_regions_with_erased(ty); let ty = self.tcx.instantiate_bound_regions_with_erased(ty);
if self.can_coerce(expected, ty) { if self.can_coerce(expected, ty) {
err.subdiagnostic( err.subdiagnostic(errors::ExpectedReturnTypeLabel::Other {
self.dcx(), span: hir_ty.span,
errors::ExpectedReturnTypeLabel::Other { span: hir_ty.span, expected }, expected,
); });
self.try_suggest_return_impl_trait(err, expected, found, fn_id); self.try_suggest_return_impl_trait(err, expected, found, fn_id);
self.note_caller_chooses_ty_for_ty_param(err, expected, found); self.note_caller_chooses_ty_for_ty_param(err, expected, found);
return true; return true;
@ -905,13 +890,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
found: Ty<'tcx>, found: Ty<'tcx>,
) { ) {
if let ty::Param(expected_ty_as_param) = expected.kind() { if let ty::Param(expected_ty_as_param) = expected.kind() {
diag.subdiagnostic( diag.subdiagnostic(errors::NoteCallerChoosesTyForTyParam {
self.dcx(), ty_param_name: expected_ty_as_param.name,
errors::NoteCallerChoosesTyForTyParam { found_ty: found,
ty_param_name: expected_ty_as_param.name, });
found_ty: found,
},
);
} }
} }
@ -1136,7 +1118,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let sp = self.tcx.sess.source_map().start_point(expr.span).with_parent(None); let sp = self.tcx.sess.source_map().start_point(expr.span).with_parent(None);
if let Some(sp) = self.tcx.sess.psess.ambiguous_block_expr_parse.borrow().get(&sp) { if let Some(sp) = self.tcx.sess.psess.ambiguous_block_expr_parse.borrow().get(&sp) {
// `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }` // `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }`
err.subdiagnostic(self.dcx(), ExprParenthesesNeeded::surrounding(*sp)); err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
true true
} else { } else {
false false
@ -1250,7 +1232,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} else { } else {
return false; return false;
}; };
diag.subdiagnostic(self.dcx(), subdiag); diag.subdiagnostic(subdiag);
return true; return true;
} }
} }

27
compiler/rustc_hir_typeck/src/method/suggest.rs
View file

@ -3729,22 +3729,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
if impls_trait(trait_info.def_id) { if impls_trait(trait_info.def_id) {
self.suggest_valid_traits(err, item_name, vec![trait_info.def_id], false); self.suggest_valid_traits(err, item_name, vec![trait_info.def_id], false);
} else { } else {
err.subdiagnostic( err.subdiagnostic(CandidateTraitNote {
self.dcx(), span: self.tcx.def_span(trait_info.def_id),
CandidateTraitNote { trait_name: self.tcx.def_path_str(trait_info.def_id),
span: self.tcx.def_span(trait_info.def_id), item_name,
trait_name: self.tcx.def_path_str(trait_info.def_id), action_or_ty: if trait_missing_method {
item_name, "NONE".to_string()
action_or_ty: if trait_missing_method { } else {
"NONE".to_string() param_type.map_or_else(
} else { || "implement".to_string(), // FIXME: it might only need to be imported into scope, not implemented.
param_type.map_or_else( |p| p.to_string(),
|| "implement".to_string(), // FIXME: it might only need to be imported into scope, not implemented. )
|p| p.to_string(),
)
},
}, },
); });
} }
} }
trait_infos => { trait_infos => {

2
compiler/rustc_hir_typeck/src/op.rs
View file

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

12
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View file

@ -61,8 +61,8 @@ use crate::traits::{
use crate::infer::relate::{self, RelateResult, TypeRelation}; use crate::infer::relate::{self, RelateResult, TypeRelation};
use rustc_data_structures::fx::{FxIndexMap, FxIndexSet}; use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
use rustc_errors::{ use rustc_errors::{
codes::*, pluralize, struct_span_code_err, Applicability, Diag, DiagCtxt, DiagStyledString, codes::*, pluralize, struct_span_code_err, Applicability, Diag, DiagCtxtHandle,
ErrorGuaranteed, IntoDiagArg, StringPart, DiagStyledString, ErrorGuaranteed, IntoDiagArg, StringPart,
}; };
use rustc_hir::def::DefKind; use rustc_hir::def::DefKind;
use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::def_id::{DefId, LocalDefId};
@ -139,8 +139,8 @@ pub struct TypeErrCtxt<'a, 'tcx> {
} }
impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
pub fn dcx(&self) -> &'tcx DiagCtxt { pub fn dcx(&self) -> DiagCtxtHandle<'tcx> {
self.infcx.tcx.dcx() self.infcx.dcx()
} }
/// This is just to avoid a potential footgun of accidentally /// This is just to avoid a potential footgun of accidentally
@ -892,7 +892,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
arm_ty, arm_ty,
arm_span, arm_span,
) { ) {
err.subdiagnostic(self.dcx(), subdiag); err.subdiagnostic(subdiag);
} }
} }
}, },
@ -918,7 +918,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
else_ty, else_ty,
else_span, else_span,
) { ) {
err.subdiagnostic(self.dcx(), subdiag); err.subdiagnostic(subdiag);
} }
} }
ObligationCauseCode::LetElse => { ObligationCauseCode::LetElse => {

2
compiler/rustc_infer/src/infer/error_reporting/note.rs
View file

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

29
compiler/rustc_infer/src/infer/error_reporting/suggest.rs
View file

@ -121,7 +121,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
span_low: cause.span.shrink_to_lo(), span_low: cause.span.shrink_to_lo(),
span_high: cause.span.shrink_to_hi(), span_high: cause.span.shrink_to_hi(),
}; };
diag.subdiagnostic(self.dcx(), sugg); diag.subdiagnostic(sugg);
} }
_ => { _ => {
// More than one matching variant. // More than one matching variant.
@ -130,7 +130,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
cause_span: cause.span, cause_span: cause.span,
compatible_variants, compatible_variants,
}; };
diag.subdiagnostic(self.dcx(), sugg); diag.subdiagnostic(sugg);
} }
} }
} }
@ -202,10 +202,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
}, },
(_, Some(ty)) if self.same_type_modulo_infer(exp_found.expected, ty) => { (_, Some(ty)) if self.same_type_modulo_infer(exp_found.expected, ty) => {
// FIXME: Seems like we can't have a suggestion and a note with different spans in a single subdiagnostic // FIXME: Seems like we can't have a suggestion and a note with different spans in a single subdiagnostic
diag.subdiagnostic( diag.subdiagnostic(ConsiderAddingAwait::FutureSugg {
self.dcx(), span: exp_span.shrink_to_hi(),
ConsiderAddingAwait::FutureSugg { span: exp_span.shrink_to_hi() }, });
);
Some(ConsiderAddingAwait::FutureSuggNote { span: exp_span }) Some(ConsiderAddingAwait::FutureSuggNote { span: exp_span })
} }
(Some(ty), _) if self.same_type_modulo_infer(ty, exp_found.found) => match cause.code() (Some(ty), _) if self.same_type_modulo_infer(ty, exp_found.found) => match cause.code()
@ -233,7 +232,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
_ => None, _ => None,
}; };
if let Some(subdiag) = subdiag { if let Some(subdiag) = subdiag {
diag.subdiagnostic(self.dcx(), subdiag); diag.subdiagnostic(subdiag);
} }
} }
@ -269,7 +268,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
} else { } else {
return; return;
}; };
diag.subdiagnostic(self.dcx(), suggestion); diag.subdiagnostic(suggestion);
} }
} }
} }
@ -401,15 +400,15 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
(true, false) => FunctionPointerSuggestion::UseRef { span, fn_name }, (true, false) => FunctionPointerSuggestion::UseRef { span, fn_name },
(false, true) => FunctionPointerSuggestion::RemoveRef { span, fn_name }, (false, true) => FunctionPointerSuggestion::RemoveRef { span, fn_name },
(true, true) => { (true, true) => {
diag.subdiagnostic(self.dcx(), FnItemsAreDistinct); diag.subdiagnostic(FnItemsAreDistinct);
FunctionPointerSuggestion::CastRef { span, fn_name, sig: *sig } FunctionPointerSuggestion::CastRef { span, fn_name, sig: *sig }
} }
(false, false) => { (false, false) => {
diag.subdiagnostic(self.dcx(), FnItemsAreDistinct); diag.subdiagnostic(FnItemsAreDistinct);
FunctionPointerSuggestion::Cast { span, fn_name, sig: *sig } FunctionPointerSuggestion::Cast { span, fn_name, sig: *sig }
} }
}; };
diag.subdiagnostic(self.dcx(), sugg); diag.subdiagnostic(sugg);
} }
(ty::FnDef(did1, args1), ty::FnDef(did2, args2)) => { (ty::FnDef(did1, args1), ty::FnDef(did2, args2)) => {
let expected_sig = let expected_sig =
@ -418,7 +417,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
&(self.normalize_fn_sig)(self.tcx.fn_sig(*did2).instantiate(self.tcx, args2)); &(self.normalize_fn_sig)(self.tcx.fn_sig(*did2).instantiate(self.tcx, args2));
if self.same_type_modulo_infer(*expected_sig, *found_sig) { if self.same_type_modulo_infer(*expected_sig, *found_sig) {
diag.subdiagnostic(self.dcx(), FnUniqTypes); diag.subdiagnostic(FnUniqTypes);
} }
if !self.same_type_modulo_infer(*found_sig, *expected_sig) if !self.same_type_modulo_infer(*found_sig, *expected_sig)
@ -447,7 +446,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
} }
}; };
diag.subdiagnostic(self.dcx(), sug); diag.subdiagnostic(sug);
} }
(ty::FnDef(did, args), ty::FnPtr(sig)) => { (ty::FnDef(did, args), ty::FnPtr(sig)) => {
let expected_sig = let expected_sig =
@ -466,7 +465,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
format!("{fn_name} as {found_sig}") format!("{fn_name} as {found_sig}")
}; };
diag.subdiagnostic(self.dcx(), FnConsiderCasting { casting }); diag.subdiagnostic(FnConsiderCasting { casting });
} }
_ => { _ => {
return; return;
@ -889,7 +888,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let diag = self.consider_returning_binding_diag(blk, expected_ty); let diag = self.consider_returning_binding_diag(blk, expected_ty);
match diag { match diag {
Some(diag) => { Some(diag) => {
err.subdiagnostic(self.dcx(), diag); err.subdiagnostic(diag);
true true
} }
None => false, None => false,

5
compiler/rustc_infer/src/infer/mod.rs
View file

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

12
compiler/rustc_interface/src/interface.rs
View file

@ -9,7 +9,7 @@ use rustc_data_structures::jobserver;
use rustc_data_structures::stable_hasher::StableHasher; use rustc_data_structures::stable_hasher::StableHasher;
use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::Lrc;
use rustc_errors::registry::Registry; use rustc_errors::registry::Registry;
use rustc_errors::{DiagCtxt, ErrorGuaranteed}; use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
use rustc_lint::LintStore; use rustc_lint::LintStore;
use rustc_middle::ty; use rustc_middle::ty;
use rustc_middle::ty::CurrentGcx; use rustc_middle::ty::CurrentGcx;
@ -46,7 +46,7 @@ pub struct Compiler {
} }
/// Converts strings provided as `--cfg [cfgspec]` into a `Cfg`. /// Converts strings provided as `--cfg [cfgspec]` into a `Cfg`.
pub(crate) fn parse_cfg(dcx: &DiagCtxt, cfgs: Vec<String>) -> Cfg { pub(crate) fn parse_cfg(dcx: DiagCtxtHandle<'_>, cfgs: Vec<String>) -> Cfg {
cfgs.into_iter() cfgs.into_iter()
.map(|s| { .map(|s| {
let psess = ParseSess::with_silent_emitter( let psess = ParseSess::with_silent_emitter(
@ -105,7 +105,7 @@ pub(crate) fn parse_cfg(dcx: &DiagCtxt, cfgs: Vec<String>) -> Cfg {
} }
/// Converts strings provided as `--check-cfg [specs]` into a `CheckCfg`. /// Converts strings provided as `--check-cfg [specs]` into a `CheckCfg`.
pub(crate) fn parse_check_cfg(dcx: &DiagCtxt, specs: Vec<String>) -> CheckCfg { pub(crate) fn parse_check_cfg(dcx: DiagCtxtHandle<'_>, specs: Vec<String>) -> CheckCfg {
// If any --check-cfg is passed then exhaustive_values and exhaustive_names // If any --check-cfg is passed then exhaustive_values and exhaustive_names
// are enabled by default. // are enabled by default.
let exhaustive_names = !specs.is_empty(); let exhaustive_names = !specs.is_empty();
@ -451,12 +451,12 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
codegen_backend.init(&sess); codegen_backend.init(&sess);
let cfg = parse_cfg(&sess.dcx(), config.crate_cfg); let cfg = parse_cfg(sess.dcx(), config.crate_cfg);
let mut cfg = config::build_configuration(&sess, cfg); let mut cfg = config::build_configuration(&sess, cfg);
util::add_configuration(&mut cfg, &mut sess, &*codegen_backend); util::add_configuration(&mut cfg, &mut sess, &*codegen_backend);
sess.psess.config = cfg; sess.psess.config = cfg;
let mut check_cfg = parse_check_cfg(&sess.dcx(), config.crate_check_cfg); let mut check_cfg = parse_check_cfg(sess.dcx(), config.crate_check_cfg);
check_cfg.fill_well_known(&sess.target); check_cfg.fill_well_known(&sess.target);
sess.psess.check_config = check_cfg; sess.psess.check_config = check_cfg;
@ -529,7 +529,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
} }
pub fn try_print_query_stack( pub fn try_print_query_stack(
dcx: &DiagCtxt, dcx: DiagCtxtHandle<'_>,
num_frames: Option<usize>, num_frames: Option<usize>,
file: Option<std::fs::File>, file: Option<std::fs::File>,
) { ) {

2
compiler/rustc_interface/src/tests.rs
View file

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

6
compiler/rustc_lint/src/lints.rs
View file

@ -1405,7 +1405,7 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
diag.note(fluent::lint_macro_to_change); diag.note(fluent::lint_macro_to_change);
} }
if let Some(cargo_update) = cargo_update { if let Some(cargo_update) = cargo_update {
diag.subdiagnostic(&diag.dcx, cargo_update); diag.subdiagnostic(cargo_update);
} }
if has_trait { if has_trait {
@ -1471,7 +1471,7 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
diag.note(fluent::lint_non_local_definitions_deprecation); diag.note(fluent::lint_non_local_definitions_deprecation);
if let Some(cargo_update) = cargo_update { if let Some(cargo_update) = cargo_update {
diag.subdiagnostic(&diag.dcx, cargo_update); diag.subdiagnostic(cargo_update);
} }
} }
} }
@ -1957,7 +1957,7 @@ impl<'a> LintDiagnostic<'a, ()> for UnusedDef<'_, '_> {
diag.note(note.to_string()); diag.note(note.to_string());
} }
if let Some(sugg) = self.suggestion { if let Some(sugg) = self.suggestion {
diag.subdiagnostic(diag.dcx, sugg); diag.subdiagnostic(sugg);
} }
} }
} }

2
compiler/rustc_macros/src/diagnostics/diagnostic.rs
View file

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

2
compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs
View file

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

6
compiler/rustc_metadata/src/creader.rs
View file

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

8
compiler/rustc_metadata/src/errors.rs
View file

@ -3,7 +3,7 @@ use std::{
path::{Path, PathBuf}, path::{Path, PathBuf},
}; };
use rustc_errors::{codes::*, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level}; use rustc_errors::{codes::*, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_macros::{Diagnostic, Subdiagnostic};
use rustc_span::{sym, Span, Symbol}; use rustc_span::{sym, Span, Symbol};
use rustc_target::spec::{PanicStrategy, TargetTriple}; use rustc_target::spec::{PanicStrategy, TargetTriple};
@ -503,7 +503,7 @@ pub(crate) struct MultipleCandidates {
} }
impl<G: EmissionGuarantee> Diagnostic<'_, G> for MultipleCandidates { impl<G: EmissionGuarantee> Diagnostic<'_, G> for MultipleCandidates {
fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let mut diag = Diag::new(dcx, level, fluent::metadata_multiple_candidates); let mut diag = Diag::new(dcx, level, fluent::metadata_multiple_candidates);
diag.arg("crate_name", self.crate_name); diag.arg("crate_name", self.crate_name);
diag.arg("flavor", self.flavor); diag.arg("flavor", self.flavor);
@ -602,7 +602,7 @@ pub struct InvalidMetadataFiles {
impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidMetadataFiles { impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidMetadataFiles {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let mut diag = Diag::new(dcx, level, fluent::metadata_invalid_meta_files); let mut diag = Diag::new(dcx, level, fluent::metadata_invalid_meta_files);
diag.arg("crate_name", self.crate_name); diag.arg("crate_name", self.crate_name);
diag.arg("add_info", self.add_info); diag.arg("add_info", self.add_info);
@ -631,7 +631,7 @@ pub struct CannotFindCrate {
impl<G: EmissionGuarantee> Diagnostic<'_, G> for CannotFindCrate { impl<G: EmissionGuarantee> Diagnostic<'_, G> for CannotFindCrate {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let mut diag = Diag::new(dcx, level, fluent::metadata_cannot_find_crate); let mut diag = Diag::new(dcx, level, fluent::metadata_cannot_find_crate);
diag.arg("crate_name", self.crate_name); diag.arg("crate_name", self.crate_name);
diag.arg("current_crate", self.current_crate); diag.arg("current_crate", self.current_crate);

8
compiler/rustc_middle/src/macros.rs
View file

@ -4,10 +4,10 @@
/// ///
/// If you have a span available, you should use [`span_bug`] instead. /// If you have a span available, you should use [`span_bug`] instead.
/// ///
/// If the bug should only be emitted when compilation didn't fail, [`DiagCtxt::span_delayed_bug`] /// If the bug should only be emitted when compilation didn't fail, [`DiagCtxtHandle::span_delayed_bug`]
/// may be useful. /// may be useful.
/// ///
/// [`DiagCtxt::span_delayed_bug`]: rustc_errors::DiagCtxt::span_delayed_bug /// [`DiagCtxtHandle::span_delayed_bug`]: rustc_errors::DiagCtxtHandle::span_delayed_bug
/// [`span_bug`]: crate::span_bug /// [`span_bug`]: crate::span_bug
#[macro_export] #[macro_export]
macro_rules! bug { macro_rules! bug {
@ -30,10 +30,10 @@ macro_rules! bug {
/// at the code the compiler was compiling when it ICEd. This is the preferred way to trigger /// at the code the compiler was compiling when it ICEd. This is the preferred way to trigger
/// ICEs. /// ICEs.
/// ///
/// If the bug should only be emitted when compilation didn't fail, [`DiagCtxt::span_delayed_bug`] /// If the bug should only be emitted when compilation didn't fail, [`DiagCtxtHandle::span_delayed_bug`]
/// may be useful. /// may be useful.
/// ///
/// [`DiagCtxt::span_delayed_bug`]: rustc_errors::DiagCtxt::span_delayed_bug /// [`DiagCtxtHandle::span_delayed_bug`]: rustc_errors::DiagCtxtHandle::span_delayed_bug
#[macro_export] #[macro_export]
macro_rules! span_bug { macro_rules! span_bug {
($span:expr, $msg:expr) => ( ($span:expr, $msg:expr) => (

2
compiler/rustc_middle/src/middle/stability.rs
View file

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

6
compiler/rustc_middle/src/ty/context.rs
View file

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

4
compiler/rustc_middle/src/ty/layout.rs
View file

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

6
compiler/rustc_mir_build/src/errors.rs
View file

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

2
compiler/rustc_mir_build/src/thir/pattern/check_match.rs
View file

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

2
compiler/rustc_mir_transform/src/errors.rs
View file

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

4
compiler/rustc_monomorphize/src/errors.rs
View file

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

6
compiler/rustc_parse/src/errors.rs
View file

@ -3,7 +3,7 @@ use std::borrow::Cow;
use rustc_ast::token::Token; use rustc_ast::token::Token;
use rustc_ast::{Path, Visibility}; use rustc_ast::{Path, Visibility};
use rustc_errors::{ use rustc_errors::{
codes::*, Applicability, Diag, DiagCtxt, Diagnostic, EmissionGuarantee, Level, codes::*, Applicability, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
SubdiagMessageOp, Subdiagnostic, SubdiagMessageOp, Subdiagnostic,
}; };
use rustc_macros::{Diagnostic, Subdiagnostic}; use rustc_macros::{Diagnostic, Subdiagnostic};
@ -1052,7 +1052,7 @@ pub(crate) struct ExpectedIdentifier {
impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for ExpectedIdentifier { impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for ExpectedIdentifier {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> { fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
let token_descr = TokenDescription::from_token(&self.token); let token_descr = TokenDescription::from_token(&self.token);
let mut diag = Diag::new( let mut diag = Diag::new(
@ -1112,7 +1112,7 @@ pub(crate) struct ExpectedSemi {
impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for ExpectedSemi { impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for ExpectedSemi {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> { fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
let token_descr = TokenDescription::from_token(&self.token); let token_descr = TokenDescription::from_token(&self.token);
let mut diag = Diag::new( let mut diag = Diag::new(

13
compiler/rustc_parse/src/lexer/mod.rs
View file

@ -7,7 +7,7 @@ use rustc_ast::ast::{self, AttrStyle};
use rustc_ast::token::{self, CommentKind, Delimiter, IdentIsRaw, Token, TokenKind}; use rustc_ast::token::{self, CommentKind, Delimiter, IdentIsRaw, Token, TokenKind};
use rustc_ast::tokenstream::TokenStream; use rustc_ast::tokenstream::TokenStream;
use rustc_ast::util::unicode::contains_text_flow_control_chars; use rustc_ast::util::unicode::contains_text_flow_control_chars;
use rustc_errors::{codes::*, Applicability, Diag, DiagCtxt, StashKey}; use rustc_errors::{codes::*, Applicability, Diag, DiagCtxtHandle, StashKey};
use rustc_lexer::unescape::{self, EscapeError, Mode}; use rustc_lexer::unescape::{self, EscapeError, Mode};
use rustc_lexer::{Base, DocStyle, RawStrError}; use rustc_lexer::{Base, DocStyle, RawStrError};
use rustc_lexer::{Cursor, LiteralKind}; use rustc_lexer::{Cursor, LiteralKind};
@ -113,8 +113,8 @@ struct StringReader<'psess, 'src> {
} }
impl<'psess, 'src> StringReader<'psess, 'src> { impl<'psess, 'src> StringReader<'psess, 'src> {
fn dcx(&self) -> &'psess DiagCtxt { fn dcx(&self) -> DiagCtxtHandle<'psess> {
&self.psess.dcx self.psess.dcx()
} }
fn mk_sp(&self, lo: BytePos, hi: BytePos) -> Span { fn mk_sp(&self, lo: BytePos, hi: BytePos) -> Span {
@ -248,8 +248,8 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
let suffix = if suffix_start < self.pos { let suffix = if suffix_start < self.pos {
let string = self.str_from(suffix_start); let string = self.str_from(suffix_start);
if string == "_" { if string == "_" {
self.psess self
.dcx .dcx()
.emit_err(errors::UnderscoreLiteralSuffix { span: self.mk_sp(suffix_start, self.pos) }); .emit_err(errors::UnderscoreLiteralSuffix { span: self.mk_sp(suffix_start, self.pos) });
None None
} else { } else {
@ -597,8 +597,7 @@ impl<'psess, 'src> StringReader<'psess, 'src> {
} }
fn report_non_started_raw_string(&self, start: BytePos, bad_char: char) -> ! { fn report_non_started_raw_string(&self, start: BytePos, bad_char: char) -> ! {
self.psess self.dcx()
.dcx
.struct_span_fatal( .struct_span_fatal(
self.mk_sp(start, self.pos), self.mk_sp(start, self.pos),
format!( format!(

4
compiler/rustc_parse/src/lexer/tokentrees.rs
View file

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

4
compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
View file

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

2
compiler/rustc_parse/src/lexer/unicode_chars.rs
View file

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

6
compiler/rustc_parse/src/lib.rs
View file

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

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

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

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

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

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

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

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

@ -1966,7 +1966,7 @@ impl<'a> Parser<'a> {
if self.token.kind == token::Not { if self.token.kind == token::Not {
if let Err(mut err) = self.unexpected() { if let Err(mut err) = self.unexpected() {
// Encounter the macro invocation // Encounter the macro invocation
err.subdiagnostic(self.dcx(), MacroExpandsToAdtField { adt_ty }); err.subdiagnostic(MacroExpandsToAdtField { adt_ty });
return Err(err); return Err(err);
} }
} }
@ -2382,13 +2382,10 @@ impl<'a> Parser<'a> {
.into_iter() .into_iter()
.any(|s| self.prev_token.is_ident_named(s)); .any(|s| self.prev_token.is_ident_named(s));
err.subdiagnostic( err.subdiagnostic(errors::FnTraitMissingParen {
self.dcx(), span: self.prev_token.span,
errors::FnTraitMissingParen { machine_applicable,
span: self.prev_token.span, });
machine_applicable,
},
);
} }
return Err(err); return Err(err);
} }

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

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

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

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

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

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

10
compiler/rustc_parse/src/validate_attr.rs
View file

@ -65,7 +65,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
let res = match res { let res = match res {
Ok(lit) => { Ok(lit) => {
if token_lit.suffix.is_some() { if token_lit.suffix.is_some() {
let mut err = psess.dcx.struct_span_err( let mut err = psess.dcx().struct_span_err(
expr.span, expr.span,
"suffixed literals are not allowed in attributes", "suffixed literals are not allowed in attributes",
); );
@ -98,7 +98,7 @@ pub fn parse_meta<'a>(psess: &'a ParseSess, attr: &Attribute) -> PResult<'a, Met
// the error because an earlier error will have already // the error because an earlier error will have already
// been reported. // been reported.
let msg = "attribute value must be a literal"; let msg = "attribute value must be a literal";
let mut err = psess.dcx.struct_span_err(expr.span, msg); let mut err = psess.dcx().struct_span_err(expr.span, msg);
if let ast::ExprKind::Err(_) = expr.kind { if let ast::ExprKind::Err(_) = expr.kind {
err.downgrade_to_delayed_bug(); err.downgrade_to_delayed_bug();
} }
@ -114,7 +114,7 @@ fn check_meta_bad_delim(psess: &ParseSess, span: DelimSpan, delim: Delimiter) {
if let Delimiter::Parenthesis = delim { if let Delimiter::Parenthesis = delim {
return; return;
} }
psess.dcx.emit_err(errors::MetaBadDelim { psess.dcx().emit_err(errors::MetaBadDelim {
span: span.entire(), span: span.entire(),
sugg: errors::MetaBadDelimSugg { open: span.open, close: span.close }, sugg: errors::MetaBadDelimSugg { open: span.open, close: span.close },
}); });
@ -124,7 +124,7 @@ pub(super) fn check_cfg_attr_bad_delim(psess: &ParseSess, span: DelimSpan, delim
if let Delimiter::Parenthesis = delim { if let Delimiter::Parenthesis = delim {
return; return;
} }
psess.dcx.emit_err(errors::CfgAttrBadDelim { psess.dcx().emit_err(errors::CfgAttrBadDelim {
span: span.entire(), span: span.entire(),
sugg: errors::MetaBadDelimSugg { open: span.open, close: span.close }, sugg: errors::MetaBadDelimSugg { open: span.open, close: span.close },
}); });
@ -191,7 +191,7 @@ fn emit_malformed_attribute(
} else { } else {
suggestions.sort(); suggestions.sort();
psess psess
.dcx .dcx()
.struct_span_err(span, error_msg) .struct_span_err(span, error_msg)
.with_span_suggestions( .with_span_suggestions(
span, span,

6
compiler/rustc_passes/src/check_attr.rs
View file

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

14
compiler/rustc_passes/src/errors.rs
View file

@ -6,8 +6,8 @@ use std::{
use crate::fluent_generated as fluent; use crate::fluent_generated as fluent;
use rustc_ast::{ast, Label}; use rustc_ast::{ast, Label};
use rustc_errors::{ use rustc_errors::{
codes::*, Applicability, Diag, DiagCtxt, DiagSymbolList, Diagnostic, EmissionGuarantee, Level, codes::*, Applicability, Diag, DiagCtxtHandle, DiagSymbolList, Diagnostic, EmissionGuarantee,
MultiSpan, SubdiagMessageOp, Subdiagnostic, Level, MultiSpan, SubdiagMessageOp, Subdiagnostic,
}; };
use rustc_hir::{self as hir, ExprKind, Target}; use rustc_hir::{self as hir, ExprKind, Target};
use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic}; use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
@ -880,7 +880,7 @@ pub struct ItemFollowingInnerAttr {
impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidAttrAtCrateLevel { impl<G: EmissionGuarantee> Diagnostic<'_, G> for InvalidAttrAtCrateLevel {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &'_ DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let mut diag = Diag::new(dcx, level, fluent::passes_invalid_attr_at_crate_level); let mut diag = Diag::new(dcx, level, fluent::passes_invalid_attr_at_crate_level);
diag.span(self.span); diag.span(self.span);
diag.arg("name", self.name); diag.arg("name", self.name);
@ -1030,7 +1030,7 @@ pub struct BreakNonLoop<'a> {
impl<'a, G: EmissionGuarantee> Diagnostic<'_, G> for BreakNonLoop<'a> { impl<'a, G: EmissionGuarantee> Diagnostic<'_, G> for BreakNonLoop<'a> {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let mut diag = Diag::new(dcx, level, fluent::passes_break_non_loop); let mut diag = Diag::new(dcx, level, fluent::passes_break_non_loop);
diag.span(self.span); diag.span(self.span);
diag.code(E0571); diag.code(E0571);
@ -1176,7 +1176,7 @@ pub struct NakedFunctionsAsmBlock {
impl<G: EmissionGuarantee> Diagnostic<'_, G> for NakedFunctionsAsmBlock { impl<G: EmissionGuarantee> Diagnostic<'_, G> for NakedFunctionsAsmBlock {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let mut diag = Diag::new(dcx, level, fluent::passes_naked_functions_asm_block); let mut diag = Diag::new(dcx, level, fluent::passes_naked_functions_asm_block);
diag.span(self.span); diag.span(self.span);
diag.code(E0787); diag.code(E0787);
@ -1264,7 +1264,7 @@ pub struct NoMainErr {
impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for NoMainErr { impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for NoMainErr {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &'a DiagCtxt, level: Level) -> Diag<'a, G> { fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
let mut diag = Diag::new(dcx, level, fluent::passes_no_main_function); let mut diag = Diag::new(dcx, level, fluent::passes_no_main_function);
diag.span(DUMMY_SP); diag.span(DUMMY_SP);
diag.code(E0601); diag.code(E0601);
@ -1322,7 +1322,7 @@ pub struct DuplicateLangItem {
impl<G: EmissionGuarantee> Diagnostic<'_, G> for DuplicateLangItem { impl<G: EmissionGuarantee> Diagnostic<'_, G> for DuplicateLangItem {
#[track_caller] #[track_caller]
fn into_diag(self, dcx: &DiagCtxt, level: Level) -> Diag<'_, G> { fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
let mut diag = Diag::new( let mut diag = Diag::new(
dcx, dcx,
level, level,

4
compiler/rustc_query_system/src/query/job.rs
View file

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

76
compiler/rustc_resolve/src/diagnostics.rs
View file

@ -6,7 +6,7 @@ use rustc_ast::{MetaItemKind, NestedMetaItem};
use rustc_ast_pretty::pprust; use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{ use rustc_errors::{
codes::*, report_ambiguity_error, struct_span_code_err, Applicability, Diag, DiagCtxt, codes::*, report_ambiguity_error, struct_span_code_err, Applicability, Diag, DiagCtxtHandle,
ErrorGuaranteed, MultiSpan, SuggestionStyle, ErrorGuaranteed, MultiSpan, SuggestionStyle,
}; };
use rustc_feature::BUILTIN_ATTRIBUTES; use rustc_feature::BUILTIN_ATTRIBUTES;
@ -120,7 +120,7 @@ fn reduce_impl_span_to_impl_keyword(sm: &SourceMap, impl_span: Span) -> Span {
} }
impl<'a, 'tcx> Resolver<'a, 'tcx> { impl<'a, 'tcx> Resolver<'a, 'tcx> {
pub(crate) fn dcx(&self) -> &'tcx DiagCtxt { pub(crate) fn dcx(&self) -> DiagCtxtHandle<'tcx> {
self.tcx.dcx() self.tcx.dcx()
} }
@ -334,12 +334,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Some((import, _, true)) if should_remove_import && !import.is_glob() => { Some((import, _, true)) if should_remove_import && !import.is_glob() => {
// Simple case - remove the entire import. Due to the above match arm, this can // Simple case - remove the entire import. Due to the above match arm, this can
// only be a single use so just remove it entirely. // only be a single use so just remove it entirely.
err.subdiagnostic( err.subdiagnostic(errors::ToolOnlyRemoveUnnecessaryImport {
self.tcx.dcx(), span: import.use_span_with_attributes,
errors::ToolOnlyRemoveUnnecessaryImport { });
span: import.use_span_with_attributes,
},
);
} }
Some((import, span, _)) => { Some((import, span, _)) => {
self.add_suggestion_for_rename_of_use(&mut err, name, import, span); self.add_suggestion_for_rename_of_use(&mut err, name, import, span);
@ -405,12 +402,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
if let Some(suggestion) = suggestion { if let Some(suggestion) = suggestion {
err.subdiagnostic( err.subdiagnostic(ChangeImportBindingSuggestion { span: binding_span, suggestion });
self.dcx(),
ChangeImportBindingSuggestion { span: binding_span, suggestion },
);
} else { } else {
err.subdiagnostic(self.dcx(), ChangeImportBinding { span: binding_span }); err.subdiagnostic(ChangeImportBinding { span: binding_span });
} }
} }
@ -458,20 +452,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// previous imports. // previous imports.
if found_closing_brace { if found_closing_brace {
if let Some(span) = extend_span_to_previous_binding(self.tcx.sess, span) { if let Some(span) = extend_span_to_previous_binding(self.tcx.sess, span) {
err.subdiagnostic(self.dcx(), errors::ToolOnlyRemoveUnnecessaryImport { span }); err.subdiagnostic(errors::ToolOnlyRemoveUnnecessaryImport { span });
} else { } else {
// Remove the entire line if we cannot extend the span back, this indicates an // Remove the entire line if we cannot extend the span back, this indicates an
// `issue_52891::{self}` case. // `issue_52891::{self}` case.
err.subdiagnostic( err.subdiagnostic(errors::RemoveUnnecessaryImport {
self.dcx(), span: import.use_span_with_attributes,
errors::RemoveUnnecessaryImport { span: import.use_span_with_attributes }, });
);
} }
return; return;
} }
err.subdiagnostic(self.dcx(), errors::RemoveUnnecessaryImport { span }); err.subdiagnostic(errors::RemoveUnnecessaryImport { span });
} }
pub(crate) fn lint_if_path_starts_with_module( pub(crate) fn lint_if_path_starts_with_module(
@ -682,10 +675,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
.dcx() .dcx()
.create_err(errors::VariableIsNotBoundInAllPatterns { multispan: msp, name }); .create_err(errors::VariableIsNotBoundInAllPatterns { multispan: msp, name });
for sp in target_sp { for sp in target_sp {
err.subdiagnostic(self.dcx(), errors::PatternDoesntBindName { span: sp, name }); err.subdiagnostic(errors::PatternDoesntBindName { span: sp, name });
} }
for sp in origin_sp { for sp in origin_sp {
err.subdiagnostic(self.dcx(), errors::VariableNotInAllPatterns { span: sp }); err.subdiagnostic(errors::VariableNotInAllPatterns { span: sp });
} }
if could_be_path { if could_be_path {
let import_suggestions = self.lookup_import_candidates( let import_suggestions = self.lookup_import_candidates(
@ -1446,12 +1439,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
); );
if macro_kind == MacroKind::Bang && ident.name == sym::macro_rules { if macro_kind == MacroKind::Bang && ident.name == sym::macro_rules {
err.subdiagnostic(self.dcx(), MaybeMissingMacroRulesName { span: ident.span }); err.subdiagnostic(MaybeMissingMacroRulesName { span: ident.span });
return; return;
} }
if macro_kind == MacroKind::Derive && (ident.name == sym::Send || ident.name == sym::Sync) { if macro_kind == MacroKind::Derive && (ident.name == sym::Send || ident.name == sym::Sync) {
err.subdiagnostic(self.dcx(), ExplicitUnsafeTraits { span: ident.span, ident }); err.subdiagnostic(ExplicitUnsafeTraits { span: ident.span, ident });
return; return;
} }
@ -1467,14 +1460,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let scope = self.local_macro_def_scopes[&def_id]; let scope = self.local_macro_def_scopes[&def_id];
let parent_nearest = parent_scope.module.nearest_parent_mod(); let parent_nearest = parent_scope.module.nearest_parent_mod();
if Some(parent_nearest) == scope.opt_def_id() { if Some(parent_nearest) == scope.opt_def_id() {
err.subdiagnostic(self.dcx(), MacroDefinedLater { span: unused_ident.span }); err.subdiagnostic(MacroDefinedLater { span: unused_ident.span });
err.subdiagnostic(self.dcx(), MacroSuggMovePosition { span: ident.span, ident }); err.subdiagnostic(MacroSuggMovePosition { span: ident.span, ident });
return; return;
} }
} }
if self.macro_names.contains(&ident.normalize_to_macros_2_0()) { if self.macro_names.contains(&ident.normalize_to_macros_2_0()) {
err.subdiagnostic(self.dcx(), AddedMacroUse); err.subdiagnostic(AddedMacroUse);
return; return;
} }
@ -1484,13 +1477,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let span = self.def_span(def_id); let span = self.def_span(def_id);
let source_map = self.tcx.sess.source_map(); let source_map = self.tcx.sess.source_map();
let head_span = source_map.guess_head_span(span); let head_span = source_map.guess_head_span(span);
err.subdiagnostic( err.subdiagnostic(ConsiderAddingADerive {
self.dcx(), span: head_span.shrink_to_lo(),
ConsiderAddingADerive { suggestion: "#[derive(Default)]\n".to_string(),
span: head_span.shrink_to_lo(), });
suggestion: "#[derive(Default)]\n".to_string(),
},
);
} }
for ns in [Namespace::MacroNS, Namespace::TypeNS, Namespace::ValueNS] { for ns in [Namespace::MacroNS, Namespace::TypeNS, Namespace::ValueNS] {
if let Ok(binding) = self.early_resolve_ident_in_lexical_scope( if let Ok(binding) = self.early_resolve_ident_in_lexical_scope(
@ -1533,7 +1523,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
imported_ident: ident, imported_ident: ident,
imported_ident_desc: &desc, imported_ident_desc: &desc,
}; };
err.subdiagnostic(self.tcx.dcx(), note); err.subdiagnostic(note);
// Silence the 'unused import' warning we might get, // Silence the 'unused import' warning we might get,
// since this diagnostic already covers that import. // since this diagnostic already covers that import.
self.record_use(ident, binding, Used::Other); self.record_use(ident, binding, Used::Other);
@ -1544,7 +1534,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
imported_ident: ident, imported_ident: ident,
imported_ident_desc: &desc, imported_ident_desc: &desc,
}; };
err.subdiagnostic(self.tcx.dcx(), note); err.subdiagnostic(note);
return; return;
} }
} }
@ -1599,7 +1589,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
}; };
did_label_def_span = true; did_label_def_span = true;
err.subdiagnostic(self.tcx.dcx(), label); err.subdiagnostic(label);
} }
let (span, msg, sugg) = if let SuggestionTarget::SimilarlyNamed = suggestion.target let (span, msg, sugg) = if let SuggestionTarget::SimilarlyNamed = suggestion.target
@ -1790,7 +1780,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
outer_ident_descr: this_res.descr(), outer_ident_descr: this_res.descr(),
outer_ident, outer_ident,
}; };
err.subdiagnostic(self.tcx.dcx(), label); err.subdiagnostic(label);
} }
} }
@ -1805,14 +1795,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
non_exhaustive = Some(attr.span); non_exhaustive = Some(attr.span);
} else if let Some(span) = ctor_fields_span { } else if let Some(span) = ctor_fields_span {
let label = errors::ConstructorPrivateIfAnyFieldPrivate { span }; let label = errors::ConstructorPrivateIfAnyFieldPrivate { span };
err.subdiagnostic(self.tcx.dcx(), label); err.subdiagnostic(label);
if let Res::Def(_, d) = res if let Res::Def(_, d) = res
&& let Some(fields) = self.field_visibility_spans.get(&d) && let Some(fields) = self.field_visibility_spans.get(&d)
{ {
let spans = fields.iter().map(|span| *span).collect(); let spans = fields.iter().map(|span| *span).collect();
let sugg = let sugg =
errors::ConsiderMakingTheFieldPublic { spans, number_of_fields: fields.len() }; errors::ConsiderMakingTheFieldPublic { spans, number_of_fields: fields.len() };
err.subdiagnostic(self.tcx.dcx(), sugg); err.subdiagnostic(sugg);
} }
} }
@ -1921,7 +1911,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
first, first,
dots: next_binding.is_some(), dots: next_binding.is_some(),
}; };
err.subdiagnostic(self.tcx.dcx(), note); err.subdiagnostic(note);
} }
// We prioritize shorter paths, non-core imports and direct imports over the alternatives. // We prioritize shorter paths, non-core imports and direct imports over the alternatives.
sugg_paths.sort_by_key(|(p, reexport)| (p.len(), p[0] == "core", *reexport)); sugg_paths.sort_by_key(|(p, reexport)| (p.len(), p[0] == "core", *reexport));
@ -1940,7 +1930,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} else { } else {
errors::ImportIdent::Directly { span: dedup_span, ident, path } errors::ImportIdent::Directly { span: dedup_span, ident, path }
}; };
err.subdiagnostic(self.tcx.dcx(), sugg); err.subdiagnostic(sugg);
break; break;
} }
@ -2521,14 +2511,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
let note = errors::FoundItemConfigureOut { span: name.span }; let note = errors::FoundItemConfigureOut { span: name.span };
err.subdiagnostic(self.tcx.dcx(), note); err.subdiagnostic(note);
if let MetaItemKind::List(nested) = &cfg.kind if let MetaItemKind::List(nested) = &cfg.kind
&& let NestedMetaItem::MetaItem(meta_item) = &nested[0] && let NestedMetaItem::MetaItem(meta_item) = &nested[0]
&& let MetaItemKind::NameValue(feature_name) = &meta_item.kind && let MetaItemKind::NameValue(feature_name) = &meta_item.kind
{ {
let note = errors::ItemWasBehindFeature { feature: feature_name.symbol }; let note = errors::ItemWasBehindFeature { feature: feature_name.symbol };
err.subdiagnostic(self.tcx.dcx(), note); err.subdiagnostic(note);
} }
} }
} }

4
compiler/rustc_resolve/src/imports.rs
View file

@ -1294,12 +1294,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// exclude decl_macro // exclude decl_macro
if self.get_macro_by_def_id(def_id).macro_rules => if self.get_macro_by_def_id(def_id).macro_rules =>
{ {
err.subdiagnostic(self.dcx(), ConsiderAddingMacroExport { err.subdiagnostic( ConsiderAddingMacroExport {
span: binding.span, span: binding.span,
}); });
} }
_ => { _ => {
err.subdiagnostic(self.dcx(), ConsiderMarkingAsPub { err.subdiagnostic( ConsiderMarkingAsPub {
span: import.span, span: import.span,
ident, ident,
}); });

24
compiler/rustc_resolve/src/late/diagnostics.rs
View file

@ -1109,14 +1109,11 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
Side::Start => (segment.ident.span.between(range.span), " @ ".into()), Side::Start => (segment.ident.span.between(range.span), " @ ".into()),
Side::End => (range.span.to(segment.ident.span), format!("{} @ ..", segment.ident)), Side::End => (range.span.to(segment.ident.span), format!("{} @ ..", segment.ident)),
}; };
err.subdiagnostic( err.subdiagnostic(errors::UnexpectedResUseAtOpInSlicePatWithRangeSugg {
self.r.dcx(), span,
errors::UnexpectedResUseAtOpInSlicePatWithRangeSugg { ident: segment.ident,
span, snippet,
ident: segment.ident, });
snippet,
},
);
} }
enum Side { enum Side {
@ -1208,13 +1205,10 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
}); });
if let Some(param) = param { if let Some(param) = param {
err.subdiagnostic( err.subdiagnostic(errors::UnexpectedResChangeTyToConstParamSugg {
self.r.dcx(), span: param.shrink_to_lo(),
errors::UnexpectedResChangeTyToConstParamSugg { applicability,
span: param.shrink_to_lo(), });
applicability,
},
);
} }
} }

8
compiler/rustc_session/src/errors.rs
View file

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

28
compiler/rustc_session/src/parse.rs
View file

@ -15,8 +15,8 @@ use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
use rustc_data_structures::sync::{AppendOnlyVec, Lock, Lrc}; use rustc_data_structures::sync::{AppendOnlyVec, Lock, Lrc};
use rustc_errors::emitter::{stderr_destination, HumanEmitter, SilentEmitter}; use rustc_errors::emitter::{stderr_destination, HumanEmitter, SilentEmitter};
use rustc_errors::{ use rustc_errors::{
fallback_fluent_bundle, ColorConfig, Diag, DiagCtxt, DiagMessage, EmissionGuarantee, MultiSpan, fallback_fluent_bundle, ColorConfig, Diag, DiagCtxt, DiagCtxtHandle, DiagMessage,
StashKey, EmissionGuarantee, MultiSpan, StashKey,
}; };
use rustc_feature::{find_feature_issue, GateIssue, UnstableFeatures}; use rustc_feature::{find_feature_issue, GateIssue, UnstableFeatures};
use rustc_span::edition::Edition; use rustc_span::edition::Edition;
@ -106,12 +106,12 @@ pub fn feature_err_issue(
// Cancel an earlier warning for this same error, if it exists. // Cancel an earlier warning for this same error, if it exists.
if let Some(span) = span.primary_span() { if let Some(span) = span.primary_span() {
if let Some(err) = sess.psess.dcx.steal_non_err(span, StashKey::EarlySyntaxWarning) { if let Some(err) = sess.dcx().steal_non_err(span, StashKey::EarlySyntaxWarning) {
err.cancel() err.cancel()
} }
} }
let mut err = sess.psess.dcx.create_err(FeatureGateError { span, explain: explain.into() }); let mut err = sess.dcx().create_err(FeatureGateError { span, explain: explain.into() });
add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None); add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None);
err err
} }
@ -140,7 +140,7 @@ pub fn feature_warn_issue(
issue: GateIssue, issue: GateIssue,
explain: &'static str, explain: &'static str,
) { ) {
let mut err = sess.psess.dcx.struct_span_warn(span, explain); let mut err = sess.dcx().struct_span_warn(span, explain);
add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None); add_feature_diagnostics_for_issue(&mut err, sess, feature, issue, false, None);
// Decorate this as a future-incompatibility lint as in rustc_middle::lint::lint_level // 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>(
inject_span: Option<Span>, inject_span: Option<Span>,
) { ) {
if let Some(n) = find_feature_issue(feature, issue) { if let Some(n) = find_feature_issue(feature, issue) {
err.subdiagnostic(sess.dcx(), FeatureDiagnosticForIssue { n }); err.subdiagnostic(FeatureDiagnosticForIssue { n });
} }
// #23973: do not suggest `#![feature(...)]` if we are in beta/stable // #23973: do not suggest `#![feature(...)]` if we are in beta/stable
if sess.psess.unstable_features.is_nightly_build() { if sess.psess.unstable_features.is_nightly_build() {
if feature_from_cli { if feature_from_cli {
err.subdiagnostic(sess.dcx(), CliFeatureDiagnosticHelp { feature }); err.subdiagnostic(CliFeatureDiagnosticHelp { feature });
} else if let Some(span) = inject_span { } else if let Some(span) = inject_span {
err.subdiagnostic(sess.dcx(), FeatureDiagnosticSuggestion { feature, span }); err.subdiagnostic(FeatureDiagnosticSuggestion { feature, span });
} else { } else {
err.subdiagnostic(sess.dcx(), FeatureDiagnosticHelp { feature }); err.subdiagnostic(FeatureDiagnosticHelp { feature });
} }
if sess.opts.unstable_opts.ui_testing { if sess.opts.unstable_opts.ui_testing {
err.subdiagnostic(sess.dcx(), SuggestUpgradeCompiler::ui_testing()); err.subdiagnostic(SuggestUpgradeCompiler::ui_testing());
} else if let Some(suggestion) = SuggestUpgradeCompiler::new() { } else if let Some(suggestion) = SuggestUpgradeCompiler::new() {
err.subdiagnostic(sess.dcx(), suggestion); err.subdiagnostic(suggestion);
} }
} }
} }
/// Info about a parsing session. /// Info about a parsing session.
pub struct ParseSess { pub struct ParseSess {
pub dcx: DiagCtxt, dcx: DiagCtxt,
pub unstable_features: UnstableFeatures, pub unstable_features: UnstableFeatures,
pub config: Cfg, pub config: Cfg,
pub check_config: CheckCfg, pub check_config: CheckCfg,
@ -326,4 +326,8 @@ impl ParseSess {
// AppendOnlyVec, so we resort to this scheme. // AppendOnlyVec, so we resort to this scheme.
self.proc_macro_quoted_spans.iter_enumerated() self.proc_macro_quoted_spans.iter_enumerated()
} }
pub fn dcx(&self) -> DiagCtxtHandle<'_> {
self.dcx.handle()
}
} }

26
compiler/rustc_session/src/session.rs
View file

@ -22,8 +22,8 @@ use rustc_errors::emitter::{stderr_destination, DynEmitter, HumanEmitter, HumanR
use rustc_errors::json::JsonEmitter; use rustc_errors::json::JsonEmitter;
use rustc_errors::registry::Registry; use rustc_errors::registry::Registry;
use rustc_errors::{ use rustc_errors::{
codes::*, fallback_fluent_bundle, Diag, DiagCtxt, DiagMessage, Diagnostic, ErrorGuaranteed, codes::*, fallback_fluent_bundle, Diag, DiagCtxt, DiagCtxtHandle, DiagMessage, Diagnostic,
FatalAbort, FluentBundle, LazyFallbackBundle, TerminalUrl, ErrorGuaranteed, FatalAbort, FluentBundle, LazyFallbackBundle, TerminalUrl,
}; };
use rustc_macros::HashStable_Generic; use rustc_macros::HashStable_Generic;
pub use rustc_span::def_id::StableCrateId; pub use rustc_span::def_id::StableCrateId;
@ -328,8 +328,8 @@ impl Session {
} }
#[inline] #[inline]
pub fn dcx(&self) -> &DiagCtxt { pub fn dcx(&self) -> DiagCtxtHandle<'_> {
&self.psess.dcx self.psess.dcx()
} }
#[inline] #[inline]
@ -1070,7 +1070,7 @@ pub fn build_session(
match profiler { match profiler {
Ok(profiler) => Some(Arc::new(profiler)), Ok(profiler) => Some(Arc::new(profiler)),
Err(e) => { Err(e) => {
dcx.emit_warn(errors::FailedToCreateProfiler { err: e.to_string() }); dcx.handle().emit_warn(errors::FailedToCreateProfiler { err: e.to_string() });
None None
} }
} }
@ -1371,7 +1371,7 @@ impl EarlyDiagCtxt {
/// format. Any errors prior to that will cause an abort and all stashed diagnostics of the /// format. Any errors prior to that will cause an abort and all stashed diagnostics of the
/// previous dcx will be emitted. /// previous dcx will be emitted.
pub fn abort_if_error_and_set_error_format(&mut self, output: ErrorOutputType) { pub fn abort_if_error_and_set_error_format(&mut self, output: ErrorOutputType) {
self.dcx.abort_if_errors(); self.dcx.handle().abort_if_errors();
let emitter = mk_emitter(output); let emitter = mk_emitter(output);
self.dcx = DiagCtxt::new(emitter); self.dcx = DiagCtxt::new(emitter);
@ -1380,44 +1380,44 @@ impl EarlyDiagCtxt {
#[allow(rustc::untranslatable_diagnostic)] #[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_note(&self, msg: impl Into<DiagMessage>) { pub fn early_note(&self, msg: impl Into<DiagMessage>) {
self.dcx.note(msg) self.dcx.handle().note(msg)
} }
#[allow(rustc::untranslatable_diagnostic)] #[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_help(&self, msg: impl Into<DiagMessage>) { pub fn early_help(&self, msg: impl Into<DiagMessage>) {
self.dcx.struct_help(msg).emit() self.dcx.handle().struct_help(msg).emit()
} }
#[allow(rustc::untranslatable_diagnostic)] #[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
#[must_use = "ErrorGuaranteed must be returned from `run_compiler` in order to exit with a non-zero status code"] #[must_use = "ErrorGuaranteed must be returned from `run_compiler` in order to exit with a non-zero status code"]
pub fn early_err(&self, msg: impl Into<DiagMessage>) -> ErrorGuaranteed { pub fn early_err(&self, msg: impl Into<DiagMessage>) -> ErrorGuaranteed {
self.dcx.err(msg) self.dcx.handle().err(msg)
} }
#[allow(rustc::untranslatable_diagnostic)] #[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_fatal(&self, msg: impl Into<DiagMessage>) -> ! { pub fn early_fatal(&self, msg: impl Into<DiagMessage>) -> ! {
self.dcx.fatal(msg) self.dcx.handle().fatal(msg)
} }
#[allow(rustc::untranslatable_diagnostic)] #[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_struct_fatal(&self, msg: impl Into<DiagMessage>) -> Diag<'_, FatalAbort> { pub fn early_struct_fatal(&self, msg: impl Into<DiagMessage>) -> Diag<'_, FatalAbort> {
self.dcx.struct_fatal(msg) self.dcx.handle().struct_fatal(msg)
} }
#[allow(rustc::untranslatable_diagnostic)] #[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_warn(&self, msg: impl Into<DiagMessage>) { pub fn early_warn(&self, msg: impl Into<DiagMessage>) {
self.dcx.warn(msg) self.dcx.handle().warn(msg)
} }
#[allow(rustc::untranslatable_diagnostic)] #[allow(rustc::untranslatable_diagnostic)]
#[allow(rustc::diagnostic_outside_of_impl)] #[allow(rustc::diagnostic_outside_of_impl)]
pub fn early_struct_warn(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> { pub fn early_struct_warn(&self, msg: impl Into<DiagMessage>) -> Diag<'_, ()> {
self.dcx.struct_warn(msg) self.dcx.handle().struct_warn(msg)
} }
} }

Some files were not shown because too many files have changed in this diff Show more