cleanup: replace try! with ?

3 files changed, 34 insertions, 34 deletions

diff --git a/globset/README.md b/globset/README.md
index 3c8c2801..71318613 100644
--- a/globset/README.md
+++ b/globset/README.md
@@ -36,7 +36,7 @@ This example shows how to match a single glob against a single file path.
 ```rust
 use globset::Glob;
 
-let glob = try!(Glob::new("*.rs")).compile_matcher();
+let glob = Glob::new("*.rs")?.compile_matcher();
 
 assert!(glob.is_match("foo.rs"));
 assert!(glob.is_match("foo/bar.rs"));
@@ -51,8 +51,8 @@ semantics. In this example, we prevent wildcards from matching path separators.
 ```rust
 use globset::GlobBuilder;
 
-let glob = try!(GlobBuilder::new("*.rs")
-    .literal_separator(true).build()).compile_matcher();
+let glob = GlobBuilder::new("*.rs")
+    .literal_separator(true).build()?.compile_matcher();
 
 assert!(glob.is_match("foo.rs"));
 assert!(!glob.is_match("foo/bar.rs")); // no longer matches
@@ -69,10 +69,10 @@ use globset::{Glob, GlobSetBuilder};
 let mut builder = GlobSetBuilder::new();
 // A GlobBuilder can be used to configure each glob's match semantics
 // independently.
-builder.add(try!(Glob::new("*.rs")));
-builder.add(try!(Glob::new("src/lib.rs")));
-builder.add(try!(Glob::new("src/**/foo.rs")));
-let set = try!(builder.build());
+builder.add(Glob::new("*.rs")?);
+builder.add(Glob::new("src/lib.rs")?);
+builder.add(Glob::new("src/**/foo.rs")?);
+let set = builder.build()?;
 
 assert_eq!(set.matches("src/bar/baz/foo.rs"), vec![0, 2]);
 ```
diff --git a/globset/src/glob.rs b/globset/src/glob.rs
index b081a21e..ff7b74aa 100644
--- a/globset/src/glob.rs
+++ b/globset/src/glob.rs
@@ -550,7 +550,7 @@ impl<'a> GlobBuilder<'a> {
             prev: None,
             cur: None,
         };
-        try!(p.parse());
+        p.parse()?;
         if p.stack.is_empty() {
             Err(Error {
                 glob: Some(self.glob.to_string()),
@@ -720,18 +720,18 @@ impl<'a> Parser<'a> {
     fn parse(&mut self) -> Result<(), Error> {
         while let Some(c) = self.bump() {
             match c {
-                '?' => try!(self.push_token(Token::Any)),
-                '*' => try!(self.parse_star()),
-                '[' => try!(self.parse_class()),
-                '{' => try!(self.push_alternate()),
-                '}' => try!(self.pop_alternate()),
-                ',' => try!(self.parse_comma()),
+                '?' => self.push_token(Token::Any)?,
+                '*' => self.parse_star()?,
+                '[' => self.parse_class()?,
+                '{' => self.push_alternate()?,
+                '}' => self.pop_alternate()?,
+                ',' => self.parse_comma()?,
                 c => {
                     if is_separator(c) {
                         // Normalize all patterns to use / as a separator.
-                        try!(self.push_token(Token::Literal('/')))
+                        self.push_token(Token::Literal('/'))?
                     } else {
-                        try!(self.push_token(Token::Literal(c)))
+                        self.push_token(Token::Literal(c))?
                     }
                 }
             }
@@ -789,19 +789,19 @@ impl<'a> Parser<'a> {
     fn parse_star(&mut self) -> Result<(), Error> {
         let prev = self.prev;
         if self.chars.peek() != Some(&'*') {
-            try!(self.push_token(Token::ZeroOrMore));
+            self.push_token(Token::ZeroOrMore)?;
             return Ok(());
         }
         assert!(self.bump() == Some('*'));
-        if !try!(self.have_tokens()) {
-            try!(self.push_token(Token::RecursivePrefix));
+        if !self.have_tokens()? {
+            self.push_token(Token::RecursivePrefix)?;
             let next = self.bump();
             if !next.map(is_separator).unwrap_or(true) {
                 return Err(self.error(ErrorKind::InvalidRecursive));
             }
             return Ok(());
         }
-        try!(self.pop_token());
+        self.pop_token()?;
         if !prev.map(is_separator).unwrap_or(false) {
             if self.stack.len() <= 1
                 || (prev != Some(',') && prev != Some('{')) {
@@ -873,7 +873,7 @@ impl<'a> Parser<'a> {
                         // invariant: in_range is only set when there is
                         // already at least one character seen.
                         let r = ranges.last_mut().unwrap();
-                        try!(add_to_last_range(&self.glob, r, '-'));
+                        add_to_last_range(&self.glob, r, '-')?;
                         in_range = false;
                     } else {
                         assert!(!ranges.is_empty());
@@ -884,8 +884,8 @@ impl<'a> Parser<'a> {
                     if in_range {
                         // invariant: in_range is only set when there is
                         // already at least one character seen.
-                        try!(add_to_last_range(
-                            &self.glob, ranges.last_mut().unwrap(), c));
+                        add_to_last_range(
+                            &self.glob, ranges.last_mut().unwrap(), c)?;
                     } else {
                         ranges.push((c, c));
                     }
diff --git a/globset/src/lib.rs b/globset/src/lib.rs
index 98080705..dd6922e6 100644
--- a/globset/src/lib.rs
+++ b/globset/src/lib.rs
@@ -22,7 +22,7 @@ This example shows how to match a single glob against a single file path.
 # fn example() -> Result<(), globset::Error> {
 use globset::Glob;
 
-let glob = try!(Glob::new("*.rs")).compile_matcher();
+let glob = Glob::new("*.rs")?.compile_matcher();
 
 assert!(glob.is_match("foo.rs"));
 assert!(glob.is_match("foo/bar.rs"));
@@ -39,8 +39,8 @@ semantics. In this example, we prevent wildcards from matching path separators.
 # fn example() -> Result<(), globset::Error> {
 use globset::GlobBuilder;
 
-let glob = try!(GlobBuilder::new("*.rs")
-    .literal_separator(true).build()).compile_matcher();
+let glob = GlobBuilder::new("*.rs")
+    .literal_separator(true).build()?.compile_matcher();
 
 assert!(glob.is_match("foo.rs"));
 assert!(!glob.is_match("foo/bar.rs")); // no longer matches
@@ -59,10 +59,10 @@ use globset::{Glob, GlobSetBuilder};
 let mut builder = GlobSetBuilder::new();
 // A GlobBuilder can be used to configure each glob's match semantics
 // independently.
-builder.add(try!(Glob::new("*.rs")));
-builder.add(try!(Glob::new("src/lib.rs")));
-builder.add(try!(Glob::new("src/**/foo.rs")));
-let set = try!(builder.build());
+builder.add(Glob::new("*.rs")?);
+builder.add(Glob::new("src/lib.rs")?);
+builder.add(Glob::new("src/**/foo.rs")?);
+let set = builder.build()?;
 
 assert_eq!(set.matches("src/bar/baz/foo.rs"), vec![0, 2]);
 # Ok(()) } example().unwrap();
@@ -412,8 +412,8 @@ impl GlobSet {
                 GlobSetMatchStrategy::Suffix(suffixes.suffix()),
                 GlobSetMatchStrategy::Prefix(prefixes.prefix()),
                 GlobSetMatchStrategy::RequiredExtension(
-                    try!(required_exts.build())),
-                GlobSetMatchStrategy::Regex(try!(regexes.regex_set())),
+                    required_exts.build()?),
+                GlobSetMatchStrategy::Regex(regexes.regex_set()?),
             ],
         })
     }
@@ -767,7 +767,7 @@ impl MultiStrategyBuilder {
 
     fn regex_set(self) -> Result<RegexSetStrategy, Error> {
         Ok(RegexSetStrategy {
-            matcher: try!(new_regex_set(self.literals)),
+            matcher: new_regex_set(self.literals)?,
             map: self.map,
         })
     }
@@ -792,7 +792,7 @@ impl RequiredExtensionStrategyBuilder {
         for (ext, regexes) in self.0.into_iter() {
             exts.insert(ext.clone(), vec![]);
             for (global_index, regex) in regexes {
-                let compiled = try!(new_regex(&regex));
+                let compiled = new_regex(&regex)?;
                 exts.get_mut(&ext).unwrap().push((global_index, compiled));
             }
         }