---

yaml
---
r: 52706
b: refs/heads/dist-snap
c: 5577ce6
h: refs/heads/master
v: v3

Author: bstrie

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 097c8aefea1feca5c3f5ff93025e9477cc6fbb0e
+refs/heads/dist-snap: 5577ce635f5d2a7a773d08d403cb707001064742
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/uint-template.rs

@@ -252,7 +252,7 @@ pub pure fn to_str_bytes<U>(neg: bool, num: T, radix: uint,
     // Enough room to hold any number in any radix.
     // Worst case: 64-bit number, binary-radix, with
     // a leading negative sign = 65 bytes.
-    let buf : [mut u8 * 65] = [mut 0u8, ..65];
+    let mut buf : [mut u8 * 65] = [0u8, ..65];
     let len = buf.len();
 
     let mut i = len;

branches/dist-snap/src/libcore/vec.rs

@@ -3155,7 +3155,7 @@ mod tests {
 
     #[test]
     fn reverse_and_reversed() {
-        let v: ~[mut int] = ~[mut 10, 20];
+        let mut v: ~[mut int] = ~[10, 20];
         assert (v[0] == 10);
         assert (v[1] == 20);
         reverse(v);
@@ -3170,13 +3170,13 @@ mod tests {
 
         let v4 = reversed::<int>(~[]);
         assert (v4 == ~[]);
-        let v3: ~[mut int] = ~[mut];
+        let mut v3: ~[mut int] = ~[];
         reverse::<int>(v3);
     }
 
     #[test]
     fn reversed_mut() {
-        let v2 = reversed::<int>(~[mut 10, 20]);
+        let mut v2 = reversed::<int>(~[10, 20]);
         assert (v2[0] == 20);
         assert (v2[1] == 10);
     }
@@ -3302,7 +3302,7 @@ mod tests {
     #[test]
     fn cast_from_mut_no_copy() {
         unsafe {
-            let x = ~[mut 1, 2, 3];
+            let mut x = ~[1, 2, 3];
             let addr = raw::to_ptr(x);
             let x_imm = cast_from_mut(x);
             let addr_imm = raw::to_ptr(x_imm);
@@ -3564,7 +3564,7 @@ mod tests {
     #[ignore(windows)]
     #[should_fail]
     fn test_consume_mut_fail() {
-        let v = ~[mut (~0, @0), (~0, @0), (~0, @0), (~0, @0)];
+        let mut v = ~[(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
         let mut i = 0;
         do consume_mut(v) |_i, _elt| {
             if i == 2 {
@@ -3592,7 +3592,7 @@ mod tests {
     #[ignore(windows)]
     #[should_fail]
     fn test_map_fail() {
-        let v = [mut (~0, @0), (~0, @0), (~0, @0), (~0, @0)];
+        let mut v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
         let mut i = 0;
         do map(v) |_elt| {
             if i == 2 {
@@ -3918,7 +3918,7 @@ mod tests {
     #[ignore(cfg(windows))]
     #[should_fail]
     fn test_as_mut_buf_fail() {
-        let v = [mut (~0, @0), (~0, @0), (~0, @0), (~0, @0)];
+        let mut v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
         do as_mut_buf(v) |_buf, _i| {
             fail
         }
@@ -3929,7 +3929,7 @@ mod tests {
     #[ignore(cfg(windows))]
     fn test_copy_memory_oob() {
         unsafe {
-            let a = [mut 1, 2, 3, 4];
+            let mut a = [1, 2, 3, 4];
             let b = [1, 2, 3, 4, 5];
             raw::copy_memory(a, b, 5);
         }

branches/dist-snap/src/libfuzzer/cycles.rs

@@ -68,7 +68,7 @@ fn nop<T>(_x: T) { }
 
 fn test_cycles(r : rand::rng, k: uint, n: uint)
 {
-    let v : ~[mut @pointy] = ~[mut];
+    let mut v : ~[mut @pointy] = ~[];
 
     // Create a graph with no edges
     range(0u, vlen) {|_i|

branches/dist-snap/src/libfuzzer/rand_util.rs

@@ -86,7 +86,7 @@ fn main()
     log(error, choice(r, ~[10, 20, 30]));
     log(error, if unlikely(r, 5u) { "unlikely" } else { "likely" });
 
-    let a = ~[mut 1, 2, 3];
+    let mut a = ~[1, 2, 3];
     shuffle(r, a);
     log(error, a);
 

branches/dist-snap/src/libstd/rope.rs

@@ -1163,7 +1163,7 @@ pub mod node {
         }
 
         pub fn empty() -> T {
-            let stack : ~[mut @Node] = ~[mut];
+            let mut stack : ~[mut @Node] = ~[];
             T { stack: stack, stackpos: -1 }
         }
 

branches/dist-snap/src/libstd/sort.rs

@@ -740,24 +740,24 @@ mod test_qsort3 {
     #[test]
     pub fn test() {
         {
-            let v1 = ~[mut 3, 7, 4, 5, 2, 9, 5, 8];
-            let v2 = ~[mut 2, 3, 4, 5, 5, 7, 8, 9];
+            let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8];
+            let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9];
             check_sort(v1, v2);
         }
         {
-            let v1 = ~[mut 1, 1, 1];
-            let v2 = ~[mut 1, 1, 1];
+            let mut v1 = ~[1, 1, 1];
+            let mut v2 = ~[1, 1, 1];
             check_sort(v1, v2);
         }
         {
-            let v1: ~[mut int] = ~[mut];
-            let v2: ~[mut int] = ~[mut];
+            let mut v1: ~[mut int] = ~[];
+            let mut v2: ~[mut int] = ~[];
             check_sort(v1, v2);
         }
-        { let v1 = ~[mut 9]; let v2 = ~[mut 9]; check_sort(v1, v2); }
+        { let mut v1 = ~[mut 9]; let v2 = ~[9]; check_sort(v1, v2); }
         {
-            let v1 = ~[mut 9, 3, 3, 3, 9];
-            let v2 = ~[mut 3, 3, 3, 9, 9];
+            let mut v1 = ~[9, 3, 3, 3, 9];
+            let mut v2 = ~[3, 3, 3, 9, 9];
             check_sort(v1, v2);
         }
     }
@@ -787,32 +787,32 @@ mod test_qsort {
     #[test]
     pub fn test() {
         {
-            let v1 = ~[mut 3, 7, 4, 5, 2, 9, 5, 8];
-            let v2 = ~[mut 2, 3, 4, 5, 5, 7, 8, 9];
+            let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8];
+            let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9];
             check_sort(v1, v2);
         }
         {
-            let v1 = ~[mut 1, 1, 1];
-            let v2 = ~[mut 1, 1, 1];
+            let mut v1 = ~[1, 1, 1];
+            let mut v2 = ~[1, 1, 1];
             check_sort(v1, v2);
         }
         {
-            let v1: ~[mut int] = ~[mut];
-            let v2: ~[mut int] = ~[mut];
+            let mut v1: ~[mut int] = ~[];
+            let mut v2: ~[mut int] = ~[];
             check_sort(v1, v2);
         }
-        { let v1 = ~[mut 9]; let v2 = ~[mut 9]; check_sort(v1, v2); }
+        { let mut v1 = ~[mut 9]; let v2 = ~[9]; check_sort(v1, v2); }
         {
-            let v1 = ~[mut 9, 3, 3, 3, 9];
-            let v2 = ~[mut 3, 3, 3, 9, 9];
+            let mut v1 = ~[9, 3, 3, 3, 9];
+            let mut v2 = ~[3, 3, 3, 9, 9];
             check_sort(v1, v2);
         }
     }
 
     // Regression test for #750
     #[test]
     pub fn test_simple() {
-        let names = ~[mut 2, 1, 3];
+        let mut names = ~[2, 1, 3];
 
         let expected = ~[1, 2, 3];
 
@@ -870,7 +870,7 @@ mod tests {
     #[test]
     pub fn test_merge_sort_mutable() {
         pub pure fn le(a: &int, b: &int) -> bool { *a <= *b }
-        let v1 = ~[mut 3, 2, 1];
+        let mut v1 = ~[3, 2, 1];
         let v2 = merge_sort(v1, le);
         assert v2 == ~[1, 2, 3];
     }
@@ -937,24 +937,24 @@ mod test_tim_sort {
     #[test]
     fn test() {
         {
-            let v1 = ~[mut 3, 7, 4, 5, 2, 9, 5, 8];
-            let v2 = ~[mut 2, 3, 4, 5, 5, 7, 8, 9];
+            let mut v1 = ~[3, 7, 4, 5, 2, 9, 5, 8];
+            let mut v2 = ~[2, 3, 4, 5, 5, 7, 8, 9];
             check_sort(v1, v2);
         }
         {
-            let v1 = ~[mut 1, 1, 1];
-            let v2 = ~[mut 1, 1, 1];
+            let mut v1 = ~[1, 1, 1];
+            let mut v2 = ~[1, 1, 1];
             check_sort(v1, v2);
         }
         {
-            let v1: ~[mut int] = ~[mut];
-            let v2: ~[mut int] = ~[mut];
+            let mut v1: ~[mut int] = ~[];
+            let mut v2: ~[mut int] = ~[];
             check_sort(v1, v2);
         }
-        { let v1 = ~[mut 9]; let v2 = ~[mut 9]; check_sort(v1, v2); }
+        { let mut v1 = ~[mut 9]; let v2 = ~[9]; check_sort(v1, v2); }
         {
-            let v1 = ~[mut 9, 3, 3, 3, 9];
-            let v2 = ~[mut 3, 3, 3, 9, 9];
+            let mut v1 = ~[9, 3, 3, 3, 9];
+            let mut v2 = ~[3, 3, 3, 9, 9];
             check_sort(v1, v2);
         }
     }

branches/dist-snap/src/libsyntax/attr.rs

@@ -269,7 +269,7 @@ pub fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
     }
 
     // This is sort of stupid here, converting to a vec of mutables and back
-    let v: ~[mut @ast::meta_item] = vec::cast_to_mut(items);
+    let mut v: ~[@ast::meta_item] = vec::cast_to_mut(items);
     std::sort::quick_sort(v, lteq);
     vec::cast_from_mut(move v)
 }

branches/dist-snap/src/libsyntax/print/pp.rs

@@ -148,9 +148,9 @@ pub fn mk_printer(out: io::Writer, linewidth: uint) -> printer {
     // fall behind.
     let n: uint = 3 * linewidth;
     debug!("mk_printer %u", linewidth);
-    let token: ~[mut token] = vec::cast_to_mut(vec::from_elem(n, EOF));
-    let size: ~[mut int] = vec::cast_to_mut(vec::from_elem(n, 0));
-    let scan_stack: ~[mut uint] = vec::cast_to_mut(vec::from_elem(n, 0u));
+    let mut token: ~[token] = vec::cast_to_mut(vec::from_elem(n, EOF));
+    let mut size: ~[int] = vec::cast_to_mut(vec::from_elem(n, 0));
+    let mut scan_stack: ~[uint] = vec::cast_to_mut(vec::from_elem(n, 0u));
     printer_(@{out: out,
                buf_len: n,
                mut margin: linewidth as int,

branches/dist-snap/src/test/bench/graph500-bfs.rs

@@ -120,7 +120,7 @@ fn gen_search_keys(graph: graph, n: uint) -> ~[node_id] {
  * Nodes that are unreachable have a parent of -1.
  */
 fn bfs(graph: graph, key: node_id) -> bfs_result {
-    let marks : ~[mut node_id] 
+    let mut marks : ~[node_id] 
         = vec::cast_to_mut(vec::from_elem(vec::len(graph), -1i64));
 
     let Q = deque::create();

branches/dist-snap/src/test/compile-fail/alt-vec-tail-move.rs

@@ -1,5 +1,5 @@
 fn main() {
-    let a = [mut 1, 2, 3, 4];
+    let mut a = [1, 2, 3, 4];
     let _ = match a {
         [1, 2, ..move tail] => tail,
         _ => core::util::unreachable()

branches/dist-snap/src/test/compile-fail/borrowck-loan-vec-content.rs

@@ -17,13 +17,13 @@ fn takes_imm_elt(_v: &int, f: fn()) {
 }
 
 fn has_mut_vec_and_does_not_try_to_change_it() {
-    let v = ~[mut 1, 2, 3];
+    let mut v = ~[1, 2, 3];
     do takes_imm_elt(&v[0]) {
     }
 }
 
 fn has_mut_vec_but_tries_to_change_it() {
-    let v = ~[mut 1, 2, 3];
+    let mut v = ~[1, 2, 3];
     do takes_imm_elt(&v[0]) { //~ NOTE loan of mutable vec content granted here
         v[1] = 4; //~ ERROR assigning to mutable vec content prohibited due to outstanding loan
     }
@@ -34,7 +34,7 @@ fn takes_const_elt(_v: &const int, f: fn()) {
 }
 
 fn has_mut_vec_and_tries_to_change_it() {
-    let v = ~[mut 1, 2, 3];
+    let mut v = ~[1, 2, 3];
     do takes_const_elt(&const v[0]) {
         v[1] = 4;
     }

branches/dist-snap/src/test/compile-fail/lub-in-args.rs

@@ -11,7 +11,7 @@
 fn two_args<T>(x: T, y: T) { }
 
 fn main() {
-    let x: ~[mut int] = ~[mut 3];
+    let mut x: ~[mut int] = ~[3];
     let y: ~[int] = ~[3];
     let a: @mut int = @mut 3;
     let b: @int = @3;

branches/dist-snap/src/test/compile-fail/mutable-huh-variance-deep.rs

@@ -11,7 +11,7 @@
 // error-pattern: mismatched types
 
 fn main() {
-    let v = ~[mut @mut ~mut ~[0]];
+    let mut v = ~[@mut ~mut ~[0]];
 
     fn f(&&v: ~[mut @mut ~mut ~[const int]]) {
     }

branches/dist-snap/src/test/compile-fail/mutable-huh-variance-vec1.rs

@@ -12,7 +12,7 @@ fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
     // and assigns a type of ~[mut ~[const int]].
-    let v: ~[mut ~[int]] = ~[mut ~[0]];
+    let mut v: ~[mut ~[int]] = ~[~[0]];
 
     fn f(&&v: ~[mut ~[const int]]) {
         v[0] = ~[mut 3]

branches/dist-snap/src/test/compile-fail/mutable-huh-variance-vec2.rs

@@ -12,7 +12,7 @@ fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
     // and assigns a type of ~[mut ~[const int]].
-    let v: ~[mut ~[mut int]] = ~[mut ~[mut 0]];
+    let mut v: ~[mut ~[mut int]] = ~[mut ~[0]];
 
     fn f(&&v: ~[mut ~[const int]]) {
         v[0] = ~[3]

branches/dist-snap/src/test/compile-fail/mutable-huh-variance-vec3.rs

@@ -12,7 +12,7 @@ fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
     // and assigns a type of ~[mut ~[const int]].
-    let v: ~[mut ~[mut ~[int]]] = ~[mut ~[mut ~[0]]];
+    let mut v: ~[mut ~[mut ~[int]]] = ~[mut ~[~[0]]];
 
     fn f(&&v: ~[mut ~[mut ~[const int]]]) {
         v[0][1] = ~[mut 3]

branches/dist-snap/src/test/compile-fail/mutable-huh-variance-vec4.rs

@@ -13,9 +13,9 @@ fn main() {
     // Note: here we do not have any type annotations
     // but we do express conflicting requirements:
 
-    let v = ~[mut ~[0]];
-    let w = ~[mut ~[mut 0]];
-    let x = ~[mut ~[mut 0]];
+    let mut v = ~[~[0]];
+    let mut w = ~[mut ~[0]];
+    let mut x = ~[mut ~[0]];
 
     fn f(&&v: ~[mut ~[int]]) {
         v[0] = ~[3]

branches/dist-snap/src/test/run-pass/empty-mutable-vec.rs

@@ -10,4 +10,4 @@
 
 
 
-fn main() { let v: ~[mut int] = ~[mut]; }
+fn main() { let mut v: ~[mut int] = ~[]; }

branches/dist-snap/src/test/run-pass/explicit-self-objects-ext-1.rs

@@ -16,7 +16,7 @@ pub trait ReaderUtil {
 impl<T: Reader> T : ReaderUtil {
 
     fn read_bytes(&self, len: uint) {
-        let count = self.read(&[mut 0], len);
+        let mut count = self.read(&[0], len);
     }
 
 }

branches/dist-snap/src/test/run-pass/explicit-self-objects-ext-2.rs

@@ -16,7 +16,7 @@ pub trait ReaderUtil {
 impl<T: Reader> T : ReaderUtil {
 
     fn read_bytes(&self, len: uint) {
-        let count = self.read(&[mut 0], len);
+        let mut count = self.read(&[0], len);
     }
 
 }

branches/dist-snap/src/test/run-pass/explicit-self-objects-ext-3.rs

@@ -16,7 +16,7 @@ pub trait ReaderUtil {
 impl<T: Reader> T : ReaderUtil {
 
     fn read_bytes(len: uint) {
-        let count = self.read(&[mut 0], len);
+        let mut count = self.read(&[0], len);
     }
 
 }

branches/dist-snap/src/test/run-pass/explicit-self-objects-ext-4.rs

@@ -16,7 +16,7 @@ pub trait ReaderUtil {
 impl<T: Reader> T : ReaderUtil {
 
     fn read_bytes(len: uint) {
-        let count = self.read(&[mut 0], len);
+        let mut count = self.read(&[0], len);
     }
 
 }