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

And remove spurious fails/unreachable() calls.

7 files changed, 34 insertions, 44 deletions

diff --git a/src/libstd/generic_os.rs b/src/libstd/generic_os.rs
index 0432d136c35..246c7ee1d45 100644
--- a/src/libstd/generic_os.rs
+++ b/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")]
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index bab37b0ba80..516aa25f05b 100644
--- a/src/libstd/io.rs
+++ b/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]; }
         }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 499e3f36061..ca3d9f8b4d7 100644
--- a/src/libstd/json.rs
+++ b/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> {
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 613a4790d36..9f4254f20c4 100644
--- a/src/libstd/list.rs
+++ b/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);
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 6eae6992bcb..ded9e1ee208 100644
--- a/src/libstd/map.rs
+++ b/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) {
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index b9656df7e2f..9c6c1b29c24 100644
--- a/src/libstd/rope.rs
+++ b/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; }
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 8a4d59d9cfa..6a78a23777e 100644
--- a/src/libstd/sort.rs
+++ b/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;