Don't panic on io errors

Fixes #920

src/archive.rs

@@ -149,6 +149,8 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
             Gnu(ar::GnuBuilder<File>),
         }
 
+        let sess = self.config.sess;
+
         let mut symbol_table = BTreeMap::new();
 
         let mut entries = Vec::new();
@@ -169,10 +171,11 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
                     let mut data = Vec::new();
                     entry.read_to_end(&mut data).unwrap();
                     data
-
                 }
                 ArchiveEntry::File(file) => {
-                    std::fs::read(file).unwrap()
+                    std::fs::read(file).unwrap_or_else(|err| {
+                        sess.fatal(&format!("error while reading object file during archive building: {}", err));
+                    })
                 }
             };
 
@@ -192,7 +195,7 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
                         if err == "Unknown file magic" {
                             // Not an object file; skip it.
                         } else {
-                            self.config.sess.fatal(&format!("Error parsing `{}` during archive creation: {}", entry_name, err));
+                            sess.fatal(&format!("error parsing `{}` during archive creation: {}", entry_name, err));
                         }
                     }
                 }
@@ -203,7 +206,9 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
 
         let mut builder = if self.config.use_gnu_style_archive {
             BuilderKind::Gnu(ar::GnuBuilder::new(
-                File::create(&self.config.dst).unwrap(),
+                File::create(&self.config.dst).unwrap_or_else(|err| {
+                    sess.fatal(&format!("error opening destination during archive building: {}", err));
+                }),
                 entries
                     .iter()
                     .map(|(name, _)| name.as_bytes().to_vec())
@@ -213,7 +218,9 @@ impl<'a> ArchiveBuilder<'a> for ArArchiveBuilder<'a> {
             ).unwrap())
         } else {
             BuilderKind::Bsd(ar::Builder::new(
-                File::create(&self.config.dst).unwrap(),
+                File::create(&self.config.dst).unwrap_or_else(|err| {
+                    sess.fatal(&format!("error opening destination during archive building: {}", err));
+                }),
                 symbol_table,
             ).unwrap())
         };
@@ -260,8 +267,10 @@ impl<'a> ArArchiveBuilder<'a> {
 
         let mut i = 0;
         while let Some(entry) = archive.next_entry() {
-            let entry = entry.unwrap();
-            let file_name = String::from_utf8(entry.header().identifier().to_vec()).unwrap();
+            let entry = entry?;
+            let file_name = String::from_utf8(entry.header().identifier().to_vec()).map_err(|err| {
+                std::io::Error::new(std::io::ErrorKind::InvalidData, err)
+            })?;
             if !skip(&file_name) {
                 self.entries.push((
                     file_name,

src/driver/aot.rs

@@ -54,7 +54,9 @@ fn emit_module<B: Backend>(
         .output_filenames(LOCAL_CRATE)
         .temp_path(OutputType::Object, Some(&name));
     let obj = product.emit();
-    std::fs::write(&tmp_file, obj).unwrap();
+    if let Err(err) = std::fs::write(&tmp_file, obj) {
+        tcx.sess.fatal(&format!("error writing object file: {}", err));
+    }
 
     let work_product = if std::env::var("CG_CLIF_INCR_CACHE_DISABLED").is_ok() {
         None
@@ -254,7 +256,9 @@ pub(super) fn run_aot(
                 crate::metadata::write_metadata(tcx, object);
             });
 
-            std::fs::write(&tmp_file, obj).unwrap();
+            if let Err(err) = std::fs::write(&tmp_file, obj) {
+                tcx.sess.fatal(&format!("error writing metadata object file: {}", err));
+            }
 
             (metadata_cgu_name, tmp_file)
         });

src/lib.rs

@@ -1,4 +1,4 @@
-#![feature(rustc_private, decl_macro, type_alias_impl_trait, associated_type_bounds, never_type)]
+#![feature(rustc_private, decl_macro, type_alias_impl_trait, associated_type_bounds, never_type, try_blocks)]
 #![warn(rust_2018_idioms)]
 #![warn(unused_lifetimes)]
 

src/pretty_clif.rs

@@ -243,19 +243,18 @@ pub(crate) fn write_clif_file<'tcx>(
     )
     .unwrap();
 
-    match ::std::fs::File::create(clif_file_name) {
-        Ok(mut file) => {
-            let target_triple = crate::target_triple(tcx.sess);
-            writeln!(file, "test compile").unwrap();
-            writeln!(file, "set is_pic").unwrap();
-            writeln!(file, "set enable_simd").unwrap();
-            writeln!(file, "target {} haswell", target_triple).unwrap();
-            writeln!(file, "").unwrap();
-            file.write(clif.as_bytes()).unwrap();
-        }
-        Err(e) => {
-            tcx.sess.warn(&format!("err opening clif file: {:?}", e));
-        }
+    let res: std::io::Result<()> = try {
+        let mut file = std::fs::File::create(clif_file_name)?;
+        let target_triple = crate::target_triple(tcx.sess);
+        writeln!(file, "test compile")?;
+        writeln!(file, "set is_pic")?;
+        writeln!(file, "set enable_simd")?;
+        writeln!(file, "target {} haswell", target_triple)?;
+        writeln!(file, "")?;
+        file.write(clif.as_bytes())?;
+    };
+    if let Err(err) = res {
+        tcx.sess.warn(&format!("err writing clif file: {}", err));
     }
 }