---

yaml
---
r: 11685
b: refs/heads/master
c: 713006c
h: refs/heads/master
i:
  11683: 1496e43
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 674587cfe5a871336f6337eabae75b20882faff5
+refs/heads/master: 713006c7b6afc25ef90ecf78f88c9e9abb31f4b9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/libcore/comm.rs

@@ -180,7 +180,7 @@ fn select2<A: send, B: send>(
         rustrt::rust_port_select(dptr, ports, n_ports, yield)
     }
 
-    let ports = [];
+    let mut ports = [];
     ports += [***p_a, ***p_b];
     let n_ports = 2 as ctypes::size_t;
     let yield = 0u;

trunk/src/libcore/either.rs

@@ -40,7 +40,7 @@ Function: lefts
 Extracts from a vector of either all the left values.
 */
 fn lefts<T: copy, U>(eithers: [t<T, U>]) -> [T] {
-    let result: [T] = [];
+    let mut result: [T] = [];
     for elt: t<T, U> in eithers {
         alt elt { left(l) { result += [l]; } _ {/* fallthrough */ } }
     }
@@ -53,7 +53,7 @@ Function: rights
 Extracts from a vector of either all the right values
 */
 fn rights<T, U: copy>(eithers: [t<T, U>]) -> [U] {
-    let result: [U] = [];
+    let mut result: [U] = [];
     for elt: t<T, U> in eithers {
         alt elt { right(r) { result += [r]; } _ {/* fallthrough */ } }
     }
@@ -70,8 +70,8 @@ right values.
 */
 fn partition<T: copy, U: copy>(eithers: [t<T, U>])
     -> {lefts: [T], rights: [U]} {
-    let lefts: [T] = [];
-    let rights: [U] = [];
+    let mut lefts: [T] = [];
+    let mut rights: [U] = [];
     for elt: t<T, U> in eithers {
         alt elt { left(l) { lefts += [l]; } right(r) { rights += [r]; } }
     }

trunk/src/libcore/extfmt.rs

@@ -81,17 +81,17 @@ mod ct {
     type error_fn = fn@(str) -> ! ;
 
     fn parse_fmt_string(s: str, error: error_fn) -> [piece] unsafe {
-        let pieces: [piece] = [];
+        let mut pieces: [piece] = [];
         let lim = str::len(s);
-        let buf = "";
+        let mut buf = "";
         fn flush_buf(buf: str, &pieces: [piece]) -> str {
             if str::len(buf) > 0u {
                 let piece = piece_string(buf);
                 pieces += [piece];
             }
             ret "";
         }
-        let i = 0u;
+        let mut i = 0u;
         while i < lim {
             let curr = str::slice(s, i, i+1u);
             if str::eq(curr, "%") {
@@ -285,7 +285,7 @@ mod rt {
     fn conv_int(cv: conv, i: int) -> str {
         let radix = 10u;
         let prec = get_int_precision(cv);
-        let s = int_to_str_prec(i, radix, prec);
+        let mut s = int_to_str_prec(i, radix, prec);
         if 0 <= i {
             if have_flag(cv.flags, flag_sign_always) {
                 s = "+" + s;
@@ -335,7 +335,7 @@ mod rt {
               count_is(c) { (float::to_str_exact, c as uint) }
               count_implied { (float::to_str, 6u) }
         };
-        let s = to_str(f, digits);
+        let mut s = to_str(f, digits);
         if 0.0 <= f {
             if have_flag(cv.flags, flag_sign_always) {
                 s = "+" + s;
@@ -389,42 +389,38 @@ mod rt {
     }
     enum pad_mode { pad_signed, pad_unsigned, pad_nozero, }
     fn pad(cv: conv, s: str, mode: pad_mode) -> str unsafe {
-        let uwidth;
-        alt cv.width {
+        let uwidth = alt cv.width {
           count_implied { ret s; }
           count_is(width) {
             // FIXME: Maybe width should be uint
-
-            uwidth = width as uint;
+            width as uint
           }
-        }
+        };
         let strlen = str::char_len(s);
         if uwidth <= strlen { ret s; }
-        let padchar = ' ';
+        let mut padchar = ' ';
         let diff = uwidth - strlen;
         if have_flag(cv.flags, flag_left_justify) {
             let padstr = str_init_elt(diff, padchar);
             ret s + padstr;
         }
-        let might_zero_pad = false;
-        let signed = false;
-        alt mode {
-          pad_nozero {
-            // fallthrough
-
-          }
-          pad_signed { might_zero_pad = true; signed = true; }
-          pad_unsigned { might_zero_pad = true; }
-        }
+        let {might_zero_pad, signed} = alt mode {
+          pad_nozero {   {might_zero_pad:false, signed:false} }
+          pad_signed {   {might_zero_pad:true,  signed:true } }
+          pad_unsigned { {might_zero_pad:true,  signed:false} }
+        };
         fn have_precision(cv: conv) -> bool {
             ret alt cv.precision { count_implied { false } _ { true } };
         }
-        let zero_padding = false;
-        if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
-               !have_precision(cv) {
-            padchar = '0';
-            zero_padding = true;
-        }
+        let zero_padding = {
+            if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
+                !have_precision(cv) {
+                padchar = '0';
+                true
+            } else {
+                false
+            }
+        };
         let padstr = str_init_elt(diff, padchar);
         // This is completely heinous. If we have a signed value then
         // potentially rip apart the intermediate result and insert some

trunk/src/libcore/float.rs

@@ -49,14 +49,14 @@ exact - Whether to enforce the exact number of significant digits
 */
 fn to_str_common(num: float, digits: uint, exact: bool) -> str {
     if is_NaN(num) { ret "NaN"; }
-    let (num, accum) = if num < 0.0 { (-num, "-") } else { (num, "") };
+    let mut (num, accum) = if num < 0.0 { (-num, "-") } else { (num, "") };
     let trunc = num as uint;
-    let frac = num - (trunc as float);
+    let mut frac = num - (trunc as float);
     accum += uint::str(trunc);
     if (frac < epsilon && !exact) || digits == 0u { ret accum; }
     accum += ".";
-    let i = digits;
-    let epsilon = 1. / pow_with_uint(10u, i);
+    let mut i = digits;
+    let mut epsilon = 1. / pow_with_uint(10u, i);
     while i > 0u && (frac >= epsilon || exact) {
         frac *= 10.0;
         epsilon *= 10.0;
@@ -132,13 +132,13 @@ Otherwise, some(n) where n is the floating-point
 number represented by [num].
 */
 fn from_str(num: str) -> option<float> {
-   let pos = 0u;                  //Current byte position in the string.
-                                  //Used to walk the string in O(n).
-   let len = str::len(num);  //Length of the string, in bytes.
+   let mut pos = 0u;               //Current byte position in the string.
+                                   //Used to walk the string in O(n).
+   let len = str::len(num);        //Length of the string, in bytes.
 
    if len == 0u { ret none; }
-   let total = 0f;                //Accumulated result
-   let c     = 'z';               //Latest char.
+   let mut total = 0f;             //Accumulated result
+   let mut c     = 'z';            //Latest char.
 
    //The string must start with one of the following characters.
    alt str::char_at(num, 0u) {
@@ -147,7 +147,7 @@ fn from_str(num: str) -> option<float> {
    }
 
    //Determine if first char is '-'/'+'. Set [pos] and [neg] accordingly.
-   let neg = false;               //Sign of the result
+   let mut neg = false;               //Sign of the result
    alt str::char_at(num, 0u) {
       '-' {
           neg = true;
@@ -179,7 +179,7 @@ fn from_str(num: str) -> option<float> {
    }
 
    if c == '.' {//Examine decimal part
-      let decimal = 1f;
+      let mut decimal = 1f;
       while(pos < len) {
          let char_range = str::char_range_at(num, pos);
          c = char_range.ch;
@@ -200,8 +200,8 @@ fn from_str(num: str) -> option<float> {
    }
 
    if (c == 'e') | (c == 'E') {//Examine exponent
-      let exponent = 0u;
-      let neg_exponent = false;
+      let mut exponent = 0u;
+      let mut neg_exponent = false;
       if(pos < len) {
           let char_range = str::char_range_at(num, pos);
           c   = char_range.ch;
@@ -275,9 +275,9 @@ fn pow_with_uint(base: uint, pow: uint) -> float {
       }
        ret 0.;
    }
-   let my_pow     = pow;
-   let total      = 1f;
-   let multiplier = base as float;
+   let mut my_pow     = pow;
+   let mut total      = 1f;
+   let mut multiplier = base as float;
    while (my_pow > 0u) {
      if my_pow % 2u == 1u {
        total = total * multiplier;

trunk/src/libcore/future.rs

@@ -93,7 +93,7 @@ fn spawn<A:send>(+blk: fn~() -> A) -> future<A> {
 
     "];
 
-    let po = comm::port();
+    let mut po = comm::port();
     let ch = comm::chan(po);
     task::spawn {||
         comm::send(ch, blk())

trunk/src/libcore/i16.rs

@@ -26,7 +26,7 @@ pure fn nonnegative(x: i16) -> bool { x >= 0i16 }
 
 #[doc = "Iterate over the range [`lo`..`hi`)"]
 fn range(lo: i16, hi: i16, it: fn(i16)) {
-    let i = lo;
+    let mut i = lo;
     while i < hi { it(i); i += 1i16; }
 }
 

trunk/src/libcore/i32.rs

@@ -26,7 +26,7 @@ pure fn nonnegative(x: i32) -> bool { x >= 0i32 }
 
 #[doc = "Iterate over the range [`lo`..`hi`)"]
 fn range(lo: i32, hi: i32, it: fn(i32)) {
-    let i = lo;
+    let mut i = lo;
     while i < hi { it(i); i += 1i32; }
 }
 

trunk/src/libcore/i64.rs

@@ -26,7 +26,7 @@ pure fn nonnegative(x: i64) -> bool { x >= 0i64 }
 
 #[doc = "Iterate over the range [`lo`..`hi`)"]
 fn range(lo: i64, hi: i64, it: fn(i64)) {
-    let i = lo;
+    let mut i = lo;
     while i < hi { it(i); i += 1i64; }
 }
 

trunk/src/libcore/i8.rs

@@ -26,7 +26,7 @@ pure fn nonnegative(x: i8) -> bool { x >= 0i8 }
 
 #[doc = "Iterate over the range [`lo`..`hi`)"]
 fn range(lo: i8, hi: i8, it: fn(i8)) {
-    let i = lo;
+    let mut i = lo;
     while i < hi { it(i); i += 1i8; }
 }
 

trunk/src/libcore/int.rs

@@ -90,7 +90,7 @@ Function: range
 Iterate over the range [`lo`..`hi`)
 */
 fn range(lo: int, hi: int, it: fn(int)) {
-    let i = lo;
+    let mut i = lo;
     while i < hi { it(i); i += 1; }
 }
 
@@ -106,15 +106,15 @@ radix - The base of the number
 */
 fn parse_buf(buf: [u8], radix: uint) -> option<int> {
     if vec::len(buf) == 0u { ret none; }
-    let i = vec::len(buf) - 1u;
-    let start = 0u;
-    let power = 1;
+    let mut i = vec::len(buf) - 1u;
+    let mut start = 0u;
+    let mut power = 1;
 
     if buf[0] == ('-' as u8) {
         power = -1;
         start = 1u;
     }
-    let n = 0;
+    let mut n = 0;
     while true {
         alt char::to_digit(buf[i] as char, radix) {
           some(d) { n += (d as int) * power; }
@@ -161,9 +161,9 @@ Returns `base` raised to the power of `exponent`
 fn pow(base: int, exponent: uint) -> int {
     if exponent == 0u { ret 1; } //Not mathemtically true if [base == 0]
     if base     == 0  { ret 0; }
-    let my_pow  = exponent;
-    let acc     = 1;
-    let multiplier = base;
+    let mut my_pow  = exponent;
+    let mut acc     = 1;
+    let mut multiplier = base;
     while(my_pow > 0u) {
       if my_pow % 2u == 1u {
          acc *= multiplier;

trunk/src/libcore/iter.rs

@@ -40,7 +40,7 @@ impl of iterable<char> for str {
 }
 
 fn enumerate<A,IA:iterable<A>>(self: IA, blk: fn(uint, A)) {
-    let i = 0u;
+    let mut i = 0u;
     self.iter {|a|
         blk(i, a);
         i += 1u;
@@ -82,7 +82,7 @@ fn flat_map<A,B,IA:iterable<A>,IB:iterable<B>>(
 }
 
 fn foldl<A,B,IA:iterable<A>>(self: IA, +b0: B, blk: fn(-B, A) -> B) -> B {
-    let b <- b0;
+    let mut b <- b0;
     self.iter {|a|
         b = blk(b, a);
     }
@@ -92,7 +92,7 @@ fn foldl<A,B,IA:iterable<A>>(self: IA, +b0: B, blk: fn(-B, A) -> B) -> B {
 fn foldr<A:copy,B,IA:iterable<A>>(
     self: IA, +b0: B, blk: fn(A, -B) -> B) -> B {
 
-    let b <- b0;
+    let mut b <- b0;
     reversed(self) {|a|
         b = blk(a, b);
     }
@@ -119,7 +119,7 @@ fn count<A,IA:iterable<A>>(self: IA, x: A) -> uint {
 }
 
 fn repeat(times: uint, blk: fn()) {
-    let i = 0u;
+    let mut i = 0u;
     while i < times {
         blk();
         i += 1u;

trunk/src/libcore/os.rs

@@ -41,7 +41,7 @@ native mod rustrt {
 
 
 fn env() -> [(str,str)] {
-    let pairs = [];
+    let mut pairs = [];
     for p in rustrt::rust_env_pairs() {
         let vs = str::splitn_char(p, '=', 1u);
         assert vec::len(vs) == 2u;
@@ -87,7 +87,7 @@ mod win32 {
     }
 
     fn as_utf16_p<T>(s: str, f: fn(*u16) -> T) -> T {
-        let t = str::to_utf16(s);
+        let mut t = str::to_utf16(s);
         // Null terminate before passing on.
         t += [0u16];
         vec::as_buf(t, f)
@@ -468,13 +468,13 @@ fn list_dir(p: path) -> [str] {
     #[cfg(target_os = "win32")]
     fn star() -> str { "*" }
 
-    let p = p;
+    let mut p = p;
     let pl = str::len(p);
     if pl == 0u || (p[pl - 1u] as char != path::consts::path_sep
                     && p[pl - 1u] as char != path::consts::alt_path_sep) {
         p += path::path_sep();
     }
-    let full_paths: [str] = [];
+    let mut full_paths: [str] = [];
     for filename: str in rustrt::rust_list_files(p + star()) {
         if !str::eq(filename, ".") {
             if !str::eq(filename, "..") {