port fs.rs to SessionDiagnostics

compiler/rustc_error_messages/locales/en-US/metadata.ftl

@@ -158,3 +158,15 @@ metadata_global_alloc_required =
 
 metadata_no_transitive_needs_dep =
     the crate `{$crate_name}` cannot depend on a crate that needs {$needs_crate_name}, but it depends on `{$deps_crate_name}`
+
+metadata_failed_write_error =
+    failed to write {$filename}: {$err}
+
+metadata_failed_create_tempdir =
+    couldn't create a temp dir: {$err}
+
+metadata_failed_create_file =
+    failed to create the file {$filename}: {$err}
+
+metadata_failed_create_encoded_metadata =
+    failed to create encoded metadata from file: {$err}

compiler/rustc_metadata/src/errors.rs

@@ -352,3 +352,29 @@ pub struct NoTransitiveNeedsDep {
     pub needs_crate_name: String,
     pub deps_crate_name: String,
 }
+
+#[derive(SessionDiagnostic)]
+#[diag(metadata::failed_write_error)]
+pub struct FailedWriteError {
+    pub filename: String,
+    pub err: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[diag(metadata::failed_create_tempdir)]
+pub struct FailedCreateTempdir {
+    pub err: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[diag(metadata::failed_create_file)]
+pub struct FailedCreateFile {
+    pub filename: String,
+    pub err: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[diag(metadata::failed_create_encoded_metadata)]
+pub struct FailedCreateEncodedMetadata {
+    pub err: String,
+}

compiler/rustc_metadata/src/fs.rs

@@ -1,3 +1,6 @@
+use crate::errors::{
+    FailedCreateEncodedMetadata, FailedCreateFile, FailedCreateTempdir, FailedWriteError,
+};
 use crate::{encode_metadata, EncodedMetadata};
 
 use rustc_data_structures::temp_dir::MaybeTempDir;
@@ -24,7 +27,10 @@ pub fn emit_metadata(sess: &Session, metadata: &[u8], tmpdir: &MaybeTempDir) ->
     let result = fs::write(&out_filename, metadata);
 
     if let Err(e) = result {
-        sess.fatal(&format!("failed to write {}: {}", out_filename.display(), e));
+        sess.emit_fatal(FailedWriteError {
+            filename: out_filename.display().to_string(),
+            err: e.to_string(),
+        });
     }
 
     out_filename
@@ -65,7 +71,7 @@ pub fn encode_and_write_metadata(
     let metadata_tmpdir = TempFileBuilder::new()
         .prefix("rmeta")
         .tempdir_in(out_filename.parent().unwrap_or_else(|| Path::new("")))
-        .unwrap_or_else(|err| tcx.sess.fatal(&format!("couldn't create a temp dir: {}", err)));
+        .unwrap_or_else(|err| tcx.sess.emit_fatal(FailedCreateTempdir { err: err.to_string() }));
     let metadata_tmpdir = MaybeTempDir::new(metadata_tmpdir, tcx.sess.opts.cg.save_temps);
     let metadata_filename = metadata_tmpdir.as_ref().join(METADATA_FILENAME);
 
@@ -74,11 +80,10 @@ pub fn encode_and_write_metadata(
     match metadata_kind {
         MetadataKind::None => {
             std::fs::File::create(&metadata_filename).unwrap_or_else(|e| {
-                tcx.sess.fatal(&format!(
+                tcx.sess.emit_fatal(FailedCreateFile {
-                    "failed to create the file {}: {}",
+                    filename: metadata_filename.display().to_string(),
-                    metadata_filename.display(),
+                    err: e.to_string(),
-                    e
+                });
-                ))
             });
         }
         MetadataKind::Uncompressed | MetadataKind::Compressed => {
@@ -94,7 +99,10 @@ pub fn encode_and_write_metadata(
     let need_metadata_file = tcx.sess.opts.output_types.contains_key(&OutputType::Metadata);
     let (metadata_filename, metadata_tmpdir) = if need_metadata_file {
         if let Err(e) = non_durable_rename(&metadata_filename, &out_filename) {
-            tcx.sess.fatal(&format!("failed to write {}: {}", out_filename.display(), e));
+            tcx.sess.emit_fatal(FailedWriteError {
+                filename: out_filename.display().to_string(),
+                err: e.to_string(),
+            });
         }
         if tcx.sess.opts.json_artifact_notifications {
             tcx.sess
@@ -110,7 +118,7 @@ pub fn encode_and_write_metadata(
     // Load metadata back to memory: codegen may need to include it in object files.
     let metadata =
         EncodedMetadata::from_path(metadata_filename, metadata_tmpdir).unwrap_or_else(|e| {
-            tcx.sess.fatal(&format!("failed to create encoded metadata from file: {}", e))
+            tcx.sess.emit_fatal(FailedCreateEncodedMetadata { err: e.to_string() });
         });
 
     let need_metadata_module = metadata_kind == MetadataKind::Compressed;