std: Remove io::io_error

* All I/O now returns IoResult<T> = Result<T, IoError>
* All formatting traits now return fmt::Result = IoResult<()>
* The if_ok!() macro was added to libstd

4 files changed, 18 insertions, 24 deletions

diff --git a/src/libstd/rt/rtio.rs b/src/libstd/rt/rtio.rs
index 455a84b4ce3..35b1e21df06 100644
--- a/src/libstd/rt/rtio.rs
+++ b/src/libstd/rt/rtio.rs
@@ -16,13 +16,13 @@ use libc;
 use ops::Drop;
 use option::{Option, Some, None};
 use path::Path;
-use result::{Result, Ok, Err};
+use result::{Result, Err};
 use rt::task::Task;
 use rt::local::Local;
 
 use ai = io::net::addrinfo;
 use io;
-use io::IoError;
+use io::{IoError, IoResult};
 use io::net::ip::{IpAddr, SocketAddr};
 use io::process::{ProcessConfig, ProcessExit};
 use io::signal::Signum;
@@ -116,23 +116,12 @@ impl<'a> LocalIo<'a> {
         return ret;
     }
 
-    pub fn maybe_raise<T>(f: |io: &mut IoFactory| -> Result<T, IoError>)
-        -> Option<T>
+    pub fn maybe_raise<T>(f: |io: &mut IoFactory| -> IoResult<T>)
+        -> IoResult<T>
     {
         match LocalIo::borrow() {
-            None => {
-                io::io_error::cond.raise(io::standard_error(io::IoUnavailable));
-                None
-            }
-            Some(mut io) => {
-                match f(io.get()) {
-                    Ok(t) => Some(t),
-                    Err(ioerr) => {
-                        io::io_error::cond.raise(ioerr);
-                        None
-                    }
-                }
-            }
+            None => Err(io::standard_error(io::IoUnavailable)),
+            Some(mut io) => f(io.get()),
         }
     }
 
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index 7c43e64f17b..515eb93001a 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -119,6 +119,7 @@ impl Task {
 
             // Run the task main function, then do some cleanup.
             f.finally(|| {
+                #[allow(unused_must_use)]
                 fn close_outputs() {
                     let mut task = Local::borrow(None::<Task>);
                     let logger = task.get().logger.take();
@@ -126,8 +127,8 @@ impl Task {
                     let stdout = task.get().stdout.take();
                     drop(task);
                     drop(logger); // loggers are responsible for flushing
-                    match stdout { Some(mut w) => w.flush(), None => {} }
-                    match stderr { Some(mut w) => w.flush(), None => {} }
+                    match stdout { Some(mut w) => { w.flush(); }, None => {} }
+                    match stderr { Some(mut w) => { w.flush(); }, None => {} }
                 }
 
                 // First, flush/destroy the user stdout/logger because these
diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index 4d2dcb6c51c..9aece13b84c 100644
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -464,9 +464,10 @@ fn begin_unwind_inner(msg: ~Any, file: &'static str, line: uint) -> ! {
             match task.stderr.take() {
                 Some(mut stderr) => {
                     Local::put(task);
-                    format_args!(|args| ::fmt::writeln(stderr, args),
-                                 "task '{}' failed at '{}', {}:{}",
-                                 n, msg_s, file, line);
+                    // FIXME: what to do when the task printing fails?
+                    let _err = format_args!(|args| ::fmt::writeln(stderr, args),
+                                            "task '{}' failed at '{}', {}:{}",
+                                            n, msg_s, file, line);
                     task = Local::take();
 
                     match util::replace(&mut task.stderr, Some(stderr)) {
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index 9c17c624987..69e240f30bc 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -11,10 +11,12 @@
 use container::Container;
 use fmt;
 use from_str::FromStr;
+use io::IoResult;
 use iter::Iterator;
 use libc;
 use option::{Some, None, Option};
 use os;
+use result::Ok;
 use str::StrSlice;
 use unstable::running_on_valgrind;
 use vec::ImmutableVector;
@@ -73,16 +75,17 @@ pub fn dumb_println(args: &fmt::Arguments) {
 
     struct Stderr;
     impl io::Writer for Stderr {
-        fn write(&mut self, data: &[u8]) {
+        fn write(&mut self, data: &[u8]) -> IoResult<()> {
             unsafe {
                 libc::write(libc::STDERR_FILENO,
                             data.as_ptr() as *libc::c_void,
                             data.len() as libc::size_t);
             }
+            Ok(()) // yes, we're lying
         }
     }
     let mut w = Stderr;
-    fmt::writeln(&mut w as &mut io::Writer, args);
+    let _ = fmt::writeln(&mut w as &mut io::Writer, args);
 }
 
 pub fn abort(msg: &str) -> ! {