Utilize ? instead of return None.

src/libcore/str/mod.rs

@@ -536,10 +536,9 @@ fn next_code_point_reverse<'a, I>(bytes: &mut I) -> Option<u32>
     where I: DoubleEndedIterator<Item = &'a u8>,
 {
     // Decode UTF-8
-    let w = match bytes.next_back() {
+    let w = match *bytes.next_back()? {
-        None => return None,
+        next_byte if next_byte < 128 => return Some(next_byte as u32),
-        Some(&next_byte) if next_byte < 128 => return Some(next_byte as u32),
+        back_byte => back_byte,
-        Some(&back_byte) => back_byte,
     };
 
     // Multibyte case follows

src/librustc/middle/region.rs

@@ -592,10 +592,7 @@ impl<'tcx> ScopeTree {
                 return Some(scope.item_local_id());
             }
 
-            match self.opt_encl_scope(scope) {
+            scope = self.opt_encl_scope(scope)?;
-                None => return None,
-                Some(parent) => scope = parent,
-            }
         }
     }
 

src/librustc/session/search_paths.rs

@@ -67,14 +67,13 @@ impl<'a> Iterator for Iter<'a> {
 
     fn next(&mut self) -> Option<(&'a Path, PathKind)> {
         loop {
-            match self.iter.next() {
+            match *self.iter.next()? {
-                Some(&(kind, ref p)) if self.kind == PathKind::All ||
+                (kind, ref p) if self.kind == PathKind::All ||
-                                        kind == PathKind::All ||
+                                  kind == PathKind::All ||
-                                        kind == self.kind => {
+                                  kind == self.kind => {
                     return Some((p, kind))
                 }
-                Some(..) => {}
+                _ => {}
-                None => return None,
             }
         }
     }

src/librustc_incremental/persist/work_product.rs

@@ -29,7 +29,7 @@ pub fn copy_cgu_workproducts_to_incr_comp_cache_dir(
         return None
     }
 
-    let saved_files: Option<Vec<_>> =
+    let saved_files =
         files.iter()
              .map(|&(kind, ref path)| {
                  let extension = match kind {
@@ -51,11 +51,7 @@ pub fn copy_cgu_workproducts_to_incr_comp_cache_dir(
                      }
                  }
              })
-             .collect();
+             .collect::<Option<Vec<_>>>()?;
-    let saved_files = match saved_files {
-        None => return None,
-        Some(v) => v,
-    };
 
     let work_product = WorkProduct {
         cgu_name: cgu_name.to_string(),

src/librustc_mir/borrow_check/prefixes.rs

@@ -87,10 +87,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
 impl<'cx, 'gcx, 'tcx> Iterator for Prefixes<'cx, 'gcx, 'tcx> {
     type Item = &'cx Place<'tcx>;
     fn next(&mut self) -> Option<Self::Item> {
-        let mut cursor = match self.next {
+        let mut cursor = self.next?;
-            None => return None,
-            Some(place) => place,
-        };
 
         // Post-processing `place`: Enqueue any remaining
         // work. Also, `place` may not be a prefix itself, but

src/librustdoc/clean/mod.rs

@@ -3923,10 +3923,7 @@ pub fn path_to_def_local(tcx: &TyCtxt, path: &[&str]) -> Option<DefId> {
     let mut path_it = path.iter().peekable();
 
     loop {
-        let segment = match path_it.next() {
+        let segment = path_it.next()?;
-            Some(segment) => segment,
-            None => return None,
-        };
 
         for item_id in mem::replace(&mut items, HirVec::new()).iter() {
             let item = tcx.hir.expect_item(item_id.id);
@@ -3961,10 +3958,7 @@ pub fn path_to_def(tcx: &TyCtxt, path: &[&str]) -> Option<DefId> {
         let mut path_it = path.iter().skip(1).peekable();
 
         loop {
-            let segment = match path_it.next() {
+            let segment = path_it.next()?;
-                Some(segment) => segment,
-                None => return None,
-            };
 
             for item in mem::replace(&mut items, Lrc::new(vec![])).iter() {
                 if item.ident.name == *segment {

src/librustdoc/html/render.rs

@@ -2079,13 +2079,13 @@ impl<'a> Item<'a> {
                 return None;
             }
         } else {
-            let (krate, src_root) = match cache.extern_locations.get(&self.item.def_id.krate) {
+            let (krate, src_root) = match *cache.extern_locations.get(&self.item.def_id.krate)? {
-                Some(&(ref name, ref src, Local)) => (name, src),
+                (ref name, ref src, Local) => (name, src),
-                Some(&(ref name, ref src, Remote(ref s))) => {
+                (ref name, ref src, Remote(ref s)) => {
                     root = s.to_string();
                     (name, src)
                 }
-                Some(&(_, _, Unknown)) | None => return None,
+                (_, _, Unknown) => return None,
             };
 
             clean_srcpath(&src_root, file, false, |component| {

src/libstd/sys/windows/path.rs

@@ -91,10 +91,7 @@ pub fn parse_prefix<'a>(path: &'a OsStr) -> Option<Prefix> {
     }
 
     fn parse_two_comps(mut path: &[u8], f: fn(u8) -> bool) -> Option<(&[u8], &[u8])> {
-        let first = match path.iter().position(|x| f(*x)) {
+        let first = &path[..path.iter().position(|x| f(*x))?];
-            None => return None,
-            Some(x) => &path[..x],
-        };
         path = &path[(first.len() + 1)..];
         let idx = path.iter().position(|x| f(*x));
         let second = &path[..idx.unwrap_or(path.len())];

src/test/run-pass/impl-trait/example-calendar.rs

@@ -753,10 +753,7 @@ where It: Iterator {
     type Item = Vec<It::Item>;
 
     fn next(&mut self) -> Option<Vec<It::Item>> {
-        let first = match self.it.next() {
+        let first = self.it.next()?;
-            Some(e) => e,
-            None => return None
-        };
 
         let mut result = Vec::with_capacity(self.n);
         result.push(first);

src/tools/compiletest/src/errors.rs

@@ -119,10 +119,7 @@ fn parse_expected(
     line: &str,
     tag: &str,
 ) -> Option<(WhichLine, Error)> {
-    let start = match line.find(tag) {
+    let start = line.find(tag)?;
-        Some(i) => i,
-        None => return None,
-    };
     let (follow, adjusts) = if line[start + tag.len()..].chars().next().unwrap() == '|' {
         (true, 0)
     } else {

src/tools/compiletest/src/header.rs

@@ -684,14 +684,8 @@ impl Config {
 
     fn parse_custom_normalization(&self, mut line: &str, prefix: &str) -> Option<(String, String)> {
         if self.parse_cfg_name_directive(line, prefix) == ParsedNameDirective::Match {
-            let from = match parse_normalization_string(&mut line) {
+            let from = parse_normalization_string(&mut line)?;
-                Some(s) => s,
+            let to = parse_normalization_string(&mut line)?;
-                None => return None,
-            };
-            let to = match parse_normalization_string(&mut line) {
-                Some(s) => s,
-                None => return None,
-            };
             Some((from, to))
         } else {
             None
@@ -850,14 +844,8 @@ fn expand_variables(mut value: String, config: &Config) -> String {
 /// ```
 fn parse_normalization_string(line: &mut &str) -> Option<String> {
     // FIXME support escapes in strings.
-    let begin = match line.find('"') {
+    let begin = line.find('"')? + 1;
-        Some(i) => i + 1,
+    let end = line[begin..].find('"')? + begin;
-        None => return None,
-    };
-    let end = match line[begin..].find('"') {
-        Some(i) => i + begin,
-        None => return None,
-    };
     let result = line[begin..end].to_owned();
     *line = &line[end + 1..];
     Some(result)

src/tools/linkchecker/main.rs

@@ -332,10 +332,7 @@ fn maybe_redirect(source: &str) -> Option<String> {
     const REDIRECT: &'static str = "<p>Redirecting to <a href=";
 
     let mut lines = source.lines();
-    let redirect_line = match lines.nth(6) {
+    let redirect_line = lines.nth(6)?;
-        Some(l) => l,
-        None => return None,
-    };
 
     redirect_line.find(REDIRECT).map(|i| {
         let rest = &redirect_line[(i + REDIRECT.len() + 1)..];