cleanup: replace try! with ?

ignore/src/gitignore.rs

@@ -322,13 +322,13 @@ impl GitignoreBuilder {
     pub fn build(&self) -> Result<Gitignore, Error> {
         let nignore = self.globs.iter().filter(|g| !g.is_whitelist()).count();
         let nwhite = self.globs.iter().filter(|g| g.is_whitelist()).count();
-        let set = try!(
+        let set =
             self.builder.build().map_err(|err| {
                 Error::Glob {
                     glob: None,
                     err: err.to_string(),
                 }
-            }));
+            })?;
         Ok(Gitignore {
             set: set,
             root: self.root.clone(),
@@ -383,7 +383,7 @@ impl GitignoreBuilder {
         gitignore: &str,
     ) -> Result<&mut GitignoreBuilder, Error> {
         for line in gitignore.lines() {
-            try!(self.add_line(from.clone(), line));
+            self.add_line(from.clone(), line)?;
         }
         Ok(self)
     }
@@ -465,7 +465,7 @@ impl GitignoreBuilder {
         if glob.actual.ends_with("/**") {
             glob.actual = format!("{}/*", glob.actual);
         }
-        let parsed = try!(
+        let parsed =
             GlobBuilder::new(&glob.actual)
                 .literal_separator(literal_separator)
                 .case_insensitive(self.case_insensitive)
@@ -475,7 +475,7 @@ impl GitignoreBuilder {
                         glob: Some(glob.original.clone()),
                         err: err.kind().to_string(),
                     }
-                }));
+                })?;
         self.builder.add(parsed);
         self.globs.push(glob);
         Ok(self)

ignore/src/overrides.rs

@@ -124,7 +124,7 @@ impl OverrideBuilder {
     ///
     /// Once a matcher is built, no new globs can be added to it.
     pub fn build(&self) -> Result<Override, Error> {
-        Ok(Override(try!(self.builder.build())))
+        Ok(Override(self.builder.build()?))
     }
 
     /// Add a glob to the set of overrides.
@@ -134,7 +134,7 @@ impl OverrideBuilder {
     /// namely, `!` at the beginning of a glob will ignore a file. Without `!`,
     /// all matches of the glob provided are treated as whitelist matches.
     pub fn add(&mut self, glob: &str) -> Result<&mut OverrideBuilder, Error> {
-        try!(self.builder.add_line(None, glob));
+        self.builder.add_line(None, glob)?;
         Ok(self)
     }
 
@@ -144,7 +144,7 @@ impl OverrideBuilder {
     pub fn case_insensitive(
         &mut self, yes: bool
     ) -> Result<&mut OverrideBuilder, Error> {
-        try!(self.builder.case_insensitive(yes));
+        self.builder.case_insensitive(yes)?;
         Ok(self)
     }
 }

ignore/src/types.rs

@@ -526,7 +526,7 @@ impl TypesBuilder {
                 }
             };
             for (iglob, glob) in def.globs.iter().enumerate() {
-                build_set.add(try!(
+                build_set.add(
                     GlobBuilder::new(glob)
                         .literal_separator(true)
                         .build()
@@ -535,14 +535,14 @@ impl TypesBuilder {
                                 glob: Some(glob.to_string()),
                                 err: err.kind().to_string(),
                             }
-                        })));
+                        })?);
                 glob_to_selection.push((isel, iglob));
             }
             selections.push(selection.clone().map(move |_| def));
         }
-        let set = try!(build_set.build().map_err(|err| {
+        let set = build_set.build().map_err(|err| {
             Error::Glob { glob: None, err: err.to_string() }
-        }));
+        })?;
         Ok(Types {
             defs: defs,
             selections: selections,
@@ -655,7 +655,7 @@ impl TypesBuilder {
                 for type_name in types {
                     let globs = self.types.get(type_name).unwrap().globs.clone();
                     for glob in globs {
-                        try!(self.add(name, &glob));
+                        self.add(name, &glob)?;
                     }
                 }
                 Ok(())

ignore/src/walk.rs

@@ -279,13 +279,13 @@ impl DirEntryRaw {
         depth: usize,
         ent: &fs::DirEntry,
     ) -> Result<DirEntryRaw, Error> {
-        let ty = try!(ent.file_type().map_err(|err| {
+        let ty = ent.file_type().map_err(|err| {
             let err = Error::Io(io::Error::from(err)).with_path(ent.path());
             Error::WithDepth {
                 depth: depth,
                 err: Box::new(err),
             }
-        }));
+        })?;
         Ok(DirEntryRaw::from_entry_os(depth, ent, ty))
     }
 
@@ -322,9 +322,9 @@ impl DirEntryRaw {
 
     #[cfg(not(unix))]
     fn from_link(depth: usize, pb: PathBuf) -> Result<DirEntryRaw, Error> {
-        let md = try!(fs::metadata(&pb).map_err(|err| {
+        let md = fs::metadata(&pb).map_err(|err| {
             Error::Io(err).with_path(&pb)
-        }));
+        })?;
         Ok(DirEntryRaw {
             path: pb,
             ty: md.file_type(),
@@ -337,9 +337,9 @@ impl DirEntryRaw {
     fn from_link(depth: usize, pb: PathBuf) -> Result<DirEntryRaw, Error> {
         use std::os::unix::fs::MetadataExt;
 
-        let md = try!(fs::metadata(&pb).map_err(|err| {
+        let md = fs::metadata(&pb).map_err(|err| {
             Error::Io(err).with_path(&pb)
-        }));
+        })?;
         Ok(DirEntryRaw {
             path: pb,
             ty: md.file_type(),