Convert all try!() to ?

src/chmod/chmod.rs

@@ -196,7 +196,7 @@ impl Chmoder {
             }
         };
         match self.fmode {
-            Some(mode) => try!(self.change_file(fperm, mode, file, name)),
+            Some(mode) => self.change_file(fperm, mode, file, name)?,
             None => {
                 let cmode_unwrapped = self.cmode.clone().unwrap();
                 for mode in cmode_unwrapped.split(',') {
@@ -209,7 +209,7 @@ impl Chmoder {
                     };
                     match result {
                         Ok(mode) => {
-                            try!(self.change_file(fperm, mode, file, name));
+                            self.change_file(fperm, mode, file, name)?;
                             fperm = mode;
                         }
                         Err(f) => {

src/cksum/cksum.rs

@@ -58,7 +58,7 @@ fn cksum(fname: &str) -> io::Result<(u32, usize)> {
     let mut rd: Box<Read> = match fname {
         "-" => Box::new(stdin()),
         _ => {
-            file = try!(File::open(&Path::new(fname)));
+            file = File::open(&Path::new(fname))?;
             Box::new(BufReader::new(file))
         }
     };

src/comm/comm.rs

@@ -117,7 +117,7 @@ fn open_file(name: &str) -> io::Result<LineReader> {
     match name {
         "-" => Ok(LineReader::Stdin(stdin())),
         _ => {
-            let f = try!(File::open(&Path::new(name)));
+            let f = File::open(&Path::new(name))?;
             Ok(LineReader::FileIn(BufReader::new(f)))
         }
     }

src/cp/cp.rs

@@ -1179,8 +1179,8 @@ pub fn localize_to_target(root: &Path, source: &Path, target: &Path) -> CopyResu
 
 pub fn paths_refer_to_same_file(p1: &Path, p2: &Path) -> io::Result<bool> {
     // We have to take symlinks and relative paths into account.
-    let pathbuf1 = try!(canonicalize(p1, CanonicalizeMode::Normal));
+    let pathbuf1 = canonicalize(p1, CanonicalizeMode::Normal)?;
-    let pathbuf2 = try!(canonicalize(p2, CanonicalizeMode::Normal));
+    let pathbuf2 = canonicalize(p2, CanonicalizeMode::Normal)?;
 
     Ok(pathbuf1 == pathbuf2)
 }

src/ln/ln.rs

@@ -269,9 +269,9 @@ fn link(src: &PathBuf, dst: &PathBuf, settings: &Settings) -> Result<()> {
                 if !read_yes() {
                     return Ok(());
                 }
-                try!(fs::remove_file(dst))
+                fs::remove_file(dst)?
             }
-            OverwriteMode::Force => try!(fs::remove_file(dst)),
+            OverwriteMode::Force => fs::remove_file(dst)?,
         };
 
         backup_path = match settings.backup {
@@ -281,14 +281,14 @@ fn link(src: &PathBuf, dst: &PathBuf, settings: &Settings) -> Result<()> {
             BackupMode::ExistingBackup => Some(existing_backup_path(dst, &settings.suffix)),
         };
         if let Some(ref p) = backup_path {
-            try!(fs::rename(dst, p));
+            fs::rename(dst, p)?;
         }
     }
 
     if settings.symbolic {
-        try!(symlink(src, dst));
+        symlink(src, dst)?;
     } else {
-        try!(fs::hard_link(src, dst));
+        fs::hard_link(src, dst)?;
     }
 
     if settings.verbose {

src/od/formatteriteminfo.rs

@@ -33,15 +33,15 @@ impl fmt::Debug for FormatWriter {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             &FormatWriter::IntWriter(ref p) => {
-                try!(f.write_str("IntWriter:"));
+                f.write_str("IntWriter:")?;
                 fmt::Pointer::fmt(p, f)
             }
             &FormatWriter::FloatWriter(ref p) => {
-                try!(f.write_str("FloatWriter:"));
+                f.write_str("FloatWriter:")?;
                 fmt::Pointer::fmt(p, f)
             }
             &FormatWriter::MultibyteWriter(ref p) => {
-                try!(f.write_str("MultibyteWriter:"));
+                f.write_str("MultibyteWriter:")?;
                 fmt::Pointer::fmt(&(*p as *const ()), f)
             }
         }

src/shred/shred.rs

@@ -491,24 +491,24 @@ fn do_pass(
     given_file_size: Option<u64>,
     exact: bool,
 ) -> Result<(), io::Error> {
-    try!(file.seek(SeekFrom::Start(0)));
+    file.seek(SeekFrom::Start(0))?;
 
     // Use the given size or the whole file if not specified
-    let size: u64 = given_file_size.unwrap_or(try!(get_file_size(path)));
+    let size: u64 = given_file_size.unwrap_or(get_file_size(path)?);
 
     let generator = BytesGenerator::new(size, generator_type, exact);
 
     for block in generator {
-        try!(file.write_all(&*block));
+        file.write_all(&*block)?;
     }
 
-    try!(file.sync_data());
+    file.sync_data()?;
 
     Ok(())
 }
 
 fn get_file_size(path: &Path) -> Result<u64, io::Error> {
-    let size: u64 = try!(fs::metadata(path)).len();
+    let size: u64 = fs::metadata(path)?.len();
 
     Ok(size)
 }
@@ -574,7 +574,7 @@ fn do_remove(path: &Path, orig_filename: &str, verbose: bool) -> Result<(), io::
     let renamed_path: Option<PathBuf> = wipe_name(&path, verbose);
     match renamed_path {
         Some(rp) => {
-            try!(fs::remove_file(rp));
+            fs::remove_file(rp)?;
         }
         None => (),
     }

src/stat/stat.rs

@@ -468,7 +468,7 @@ impl Stater {
         let default_tokens = if fmtstr.is_empty() {
             Stater::generate_tokens(&Stater::default_fmt(showfs, terse, false), use_printf).unwrap()
         } else {
-            try!(Stater::generate_tokens(&fmtstr, use_printf))
+            Stater::generate_tokens(&fmtstr, use_printf)?
         };
         let default_dev_tokens =
             Stater::generate_tokens(&Stater::default_fmt(showfs, terse, true), use_printf).unwrap();

src/stdbuf/stdbuf.rs

@@ -172,9 +172,9 @@ fn parse_options(
         return Ok(OkMsg::Version);
     }
     let mut modified = false;
-    options.stdin = try!(check_option(&matches, "input", &mut modified).ok_or(ErrMsg::Fatal));
+    options.stdin = check_option(&matches, "input", &mut modified).ok_or(ErrMsg::Fatal)?;
-    options.stdout = try!(check_option(&matches, "output", &mut modified).ok_or(ErrMsg::Fatal));
+    options.stdout = check_option(&matches, "output", &mut modified).ok_or(ErrMsg::Fatal)?;
-    options.stderr = try!(check_option(&matches, "error", &mut modified).ok_or(ErrMsg::Fatal));
+    options.stderr = check_option(&matches, "error", &mut modified).ok_or(ErrMsg::Fatal)?;
 
     if matches.free.len() != 1 {
         return Err(ErrMsg::Retry);

src/sum/sum.rs

@@ -68,7 +68,7 @@ fn open(name: &str) -> Result<Box<Read>> {
     match name {
         "-" => Ok(Box::new(stdin()) as Box<Read>),
         _ => {
-            let f = try!(File::open(&Path::new(name)));
+            let f = File::open(&Path::new(name))?;
             Ok(Box::new(f) as Box<Read>)
         }
     }

src/tee/tee.rs

@@ -131,14 +131,14 @@ struct MultiWriter {
 impl Write for MultiWriter {
     fn write(&mut self, buf: &[u8]) -> Result<usize> {
         for writer in &mut self.writers {
-            try!(writer.write_all(buf));
+            writer.write_all(buf)?;
         }
         Ok(buf.len())
     }
 
     fn flush(&mut self) -> Result<()> {
         for writer in &mut self.writers {
-            try!(writer.flush());
+            writer.flush()?;
         }
         Ok(())
     }

src/wc/wc.rs

@@ -144,7 +144,7 @@ fn wc(files: Vec<String>, settings: &Settings) -> StdResult<(), i32> {
     let mut max_width: usize = 0;
 
     for path in &files {
-        let mut reader = try!(open(&path[..]));
+        let mut reader = open(&path[..])?;
 
         let mut line_count: usize = 0;
         let mut word_count: usize = 0;

tests/common/util.rs

@@ -162,16 +162,16 @@ pub fn log_info<T: AsRef<str>, U: AsRef<str>>(msg: T, par: U) {
 }
 
 pub fn recursive_copy(src: &Path, dest: &Path) -> Result<()> {
-    if try!(fs::metadata(src)).is_dir() {
+    if fs::metadata(src)?.is_dir() {
         for entry in try!(fs::read_dir(src)) {
-            let entry = try!(entry);
+            let entry = entry?;
             let mut new_dest = PathBuf::from(dest);
             new_dest.push(entry.file_name());
-            if try!(fs::metadata(entry.path())).is_dir() {
+            if fs::metadata(entry.path())?.is_dir() {
-                try!(fs::create_dir(&new_dest));
+                fs::create_dir(&new_dest)?;
-                try!(recursive_copy(&entry.path(), &new_dest));
+                recursive_copy(&entry.path(), &new_dest)?;
             } else {
-                try!(fs::copy(&entry.path(), new_dest));
+                fs::copy(&entry.path(), new_dest)?;
             }
         }
     }