Skip to content

Commit a64ef7d

Browse files
borsbors
committed
Auto merge of #100754 - davidtwco:translation-incremental, r=compiler-errors
incremental: migrate diagnostics - Apply the diagnostic migration lints to more functions on `Session`, namely: `span_warn`, `span_warn_with_code`, `warn` `note_without_error`, `span_note_without_error`, `struct_note_without_error`. - Add impls of `IntoDiagnosticArg` for `std::io::Error`, `std::path::Path` and `std::path::PathBuf`. - Migrate the `rustc_incremental` crate's diagnostics to translatable diagnostic structs. r? `@compiler-errors` cc #100717
2 parents 7c4a9a9 + 2ff4664 commit a64ef7d

File tree

49 files changed

+1157
-428
lines changed

Some content is hidden

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

49 files changed

+1157
-428
lines changed

‎compiler/rustc_borrowck/src/diagnostics/region_name.rs

+6
Original file line numberDiff line numberDiff line change
@@ -187,6 +187,12 @@ impl Display for RegionName {
187187
}
188188
}
189189

190+
impl rustc_errors::IntoDiagnosticArg for RegionName {
191+
fn into_diagnostic_arg(self) -> rustc_errors::DiagnosticArgValue<'static> {
192+
self.to_string().into_diagnostic_arg()
193+
}
194+
}
195+
190196
impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
191197
pub(crate) fn mir_def_id(&self) -> hir::def_id::LocalDefId {
192198
self.body.source.def_id().expect_local()

‎compiler/rustc_borrowck/src/nll.rs

+2
Original file line numberDiff line numberDiff line change
@@ -369,6 +369,8 @@ pub(super) fn dump_mir_results<'tcx>(
369369
};
370370
}
371371

372+
#[allow(rustc::diagnostic_outside_of_impl)]
373+
#[allow(rustc::untranslatable_diagnostic)]
372374
pub(super) fn dump_annotation<'tcx>(
373375
infcx: &InferCtxt<'tcx>,
374376
body: &Body<'tcx>,

‎compiler/rustc_borrowck/src/session_diagnostics.rs

+1-13
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
use rustc_errors::{IntoDiagnosticArg, MultiSpan};
1+
use rustc_errors::MultiSpan;
22
use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
33
use rustc_middle::ty::{GenericArg, Ty};
44
use rustc_span::Span;
@@ -128,18 +128,6 @@ pub(crate) enum LifetimeReturnCategoryErr<'a> {
128128
},
129129
}
130130

131-
impl IntoDiagnosticArg for &RegionName {
132-
fn into_diagnostic_arg(self) -> rustc_errors::DiagnosticArgValue<'static> {
133-
format!("{}", self).into_diagnostic_arg()
134-
}
135-
}
136-
137-
impl IntoDiagnosticArg for RegionName {
138-
fn into_diagnostic_arg(self) -> rustc_errors::DiagnosticArgValue<'static> {
139-
format!("{}", self).into_diagnostic_arg()
140-
}
141-
}
142-
143131
#[derive(Subdiagnostic)]
144132
pub(crate) enum RequireStaticErr {
145133
#[note(borrowck_used_impl_require_static)]

‎compiler/rustc_codegen_gcc/src/lib.rs

+1
Original file line numberDiff line numberDiff line change
@@ -200,6 +200,7 @@ unsafe impl Sync for GccContext {}
200200
impl WriteBackendMethods for GccCodegenBackend {
201201
type Module = GccContext;
202202
type TargetMachine = ();
203+
type TargetMachineError = ();
203204
type ModuleBuffer = ModuleBuffer;
204205
type ThinData = ();
205206
type ThinBuffer = ThinBuffer;

‎compiler/rustc_codegen_llvm/src/back/lto.rs

+28-37
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
use crate::back::write::{self, save_temp_bitcode, DiagnosticHandlers};
2-
use crate::errors::DynamicLinkingWithLTO;
2+
use crate::errors::{
3+
DynamicLinkingWithLTO, LlvmError, LtoBitcodeFromRlib, LtoDisallowed, LtoDylib,
4+
};
35
use crate::llvm::{self, build_string};
46
use crate::{LlvmCodegenBackend, ModuleLlvm};
57
use object::read::archive::ArchiveFile;
@@ -77,15 +79,12 @@ fn prepare_lto(
7779
// Make sure we actually can run LTO
7880
for crate_type in cgcx.crate_types.iter() {
7981
if !crate_type_allows_lto(*crate_type) {
80-
let e = diag_handler.fatal(
81-
"lto can only be run for executables, cdylibs and \
82-
static library outputs",
83-
);
84-
return Err(e);
82+
diag_handler.emit_err(LtoDisallowed);
83+
return Err(FatalError);
8584
} else if *crate_type == CrateType::Dylib {
8685
if !cgcx.opts.unstable_opts.dylib_lto {
87-
return Err(diag_handler
88-
.fatal("lto cannot be used for `dylib` crate type without `-Zdylib-lto`"));
86+
diag_handler.emit_err(LtoDylib);
87+
return Err(FatalError);
8988
}
9089
}
9190
}
@@ -127,7 +126,10 @@ fn prepare_lto(
127126
let module = SerializedModule::FromRlib(data.to_vec());
128127
upstream_modules.push((module, CString::new(name).unwrap()));
129128
}
130-
Err(msg) => return Err(diag_handler.fatal(&msg)),
129+
Err(e) => {
130+
diag_handler.emit_err(e);
131+
return Err(FatalError);
132+
}
131133
}
132134
}
133135
}
@@ -140,7 +142,7 @@ fn prepare_lto(
140142
Ok((symbols_below_threshold, upstream_modules))
141143
}
142144

143-
fn get_bitcode_slice_from_object_data(obj: &[u8]) -> Result<&[u8], String> {
145+
fn get_bitcode_slice_from_object_data(obj: &[u8]) -> Result<&[u8], LtoBitcodeFromRlib> {
144146
let mut len = 0;
145147
let data =
146148
unsafe { llvm::LLVMRustGetBitcodeSliceFromObjectData(obj.as_ptr(), obj.len(), &mut len) };
@@ -155,8 +157,9 @@ fn get_bitcode_slice_from_object_data(obj: &[u8]) -> Result<&[u8], String> {
155157
Ok(bc)
156158
} else {
157159
assert!(len == 0);
158-
let msg = llvm::last_error().unwrap_or_else(|| "unknown LLVM error".to_string());
159-
Err(format!("failed to get bitcode from object file for LTO ({})", msg))
160+
Err(LtoBitcodeFromRlib {
161+
llvm_err: llvm::last_error().unwrap_or_else(|| "unknown LLVM error".to_string()),
162+
})
160163
}
161164
}
162165

@@ -328,10 +331,9 @@ fn fat_lto(
328331
});
329332
info!("linking {:?}", name);
330333
let data = bc_decoded.data();
331-
linker.add(data).map_err(|()| {
332-
let msg = format!("failed to load bitcode of module {:?}", name);
333-
write::llvm_err(diag_handler, &msg)
334-
})?;
334+
linker
335+
.add(data)
336+
.map_err(|()| write::llvm_err(diag_handler, LlvmError::LoadBitcode { name }))?;
335337
serialized_bitcode.push(bc_decoded);
336338
}
337339
drop(linker);
@@ -489,7 +491,7 @@ fn thin_lto(
489491
symbols_below_threshold.as_ptr(),
490492
symbols_below_threshold.len() as u32,
491493
)
492-
.ok_or_else(|| write::llvm_err(diag_handler, "failed to prepare thin LTO context"))?;
494+
.ok_or_else(|| write::llvm_err(diag_handler, LlvmError::PrepareThinLtoContext))?;
493495

494496
let data = ThinData(data);
495497

@@ -562,8 +564,7 @@ fn thin_lto(
562564
// session, overwriting the previous serialized data (if any).
563565
if let Some(path) = key_map_path {
564566
if let Err(err) = curr_key_map.save_to_file(&path) {
565-
let msg = format!("Error while writing ThinLTO key data: {}", err);
566-
return Err(write::llvm_err(diag_handler, &msg));
567+
return Err(write::llvm_err(diag_handler, LlvmError::WriteThinLtoKey { err }));
567568
}
568569
}
569570

@@ -689,8 +690,7 @@ pub unsafe fn optimize_thin_module(
689690

690691
let module_name = &thin_module.shared.module_names[thin_module.idx];
691692
let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, module_name.to_str().unwrap());
692-
let tm =
693-
(cgcx.tm_factory)(tm_factory_config).map_err(|e| write::llvm_err(&diag_handler, &e))?;
693+
let tm = (cgcx.tm_factory)(tm_factory_config).map_err(|e| write::llvm_err(&diag_handler, e))?;
694694

695695
// Right now the implementation we've got only works over serialized
696696
// modules, so we create a fresh new LLVM context and parse the module
@@ -717,8 +717,7 @@ pub unsafe fn optimize_thin_module(
717717
let mut cu2 = ptr::null_mut();
718718
llvm::LLVMRustThinLTOGetDICompileUnit(llmod, &mut cu1, &mut cu2);
719719
if !cu2.is_null() {
720-
let msg = "multiple source DICompileUnits found";
721-
return Err(write::llvm_err(&diag_handler, msg));
720+
return Err(write::llvm_err(&diag_handler, LlvmError::MultipleSourceDiCompileUnit));
722721
}
723722

724723
// Up next comes the per-module local analyses that we do for Thin LTO.
@@ -733,8 +732,7 @@ pub unsafe fn optimize_thin_module(
733732
let _timer =
734733
cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_rename", thin_module.name());
735734
if !llvm::LLVMRustPrepareThinLTORename(thin_module.shared.data.0, llmod, target) {
736-
let msg = "failed to prepare thin LTO module";
737-
return Err(write::llvm_err(&diag_handler, msg));
735+
return Err(write::llvm_err(&diag_handler, LlvmError::PrepareThinLtoModule));
738736
}
739737
save_temp_bitcode(cgcx, &module, "thin-lto-after-rename");
740738
}
@@ -744,8 +742,7 @@ pub unsafe fn optimize_thin_module(
744742
.prof
745743
.generic_activity_with_arg("LLVM_thin_lto_resolve_weak", thin_module.name());
746744
if !llvm::LLVMRustPrepareThinLTOResolveWeak(thin_module.shared.data.0, llmod) {
747-
let msg = "failed to prepare thin LTO module";
748-
return Err(write::llvm_err(&diag_handler, msg));
745+
return Err(write::llvm_err(&diag_handler, LlvmError::PrepareThinLtoModule));
749746
}
750747
save_temp_bitcode(cgcx, &module, "thin-lto-after-resolve");
751748
}
@@ -755,8 +752,7 @@ pub unsafe fn optimize_thin_module(
755752
.prof
756753
.generic_activity_with_arg("LLVM_thin_lto_internalize", thin_module.name());
757754
if !llvm::LLVMRustPrepareThinLTOInternalize(thin_module.shared.data.0, llmod) {
758-
let msg = "failed to prepare thin LTO module";
759-
return Err(write::llvm_err(&diag_handler, msg));
755+
return Err(write::llvm_err(&diag_handler, LlvmError::PrepareThinLtoModule));
760756
}
761757
save_temp_bitcode(cgcx, &module, "thin-lto-after-internalize");
762758
}
@@ -765,8 +761,7 @@ pub unsafe fn optimize_thin_module(
765761
let _timer =
766762
cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_import", thin_module.name());
767763
if !llvm::LLVMRustPrepareThinLTOImport(thin_module.shared.data.0, llmod, target) {
768-
let msg = "failed to prepare thin LTO module";
769-
return Err(write::llvm_err(&diag_handler, msg));
764+
return Err(write::llvm_err(&diag_handler, LlvmError::PrepareThinLtoModule));
770765
}
771766
save_temp_bitcode(cgcx, &module, "thin-lto-after-import");
772767
}
@@ -886,11 +881,7 @@ pub fn parse_module<'a>(
886881
diag_handler: &Handler,
887882
) -> Result<&'a llvm::Module, FatalError> {
888883
unsafe {
889-
llvm::LLVMRustParseBitcodeForLTO(cx, data.as_ptr(), data.len(), name.as_ptr()).ok_or_else(
890-
|| {
891-
let msg = "failed to parse bitcode for LTO module";
892-
write::llvm_err(diag_handler, msg)
893-
},
894-
)
884+
llvm::LLVMRustParseBitcodeForLTO(cx, data.as_ptr(), data.len(), name.as_ptr())
885+
.ok_or_else(|| write::llvm_err(diag_handler, LlvmError::ParseBitcode))
895886
}
896887
}

‎compiler/rustc_codegen_llvm/src/back/write.rs

+32-32
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,9 @@ use crate::back::profiling::{
55
use crate::base;
66
use crate::common;
77
use crate::consts;
8+
use crate::errors::{
9+
CopyBitcode, FromLlvmDiag, FromLlvmOptimizationDiag, LlvmError, WithLlvmError, WriteBytecode,
10+
};
811
use crate::llvm::{self, DiagnosticInfo, PassManager};
912
use crate::llvm_util;
1013
use crate::type_::Type;
@@ -37,10 +40,10 @@ use std::slice;
3740
use std::str;
3841
use std::sync::Arc;
3942

40-
pub fn llvm_err(handler: &rustc_errors::Handler, msg: &str) -> FatalError {
43+
pub fn llvm_err<'a>(handler: &rustc_errors::Handler, err: LlvmError<'a>) -> FatalError {
4144
match llvm::last_error() {
42-
Some(err) => handler.fatal(&format!("{}: {}", msg, err)),
43-
None => handler.fatal(msg),
45+
Some(llvm_err) => handler.emit_almost_fatal(WithLlvmError(err, llvm_err)),
46+
None => handler.emit_almost_fatal(err),
4447
}
4548
}
4649

@@ -85,10 +88,9 @@ pub fn write_output_file<'ll>(
8588
}
8689
}
8790

88-
result.into_result().map_err(|()| {
89-
let msg = format!("could not write output to {}", output.display());
90-
llvm_err(handler, &msg)
91-
})
91+
result
92+
.into_result()
93+
.map_err(|()| llvm_err(handler, LlvmError::WriteOutput { path: output }))
9294
}
9395
}
9496

@@ -98,7 +100,7 @@ pub fn create_informational_target_machine(sess: &Session) -> &'static mut llvm:
98100
// system/tcx is set up.
99101
let features = llvm_util::global_llvm_features(sess, false);
100102
target_machine_factory(sess, config::OptLevel::No, &features)(config)
101-
.unwrap_or_else(|err| llvm_err(sess.diagnostic(), &err).raise())
103+
.unwrap_or_else(|err| llvm_err(sess.diagnostic(), err).raise())
102104
}
103105

104106
pub fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> &'static mut llvm::TargetMachine {
@@ -117,7 +119,7 @@ pub fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> &'static mut ll
117119
tcx.backend_optimization_level(()),
118120
tcx.global_backend_features(()),
119121
)(config)
120-
.unwrap_or_else(|err| llvm_err(tcx.sess.diagnostic(), &err).raise())
122+
.unwrap_or_else(|err| llvm_err(tcx.sess.diagnostic(), err).raise())
121123
}
122124

123125
pub fn to_llvm_opt_settings(
@@ -240,9 +242,7 @@ pub fn target_machine_factory(
240242
)
241243
};
242244

243-
tm.ok_or_else(|| {
244-
format!("Could not create LLVM TargetMachine for triple: {}", triple.to_str().unwrap())
245-
})
245+
tm.ok_or_else(|| LlvmError::CreateTargetMachine { triple: triple.clone() })
246246
})
247247
}
248248

@@ -355,25 +355,28 @@ unsafe extern "C" fn diagnostic_handler(info: &DiagnosticInfo, user: *mut c_void
355355
};
356356

357357
if enabled {
358-
diag_handler.note_without_error(&format!(
359-
"{}:{}:{}: {}: {}",
360-
opt.filename, opt.line, opt.column, opt.pass_name, opt.message,
361-
));
358+
diag_handler.emit_note(FromLlvmOptimizationDiag {
359+
filename: &opt.filename,
360+
line: opt.line,
361+
column: opt.column,
362+
pass_name: &opt.pass_name,
363+
message: &opt.message,
364+
});
362365
}
363366
}
364367
llvm::diagnostic::PGO(diagnostic_ref) | llvm::diagnostic::Linker(diagnostic_ref) => {
365-
let msg = llvm::build_string(|s| {
368+
let message = llvm::build_string(|s| {
366369
llvm::LLVMRustWriteDiagnosticInfoToString(diagnostic_ref, s)
367370
})
368371
.expect("non-UTF8 diagnostic");
369-
diag_handler.warn(&msg);
372+
diag_handler.emit_warning(FromLlvmDiag { message });
370373
}
371374
llvm::diagnostic::Unsupported(diagnostic_ref) => {
372-
let msg = llvm::build_string(|s| {
375+
let message = llvm::build_string(|s| {
373376
llvm::LLVMRustWriteDiagnosticInfoToString(diagnostic_ref, s)
374377
})
375378
.expect("non-UTF8 diagnostic");
376-
diag_handler.err(&msg);
379+
diag_handler.emit_err(FromLlvmDiag { message });
377380
}
378381
llvm::diagnostic::UnknownDiagnostic(..) => {}
379382
}
@@ -494,7 +497,7 @@ pub(crate) unsafe fn llvm_optimize(
494497
llvm_plugins.as_ptr().cast(),
495498
llvm_plugins.len(),
496499
);
497-
result.into_result().map_err(|()| llvm_err(diag_handler, "failed to run LLVM passes"))
500+
result.into_result().map_err(|()| llvm_err(diag_handler, LlvmError::RunLlvmPasses))
498501
}
499502

500503
// Unsafe due to LLVM calls.
@@ -547,8 +550,7 @@ pub(crate) fn link(
547550
let _timer = cgcx.prof.generic_activity_with_arg("LLVM_link_module", &*module.name);
548551
let buffer = ModuleBuffer::new(module.module_llvm.llmod());
549552
linker.add(buffer.data()).map_err(|()| {
550-
let msg = format!("failed to serialize module {:?}", module.name);
551-
llvm_err(diag_handler, &msg)
553+
llvm_err(diag_handler, LlvmError::SerializeModule { name: &module.name })
552554
})?;
553555
}
554556
drop(linker);
@@ -626,9 +628,8 @@ pub(crate) unsafe fn codegen(
626628
let _timer = cgcx
627629
.prof
628630
.generic_activity_with_arg("LLVM_module_codegen_emit_bitcode", &*module.name);
629-
if let Err(e) = fs::write(&bc_out, data) {
630-
let msg = format!("failed to write bytecode to {}: {}", bc_out.display(), e);
631-
diag_handler.err(&msg);
631+
if let Err(err) = fs::write(&bc_out, data) {
632+
diag_handler.emit_err(WriteBytecode { path: &bc_out, err });
632633
}
633634
}
634635

@@ -678,10 +679,9 @@ pub(crate) unsafe fn codegen(
678679
record_artifact_size(&cgcx.prof, "llvm_ir", &out);
679680
}
680681

681-
result.into_result().map_err(|()| {
682-
let msg = format!("failed to write LLVM IR to {}", out.display());
683-
llvm_err(diag_handler, &msg)
684-
})?;
682+
result
683+
.into_result()
684+
.map_err(|()| llvm_err(diag_handler, LlvmError::WriteIr { path: &out }))?;
685685
}
686686

687687
if config.emit_asm {
@@ -749,8 +749,8 @@ pub(crate) unsafe fn codegen(
749749

750750
EmitObj::Bitcode => {
751751
debug!("copying bitcode {:?} to obj {:?}", bc_out, obj_out);
752-
if let Err(e) = link_or_copy(&bc_out, &obj_out) {
753-
diag_handler.err(&format!("failed to copy bitcode to object file: {}", e));
752+
if let Err(err) = link_or_copy(&bc_out, &obj_out) {
753+
diag_handler.emit_err(CopyBitcode { err });
754754
}
755755

756756
if !config.emit_bc {

0 commit comments

Comments
 (0)