RIMOV, round 4

find ./ -type f -name "*.rs" -exec sed -i "s/let mut \(.*\)\[mut[
]\?/let mut \1\[/g" {} \;

diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs
index cef9f22908f5c9145f107a5bda5898f2e71e9f63..eee82f4626fa8f07b036cd9fd68672f4b69054bf 100644 (file)
--- a/src/libcore/uint-template.rs
+++ b/src/libcore/uint-template.rs
@@ -252,7 +252,7 @@ pub fn from_str_radix(buf: &str, radix: u64) -> Option<u64> {
     // Enough room to hold any number in any radix.
     // Worst case: 64-bit number, binary-radix, with
     // a leading negative sign = 65 bytes.
-    let mut buf : [mut u8 * 65] = [0u8, ..65];
+    let mut buf : [u8 * 65] = [0u8, ..65];
     let len = buf.len();
 
     let mut i = len;

diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index aa211544b37c190221197372b47b9bc5cc01ea9c..f18d72c0d88613df64cd5a31678740b871df1232 100644 (file)
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -3155,7 +3155,7 @@ fn test_rfind_between() {
 
     #[test]
     fn reverse_and_reversed() {
-        let mut v: ~[mut int] = ~[10, 20];
+        let mut v: ~[int] = ~[10, 20];
         assert (v[0] == 10);
         assert (v[1] == 20);
         reverse(v);
@@ -3170,7 +3170,7 @@ fn reverse_and_reversed() {
 
         let v4 = reversed::<int>(~[]);
         assert (v4 == ~[]);
-        let mut v3: ~[mut int] = ~[];
+        let mut v3: ~[int] = ~[];
         reverse::<int>(v3);
     }
 

diff --git a/src/libfuzzer/cycles.rs b/src/libfuzzer/cycles.rs
index 80ba52e950f9df2d788fc9c1072fb02fb810a0d9..62401b4b434f4ad47c8bb4010c6c7f62bffecbf5 100644 (file)
--- a/src/libfuzzer/cycles.rs
+++ b/src/libfuzzer/cycles.rs
@@ -68,7 +68,7 @@ fn nop<T>(_x: T) { }
 
 fn test_cycles(r : rand::rng, k: uint, n: uint)
 {
-    let mut v : ~[mut @pointy] = ~[];
+    let mut v : ~[@pointy] = ~[];
 
     // Create a graph with no edges
     range(0u, vlen) {|_i|

diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index b7e2b8f6e71c00b282a12e85cb949b32473a20f9..fab98f5d571c28883cd624fd2938134fd88dfce7 100644 (file)
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -1163,7 +1163,7 @@ pub struct T {
         }
 
         pub fn empty() -> T {
-            let mut stack : ~[mut @Node] = ~[];
+            let mut stack : ~[@Node] = ~[];
             T { stack: stack, stackpos: -1 }
         }
 

diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index e376baad60a44d49d5d425bd0f16aa132bf79ee8..648b07ae0241bb64fed8cfa7363ad2f3bc3d1afc 100644 (file)
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -750,11 +750,11 @@ pub fn test() {
             check_sort(v1, v2);
         }
         {
-            let mut v1: ~[mut int] = ~[];
-            let mut v2: ~[mut int] = ~[];
+            let mut v1: ~[int] = ~[];
+            let mut v2: ~[int] = ~[];
             check_sort(v1, v2);
         }
-        { let mut v1 = ~[mut 9]; let v2 = ~[9]; check_sort(v1, v2); }
+        { let mut v1 = ~[9]; let v2 = ~[9]; check_sort(v1, v2); }
         {
             let mut v1 = ~[9, 3, 3, 3, 9];
             let mut v2 = ~[3, 3, 3, 9, 9];
@@ -797,11 +797,11 @@ pub fn test() {
             check_sort(v1, v2);
         }
         {
-            let mut v1: ~[mut int] = ~[];
-            let mut v2: ~[mut int] = ~[];
+            let mut v1: ~[int] = ~[];
+            let mut v2: ~[int] = ~[];
             check_sort(v1, v2);
         }
-        { let mut v1 = ~[mut 9]; let v2 = ~[9]; check_sort(v1, v2); }
+        { let mut v1 = ~[9]; let v2 = ~[9]; check_sort(v1, v2); }
         {
             let mut v1 = ~[9, 3, 3, 3, 9];
             let mut v2 = ~[3, 3, 3, 9, 9];
@@ -947,11 +947,11 @@ fn test() {
             check_sort(v1, v2);
         }
         {
-            let mut v1: ~[mut int] = ~[];
-            let mut v2: ~[mut int] = ~[];
+            let mut v1: ~[int] = ~[];
+            let mut v2: ~[int] = ~[];
             check_sort(v1, v2);
         }
-        { let mut v1 = ~[mut 9]; let v2 = ~[9]; check_sort(v1, v2); }
+        { let mut v1 = ~[9]; let v2 = ~[9]; check_sort(v1, v2); }
         {
             let mut v1 = ~[9, 3, 3, 3, 9];
             let mut v2 = ~[3, 3, 3, 9, 9];

diff --git a/src/test/compile-fail/lub-in-args.rs b/src/test/compile-fail/lub-in-args.rs
index aa2dc8cda3552f69bbcf2ad0053d41d13ee42930..8734ef8c0aaed4157127c8ae70abd3c10b7e75b0 100644 (file)
--- a/src/test/compile-fail/lub-in-args.rs
+++ b/src/test/compile-fail/lub-in-args.rs
@@ -11,7 +11,7 @@
 fn two_args<T>(x: T, y: T) { }
 
 fn main() {
-    let mut x: ~[mut int] = ~[3];
+    let mut x: ~[int] = ~[3];
     let y: ~[int] = ~[3];
     let a: @mut int = @mut 3;
     let b: @int = @3;

diff --git a/src/test/compile-fail/mutable-huh-variance-vec1.rs b/src/test/compile-fail/mutable-huh-variance-vec1.rs
index 404424ba44b8ed2c1d03311b9d98665acca4f2aa..93f734b39abc3e060288268d2b9a4cffc04ca18b 100644 (file)
--- a/src/test/compile-fail/mutable-huh-variance-vec1.rs
+++ b/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 mut v: ~[mut ~[int]] = ~[~[0]];
+    let mut v: ~[~[int]] = ~[~[0]];
 
     fn f(&&v: ~[mut ~[const int]]) {
         v[0] = ~[mut 3]

diff --git a/src/test/compile-fail/mutable-huh-variance-vec2.rs b/src/test/compile-fail/mutable-huh-variance-vec2.rs
index 4ece2cb0c546a75b5bbb0eb963fd6400b7910ab2..be3f28a440f9cd166ab78e89c36718a5504322d9 100644 (file)
--- a/src/test/compile-fail/mutable-huh-variance-vec2.rs
+++ b/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 mut v: ~[mut ~[mut int]] = ~[mut ~[0]];
+    let mut v: ~[mut ~[mut int]] = ~[~[0]];
 
     fn f(&&v: ~[mut ~[const int]]) {
         v[0] = ~[3]

diff --git a/src/test/compile-fail/mutable-huh-variance-vec3.rs b/src/test/compile-fail/mutable-huh-variance-vec3.rs
index b95da9725ae9c18333925a3fa9dcdacec59b98e8..eaf10e314ae82afcbffba98cfba0873f0292da44 100644 (file)
--- a/src/test/compile-fail/mutable-huh-variance-vec3.rs
+++ b/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 mut v: ~[mut ~[mut ~[int]]] = ~[mut ~[~[0]]];
+    let mut v: ~[mut ~[mut ~[int]]] = ~[~[~[0]]];
 
     fn f(&&v: ~[mut ~[mut ~[const int]]]) {
         v[0][1] = ~[mut 3]

diff --git a/src/test/compile-fail/mutable-huh-variance-vec4.rs b/src/test/compile-fail/mutable-huh-variance-vec4.rs
index 37bc5697230c11f98b8aceaebf8345a62ecaa2f4..046f6b71d0089a2a5cea55bf7b10d053db955845 100644 (file)
--- a/src/test/compile-fail/mutable-huh-variance-vec4.rs
+++ b/src/test/compile-fail/mutable-huh-variance-vec4.rs
@@ -14,8 +14,8 @@ fn main() {
     // but we do express conflicting requirements:
 
     let mut v = ~[~[0]];
-    let mut w = ~[mut ~[0]];
-    let mut x = ~[mut ~[0]];
+    let mut w = ~[~[0]];
+    let mut x = ~[~[0]];
 
     fn f(&&v: ~[mut ~[int]]) {
         v[0] = ~[3]

diff --git a/src/test/run-pass/empty-mutable-vec.rs b/src/test/run-pass/empty-mutable-vec.rs
index bbd7ceb76369ffa8c4abdf911b8939e6f2889836..7ab10a0b3e9d5217d78f864f89b2ea18a45d7eaf 100644 (file)
--- a/src/test/run-pass/empty-mutable-vec.rs
+++ b/src/test/run-pass/empty-mutable-vec.rs
@@ -10,4 +10,4 @@
 
 
 
-fn main() { let mut v: ~[mut int] = ~[]; }
+fn main() { let mut v: ~[int] = ~[]; }

diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index a8f4597fd1464f726216e144721631250c97e7de..958910376947692093c5fdf904b82b32cbbb27fa 100644 (file)
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -15,7 +15,7 @@
 fn two(it: fn(int)) { it(0); it(1); }
 
 fn main() {
-    let mut a: ~[mut int] = ~[-1, -1, -1, -1];
+    let mut a: ~[int] = ~[-1, -1, -1, -1];
     let mut p: int = 0;
     do two |i| {
         do two |j| { a[p] = 10 * i + j; p += 1; }

diff --git a/src/test/run-pass/log-linearized.rs b/src/test/run-pass/log-linearized.rs
index 532dee7e4da261de8f230c1a6387c169f9354adc..a9e3f9d026179b98aa08d365c7e2c24e1e40176b 100644 (file)
--- a/src/test/run-pass/log-linearized.rs
+++ b/src/test/run-pass/log-linearized.rs
@@ -20,7 +20,7 @@ struct Smallintmap<T> {mut v: ~[mut option<T>]}
 struct V<T> { v: ~[mut option<T>] }
 
 fn mk<T>() -> @Smallintmap<T> {
-    let mut v: ~[mut option<T>] = ~[];
+    let mut v: ~[option<T>] = ~[];
     return @Smallintmap {mut v: move v};
 }
 

diff --git a/src/test/run-pass/swap-2.rs b/src/test/run-pass/swap-2.rs
index 7dc37cbc62eeff2c8811a196b8e19803759d28d6..09360e0ec94af2a491a5bd732717e8858320fd24 100644 (file)
--- a/src/test/run-pass/swap-2.rs
+++ b/src/test/run-pass/swap-2.rs
@@ -11,7 +11,7 @@
 fn swap<T>(v: &[mut T], i: int, j: int) { v[i] <-> v[j]; }
 
 fn main() {
-    let mut a: ~[mut int] = ~[0, 1, 2, 3, 4, 5, 6];
+    let mut a: ~[int] = ~[0, 1, 2, 3, 4, 5, 6];
     swap(a, 2, 4);
     assert (a[2] == 4);
     assert (a[4] == 2);