Mass rename if_ok! to try!

This "bubble up an error" macro was originally named if_ok! in order to get it
landed, but after the fact it was discovered that this name is not exactly
desirable.

The name `if_ok!` isn't immediately clear that is has much to do with error
handling, and it doesn't look fantastic in all contexts (if if_ok!(...) {}). In
general, the agreed opinion about `if_ok!` is that is came in as subpar.

The name `try!` is more invocative of error handling, it's shorter by 2 letters,
and it looks fitting in almost all circumstances. One concern about the word
`try!` is that it's too invocative of exceptions, but the belief is that this
will be overcome with documentation and examples.

Close #12037

5 files changed, 27 insertions, 27 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 227f3a0a083..df2a800c292 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -88,7 +88,7 @@ impl<R: Reader> BufferedReader<R> {
 impl<R: Reader> Buffer for BufferedReader<R> {
     fn fill<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos == self.cap {
-            self.cap = if_ok!(self.inner.read(self.buf));
+            self.cap = try!(self.inner.read(self.buf));
             self.pos = 0;
         }
         Ok(self.buf.slice(self.pos, self.cap))
@@ -103,7 +103,7 @@ impl<R: Reader> Buffer for BufferedReader<R> {
 impl<R: Reader> Reader for BufferedReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
         let nread = {
-            let available = if_ok!(self.fill());
+            let available = try!(self.fill());
             let nread = cmp::min(available.len(), buf.len());
             vec::bytes::copy_memory(buf, available.slice_to(nread));
             nread
@@ -182,7 +182,7 @@ impl<W: Writer> BufferedWriter<W> {
 impl<W: Writer> Writer for BufferedWriter<W> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         if self.pos + buf.len() > self.buf.len() {
-            if_ok!(self.flush_buf());
+            try!(self.flush_buf());
         }
 
         if buf.len() > self.buf.len() {
@@ -233,9 +233,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         match buf.iter().rposition(|&b| b == '\n' as u8) {
             Some(i) => {
-                if_ok!(self.inner.write(buf.slice_to(i + 1)));
-                if_ok!(self.inner.flush());
-                if_ok!(self.inner.write(buf.slice_from(i + 1)));
+                try!(self.inner.write(buf.slice_to(i + 1)));
+                try!(self.inner.flush());
+                try!(self.inner.write(buf.slice_from(i + 1)));
                 Ok(())
             }
             None => self.inner.write(buf),
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index cd6c6763f66..7f2af92b078 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -339,8 +339,8 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
         })
     }
 
-    let mut reader = if_ok!(File::open(from));
-    let mut writer = if_ok!(File::create(to));
+    let mut reader = try!(File::open(from));
+    let mut writer = try!(File::create(to));
     let mut buf = [0, ..io::DEFAULT_BUF_SIZE];
 
     loop {
@@ -349,10 +349,10 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => { break }
             Err(e) => return Err(e)
         };
-        if_ok!(writer.write(buf.slice_to(amt)));
+        try!(writer.write(buf.slice_to(amt)));
     }
 
-    chmod(to, if_ok!(from.stat()).perm)
+    chmod(to, try!(from.stat()).perm)
 }
 
 /// Changes the permission mode bits found on a file or a directory. This
@@ -460,10 +460,10 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
 /// // one possible implementation of fs::walk_dir only visiting files
 /// fn visit_dirs(dir: &Path, cb: |&Path|) -> io::IoResult<()> {
 ///     if dir.is_dir() {
-///         let contents = if_ok!(fs::readdir(dir));
+///         let contents = try!(fs::readdir(dir));
 ///         for entry in contents.iter() {
 ///             if entry.is_dir() {
-///                 if_ok!(visit_dirs(entry, |p| cb(p)));
+///                 try!(visit_dirs(entry, |p| cb(p)));
 ///             } else {
 ///                 cb(entry);
 ///             }
@@ -490,7 +490,7 @@ pub fn readdir(path: &Path) -> IoResult<~[Path]> {
 /// rooted at `path`. The path given will not be iterated over, and this will
 /// perform iteration in a top-down order.
 pub fn walk_dir(path: &Path) -> IoResult<Directories> {
-    Ok(Directories { stack: if_ok!(readdir(path)) })
+    Ok(Directories { stack: try!(readdir(path)) })
 }
 
 /// An iterator which walks over a directory
@@ -529,7 +529,7 @@ pub fn mkdir_recursive(path: &Path, mode: FilePermission) -> IoResult<()> {
         return Ok(())
     }
     if path.filename().is_some() {
-        if_ok!(mkdir_recursive(&path.dir_path(), mode));
+        try!(mkdir_recursive(&path.dir_path(), mode));
     }
     mkdir(path, mode)
 }
@@ -542,12 +542,12 @@ pub fn mkdir_recursive(path: &Path, mode: FilePermission) -> IoResult<()> {
 /// This function will return an `Err` value if an error happens. See
 /// `file::unlink` and `fs::readdir` for possible error conditions.
 pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
-    let children = if_ok!(readdir(path));
+    let children = try!(readdir(path));
     for child in children.iter() {
         if child.is_dir() {
-            if_ok!(rmdir_recursive(child));
+            try!(rmdir_recursive(child));
         } else {
-            if_ok!(unlink(child));
+            try!(unlink(child));
         }
     }
     // Directory should now be empty
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index ff61ef15fa5..49c37b4520f 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -113,7 +113,7 @@ impl Writer for MemWriter {
 impl Seek for MemWriter {
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
-        let new = if_ok!(combine(style, self.pos, self.buf.len(), pos));
+        let new = try!(combine(style, self.pos, self.buf.len(), pos));
         self.pos = new as uint;
         Ok(())
     }
@@ -183,7 +183,7 @@ impl Reader for MemReader {
 impl Seek for MemReader {
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
-        let new = if_ok!(combine(style, self.pos, self.buf.len(), pos));
+        let new = try!(combine(style, self.pos, self.buf.len(), pos));
         self.pos = new as uint;
         Ok(())
     }
@@ -253,7 +253,7 @@ impl<'a> Writer for BufWriter<'a> {
 impl<'a> Seek for BufWriter<'a> {
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
-        let new = if_ok!(combine(style, self.pos, self.buf.len(), pos));
+        let new = try!(combine(style, self.pos, self.buf.len(), pos));
         self.pos = new as uint;
         Ok(())
     }
@@ -313,7 +313,7 @@ impl<'a> Reader for BufReader<'a> {
 impl<'a> Seek for BufReader<'a> {
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
-        let new = if_ok!(combine(style, self.pos, self.buf.len(), pos));
+        let new = try!(combine(style, self.pos, self.buf.len(), pos));
         self.pos = new as uint;
         Ok(())
     }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 2eadf9a7f4f..db5ee09fa14 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -365,7 +365,7 @@ pub struct IoError {
 
 impl fmt::Show for IoError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        if_ok!(fmt.buf.write_str(self.desc));
+        try!(fmt.buf.write_str(self.desc));
         match self.detail {
             Some(ref s) => write!(fmt.buf, " ({})", *s),
             None => Ok(())
@@ -581,7 +581,7 @@ pub trait Reader {
         let mut pos = 0;
         let mut i = nbytes;
         while i > 0 {
-            val += (if_ok!(self.read_u8()) as u64) << pos;
+            val += (try!(self.read_u8()) as u64) << pos;
             pos += 8;
             i -= 1;
         }
@@ -605,7 +605,7 @@ pub trait Reader {
         let mut i = nbytes;
         while i > 0 {
             i -= 1;
-            val += (if_ok!(self.read_u8()) as u64) << i * 8;
+            val += (try!(self.read_u8()) as u64) << i * 8;
         }
         Ok(val)
     }
@@ -1191,7 +1191,7 @@ pub trait Buffer: Reader {
     /// This function will also return error if the stream does not contain a
     /// valid utf-8 encoded codepoint as the next few bytes in the stream.
     fn read_char(&mut self) -> IoResult<char> {
-        let first_byte = if_ok!(self.read_byte());
+        let first_byte = try!(self.read_byte());
         let width = str::utf8_char_width(first_byte);
         if width == 1 { return Ok(first_byte as char) }
         if width == 0 { return Err(standard_error(InvalidInput)) } // not utf8
@@ -1199,7 +1199,7 @@ pub trait Buffer: Reader {
         {
             let mut start = 1;
             while start < width {
-                match if_ok!(self.read(buf.mut_slice(start, width))) {
+                match try!(self.read(buf.mut_slice(start, width))) {
                     n if n == width - start => break,
                     n if n < width - start => { start += n; }
                     _ => return Err(standard_error(InvalidInput)),
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 79ae9faf629..acaffd00665 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -189,7 +189,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
         };
-        if_ok!(w.write(buf.slice_to(len)));
+        try!(w.write(buf.slice_to(len)));
     }
 }