Remove die!, raplace invocations with fail! Issue #4524 pt 3

Author: Nick Desaulniers

src/compiletest/compiletest.rc

@@ -70,7 +70,7 @@ pub fn parse_config(args: ~[~str]) -> config {
     let matches =
         &match getopts::getopts(args_, opts) {
           Ok(m) => m,
-          Err(f) => die!(getopts::fail_str(f))
+          Err(f) => fail!(getopts::fail_str(f))
         };
 
     fn opt_path(m: &getopts::Matches, nm: ~str) -> Path {
@@ -133,7 +133,7 @@ pub fn str_mode(s: ~str) -> mode {
       ~"run-pass" => mode_run_pass,
       ~"pretty" => mode_pretty,
       ~"debug-info" => mode_debug_info,
-      _ => die!(~"invalid mode")
+      _ => fail!(~"invalid mode")
     }
 }
 
@@ -151,7 +151,7 @@ pub fn run_tests(config: config) {
     let opts = test_opts(config);
     let tests = make_tests(config);
     let res = test::run_tests_console(&opts, tests);
-    if !res { die!(~"Some tests failed"); }
+    if !res { fail!(~"Some tests failed"); }
 }
 
 pub fn test_opts(config: config) -> test::TestOpts {

src/compiletest/header.rs

@@ -145,7 +145,7 @@ fn parse_exec_env(line: ~str) -> Option<(~str, ~str)> {
         match strs.len() {
           1u => (strs[0], ~""),
           2u => (strs[0], strs[1]),
-          n => die!(fmt!("Expected 1 or 2 strings, not %u", n))
+          n => fail!(fmt!("Expected 1 or 2 strings, not %u", n))
         }
     }
 }

src/compiletest/procsrv.rs

@@ -71,7 +71,7 @@ pub fn run(lib_path: ~str,
         os::close(pipe_in.out);
         os::close(pipe_out.in);
         os::close(pipe_err.in);
-        die!();
+        fail!();
     }
 
 
@@ -99,7 +99,7 @@ pub fn run(lib_path: ~str,
           (2, s) => {
             errs = s;
           }
-          _ => { die!() }
+          _ => { fail!() }
         };
         count -= 1;
     };

src/compiletest/runtest.rs

@@ -202,7 +202,7 @@ actual:\n\
 \n",
                      expected, actual);
             io::stdout().write_str(msg);
-            die!();
+            fail!();
         }
     }
 
@@ -518,7 +518,7 @@ fn compose_and_run_compiler(
 fn ensure_dir(path: &Path) {
     if os::path_is_dir(path) { return; }
     if !os::make_dir(path, 0x1c0i32) {
-        die!(fmt!("can't make dir %s", path.to_str()));
+        fail!(fmt!("can't make dir %s", path.to_str()));
     }
 }
 
@@ -668,7 +668,7 @@ fn maybe_dump_to_stdout(config: config, out: ~str, err: ~str) {
 
 fn error(err: ~str) { io::stdout().write_line(fmt!("\nerror: %s", err)); }
 
-fn fatal(err: ~str) -> ! { error(err); die!(); }
+fn fatal(err: ~str) -> ! { error(err); fail!(); }
 
 fn fatal_ProcRes(err: ~str, ProcRes: ProcRes) -> ! {
     let msg =
@@ -686,5 +686,5 @@ stderr:\n\
 \n",
              err, ProcRes.cmdline, ProcRes.stdout, ProcRes.stderr);
     io::stdout().write_str(msg);
-    die!();
+    fail!();
 }

src/libcargo/cargo.rc

@@ -295,7 +295,7 @@ pub fn load_link(mis: ~[@ast::meta_item]) -> (Option<~str>,
                     _ => { }
                 }
             }
-            _ => die!(~"load_link: meta items must be name-values")
+            _ => fail!(~"load_link: meta items must be name-values")
         }
     }
     (name, vers, uuid)
@@ -332,7 +332,7 @@ pub fn load_crate(filename: &Path) -> Option<Crate> {
                 }
             }
             _ => {
-                die!(~"crate attributes may not contain " +
+                fail!(~"crate attributes may not contain " +
                      ~"meta_words");
             }
         }
@@ -435,7 +435,7 @@ pub fn rest(s: ~str, start: uint) -> ~str {
 pub fn need_dir(s: &Path) {
     if os::path_is_dir(s) { return; }
     if !os::make_dir(s, 493_i32 /* oct: 755 */) {
-        die!(fmt!("can't make_dir %s", s.to_str()));
+        fail!(fmt!("can't make_dir %s", s.to_str()));
     }
 }
 
@@ -453,14 +453,14 @@ pub fn valid_pkg_name(s: &str) -> bool {
 
 pub fn parse_source(name: ~str, j: &json::Json) -> @Source {
     if !valid_pkg_name(name) {
-        die!(fmt!("'%s' is an invalid source name", name));
+        fail!(fmt!("'%s' is an invalid source name", name));
     }
 
     match *j {
         json::Object(ref j) => {
             let mut url = match j.find(&~"url") {
                 Some(&json::String(u)) => copy u,
-                _ => die!(~"needed 'url' field in source")
+                _ => fail!(~"needed 'url' field in source")
             };
             let method = match j.find(&~"method") {
                 Some(&json::String(u)) => copy u,
@@ -485,7 +485,7 @@ pub fn parse_source(name: ~str, j: &json::Json) -> @Source {
                 mut keyfp: keyfp,
                 packages: DVec() };
         }
-        _ => die!(~"needed dict value in source")
+        _ => fail!(~"needed dict value in source")
     };
 }
 
@@ -500,8 +500,8 @@ pub fn try_parse_sources(filename: &Path,
                 debug!("source: %s", *k);
             }
         }
-        Ok(_) => die!(~"malformed sources.json"),
-        Err(e) => die!(fmt!("%s:%s", filename.to_str(), e.to_str()))
+        Ok(_) => fail!(~"malformed sources.json"),
+        Err(e) => fail!(fmt!("%s:%s", filename.to_str(), e.to_str()))
     }
 }
 
@@ -662,7 +662,7 @@ pub fn build_cargo_options(argv: ~[~str]) -> Options {
     let matches = &match getopts::getopts(argv, opts()) {
         result::Ok(m) => m,
         result::Err(f) => {
-            die!(fmt!("%s", getopts::fail_str(f)));
+            fail!(fmt!("%s", getopts::fail_str(f)));
         }
     };
 
@@ -675,10 +675,10 @@ pub fn build_cargo_options(argv: ~[~str]) -> Options {
     let is_install = len > 1u && matches.free[1] == ~"install";
     let is_uninstall = len > 1u && matches.free[1] == ~"uninstall";
 
-    if G && g { die!(~"-G and -g both provided"); }
+    if G && g { fail!(~"-G and -g both provided"); }
 
     if !is_install && !is_uninstall && (g || G) {
-        die!(~"-g and -G are only valid for `install` and `uninstall|rm`");
+        fail!(~"-g and -G are only valid for `install` and `uninstall|rm`");
     }
 
     let mode =
@@ -845,7 +845,7 @@ pub fn install_source(c: &mut Cargo, path: &Path) {
     }
 
     if vec::is_empty(cratefiles) {
-        die!(~"this doesn't look like a rust package (no .rc files)");
+        fail!(~"this doesn't look like a rust package (no .rc files)");
     }
 
     for cratefiles.each |cf| {
@@ -889,7 +889,7 @@ pub fn install_curl(c: &mut Cargo, wd: &Path, url: ~str) {
     let p = run::program_output(~"curl", ~[~"-f", ~"-s", ~"-o",
                                          tarpath.to_str(), url]);
     if p.status != 0 {
-        die!(fmt!("fetch of %s failed: %s", url, p.err));
+        fail!(fmt!("fetch of %s failed: %s", url, p.err));
     }
     run::run_program(~"tar", ~[~"-x", ~"--strip-components=1",
                                ~"-C", wd.to_str(),
@@ -1123,7 +1123,7 @@ pub fn install_query(c: &mut Cargo, wd: &Path, target: ~str) {
 pub fn get_temp_workdir(c: &Cargo) -> Path {
     match tempfile::mkdtemp(&c.workdir, "cargo") {
       Some(wd) => wd,
-      None => die!(fmt!("needed temp dir: %s",
+      None => fail!(fmt!("needed temp dir: %s",
                         c.workdir.to_str()))
     }
 }
@@ -1138,7 +1138,7 @@ pub fn cmd_install(c: &mut Cargo) {
                                                    wd.to_str()]);
 
             if status != 0 {
-                die!(fmt!("could not copy directory: %s", cwd.to_str()));
+                fail!(fmt!("could not copy directory: %s", cwd.to_str()));
             }
 
             install_source(c, &wd);

src/libcargo/pgp.rs

@@ -87,7 +87,7 @@ pub fn init(root: &Path) {
         p.input().write_str(signing_key());
         let s = p.finish();
         if s != 0 {
-            die!(~"pgp init failed");
+            fail!(~"pgp init failed");
         }
     }
 }
@@ -98,7 +98,7 @@ pub fn add(root: &Path, key: &Path) {
         run::program_output(~"gpg", ~[~"--homedir", path.to_str(),
                                       ~"--import", key.to_str()]);
     if p.status != 0 {
-        die!(~"pgp add failed: " + p.out);
+        fail!(~"pgp add failed: " + p.out);
     }
 }
 

src/libcore/char.rs

@@ -150,7 +150,7 @@ pub pure fn is_digit_radix(c: char, radix: uint) -> bool {
 #[inline]
 pub pure fn to_digit(c: char, radix: uint) -> Option<uint> {
     if radix > 36 {
-        die!(fmt!("to_digit: radix %? is to high (maximum 36)", radix));
+        fail!(fmt!("to_digit: radix %? is to high (maximum 36)", radix));
     }
     let val = match c {
       '0' .. '9' => c as uint - ('0' as uint),
@@ -173,7 +173,7 @@ pub pure fn to_digit(c: char, radix: uint) -> Option<uint> {
 #[inline]
 pub pure fn from_digit(num: uint, radix: uint) -> Option<char> {
     if radix > 36 {
-        die!(fmt!("from_digit: radix %? is to high (maximum 36)", num));
+        fail!(fmt!("from_digit: radix %? is to high (maximum 36)", num));
     }
     if num < radix {
         if num < 10 {

src/libcore/condition.rs

@@ -37,7 +37,7 @@ impl<T, U> Condition<T, U> {
 
     fn raise(t: T) -> U {
         let msg = fmt!("Unhandled condition: %s: %?", self.name, t);
-        self.raise_default(t, || die!(copy msg))
+        self.raise_default(t, || fail!(copy msg))
     }
 
     fn raise_default(t: T, default: &fn() -> U) -> U {

src/libcore/dlist.rs

@@ -44,18 +44,18 @@ priv impl<T> DListNode<T> {
         match self.next {
             Some(neighbour) => match neighbour.prev {
               Some(me) => if !managed::mut_ptr_eq(self, me) {
-                  die!(~"Asymmetric next-link in dlist node.")
+                  fail!(~"Asymmetric next-link in dlist node.")
               },
-              None => die!(~"One-way next-link in dlist node.")
+              None => fail!(~"One-way next-link in dlist node.")
             },
             None => ()
         }
         match self.prev {
             Some(neighbour) => match neighbour.next {
               Some(me) => if !managed::mut_ptr_eq(me, self) {
-                  die!(~"Asymmetric prev-link in dlist node.")
+                  fail!(~"Asymmetric prev-link in dlist node.")
               },
-              None => die!(~"One-way prev-link in dlist node.")
+              None => fail!(~"One-way prev-link in dlist node.")
             },
             None => ()
         }
@@ -72,7 +72,7 @@ impl<T> DListNode<T> {
     pure fn next_node(@mut self) -> @mut DListNode<T> {
         match self.next_link() {
             Some(nobe) => nobe,
-            None       => die!(~"This dlist node has no next neighbour.")
+            None       => fail!(~"This dlist node has no next neighbour.")
         }
     }
     /// Get the previous node in the list, if there is one.
@@ -84,7 +84,7 @@ impl<T> DListNode<T> {
     pure fn prev_node(@mut self) -> @mut DListNode<T> {
         match self.prev_link() {
             Some(nobe) => nobe,
-            None       => die!(~"This dlist node has no previous neighbour.")
+            None       => fail!(~"This dlist node has no previous neighbour.")
         }
     }
 }
@@ -136,21 +136,21 @@ priv impl<T> DList<T> {
         // These asserts could be stronger if we had node-root back-pointers,
         // but those wouldn't allow for O(1) append.
         if self.size == 0 {
-            die!(~"This dlist is empty; that node can't be on it.")
+            fail!(~"This dlist is empty; that node can't be on it.")
         }
-        if !nobe.linked { die!(~"That node isn't linked to any dlist.") }
+        if !nobe.linked { fail!(~"That node isn't linked to any dlist.") }
         if !((nobe.prev.is_some()
               || managed::mut_ptr_eq(self.hd.expect(~"headless dlist?"),
                                  nobe)) &&
              (nobe.next.is_some()
               || managed::mut_ptr_eq(self.tl.expect(~"tailless dlist?"),
                                  nobe))) {
-            die!(~"That node isn't on this dlist.")
+            fail!(~"That node isn't on this dlist.")
         }
     }
     fn make_mine(nobe: @mut DListNode<T>) {
         if nobe.prev.is_some() || nobe.next.is_some() || nobe.linked {
-            die!(~"Cannot insert node that's already on a dlist!")
+            fail!(~"Cannot insert node that's already on a dlist!")
         }
         nobe.linked = true;
     }
@@ -322,15 +322,15 @@ impl<T> DList<T> {
     pure fn head_n(@mut self) -> @mut DListNode<T> {
         match self.hd {
             Some(nobe) => nobe,
-            None       => die!(
+            None       => fail!(
                 ~"Attempted to get the head of an empty dlist.")
         }
     }
     /// Get the node at the list's tail, failing if empty. O(1).
     pure fn tail_n(@mut self) -> @mut DListNode<T> {
         match self.tl {
             Some(nobe) => nobe,
-            None       => die!(
+            None       => fail!(
                 ~"Attempted to get the tail of an empty dlist.")
         }
     }
@@ -344,7 +344,7 @@ impl<T> DList<T> {
      */
     fn append(@mut self, them: @mut DList<T>) {
         if managed::mut_ptr_eq(self, them) {
-            die!(~"Cannot append a dlist to itself!")
+            fail!(~"Cannot append a dlist to itself!")
         }
         if them.len() > 0 {
             self.link(self.tl, them.hd);
@@ -361,7 +361,7 @@ impl<T> DList<T> {
      */
     fn prepend(@mut self, them: @mut DList<T>) {
         if managed::mut_ptr_eq(self, them) {
-            die!(~"Cannot prepend a dlist to itself!")
+            fail!(~"Cannot prepend a dlist to itself!")
         }
         if them.len() > 0 {
             self.link(them.tl, self.hd);

src/libcore/dvec.rs

@@ -87,7 +87,7 @@ priv impl<A> DVec<A> {
         unsafe {
             let data: *() = cast::reinterpret_cast(&self.data);
             if data.is_null() {
-                die!(~"Recursive use of dvec");
+                fail!(~"Recursive use of dvec");
             }
         }
     }
@@ -98,7 +98,7 @@ priv impl<A> DVec<A> {
             let mut data = cast::reinterpret_cast(&null::<()>());
             data <-> self.data;
             let data_ptr: *() = cast::reinterpret_cast(&data);
-            if data_ptr.is_null() { die!(~"Recursive use of dvec"); }
+            if data_ptr.is_null() { fail!(~"Recursive use of dvec"); }
             return f(move data);
         }
     }
@@ -175,7 +175,7 @@ impl<A> DVec<A> {
             let mut data = cast::reinterpret_cast(&null::<()>());
             data <-> self.data;
             let data_ptr: *() = cast::reinterpret_cast(&data);
-            if data_ptr.is_null() { die!(~"Recursive use of dvec"); }
+            if data_ptr.is_null() { fail!(~"Recursive use of dvec"); }
             self.data = move ~[move t];
             self.data.push_all_move(move data);
         }
@@ -325,7 +325,7 @@ impl<A: Copy> DVec<A> {
 
         let length = self.len();
         if length == 0 {
-            die!(~"attempt to retrieve the last element of an empty vector");
+            fail!(~"attempt to retrieve the last element of an empty vector");
         }
 
         return self.data[length - 1];