auto merge of #9320 : chris-morgan/rust/unreachable-macro-part-two-of-two-containing-the-destruction-of-the-unreachable-function, r=alexcrichton

bors · bors · commit e5fdc7dee520 · 2013-09-20T00:36:11.000-07:00
This is the second of two parts of #8991, now possible as a new snapshot has been made. (The first part implemented the unreachable!() macro; it was #8992, 6b7b8f2.) ``std::util::unreachable()`` is removed summarily; any code which used it should now use the ``unreachable!()`` macro. Closes #9312. Closes #8991.
diff --git a/src/libextra/glob.rs b/src/libextra/glob.rs
@@ -23,7 +23,7 @@
  * `glob`/`fnmatch` functions.
  */
 
-use std::{os, path, util};
+use std::{os, path};
 
 use sort;
 
@@ -356,7 +356,7 @@ impl Pattern {
                             chars_eq(c, c2, options.case_sensitive)
                         }
                         AnySequence => {
-                            util::unreachable()
+                            unreachable!()
                         }
                     };
                     if !matches {
diff --git a/src/libextra/terminfo/parm.rs b/src/libextra/terminfo/parm.rs
@@ -261,7 +261,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
                                 flags.width = (cur as uint - '0' as uint);
                                 fstate = FormatStateWidth;
                             }
-                            _ => util::unreachable()
+                            _ => unreachable!()
                         }
                         state = FormatPattern(flags, fstate);
                     }
@@ -487,7 +487,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
                         FormatDigit => 10,
                         FormatOctal => 8,
                         FormatHex|FormatHEX => 16,
-                        FormatString => util::unreachable()
+                        FormatString => unreachable!()
                     };
                     let mut s = ~[];
                     match op {
@@ -535,7 +535,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
                                 s.push_all_move(s_);
                             }
                         }
-                        FormatString => util::unreachable()
+                        FormatString => unreachable!()
                     }
                     s
                 }
diff --git a/src/librustc/back/rpath.rs b/src/librustc/back/rpath.rs
@@ -14,7 +14,7 @@ use metadata::cstore;
 use metadata::filesearch;
 
 use std::hashmap::HashSet;
-use std::{os, util, vec};
+use std::{os, vec};
 
 fn not_win32(os: session::Os) -> bool {
   os != session::OsWin32
@@ -116,7 +116,7 @@ pub fn get_rpath_relative_to_output(os: session::Os,
         session::OsAndroid | session::OsLinux | session::OsFreebsd
                           => "$ORIGIN",
         session::OsMacos => "@executable_path",
-        session::OsWin32 => util::unreachable()
+        session::OsWin32 => unreachable!()
     };
 
     Path(prefix).push_rel(&os::make_absolute(output).get_relative_to(&os::make_absolute(lib)))
diff --git a/src/librustc/middle/entry.rs b/src/librustc/middle/entry.rs
@@ -18,7 +18,6 @@ use syntax::codemap::Span;
 use syntax::parse::token::special_idents;
 use syntax::visit;
 use syntax::visit::Visitor;
-use std::util;
 
 struct EntryContext {
     session: Session,
@@ -94,7 +93,7 @@ fn find_item(item: @item, ctxt: &mut EntryContext) {
                             ctxt.non_main_fns.push((item.id, item.span));
                         }
                     }
-                    _ => util::unreachable()
+                    _ => unreachable!()
                 }
             }
 
diff --git a/src/librustc/middle/trans/_match.rs b/src/librustc/middle/trans/_match.rs
@@ -356,7 +356,7 @@ fn variant_opt(bcx: @mut Block, pat_id: ast::NodeId)
                                adt::represent_node(bcx, pat_id))
                 }
             }
-            ::std::util::unreachable();
+            unreachable!();
         }
         ast::DefFn(*) |
         ast::DefStruct(_) => {
diff --git a/src/librustdoc/prune_private_pass.rs b/src/librustdoc/prune_private_pass.rs
@@ -20,8 +20,6 @@ use fold::Fold;
 use fold;
 use pass::Pass;
 
-use std::util;
-
 pub fn mk_pass() -> Pass {
     Pass {
         name: ~"prune_private",
@@ -148,7 +146,7 @@ fn is_visible(srv: astsrv::Srv, doc: doc::ItemDoc) -> bool {
                     }
                 }
             }
-            _ => util::unreachable()
+            _ => unreachable!()
         }
     }
 }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
@@ -27,7 +27,7 @@ use option::{None, Option, Some};
 use rand::RngUtil;
 use rand;
 use uint;
-use util::{replace, unreachable};
+use util::replace;
 use vec::{ImmutableVector, MutableVector, OwnedVector};
 use vec;
 
@@ -187,7 +187,7 @@ impl<K:Hash + Eq,V> HashMap<K, V> {
     fn mut_value_for_bucket<'a>(&'a mut self, idx: uint) -> &'a mut V {
         match self.buckets[idx] {
             Some(ref mut bkt) => &mut bkt.value,
-            None => unreachable()
+            None => unreachable!()
         }
     }
 
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
@@ -56,7 +56,6 @@ use str;
 use sys;
 use u32;
 use uint;
-use util;
 use vec;
 use libc::size_t;
 
@@ -586,7 +585,7 @@ impl<R: Rng> RngUtil for R {
                 return Some(item.item.clone());
             }
         }
-        util::unreachable();
+        unreachable!();
     }
 
     /**
diff --git a/src/libstd/rt/io/extensions.rs b/src/libstd/rt/io/extensions.rs
@@ -21,7 +21,6 @@ use rt::io::{Reader, Writer, Decorator};
 use rt::io::{read_error, standard_error, EndOfFile, DEFAULT_BUF_SIZE};
 use option::{Option, Some, None};
 use unstable::finally::Finally;
-use util;
 use cast;
 use io::{u64_to_le_bytes, u64_to_be_bytes};
 
@@ -293,7 +292,7 @@ impl<T: Reader> ReaderUtil for T {
                 self.read_byte()
             }
             Some(1) => Some(buf[0]),
-            Some(_) => util::unreachable(),
+            Some(_) => unreachable!(),
             None => None
         }
     }
diff --git a/src/libstd/util.rs b/src/libstd/util.rs
@@ -104,34 +104,6 @@ impl Void {
 }
 
 
-/**
-A utility function for indicating unreachable code. It will fail if
-executed. This is occasionally useful to put after loops that never
-terminate normally, but instead directly return from a function.
-
-# Example
-
-~~~ {.rust}
-fn choose_weighted_item(v: &[Item]) -> Item {
-    assert!(!v.is_empty());
-    let mut so_far = 0u;
-    for v.each |item| {
-        so_far += item.weight;
-        if so_far > 100 {
-            return item;
-        }
-    }
-    // The above loop always returns, so we must hint to the
-    // type checker that it isn't possible to get down here
-    util::unreachable();
-}
-~~~
-
-*/
-pub fn unreachable() -> ! {
-    fail!("internal error: entered unreachable code");
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs b/src/test/compile-fail/borrowck-move-out-of-vec-tail.rs
@@ -19,14 +19,14 @@ pub fn main() {
                     //~^^ ERROR cannot move out of dereference of & pointer
                 }
                 _ => {
-                    ::std::util::unreachable();
+                    unreachable!();
                 }
             }
             let z = tail[0].clone();
             info!(fmt!("%?", z));
         }
         _ => {
-            ::std::util::unreachable();
+            unreachable!();
         }
     }
 }
diff --git a/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs b/src/test/compile-fail/borrowck-vec-pattern-move-tail.rs
@@ -2,7 +2,7 @@ fn main() {
     let mut a = [1, 2, 3, 4];
     let t = match a {
         [1, 2, ..tail] => tail,
-        _ => std::util::unreachable()
+        _ => unreachable!()
     };
     a[0] = 0; //~ ERROR cannot assign to `a[]` because it is borrowed
     t[0];
diff --git a/src/test/debug-info/lexical-scope-in-if.rs b/src/test/debug-info/lexical-scope-in-if.rs
@@ -78,8 +78,6 @@
 // check:$16 = -1
 // debugger:continue
 
-use std::util;
-
 fn main() {
 
     let x = 999;
@@ -102,14 +100,14 @@ fn main() {
         zzz();
         sentinel();
     } else {
-        util::unreachable();
+        unreachable!();
     }
 
     zzz();
     sentinel();
 
     if x > 1000 {
-        util::unreachable();
+        unreachable!();
     } else {
         zzz();
         sentinel();
diff --git a/src/test/run-pass/vec-matching-fixed.rs b/src/test/run-pass/vec-matching-fixed.rs
@@ -1,12 +1,12 @@
 fn a() {
     let x = [1, 2, 3];
     match x {
-        [1, 2, 4] => ::std::util::unreachable(),
-        [0, 2, 3, .._] => ::std::util::unreachable(),
-        [0, .._, 3] => ::std::util::unreachable(),
-        [0, .._] => ::std::util::unreachable(),
+        [1, 2, 4] => unreachable!(),
+        [0, 2, 3, .._] => unreachable!(),
+        [0, .._, 3] => unreachable!(),
+        [0, .._] => unreachable!(),
         [1, 2, 3] => (),
-        [_, _, _] => ::std::util::unreachable(),
+        [_, _, _] => unreachable!(),
     }
     match x {
         [.._] => (),
diff --git a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs
@@ -3,7 +3,7 @@ pub fn main() {
     if !x.is_empty() {
         let el = match x {
             [1, ..ref tail] => &tail[0],
-            _ => ::std::util::unreachable()
+            _ => unreachable!()
         };
         printfln!("%d", *el);
     }
diff --git a/src/test/run-pass/vec-tail-matching.rs b/src/test/run-pass/vec-tail-matching.rs
@@ -17,19 +17,19 @@ pub fn main() {
 
             match tail {
                 [Foo { _ }, _, Foo { _ }, .. _tail] => {
-                    ::std::util::unreachable();
+                    unreachable!();
                 }
                 [Foo { string: ref a }, Foo { string: ref b }] => {
                     assert_eq!("bar", a.slice(0, a.len()));
                     assert_eq!("baz", b.slice(0, b.len()));
                 }
                 _ => {
-                    ::std::util::unreachable();
+                    unreachable!();
                 }
             }
         }
         _ => {
-            ::std::util::unreachable();
+            unreachable!();
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`	* `glob`/`fnmatch` functions.
`24`	`24`	`*/`
`25`	`25`
`26`		`-use std::{os, path, util};`
	`26`	`+use std::{os, path};`
`27`	`27`
`28`	`28`	`use sort;`
`29`	`29`
`@@ -356,7 +356,7 @@ impl Pattern {`
`356`	`356`	`chars_eq(c, c2, options.case_sensitive)`
`357`	`357`	`}`
`358`	`358`	`AnySequence => {`
`359`		`- util::unreachable()`
	`359`	`+ unreachable!()`
`360`	`360`	`}`
`361`	`361`	`};`
`362`	`362`	`if !matches {`
Original file line number	Diff line number	Diff line change
`@@ -261,7 +261,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)`
`261`	`261`	`flags.width = (cur as uint - '0' as uint);`
`262`	`262`	`fstate = FormatStateWidth;`
`263`	`263`	`}`
`264`		`- _ => util::unreachable()`
	`264`	`+ _ => unreachable!()`
`265`	`265`	`}`
`266`	`266`	`state = FormatPattern(flags, fstate);`
`267`	`267`	`}`
`@@ -487,7 +487,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {`
`487`	`487`	`FormatDigit => 10,`
`488`	`488`	`FormatOctal => 8,`
`489`	`489`	`FormatHex\|FormatHEX => 16,`
`490`		`- FormatString => util::unreachable()`
	`490`	`+ FormatString => unreachable!()`
`491`	`491`	`};`
`492`	`492`	`let mut s = ~[];`
`493`	`493`	`match op {`
`@@ -535,7 +535,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {`
`535`	`535`	`s.push_all_move(s_);`
`536`	`536`	`}`
`537`	`537`	`}`
`538`		`- FormatString => util::unreachable()`
	`538`	`+ FormatString => unreachable!()`
`539`	`539`	`}`
`540`	`540`	`s`
`541`	`541`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,6 @@ use syntax::codemap::Span;`
`18`	`18`	`use syntax::parse::token::special_idents;`
`19`	`19`	`use syntax::visit;`
`20`	`20`	`use syntax::visit::Visitor;`
`21`		`-use std::util;`
`22`	`21`
`23`	`22`	`struct EntryContext {`
`24`	`23`	`session: Session,`
`@@ -94,7 +93,7 @@ fn find_item(item: @item, ctxt: &mut EntryContext) {`
`94`	`93`	`ctxt.non_main_fns.push((item.id, item.span));`
`95`	`94`	`}`
`96`	`95`	`}`
`97`		`- _ => util::unreachable()`
	`96`	`+ _ => unreachable!()`
`98`	`97`	`}`
`99`	`98`	`}`
`100`	`99`
Original file line number	Diff line number	Diff line change
`@@ -356,7 +356,7 @@ fn variant_opt(bcx: @mut Block, pat_id: ast::NodeId)`
`356`	`356`	`adt::represent_node(bcx, pat_id))`
`357`	`357`	`}`
`358`	`358`	`}`
`359`		`- ::std::util::unreachable();`
	`359`	`+ unreachable!();`
`360`	`360`	`}`
`361`	`361`	`ast::DefFn(*) \|`
`362`	`362`	`ast::DefStruct(_) => {`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,6 @@ use fold::Fold;`
`20`	`20`	`use fold;`
`21`	`21`	`use pass::Pass;`
`22`	`22`
`23`		`-use std::util;`
`24`		`-`
`25`	`23`	`pub fn mk_pass() -> Pass {`
`26`	`24`	`Pass {`
`27`	`25`	`name: ~"prune_private",`
`@@ -148,7 +146,7 @@ fn is_visible(srv: astsrv::Srv, doc: doc::ItemDoc) -> bool {`
`148`	`146`	`}`
`149`	`147`	`}`
`150`	`148`	`}`
`151`		`- _ => util::unreachable()`
	`149`	`+ _ => unreachable!()`
`152`	`150`	`}`
`153`	`151`	`}`
`154`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,6 @@ use str;`
`56`	`56`	`use sys;`
`57`	`57`	`use u32;`
`58`	`58`	`use uint;`
`59`		`-use util;`
`60`	`59`	`use vec;`
`61`	`60`	`use libc::size_t;`
`62`	`61`
`@@ -586,7 +585,7 @@ impl<R: Rng> RngUtil for R {`
`586`	`585`	`return Some(item.item.clone());`
`587`	`586`	`}`
`588`	`587`	`}`
`589`		`- util::unreachable();`
	`588`	`+ unreachable!();`
`590`	`589`	`}`
`591`	`590`
`592`	`591`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@ use rt::io::{Reader, Writer, Decorator};`
`21`	`21`	`use rt::io::{read_error, standard_error, EndOfFile, DEFAULT_BUF_SIZE};`
`22`	`22`	`use option::{Option, Some, None};`
`23`	`23`	`use unstable::finally::Finally;`
`24`		`-use util;`
`25`	`24`	`use cast;`
`26`	`25`	`use io::{u64_to_le_bytes, u64_to_be_bytes};`
`27`	`26`
`@@ -293,7 +292,7 @@ impl<T: Reader> ReaderUtil for T {`
`293`	`292`	`self.read_byte()`
`294`	`293`	`}`
`295`	`294`	`Some(1) => Some(buf[0]),`
`296`		`- Some(_) => util::unreachable(),`
	`295`	`+ Some(_) => unreachable!(),`
`297`	`296`	`None => None`
`298`	`297`	`}`
`299`	`298`	`}`