---

yaml
---
r: 148849
b: refs/heads/try2
c: 5e8ba72
h: refs/heads/master
i:
  148847: 9941993
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: b211b00d21fc7c03c3c378ad5eab60666a00fc08
+refs/heads/try2: 5e8ba7252a162fc6a3c5186904947f5969d732af
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/back/archive.rs

@@ -17,6 +17,7 @@ use lib::llvm::{ArchiveRef, llvm};
 
 use std::cast;
 use std::io::fs;
+use std::io;
 use std::libc;
 use std::os;
 use std::run::{ProcessOptions, Process, ProcessOutput};
@@ -50,9 +51,8 @@ fn run_ar(sess: Session, args: &str, cwd: Option<&Path>,
         Some(p) => { debug!("inside {}", p.display()); }
         None => {}
     }
-    let mut opt_prog = Process::new(ar, args.as_slice(), opts);
-    match opt_prog {
-        Some(ref mut prog) => {
+    match Process::new(ar, args.as_slice(), opts) {
+        Ok(mut prog) => {
             let o = prog.finish_with_output();
             if !o.status.success() {
                 sess.err(format!("{} {} failed with: {}", ar, args.connect(" "),
@@ -63,8 +63,8 @@ fn run_ar(sess: Session, args: &str, cwd: Option<&Path>,
             }
             o
         },
-        None => {
-            sess.err(format!("could not exec `{}`", ar));
+        Err(e) => {
+            sess.err(format!("could not exec `{}`: {}", ar, e));
             sess.abort_if_errors();
             fail!("rustc::back::archive::run_ar() should not reach this point");
         }
@@ -94,32 +94,33 @@ impl Archive {
             let archive = os::make_absolute(&self.dst);
             run_ar(self.sess, "x", Some(loc.path()), [&archive,
                                                       &Path::new(file)]);
-            fs::File::open(&loc.path().join(file)).read_to_end()
+            fs::File::open(&loc.path().join(file)).read_to_end().unwrap()
         } else {
             run_ar(self.sess, "p", None, [&self.dst, &Path::new(file)]).output
         }
     }
 
     /// Adds all of the contents of a native library to this archive. This will
     /// search in the relevant locations for a library named `name`.
-    pub fn add_native_library(&mut self, name: &str) {
+    pub fn add_native_library(&mut self, name: &str) -> io::IoResult<()> {
         let location = self.find_library(name);
-        self.add_archive(&location, name, []);
+        self.add_archive(&location, name, [])
     }
 
     /// Adds all of the contents of the rlib at the specified path to this
     /// archive.
     ///
     /// This ignores adding the bytecode from the rlib, and if LTO is enabled
     /// then the object file also isn't added.
-    pub fn add_rlib(&mut self, rlib: &Path, name: &str, lto: bool) {
+    pub fn add_rlib(&mut self, rlib: &Path, name: &str,
+                    lto: bool) -> io::IoResult<()> {
         let object = format!("{}.o", name);
         let bytecode = format!("{}.bc", name);
         let mut ignore = ~[METADATA_FILENAME, bytecode.as_slice()];
         if lto {
             ignore.push(object.as_slice());
         }
-        self.add_archive(rlib, name, ignore);
+        self.add_archive(rlib, name, ignore)
     }
 
     /// Adds an arbitrary file to this archive
@@ -144,7 +145,8 @@ impl Archive {
         str::from_utf8(output.output).unwrap().lines().map(|s| s.to_owned()).collect()
     }
 
-    fn add_archive(&mut self, archive: &Path, name: &str, skip: &[&str]) {
+    fn add_archive(&mut self, archive: &Path, name: &str,
+                   skip: &[&str]) -> io::IoResult<()> {
         let loc = TempDir::new("rsar").unwrap();
 
         // First, extract the contents of the archive to a temporary directory
@@ -159,7 +161,7 @@ impl Archive {
         // We skip any files explicitly desired for skipping, and we also skip
         // all SYMDEF files as these are just magical placeholders which get
         // re-created when we make a new archive anyway.
-        let files = fs::readdir(loc.path());
+        let files = if_ok!(fs::readdir(loc.path()));
         let mut inputs = ~[];
         for file in files.iter() {
             let filename = file.filename_str().unwrap();
@@ -168,14 +170,15 @@ impl Archive {
 
             let filename = format!("r-{}-{}", name, filename);
             let new_filename = file.with_filename(filename);
-            fs::rename(file, &new_filename);
+            if_ok!(fs::rename(file, &new_filename));
             inputs.push(new_filename);
         }
 
         // Finally, add all the renamed files to this archive
         let mut args = ~[&self.dst];
         args.extend(&mut inputs.iter());
         run_ar(self.sess, "r", None, args.as_slice());
+        Ok(())
     }
 
     fn find_library(&self, name: &str) -> Path {

branches/try2/src/librustc/back/link.rs

@@ -100,7 +100,6 @@ pub mod write {
     use util::common::time;
 
     use std::c_str::ToCStr;
-    use std::io;
     use std::libc::{c_uint, c_int};
     use std::path::Path;
     use std::run;
@@ -297,21 +296,17 @@ pub mod write {
             assembly.as_str().unwrap().to_owned()];
 
         debug!("{} '{}'", cc, args.connect("' '"));
-        let opt_prog = {
-            let _guard = io::ignore_io_error();
-            run::process_output(cc, args)
-        };
-        match opt_prog {
-            Some(prog) => {
+        match run::process_output(cc, args) {
+            Ok(prog) => {
                 if !prog.status.success() {
                     sess.err(format!("linking with `{}` failed: {}", cc, prog.status));
                     sess.note(format!("{} arguments: '{}'", cc, args.connect("' '")));
                     sess.note(str::from_utf8_owned(prog.error + prog.output).unwrap());
                     sess.abort_if_errors();
                 }
             },
-            None => {
-                sess.err(format!("could not exec the linker `{}`", cc));
+            Err(e) => {
+                sess.err(format!("could not exec the linker `{}`: {}", cc, e));
                 sess.abort_if_errors();
             }
         }
@@ -768,6 +763,15 @@ fn get_system_tool(sess: Session, tool: &str) -> ~str {
     }
 }
 
+fn remove(sess: Session, path: &Path) {
+    match fs::unlink(path) {
+        Ok(..) => {}
+        Err(e) => {
+            sess.err(format!("failed to remove {}: {}", path.display(), e));
+        }
+    }
+}
+
 /// Perform the linkage portion of the compilation phase. This will generate all
 /// of the requested outputs for this compilation session.
 pub fn link_binary(sess: Session,
@@ -785,17 +789,15 @@ pub fn link_binary(sess: Session,
 
     // Remove the temporary object file and metadata if we aren't saving temps
     if !sess.opts.save_temps {
-        fs::unlink(obj_filename);
-        fs::unlink(&obj_filename.with_extension("metadata.o"));
+        remove(sess, obj_filename);
+        remove(sess, &obj_filename.with_extension("metadata.o"));
     }
 
     out_filenames
 }
 
 fn is_writeable(p: &Path) -> bool {
-    use std::io;
-
-    match io::result(|| p.stat()) {
+    match p.stat() {
         Err(..) => true,
         Ok(m) => m.perm & io::UserWrite == io::UserWrite
     }
@@ -884,7 +886,7 @@ fn link_rlib(sess: Session,
     for &(ref l, kind) in used_libraries.get().iter() {
         match kind {
             cstore::NativeStatic => {
-                a.add_native_library(l.as_slice());
+                a.add_native_library(l.as_slice()).unwrap();
             }
             cstore::NativeFramework | cstore::NativeUnknown => {}
         }
@@ -919,16 +921,23 @@ fn link_rlib(sess: Session,
             // the same filename for metadata (stomping over one another)
             let tmpdir = TempDir::new("rustc").expect("needs a temp dir");
             let metadata = tmpdir.path().join(METADATA_FILENAME);
-            fs::File::create(&metadata).write(trans.metadata);
+            match fs::File::create(&metadata).write(trans.metadata) {
+                Ok(..) => {}
+                Err(e) => {
+                    sess.err(format!("failed to write {}: {}",
+                                     metadata.display(), e));
+                    sess.abort_if_errors();
+                }
+            }
             a.add_file(&metadata, false);
-            fs::unlink(&metadata);
+            remove(sess, &metadata);
 
             // For LTO purposes, the bytecode of this library is also inserted
             // into the archive.
             let bc = obj_filename.with_extension("bc");
             a.add_file(&bc, false);
             if !sess.opts.save_temps {
-                fs::unlink(&bc);
+                remove(sess, &bc);
             }
 
             // After adding all files to the archive, we need to update the
@@ -959,7 +968,7 @@ fn link_rlib(sess: Session,
 // metadata file).
 fn link_staticlib(sess: Session, obj_filename: &Path, out_filename: &Path) {
     let mut a = link_rlib(sess, None, obj_filename, out_filename);
-    a.add_native_library("morestack");
+    a.add_native_library("morestack").unwrap();
 
     let crates = sess.cstore.get_used_crates(cstore::RequireStatic);
     for &(cnum, ref path) in crates.iter() {
@@ -970,7 +979,7 @@ fn link_staticlib(sess: Session, obj_filename: &Path, out_filename: &Path) {
                 continue
             }
         };
-        a.add_rlib(&p, name, sess.lto());
+        a.add_rlib(&p, name, sess.lto()).unwrap();
         let native_libs = csearch::get_native_libraries(sess.cstore, cnum);
         for &(kind, ref lib) in native_libs.iter() {
             let name = match kind {
@@ -1004,23 +1013,19 @@ fn link_natively(sess: Session, dylib: bool, obj_filename: &Path,
 
     // Invoke the system linker
     debug!("{} {}", cc_prog, cc_args.connect(" "));
-    let opt_prog = {
-        let _guard = io::ignore_io_error();
-        time(sess.time_passes(), "running linker", (), |()|
-             run::process_output(cc_prog, cc_args))
-    };
-
-    match opt_prog {
-        Some(prog) => {
+    let prog = time(sess.time_passes(), "running linker", (), |()|
+                    run::process_output(cc_prog, cc_args));
+    match prog {
+        Ok(prog) => {
             if !prog.status.success() {
                 sess.err(format!("linking with `{}` failed: {}", cc_prog, prog.status));
                 sess.note(format!("{} arguments: '{}'", cc_prog, cc_args.connect("' '")));
                 sess.note(str::from_utf8_owned(prog.error + prog.output).unwrap());
                 sess.abort_if_errors();
             }
         },
-        None => {
-            sess.err(format!("could not exec the linker `{}`", cc_prog));
+        Err(e) => {
+            sess.err(format!("could not exec the linker `{}`: {}", cc_prog, e));
             sess.abort_if_errors();
         }
     }
@@ -1030,8 +1035,14 @@ fn link_natively(sess: Session, dylib: bool, obj_filename: &Path,
     // the symbols
     if sess.targ_cfg.os == abi::OsMacos && sess.opts.debuginfo {
         // FIXME (#9639): This needs to handle non-utf8 paths
-        run::process_status("dsymutil",
-                            [out_filename.as_str().unwrap().to_owned()]);
+        match run::process_status("dsymutil",
+                                  [out_filename.as_str().unwrap().to_owned()]) {
+            Ok(..) => {}
+            Err(e) => {
+                sess.err(format!("failed to run dsymutil: {}", e));
+                sess.abort_if_errors();
+            }
+        }
     }
 }
 
@@ -1225,7 +1236,16 @@ fn add_upstream_rust_crates(args: &mut ~[~str], sess: Session,
                     time(sess.time_passes(), format!("altering {}.rlib", name),
                          (), |()| {
                         let dst = tmpdir.join(cratepath.filename().unwrap());
-                        fs::copy(&cratepath, &dst);
+                        match fs::copy(&cratepath, &dst) {
+                            Ok(..) => {}
+                            Err(e) => {
+                                sess.err(format!("failed to copy {} to {}: {}",
+                                                 cratepath.display(),
+                                                 dst.display(),
+                                                 e));
+                                sess.abort_if_errors();
+                            }
+                        }
                         let dst_str = dst.as_str().unwrap().to_owned();
                         let mut archive = Archive::open(sess, dst);
                         archive.remove_file(format!("{}.o", name));