Use loop instead of while(true) in libraries and compiler itself

And remove spurious fails/unreachable() calls.

Author: catamorphism

src/libcore/int.rs

@@ -64,16 +64,15 @@ fn parse_buf(buf: [u8], radix: uint) -> option<int> {
         start = 1u;
     }
     let mut n = 0;
-    while true {
+    loop {
         alt char::to_digit(buf[i] as char, radix) {
           some(d) { n += (d as int) * power; }
           none { ret none; }
         }
         power *= radix as int;
         if i <= start { ret some(n); }
         i -= 1u;
-    }
-    fail;
+    };
 }
 
 #[doc = "Parse a string to an int"]

src/libcore/u64.rs

@@ -70,16 +70,15 @@ fn from_str(buf: str, radix: u64) -> option<u64> {
     if str::len(buf) == 0u { ret none; }
     let mut i = str::len(buf) - 1u;
     let mut power = 1u64, n = 0u64;
-    while true {
+    loop {
         alt char::to_digit(buf[i] as char, radix as uint) {
           some(d) { n += d as u64 * power; }
           none { ret none; }
         }
         power *= radix;
         if i == 0u { ret some(n); }
         i -= 1u;
-    }
-    fail;
+    };
 }
 
 #[doc = "Computes the bitwise complement"]

src/libcore/uint.rs

@@ -133,16 +133,15 @@ fn parse_buf(buf: [u8], radix: uint) -> option<uint> {
     let mut i = vec::len(buf) - 1u;
     let mut power = 1u;
     let mut n = 0u;
-    while true {
+    loop {
         alt char::to_digit(buf[i] as char, radix) {
           some(d) { n += d * power; }
           none { ret none; }
         }
         power *= radix;
         if i == 0u { ret some(n); }
         i -= 1u;
-    }
-    fail;
+    };
 }
 
 #[doc = "Parse a string to an int"]

src/libstd/generic_os.rs

@@ -59,7 +59,7 @@ fn setenv(n: str, v: str) {
 #[cfg(target_os = "win32")]
 fn getenv(n: str) -> option<str> {
     let nsize = 256u;
-    while true {
+    loop {
         let v: [u8] = [];
         vec::reserve(v, nsize);
         let res =
@@ -80,7 +80,6 @@ fn getenv(n: str) -> option<str> {
             ret option::some(str::from_bytes(v)); // UTF-8 or fail
         } else { nsize = res; }
     }
-    core::unreachable();
 }
 
 #[cfg(target_os = "win32")]

src/libstd/io.rs

@@ -104,7 +104,7 @@ impl reader_util for reader {
 
     fn read_line() -> str {
         let buf: [u8] = [];
-        while true {
+        loop {
             let ch = self.read_byte();
             if ch == -1 || ch == 10 { break; }
             buf += [ch as u8];
@@ -114,7 +114,7 @@ impl reader_util for reader {
 
     fn read_c_str() -> str {
         let buf: [u8] = [];
-        while true {
+        loop {
             let ch = self.read_byte();
             if ch < 1 { break; } else { buf += [ch as u8]; }
         }

src/libstd/json.rs

@@ -383,23 +383,23 @@ impl parser for parser {
             ret ok(list(values));
         }
 
-        while true {
+        loop {
             alt self.parse_value() {
               ok(v) { vec::push(values, v); }
               e { ret e; }
             }
 
             self.parse_whitespace();
-            if self.eof() { break; }
+            if self.eof() {
+                ret self.error("EOF while parsing list");
+            }
 
             alt self.ch {
               ',' { self.bump(); }
               ']' { self.bump(); ret ok(list(values)); }
               _ { ret self.error("expecting ',' or ']'"); }
             }
-        }
-
-        ret self.error("EOF while parsing list");
+        };
     }
 
     fn parse_object() -> result::t<json, error> {

src/libstd/list.rs

@@ -43,27 +43,25 @@ is returned. If `f` matches no elements then none is returned.
 fn find<T: copy, U: copy>(ls: list<T>, f: fn(T) -> option<U>)
     -> option<U> {
     let ls = ls;
-    while true {
+    loop {
         alt ls {
           cons(hd, tl) {
             alt f(hd) { none { ls = *tl; } some(rs) { ret some(rs); } }
           }
-          nil { break; }
+          nil { ret none; }
         }
-    }
-    ret none;
+    };
 }
 
 #[doc = "Returns true if a list contains an element with the given value"]
 fn has<T: copy>(ls: list<T>, elt: T) -> bool {
     let ls = ls;
-    while true {
+    loop {
         alt ls {
           cons(hd, tl) { if elt == hd { ret true; } else { ls = *tl; } }
-          nil { break; }
+          nil { ret false; }
         }
-    }
-    ret false;
+    };
 }
 
 #[doc = "Returns true if the list is empty"]
@@ -113,7 +111,7 @@ fn iter<T>(l: list<T>, f: fn(T)) {
       cons(hd, tl) {
         f(hd);
         let cur = tl;
-        while true {
+        loop {
             alt *cur {
               cons(hd, tl) {
                 f(hd);

src/libstd/map.rs

@@ -96,7 +96,7 @@ mod chained {
         e_root: @entry<K,V>) -> search_result<K,V> {
         let e0 = e_root;
         let comp = 1u;   // for logging
-        while true {
+        loop {
             alt e0.next {
               absent {
                 #debug("search_tbl: absent, comp %u, hash %u, idx %u",
@@ -115,8 +115,7 @@ mod chained {
                 }
               }
             }
-        }
-        core::unreachable();
+        };
     }
 
     fn search_tbl<K: copy, V: copy>(
@@ -209,7 +208,7 @@ mod chained {
     fn foreach_entry<K: copy, V: copy>(chain0: chain<K,V>,
                                      blk: fn(@entry<K,V>)) {
         let chain = chain0;
-        while true {
+        loop {
             alt chain {
               absent { ret; }
               present(entry) {

src/libstd/rope.rs

@@ -800,7 +800,7 @@ mod node {
         let buf = vec::to_mut(vec::init_elt(byte_len(node), 0u8));
         let offset = 0u;//Current position in the buffer
         let it = leaf_iterator::start(node);
-        while true {
+        loop {
             alt(leaf_iterator::next(it)) {
               option::none { break; }
               option::some(x) {
@@ -862,7 +862,7 @@ mod node {
         //1. Gather all leaves as a forest
         let forest = [mutable];
         let it = leaf_iterator::start(node);
-        while true {
+        loop {
             alt (leaf_iterator::next(it)) {
               option::none   { break; }
               option::some(x) { forest += [mutable @leaf(x)]; }
@@ -896,7 +896,7 @@ mod node {
     fn sub_bytes(node: @node, byte_offset: uint, byte_len: uint) -> @node {
         let node        = node;
         let byte_offset = byte_offset;
-        while true {
+        loop {
             if byte_offset == 0u && byte_len == node::byte_len(node) {
                 ret node;
             }
@@ -932,8 +932,7 @@ mod node {
                 }
               }
             }
-        }
-        core::unreachable();
+        };
     }
 
     #[doc ="
@@ -958,7 +957,7 @@ mod node {
     fn sub_chars(node: @node, char_offset: uint, char_len: uint) -> @node {
         let node        = node;
         let char_offset = char_offset;
-        while true {
+        loop {
             alt(*node) {
               node::leaf(x) {
                 if char_offset == 0u && char_len == x.char_len {
@@ -997,8 +996,7 @@ mod node {
                 }
               }
             }
-        }
-        core::unreachable();
+        };
     }
 
     fn concat2(left: @node, right: @node) -> @node {
@@ -1066,7 +1064,7 @@ mod node {
     "]
     fn loop_leaves(node: @node, it: fn(leaf) -> bool) -> bool{
         let current = node;
-        while true {
+        loop {
             alt(*current) {
               leaf(x) {
                 ret it(x);
@@ -1079,8 +1077,7 @@ mod node {
                 }
               }
             }
-        }
-        core::unreachable();
+        };
     }
 
     #[doc ="
@@ -1103,7 +1100,7 @@ mod node {
     fn char_at(node: @node, pos: uint) -> char {
         let node    = node;
         let pos     = pos;
-        while true {
+        loop {
             alt *node {
               leaf(x) {
                 ret str::char_at(*x.content, pos);
@@ -1114,8 +1111,7 @@ mod node {
                        else { pos -= left_len; right };
               }
             }
-        }
-        core::unreachable();
+        };
     }
 
     mod leaf_iterator {
@@ -1139,7 +1135,7 @@ mod node {
 
         fn next(it: t) -> option<leaf> {
             if it.stackpos < 0 { ret option::none; }
-            while true {
+            loop {
                 let current = it.stack[it.stackpos];
                 it.stackpos -= 1;
                 alt(*current) {
@@ -1153,8 +1149,7 @@ mod node {
                     ret option::some(x);
                   }
                 }
-            }
-            core::unreachable();
+            };
         }
     }
 
@@ -1182,7 +1177,7 @@ mod node {
         }
 
         fn next(it: t) -> option<char> {
-            while true {
+            loop {
                 alt(get_current_or_next_leaf(it)) {
                   option::none { ret option::none; }
                   option::some(_) {
@@ -1197,8 +1192,7 @@ mod node {
                     }
                   }
                 }
-            }
-            core::unreachable();
+            };
         }
 
         fn get_current_or_next_leaf(it: t) -> option<leaf> {
@@ -1326,7 +1320,7 @@ mod tests {
 
         let len = 0u;
         let it  = iterator::char::start(r);
-        while true {
+        loop {
             alt(node::char_iterator::next(it)) {
               option::none { break; }
               option::some(_) { len += 1u; }

src/libstd/sort.rs

@@ -100,7 +100,7 @@ fn qsort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
     let j: int = right;
     let p: int = i;
     let q: int = j;
-    while true {
+    loop {
         i += 1;
         while compare_func_lt(copy arr[i], v) { i += 1; }
         j -= 1;