implement error handling for codegen()

it no longer returns Result, so instead of unwrapping, I implemented
errors

Author: karolzwolak

crates/rustc_codegen_c/messages.ftl

@@ -0,0 +1,5 @@
+codegen_c_cc_spawn_err = Failed to spawn C compiler : {$err}
+
+codegen_c_cc_err = C compiler returned an error. stderr : `{$cc_stderr}`; stdout : `{$cc_stdout}`
+
+codegen_c_c_file_write_err = Failed to write C source file : {$err}

crates/rustc_codegen_c/src/errors.rs

@@ -0,0 +1,20 @@
+use rustc_macros::Diagnostic;
+
+#[derive(Diagnostic)]
+#[diag(codegen_c_c_file_write_err)]
+pub(crate) struct CFileWriteError {
+    pub err: std::io::Error,
+}
+
+#[derive(Diagnostic)]
+#[diag(codegen_c_cc_spawn_err)]
+pub(crate) struct CCompilerSpawnError {
+    pub err: std::io::Error,
+}
+
+#[derive(Diagnostic)]
+#[diag(codegen_c_cc_err)]
+pub(crate) struct CCompilerError {
+    pub cc_stderr: String,
+    pub cc_stdout: String,
+}

crates/rustc_codegen_c/src/lib.rs

@@ -10,6 +10,7 @@ extern crate rustc_errors;
 extern crate rustc_fluent_macro;
 extern crate rustc_hash;
 extern crate rustc_hir;
+extern crate rustc_macros;
 extern crate rustc_metadata;
 extern crate rustc_middle;
 extern crate rustc_session;
@@ -44,6 +45,7 @@ mod archive;
 mod base;
 mod builder;
 mod context;
+mod errors;
 mod write;
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
@@ -149,7 +151,6 @@ impl WriteBackendMethods for CCodegen {
 
     fn run_thin_lto(
         _cgcx: &CodegenContext<Self>,
-        // FIXME(bjorn3): Limit LTO exports to these symbols
         _exported_symbols_for_lto: &[String],
         _each_linked_rlib_for_lto: &[PathBuf],
         _modules: Vec<(String, Self::ThinBuffer)>,

crates/rustc_codegen_c/src/write.rs

@@ -1,5 +1,6 @@
 use std::fs;
-use std::io::Write;
+use std::io::{self, Write};
+use std::path::PathBuf;
 use std::process::{Command, Stdio};
 
 use rustc_codegen_ssa::back::write::{CodegenContext, ModuleConfig};
@@ -8,11 +9,33 @@ use rustc_errors::{DiagCtxtHandle, FatalError};
 use rustc_session::config::OutputType;
 use tracing::error;
 
+fn write_module(c_out: &PathBuf, module: &ModuleCodegen<String>) -> io::Result<()> {
+    let mut c_out_file = fs::File::create(c_out)?;
+    writeln!(c_out_file, "// file: {}.c", module.name)?;
+    write!(c_out_file, "{}", module.module_llvm)?;
+    Ok(())
+}
+fn compiled_module(
+    success: bool,
+    module: ModuleCodegen<String>,
+    cgcx: &CodegenContext<crate::CCodegen>,
+) -> CompiledModule {
+    module.into_compiled_module(
+        success,
+        false,
+        false,
+        false,
+        false,
+        &cgcx.output_filenames,
+        cgcx.invocation_temp.as_deref(),
+    )
+}
+
 pub(crate) fn codegen(
     cgcx: &CodegenContext<crate::CCodegen>,
     module: ModuleCodegen<String>,
     _config: &ModuleConfig,
-) -> Result<CompiledModule, FatalError> {
+) -> CompiledModule {
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
     let obj_out = cgcx.output_filenames.temp_path_for_cgu(
@@ -23,44 +46,41 @@ pub(crate) fn codegen(
     let c_out = obj_out.with_extension("c");
 
     // output c source code
-    let c_out_file = fs::File::create(&c_out).map_err(|_| FatalError)?;
-    writeln!(&c_out_file, "// file: {}.c", module.name).map_err(|_| FatalError)?;
-    write!(&c_out_file, "{}", module.module_llvm).map_err(|_| FatalError)?;
+    if let Err(c_out_err) = write_module(&c_out, &module) {
+        dcx.emit_err(crate::errors::CFileWriteError { err: c_out_err });
+        return compiled_module(false, module, cgcx);
+    }
 
     // invoke cc to compile
     // FIXME: configure cc
     // FIXME: handle long command line (windows)
     // FIXME: flush_linked_file (windows)
     let mut cmd = Command::new("clang");
     cmd.arg(&c_out).arg("-o").arg(&obj_out).arg("-c");
-    let output = match cmd
+    let success = match cmd
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .spawn()
         .and_then(|child| child.wait_with_output())
     {
-        Ok(output) => output,
+        Ok(output) if !output.status.success() => {
+            error!("compiler stderr:\n{}", String::from_utf8_lossy(&output.stderr));
+            error!("compiler stdout:\n{}", String::from_utf8_lossy(&output.stdout));
+            dcx.emit_err(crate::errors::CCompilerError {
+                cc_stderr: String::from_utf8_lossy(&output.stderr).to_string(),
+                cc_stdout: String::from_utf8_lossy(&output.stdout).to_string(),
+            });
+            false
+        }
+        Ok(_) => true,
         Err(e) => {
             error!("failed to spawn C compiler: {}", e);
-            return Err(FatalError);
+            dcx.emit_err(crate::errors::CCompilerSpawnError { err: e });
+            false
         }
     };
 
-    if !output.status.success() {
-        error!("compiler stderr:\n{}", String::from_utf8_lossy(&output.stderr));
-        error!("compiler stdout:\n{}", String::from_utf8_lossy(&output.stdout));
-        return Err(FatalError);
-    }
-
-    Ok(module.into_compiled_module(
-        true,
-        false,
-        false,
-        false,
-        false,
-        &cgcx.output_filenames,
-        cgcx.invocation_temp.as_deref(),
-    ))
+    compiled_module(success, module, cgcx)
 }
 
 pub(crate) fn link(