annotate libstd and start enforcing mutability

18 files changed, 144 insertions, 137 deletions

diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index ee210780a26..9fb33d8bd5a 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -45,7 +45,7 @@ fn process(v0: t, v1: t, op: fn(uint, uint) -> uint) -> bool {
     let len = vec::len(v1.storage);
     assert (vec::len(v0.storage) == len);
     assert (v0.nbits == v1.nbits);
-    let changed = false;
+    let mut changed = false;
     uint::range(0u, len) {|i|
         let w0 = v0.storage[i];
         let w1 = v1.storage[i];
@@ -113,7 +113,7 @@ fn equal(v0: t, v1: t) -> bool {
     //        we can eliminate this painful while-loop
 
     let len = vec::len(v1.storage);
-    let i = 0u;
+    let mut i = 0u;
     while i < len {
         if v0.storage[i] != v1.storage[i] { ret false; }
         i = i + 1u;
@@ -201,7 +201,7 @@ The resulting string has the same length as the bitvector, and each character
 is either '0' or '1'.
 "]
 fn to_str(v: t) -> str {
-    let rs = "";
+    let mut rs = "";
     for i: uint in to_vec(v) { if i == 1u { rs += "1"; } else { rs += "0"; } }
     ret rs;
 }
@@ -215,7 +215,7 @@ bitvector and vector must have the same length
 fn eq_vec(v0: t, v1: [uint]) -> bool {
     assert (v0.nbits == vec::len::<uint>(v1));
     let len = v0.nbits;
-    let i = 0u;
+    let mut i = 0u;
     while i < len {
         let w0 = get(v0, i);
         let w1 = v1[i];
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index dfd97978d2a..dc5b2a66edb 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -26,9 +26,9 @@ fn create<T: copy>() -> t<T> {
     fn grow<T: copy>(nelts: uint, lo: uint, elts: [mutable cell<T>]) ->
        [mutable cell<T>] {
         assert (nelts == vec::len(elts));
-        let rv = [mutable];
+        let mut rv = [mutable];
 
-        let i = 0u;
+        let mut i = 0u;
         let nalloc = uint::next_power_of_two(nelts + 1u);
         while i < nalloc {
             if i < nelts {
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 2e08b51be16..364eb16408c 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -77,7 +77,7 @@ fn doc_at(data: @[u8], start: uint) -> tagged_doc {
 }
 
 fn maybe_get_doc(d: doc, tg: uint) -> option<doc> {
-    let pos = d.start;
+    let mut pos = d.start;
     while pos < d.end {
         let elt_tag = vuint_at(*d.data, pos);
         let elt_size = vuint_at(*d.data, elt_tag.next);
@@ -100,7 +100,7 @@ fn get_doc(d: doc, tg: uint) -> doc {
 }
 
 fn docs(d: doc, it: fn(uint, doc)) {
-    let pos = d.start;
+    let mut pos = d.start;
     while pos < d.end {
         let elt_tag = vuint_at(*d.data, pos);
         let elt_size = vuint_at(*d.data, elt_tag.next);
@@ -110,7 +110,7 @@ fn docs(d: doc, it: fn(uint, doc)) {
 }
 
 fn tagged_docs(d: doc, tg: uint, it: fn(doc)) {
-    let pos = d.start;
+    let mut pos = d.start;
     while pos < d.end {
         let elt_tag = vuint_at(*d.data, pos);
         let elt_size = vuint_at(*d.data, elt_tag.next);
@@ -154,20 +154,19 @@ fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 }
 type writer = {writer: io::writer, mutable size_positions: [uint]};
 
 fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
-    let buf: [u8];
-    alt size {
-      1u { buf = [0x80u8 | (n as u8)]; }
-      2u { buf = [0x40u8 | ((n >> 8_u) as u8), n as u8]; }
+    let buf: [u8] = alt size {
+      1u { [0x80u8 | (n as u8)] }
+      2u { [0x40u8 | ((n >> 8_u) as u8), n as u8] }
       3u {
-        buf = [0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
-               n as u8];
+        [0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
+               n as u8]
       }
       4u {
-        buf = [0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
-               (n >> 8_u) as u8, n as u8];
+        [0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
+               (n >> 8_u) as u8, n as u8]
       }
       _ { fail #fmt("vint to write too big: %?", n); }
-    }
+    };
     w.write(buf);
 }
 
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 8d6aade9fad..75abfd6257b 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -171,21 +171,21 @@ fn getopts(args: [str], opts: [opt]) -> result unsafe {
     let n_opts = vec::len::<opt>(opts);
     fn f(_x: uint) -> [optval] { ret []; }
     let vals = vec::to_mut(vec::from_fn(n_opts, f));
-    let free: [str] = [];
+    let mut free: [str] = [];
     let l = vec::len(args);
-    let i = 0u;
+    let mut i = 0u;
     while i < l {
         let cur = args[i];
         let curlen = str::len(cur);
         if !is_arg(cur) {
             free += [cur];
         } else if str::eq(cur, "--") {
-            let j = i + 1u;
+            let mut j = i + 1u;
             while j < l { free += [args[j]]; j += 1u; }
             break;
         } else {
-            let names;
-            let i_arg = option::none::<str>;
+            let mut names;
+            let mut i_arg = option::none::<str>;
             if cur[1] == '-' as u8 {
                 let tail = str::slice(cur, 2u, curlen);
                 let tail_eq = str::splitn_char(tail, '=', 1u);
@@ -198,7 +198,7 @@ fn getopts(args: [str], opts: [opt]) -> result unsafe {
                         option::some::<str>(tail_eq[1]);
                 }
             } else {
-                let j = 1u;
+                let mut j = 1u;
                 names = [];
                 while j < curlen {
                     let range = str::char_range_at(cur, j);
@@ -206,14 +206,13 @@ fn getopts(args: [str], opts: [opt]) -> result unsafe {
                     j = range.next;
                 }
             }
-            let name_pos = 0u;
+            let mut name_pos = 0u;
             for nm: name in names {
                 name_pos += 1u;
-                let optid;
-                alt find_opt(opts, nm) {
-                  some(id) { optid = id; }
+                let optid = alt find_opt(opts, nm) {
+                  some(id) { id }
                   none { ret err(unrecognized_option(name_str(nm))); }
-                }
+                };
                 alt opts[optid].hasarg {
                   no {
                     if !option::is_none::<str>(i_arg) {
@@ -289,7 +288,7 @@ Returns a vector of the arguments provided to all matches of the given option.
 Used when an option accepts multiple values.
 "]
 fn opt_strs(m: match, nm: str) -> [str] {
-    let acc: [str] = [];
+    let mut acc: [str] = [];
     for v: optval in opt_vals(m, nm) {
         alt v { val(s) { acc += [s]; } _ { } }
     }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 4e197d30c95..b5f526da2ed 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -46,7 +46,7 @@ fn to_writer(wr: io::writer, j: json) {
       num(n) { wr.write_str(float::to_str(n, 6u)); }
       string(s) {
         wr.write_char('"');
-        let escaped = "";
+        let mut escaped = "";
         str::chars_iter(s) { |c|
             alt c {
               '"' { escaped += "\\\""; }
@@ -67,7 +67,7 @@ fn to_writer(wr: io::writer, j: json) {
       }
       list(v) {
         wr.write_char('[');
-        let first = true;
+        let mut first = true;
         vec::iter(v) { |item|
             if !first {
                 wr.write_str(", ");
@@ -84,7 +84,7 @@ fn to_writer(wr: io::writer, j: json) {
         }
 
         wr.write_str("{ ");
-        let first = true;
+        let mut first = true;
         d.items { |key, value|
             if !first {
                 wr.write_str(", ");
@@ -189,14 +189,14 @@ impl parser for parser {
     }
 
     fn parse_number() -> result<json, error> {
-        let neg = 1f;
+        let mut neg = 1f;
 
         if self.ch == '-' {
             self.bump();
             neg = -1f;
         }
 
-        let res =  alt self.parse_integer() {
+        let mut res = alt self.parse_integer() {
           ok(res) { res }
           err(e) { ret err(e); }
         };
@@ -219,7 +219,7 @@ impl parser for parser {
     }
 
     fn parse_integer() -> result<float, error> {
-        let res = 0f;
+        let mut res = 0f;
 
         alt self.ch {
           '0' {
@@ -259,8 +259,8 @@ impl parser for parser {
           _ { ret self.error("invalid number"); }
         }
 
-        let res = res;
-        let dec = 1f;
+        let mut res = res;
+        let mut dec = 1f;
         while !self.eof() {
             alt self.ch {
               '0' to '9' {
@@ -279,9 +279,9 @@ impl parser for parser {
     fn parse_exponent(res: float) -> result<float, error> {
         self.bump();
 
-        let res = res;
-        let exp = 0u;
-        let neg_exp = false;
+        let mut res = res;
+        let mut exp = 0u;
+        let mut neg_exp = false;
 
         alt self.ch {
           '+' { self.bump(); }
@@ -318,8 +318,8 @@ impl parser for parser {
     }
 
     fn parse_str() -> result<str, error> {
-        let escape = false;
-        let res = "";
+        let mut escape = false;
+        let mut res = "";
 
         while !self.eof() {
             self.bump();
@@ -336,8 +336,8 @@ impl parser for parser {
                   't' { str::push_char(res, '\t'); }
                   'u' {
                       // Parse \u1234.
-                      let i = 0u;
-                      let n = 0u;
+                      let mut i = 0u;
+                      let mut n = 0u;
                       while i < 4u {
                           alt self.next_char() {
                             '0' to '9' {
@@ -346,6 +346,7 @@ impl parser for parser {
                             }
                             _ { ret self.error("invalid \\u escape"); }
                           }
+                          i += 1u;
                       }
 
                       // Error out if we didn't parse 4 digits.
@@ -376,7 +377,7 @@ impl parser for parser {
         self.bump();
         self.parse_whitespace();
 
-        let values = [];
+        let mut values = [];
 
         if self.ch == ']' {
             self.bump();
@@ -479,7 +480,7 @@ fn eq(value0: json, value1: json) -> bool {
       (list(l0), list(l1)) { vec::all2(l0, l1, eq) }
       (dict(d0), dict(d1)) {
           if d0.size() == d1.size() {
-              let equal = true;
+              let mut equal = true;
               d0.items { |k, v0|
                   alt d1.find(k) {
                     some(v1) {
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index a33ba0b647a..2636aa2bde1 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -28,7 +28,7 @@ accumulated result.
 * f - The function to apply
 "]
 fn foldl<T: copy, U>(ls: list<U>, z: T, f: fn(T, U) -> T) -> T {
-    let accum: T = z;
+    let mut accum: T = z;
     iter(ls) {|elt| accum = f(accum, elt);}
     accum
 }
@@ -41,7 +41,7 @@ When function `f` returns true then an option containing the element
 is returned. If `f` matches no elements then none is returned.
 "]
 fn find<T: copy>(ls: list<T>, f: fn(T) -> bool) -> option<T> {
-    let ls = ls;
+    let mut ls = ls;
     loop {
         alt ls {
           cons(hd, tl) {
@@ -55,7 +55,7 @@ fn find<T: copy>(ls: list<T>, f: fn(T) -> bool) -> option<T> {
 
 #[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;
+    let mut ls = ls;
     loop {
         alt ls {
           cons(hd, tl) { if elt == hd { ret true; } else { ls = *tl; } }
@@ -79,7 +79,7 @@ pure fn is_not_empty<T: copy>(ls: list<T>) -> bool {
 
 #[doc = "Returns the length of a list"]
 fn len<T>(ls: list<T>) -> uint {
-    let count = 0u;
+    let mut count = 0u;
     iter(ls) {|_e| count += 1u;}
     count
 }
@@ -110,7 +110,7 @@ fn iter<T>(l: list<T>, f: fn(T)) {
     alt l {
       cons(hd, tl) {
         f(hd);
-        let cur = tl;
+        let mut cur = tl;
         loop {
             alt *cur {
               cons(hd, tl) {
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 517654d1c15..53eb04fe070 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -94,8 +94,8 @@ mod chained {
     fn search_rem<K: copy, V: copy>(
         tbl: t<K,V>, k: K, h: uint, idx: uint,
         e_root: @entry<K,V>) -> search_result<K,V> {
-        let e0 = e_root;
-        let comp = 1u;   // for logging
+        let mut e0 = e_root;
+        let mut comp = 1u;   // for logging
         loop {
             alt e0.next {
               absent {
@@ -207,7 +207,7 @@ mod chained {
 
     fn foreach_entry<K: copy, V: copy>(chain0: chain<K,V>,
                                      blk: fn(@entry<K,V>)) {
-        let chain = chain0;
+        let mut chain = chain0;
         loop {
             alt chain {
               absent { ret; }
@@ -222,7 +222,8 @@ mod chained {
 
     fn foreach_chain<K: copy, V: copy>(chains: [const chain<K,V>],
                                      blk: fn(@entry<K,V>)) {
-        let i = 0u, n = vec::len(chains);
+        let mut i = 0u;
+        let n = vec::len(chains);
         while i < n {
             foreach_entry(chains[i], blk);
             i += 1u;
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index 95c532129e7..8f790c88ae9 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -5,36 +5,37 @@ fn md4(msg: [u8]) -> {a: u32, b: u32, c: u32, d: u32} {
     let orig_len: u64 = (vec::len(msg) * 8u) as u64;
 
     // pad message
-    let msg = msg + [0x80u8];
-    let bitlen = orig_len + 8u64;
+    let mut msg = msg + [0x80u8];
+    let mut bitlen = orig_len + 8u64;
     while (bitlen + 64u64) % 512u64 > 0u64 {
         msg += [0u8];
         bitlen += 8u64;
     }
 
     // append length
-    let i = 0u64;
+    let mut i = 0u64;
     while i < 8u64 {
         msg += [(orig_len >> (i * 8u64)) as u8];
         i += 1u64;
     }
 
-    let a = 0x67452301u32;
-    let b = 0xefcdab89u32;
-    let c = 0x98badcfeu32;
-    let d = 0x10325476u32;
+    let mut a = 0x67452301u32;
+    let mut b = 0xefcdab89u32;
+    let mut c = 0x98badcfeu32;
+    let mut d = 0x10325476u32;
 
     fn rot(r: int, x: u32) -> u32 {
         let r = r as u32;
         (x << r) | (x >> (32u32 - r))
     }
 
-    let i = 0u, e = vec::len(msg);
+    let mut i = 0u;
+    let e = vec::len(msg);
     let x = vec::to_mut(vec::from_elem(16u, 0u32));
     while i < e {
         let aa = a, bb = b, cc = c, dd = d;
 
-        let j = 0u, base = i;
+        let mut j = 0u, base = i;
         while j < 16u {
             x[j] = (msg[base] as u32) + (msg[base + 1u] as u32 << 8u32) +
                 (msg[base + 2u] as u32 << 16u32) +
@@ -42,7 +43,7 @@ fn md4(msg: [u8]) -> {a: u32, b: u32, c: u32, d: u32} {
             j += 1u; base += 4u;
         }
 
-        let j = 0u;
+        let mut j = 0u;
         while j < 16u {
             a = rot(3, a + ((b & c) | (!b & d)) + x[j]);
             j += 1u;
@@ -54,7 +55,8 @@ fn md4(msg: [u8]) -> {a: u32, b: u32, c: u32, d: u32} {
             j += 1u;
         }
 
-        let j = 0u, q = 0x5a827999u32;
+        let mut j = 0u;
+        let q = 0x5a827999u32;
         while j < 4u {
             a = rot(3, a + ((b & c) | ((b & d) | (c & d))) + x[j] + q);
             d = rot(5, d + ((a & b) | ((a & c) | (b & c))) + x[j + 4u] + q);
@@ -63,7 +65,8 @@ fn md4(msg: [u8]) -> {a: u32, b: u32, c: u32, d: u32} {
             j += 1u;
         }
 
-        let j = 0u, q = 0x6ed9eba1u32;
+        let mut j = 0u;
+        let q = 0x6ed9eba1u32;
         while j < 8u {
             let jj = if j > 2u { j - 3u } else { j };
             a = rot(3, a + (b ^ c ^ d) + x[jj] + q);
@@ -84,9 +87,9 @@ fn md4_str(msg: [u8]) -> str {
     fn app(a: u32, b: u32, c: u32, d: u32, f: fn(u32)) {
         f(a); f(b); f(c); f(d);
     }
-    let result = "";
+    let mut result = "";
     app(a, b, c, d) {|u|
-        let i = 0u32;
+        let mut i = 0u32;
         while i < 4u32 {
             let byte = (u >> (i * 8u32)) as u8;
             if byte <= 16u8 { result += "0"; }
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index e7763050cfa..eadd4b3e0dd 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -155,7 +155,7 @@ measure to ensure that the result is balanced.
 "]
 fn concat(v: [rope]) -> rope {
     //Copy `v` into a mutable vector
-    let len   = vec::len(v);
+    let mut len = vec::len(v);
     if len == 0u { ret node::empty; }
     let ropes = vec::to_mut(vec::from_elem(len, v[0]));
     uint::range(1u, len) {|i|
@@ -684,12 +684,12 @@ mod node {
             ret candidate;
         } else {
             //Firstly, split `str` in slices of hint_max_leaf_char_len
-            let leaves = uint::div_ceil(char_len, hint_max_leaf_char_len);
+            let mut leaves = uint::div_ceil(char_len, hint_max_leaf_char_len);
             //Number of leaves
             let nodes  = vec::to_mut(vec::from_elem(leaves, candidate));
 
-            let i = 0u;
-            let offset = byte_start;
+            let mut i = 0u;
+            let mut offset = byte_start;
             let first_leaf_char_len =
                 if char_len%hint_max_leaf_char_len == 0u {
                   hint_max_leaf_char_len
@@ -753,17 +753,17 @@ mod node {
                execution and should be discarded as meaningless afterwards.
     "]
     fn tree_from_forest_destructive(forest: [mutable @node]) -> @node {
-        let i = 0u;
-        let len = vec::len(forest);
+        let mut i = 0u;
+        let mut len = vec::len(forest);
         while len > 1u {
             i = 0u;
             while i < len - 1u {//Concat nodes 0 with 1, 2 with 3 etc.
-                let left  = forest[i];
-                let right = forest[i+1u];
+                let mut left  = forest[i];
+                let mut right = forest[i+1u];
                 let left_len = char_len(left);
                 let right_len= char_len(right);
-                let left_height= height(left);
-                let right_height=height(right);
+                let mut left_height= height(left);
+                let mut right_height=height(right);
                 if left_len + right_len > hint_max_leaf_char_len {
                     if left_len <= hint_max_leaf_char_len {
                         left = flatten(left);
@@ -797,16 +797,17 @@ mod node {
     }
 
     fn serialize_node(node: @node) -> str unsafe {
-        let buf = vec::to_mut(vec::from_elem(byte_len(node), 0u8));
-        let offset = 0u;//Current position in the buffer
+        let mut buf = vec::to_mut(vec::from_elem(byte_len(node), 0u8));
+        let mut offset = 0u;//Current position in the buffer
         let it = leaf_iterator::start(node);
         loop {
             alt(leaf_iterator::next(it)) {
               option::none { break; }
               option::some(x) {
                 //TODO: Replace with memcpy or something similar
-                let local_buf: [u8] = unsafe::reinterpret_cast(*x.content);
-                let i = x.byte_offset;
+                let mut local_buf: [u8] =
+                    unsafe::reinterpret_cast(*x.content);
+                let mut i = x.byte_offset;
                 while i < x.byte_len {
                     buf[offset] = local_buf[i];
                     offset += 1u;
@@ -860,7 +861,7 @@ mod node {
     fn bal(node: @node) -> option<@node> {
         if height(node) < hint_max_node_height { ret option::none; }
         //1. Gather all leaves as a forest
-        let forest = [mutable];
+        let mut forest = [mutable];
         let it = leaf_iterator::start(node);
         loop {
             alt (leaf_iterator::next(it)) {
@@ -894,8 +895,8 @@ mod node {
     valid positions in `node`.
     "]
     fn sub_bytes(node: @node, byte_offset: uint, byte_len: uint) -> @node {
-        let node        = node;
-        let byte_offset = byte_offset;
+        let mut node        = node;
+        let mut byte_offset = byte_offset;
         loop {
             if byte_offset == 0u && byte_len == node::byte_len(node) {
                 ret node;
@@ -955,8 +956,8 @@ mod node {
     valid positions in `node`.
     "]
     fn sub_chars(node: @node, char_offset: uint, char_len: uint) -> @node {
-        let node        = node;
-        let char_offset = char_offset;
+        let mut node        = node;
+        let mut char_offset = char_offset;
         loop {
             alt(*node) {
               node::leaf(x) {
@@ -1018,8 +1019,8 @@ mod node {
     fn cmp(a: @node, b: @node) -> int {
         let ita = char_iterator::start(a);
         let itb = char_iterator::start(b);
-        let result = 0;
-        let pos = 0u;
+        let mut result = 0;
+        let mut pos = 0u;
         while result == 0 {
             alt((char_iterator::next(ita), char_iterator::next(itb))) {
               (option::none, option::none) {
@@ -1063,7 +1064,7 @@ mod node {
     that is if `it` returned `false` at any point.
     "]
     fn loop_leaves(node: @node, it: fn(leaf) -> bool) -> bool{
-        let current = node;
+        let mut current = node;
         loop {
             alt(*current) {
               leaf(x) {
@@ -1098,8 +1099,8 @@ mod node {
     length of the largest leaf.
     "]
     fn char_at(node: @node, pos: uint) -> char {
-        let node    = node;
-        let pos     = pos;
+        let mut node    = node;
+        let mut pos     = pos;
         loop {
             alt *node {
               leaf(x) {
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 7d4bc705c1a..d7deb7a3d06 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -82,13 +82,13 @@ fn sha1() -> sha1 {
         // FIXME: Make precondition
         assert (vec::len(st.h) == digest_buf_len);
         assert (vec::len(st.work_buf) == work_buf_len);
-        let t: int; // Loop counter
+        let mut t: int; // Loop counter
         let w = st.work_buf;
 
         // Initialize the first 16 words of the vector w
         t = 0;
         while t < 16 {
-            let tmp;
+            let mut tmp;
             tmp = (st.msg_block[t * 4] as u32) << 24u32;
             tmp = tmp | (st.msg_block[t * 4 + 1] as u32) << 16u32;
             tmp = tmp | (st.msg_block[t * 4 + 2] as u32) << 8u32;
@@ -103,12 +103,12 @@ fn sha1() -> sha1 {
             w[t] = circular_shift(1u32, val);
             t += 1;
         }
-        let a = st.h[0];
-        let b = st.h[1];
-        let c = st.h[2];
-        let d = st.h[3];
-        let e = st.h[4];
-        let temp: u32;
+        let mut a = st.h[0];
+        let mut b = st.h[1];
+        let mut c = st.h[2];
+        let mut d = st.h[3];
+        let mut e = st.h[4];
+        let mut temp: u32;
         t = 0;
         while t < 20 {
             temp = circular_shift(5u32, a) + (b & c | !b & d) + e + w[t] + k0;
@@ -160,7 +160,7 @@ fn sha1() -> sha1 {
     }
     fn mk_result(st: sha1state) -> [u8] {
         if !st.computed { pad_msg(st); st.computed = true; }
-        let rs: [u8] = [];
+        let mut rs: [u8] = [];
         for hpart: u32 in st.h {
             let a = (hpart >> 24u32 & 0xFFu32) as u8;
             let b = (hpart >> 16u32 & 0xFFu32) as u8;
@@ -237,7 +237,7 @@ fn sha1() -> sha1 {
         fn result() -> [u8] { ret mk_result(self); }
         fn result_str() -> str {
             let r = mk_result(self);
-            let s = "";
+            let mut s = "";
             for b: u8 in r { s += uint::to_str(b as uint, 16u); }
             ret s;
         }
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index 3ddc2bb5d6e..e90fb1abd96 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -66,7 +66,7 @@ fn max_key<T>(m: smallintmap<T>) -> uint {
 #[doc = "Implements the map::map interface for smallintmap"]
 impl <V: copy> of map::map<uint, V> for smallintmap<V> {
     fn size() -> uint {
-        let sz = 0u;
+        let mut sz = 0u;
         for item in self.v {
             alt item { some(_) { sz += 1u; } _ {} }
         }
@@ -90,7 +90,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
     fn find(&&key: uint) -> option<V> { find(self, key) }
     fn rehash() { fail }
     fn items(it: fn(&&uint, V)) {
-        let idx = 0u;
+        let mut idx = 0u;
         for item in self.v {
             alt item {
               some(elt) {
@@ -102,7 +102,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
         }
     }
     fn keys(it: fn(&&uint)) {
-        let idx = 0u;
+        let mut idx = 0u;
         for item in self.v {
             if item != none { it(idx); }
             idx += 1u;
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index 6a78a23777e..ce3982fb433 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -33,12 +33,12 @@ fn merge_sort<T: copy>(le: le<T>, v: [const T]) -> [T] {
     }
 
     fn merge<T: copy>(le: le<T>, a: [T], b: [T]) -> [T] {
-        let rs = [];
+        let mut rs = [];
         vec::reserve(rs, len(a) + len(b));
         let a_len = len(a);
-        let a_ix = 0u;
+        let mut a_ix = 0u;
         let b_len = len(b);
-        let b_ix = 0u;
+        let mut b_ix = 0u;
         while a_ix < a_len && b_ix < b_len {
             if le(a[a_ix], b[b_ix]) {
                 rs += [a[a_ix]];
@@ -55,8 +55,8 @@ fn part<T: copy>(compare_func: le<T>, arr: [mutable T], left: uint,
                 right: uint, pivot: uint) -> uint {
     let pivot_value = arr[pivot];
     arr[pivot] <-> arr[right];
-    let storage_index: uint = left;
-    let i: uint = left;
+    let mut storage_index: uint = left;
+    let mut i: uint = left;
     while i < right {
         if compare_func(copy arr[i], pivot_value) {
             arr[i] <-> arr[storage_index];
@@ -96,10 +96,10 @@ fn qsort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
                   arr: [mutable T], left: int, right: int) {
     if right <= left { ret; }
     let v: T = arr[right];
-    let i: int = left - 1;
-    let j: int = right;
-    let p: int = i;
-    let q: int = j;
+    let mut i: int = left - 1;
+    let mut j: int = right;
+    let mut p: int = i;
+    let mut q: int = j;
     loop {
         i += 1;
         while compare_func_lt(copy arr[i], v) { i += 1; }
@@ -122,7 +122,7 @@ fn qsort3<T: copy>(compare_func_lt: le<T>, compare_func_eq: le<T>,
     arr[i] <-> arr[right];
     j = i - 1;
     i += 1;
-    let k: int = left;
+    let mut k: int = left;
     while k < p {
         arr[k] <-> arr[j];
         k += 1;
diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs
index eb1af5b6dbb..91b03ea6b71 100644
--- a/src/libstd/tempfile.rs
+++ b/src/libstd/tempfile.rs
@@ -6,7 +6,7 @@ import rand;
 
 fn mkdtemp(prefix: str, suffix: str) -> option<str> {
     let r = rand::rng();
-    let i = 0u;
+    let mut i = 0u;
     while (i < 1000u) {
         let s = prefix + r.gen_str(16u) + suffix;
         if os::make_dir(s, 0x1c0i32) {  // FIXME: u+rwx
diff --git a/src/libstd/term.rs b/src/libstd/term.rs
index 302852a8edf..c18cc2a625d 100644
--- a/src/libstd/term.rs
+++ b/src/libstd/term.rs
@@ -49,7 +49,7 @@ fn color_supported() -> bool {
 fn set_color(writer: io::writer, first_char: u8, color: u8) {
     assert (color < 16u8);
     esc(writer);
-    let color = color;
+    let mut color = color;
     if color >= 8u8 { writer.write(['1' as u8, ';' as u8]); color -= 8u8; }
     writer.write([first_char, ('0' as u8) + color, 'm' as u8]);
 }
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 828f0ca85d4..cbfad268adb 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -237,7 +237,7 @@ type monitor_msg = (test_desc, test_result);
 fn run_tests(opts: test_opts, tests: [test_desc],
              callback: fn@(testevent)) {
 
-    let filtered_tests = filter_tests(opts, tests);
+    let mut filtered_tests = filter_tests(opts, tests);
     callback(te_filtered(filtered_tests));
 
     // It's tempting to just spawn all the tests at once, but since we have
@@ -246,9 +246,9 @@ fn run_tests(opts: test_opts, tests: [test_desc],
     #debug("using %u test tasks", concurrency);
 
     let total = vec::len(filtered_tests);
-    let run_idx = 0u;
-    let wait_idx = 0u;
-    let done_idx = 0u;
+    let mut run_idx = 0u;
+    let mut wait_idx = 0u;
+    let mut done_idx = 0u;
 
     let p = comm::port();
     let ch = comm::chan(p);
@@ -294,7 +294,7 @@ fn get_concurrency() -> uint {
 
 fn filter_tests(opts: test_opts,
                 tests: [test_desc]) -> [test_desc] {
-    let filtered = tests;
+    let mut filtered = tests;
 
     // Remove tests that don't match the test filter
     filtered = if option::is_none(opts.filter) {
@@ -355,9 +355,8 @@ fn run_test(+test: test_desc, monitor_ch: comm::chan<monitor_msg>) {
     }
 
     task::spawn {||
-
         let testfn = test.fn;
-        let builder = task::task_builder();
+        let mut builder = task::task_builder();
         let result_future = task::future_result(builder);
         task::unsupervise(builder);
         task::run(builder, testfn);
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index dcdc82434ab..1e48c307ac1 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -12,8 +12,8 @@ Returns the current time as a `timeval` containing the seconds and
 microseconds since 1970-01-01T00:00:00Z.
 "]
 fn get_time() -> timeval {
-    let sec = 0u32;
-    let usec = 0u32;
+    let mut sec = 0u32;
+    let mut usec = 0u32;
     rustrt::get_time(sec, usec);
     ret {sec: sec, usec: usec};
 }
@@ -22,7 +22,11 @@ fn get_time() -> timeval {
 Returns the current value of a high-resolution performance counter
 in nanoseconds since an unspecified epoch.
 "]
-fn precise_time_ns() -> u64 { let ns = 0u64; rustrt::precise_time_ns(ns); ns }
+fn precise_time_ns() -> u64 {
+    let mut ns = 0u64;
+    rustrt::precise_time_ns(ns);
+    ns
+}
 
 #[doc = "
 Returns the current value of a high-resolution performance counter
diff --git a/src/libstd/ufind.rs b/src/libstd/ufind.rs
index eee4c836277..53bdabfc203 100644
--- a/src/libstd/ufind.rs
+++ b/src/libstd/ufind.rs
@@ -47,6 +47,6 @@ fn set_count(ufnd: ufind) -> uint { ret vec::len::<node>(ufnd.nodes); }
 fn prune(ufnd: ufind, n: uint) {
     // TODO: Use "slice" once we get rid of "const"
 
-    let len = vec::len::<node>(ufnd.nodes);
+    let mut len = vec::len::<node>(ufnd.nodes);
     while len != n { vec::pop::<node>(ufnd.nodes); len -= 1u; }
 }
diff --git a/src/libstd/uv.rs b/src/libstd/uv.rs
index fb7a4883c05..fd54f7d9291 100644
--- a/src/libstd/uv.rs
+++ b/src/libstd/uv.rs
@@ -146,8 +146,8 @@ fn loop_new() -> uv_loop unsafe {
         // the main loop that this task blocks on.
         // should have the same lifetime as the C libuv
         // event loop.
-        let keep_going = true;
-        while (keep_going) {
+        let mut keep_going = true;
+        while keep_going {
             alt comm::recv(rust_loop_port) {
               msg_run(end_chan) {
                 // start the libuv event loop
@@ -339,7 +339,7 @@ fn async_init (
     lp: uv_loop,
     async_cb: fn~(uv_handle),
     after_cb: fn~(uv_handle)) {
-    let msg = msg_async_init(async_cb, after_cb);
+    let mut msg = msg_async_init(async_cb, after_cb);
     let loop_chan = get_loop_chan_from_uv_loop(lp);
     comm::send(loop_chan, msg);
 }
@@ -363,7 +363,7 @@ fn close(h: uv_handle, cb: fn~()) {
 }
 
 fn timer_init(lp: uv_loop, after_cb: fn~(uv_handle)) {
-    let msg = msg_timer_init(after_cb);
+    let mut msg = msg_timer_init(after_cb);
     let loop_chan = get_loop_chan_from_uv_loop(lp);
     comm::send(loop_chan, msg);
 }
@@ -372,7 +372,7 @@ fn timer_start(the_timer: uv_handle, timeout: u32, repeat:u32,
                timer_cb: fn~(uv_handle)) {
     alt the_timer {
       uv_timer(id, lp) {
-        let msg = msg_timer_start(id, timeout, repeat, timer_cb);
+        let mut msg = msg_timer_start(id, timeout, repeat, timer_cb);
         let loop_chan = get_loop_chan_from_uv_loop(lp);
         comm::send(loop_chan, msg);
       }
@@ -387,7 +387,7 @@ fn timer_stop(the_timer: uv_handle, after_cb: fn~(uv_handle)) {
     alt the_timer {
       uv_timer(id, lp) {
         let loop_chan = get_loop_chan_from_uv_loop(lp);
-        let msg = msg_timer_stop(id, after_cb);
+        let mut msg = msg_timer_stop(id, after_cb);
         comm::send(loop_chan, msg);
       }
       _ {
@@ -466,7 +466,7 @@ crust fn process_operation(
         data: *uv_loop_data) unsafe {
     let op_port = (*data).operation_port;
     let loop_chan = get_loop_chan_from_data(data);
-    let op_pending = comm::peek(op_port);
+    let mut op_pending = comm::peek(op_port);
     while(op_pending) {
         alt comm::recv(op_port) {
           op_async_init(id) {