Reformat for new mode syntax, step 1

Long lines were fixed in a very crude way, as I'll be following up
with another reformat in a bit.

12 files changed, 43 insertions, 43 deletions

diff --git a/src/test/stdtest/deque.rs b/src/test/stdtest/deque.rs
index acdde57b86e..104d68f03bb 100644
--- a/src/test/stdtest/deque.rs
+++ b/src/test/stdtest/deque.rs
@@ -79,9 +79,9 @@ fn test_boxes(a: @int, b: @int, c: @int, d: @int) {
     assert (deq.get(3) == d);
 }
 
-type eqfn<T> = fn(&T, &T) -> bool;
+type eqfn<T> = fn(T, T) -> bool;
 
-fn test_parameterized<@T>(e: eqfn<T>, a: &T, b: &T, c: &T, d: &T) {
+fn test_parameterized<@T>(e: eqfn<T>, a: T, b: T, c: T, d: T) {
     let deq: deque::t<T> = deque::create::<T>();
     assert (deq.size() == 0u);
     deq.add_front(a);
@@ -119,9 +119,9 @@ type reccy = {x: int, y: int, t: taggy};
 
 #[test]
 fn test() {
-    fn inteq(a: &int, b: &int) -> bool { ret a == b; }
-    fn intboxeq(a: &@int, b: &@int) -> bool { ret a == b; }
-    fn taggyeq(a: &taggy, b: &taggy) -> bool {
+    fn inteq(a: int, b: int) -> bool { ret a == b; }
+    fn intboxeq(a: @int, b: @int) -> bool { ret a == b; }
+    fn taggyeq(a: taggy, b: taggy) -> bool {
         alt a {
           one(a1) { alt b { one(b1) { ret a1 == b1; } _ { ret false; } } }
           two(a1, a2) {
@@ -138,7 +138,7 @@ fn test() {
           }
         }
     }
-    fn taggypareq<@T>(a: &taggypar<T>, b: &taggypar<T>) -> bool {
+    fn taggypareq<@T>(a: taggypar<T>, b: taggypar<T>) -> bool {
         alt a {
           onepar::<T>(a1) {
             alt b { onepar::<T>(b1) { ret a1 == b1; } _ { ret false; } }
@@ -159,7 +159,7 @@ fn test() {
           }
         }
     }
-    fn reccyeq(a: &reccy, b: &reccy) -> bool {
+    fn reccyeq(a: reccy, b: reccy) -> bool {
         ret a.x == b.x && a.y == b.y && taggyeq(a.t, b.t);
     }
     log "*** test boxes";
diff --git a/src/test/stdtest/either.rs b/src/test/stdtest/either.rs
index 5b3a3959cb3..966a04f70f4 100644
--- a/src/test/stdtest/either.rs
+++ b/src/test/stdtest/either.rs
@@ -5,16 +5,16 @@ import std::vec::len;
 #[test]
 fn test_either_left() {
     let val = left(10);
-    fn f_left(x: &int) -> bool { x == 10 }
-    fn f_right(_x: &uint) -> bool { false }
+    fn f_left(x: int) -> bool { x == 10 }
+    fn f_right(_x: uint) -> bool { false }
     assert (either(f_left, f_right, val));
 }
 
 #[test]
 fn test_either_right() {
     let val = right(10u);
-    fn f_left(_x: &int) -> bool { false }
-    fn f_right(x: &uint) -> bool { x == 10u }
+    fn f_left(_x: int) -> bool { false }
+    fn f_right(x: uint) -> bool { x == 10u }
     assert (either(f_left, f_right, val));
 }
 
diff --git a/src/test/stdtest/list.rs b/src/test/stdtest/list.rs
index 3880ee8d613..7906d277a10 100644
--- a/src/test/stdtest/list.rs
+++ b/src/test/stdtest/list.rs
@@ -17,7 +17,7 @@ fn test_from_vec() {
 #[test]
 fn test_foldl() {
     let l = from_vec([0, 1, 2, 3, 4]);
-    fn add(a: &int, b: &uint) -> uint { ret (a as uint) + b; }
+    fn add(a: int, b: uint) -> uint { ret (a as uint) + b; }
     let rs = list::foldl(l, 0u, add);
     assert (rs == 10u);
 }
@@ -25,7 +25,7 @@ fn test_foldl() {
 #[test]
 fn test_find_success() {
     let l = from_vec([0, 1, 2]);
-    fn match(i: &int) -> option::t<int> {
+    fn match(i: int) -> option::t<int> {
         ret if i == 2 { option::some(i) } else { option::none::<int> };
     }
     let rs = list::find(l, match);
@@ -35,7 +35,7 @@ fn test_find_success() {
 #[test]
 fn test_find_fail() {
     let l = from_vec([0, 1, 2]);
-    fn match(_i: &int) -> option::t<int> { ret option::none::<int>; }
+    fn match(_i: int) -> option::t<int> { ret option::none::<int>; }
     let rs = list::find(l, match);
     assert (rs == option::none::<int>);
 }
diff --git a/src/test/stdtest/map.rs b/src/test/stdtest/map.rs
index 67240a7c69b..ff978085a27 100644
--- a/src/test/stdtest/map.rs
+++ b/src/test/stdtest/map.rs
@@ -11,7 +11,7 @@ import std::option;
 #[test]
 fn test_simple() {
     log "*** starting test_simple";
-    fn eq_uint(x: &uint, y: &uint) -> bool { ret x == y; }
+    fn eq_uint(x: uint, y: uint) -> bool { ret x == y; }
     let hasher_uint: map::hashfn<uint> = util::id;
     let eqer_uint: map::eqfn<uint> = eq_uint;
     let hasher_str: map::hashfn<str> = str::hash;
@@ -83,7 +83,7 @@ fn test_simple() {
 fn test_growth() {
     log "*** starting test_growth";
     let num_to_insert: uint = 64u;
-    fn eq_uint(x: &uint, y: &uint) -> bool { ret x == y; }
+    fn eq_uint(x: uint, y: uint) -> bool { ret x == y; }
     log "uint -> uint";
     let hasher_uint: map::hashfn<uint> = util::id;
     let eqer_uint: map::eqfn<uint> = eq_uint;
@@ -157,8 +157,8 @@ fn test_growth() {
 fn test_removal() {
     log "*** starting test_removal";
     let num_to_insert: uint = 64u;
-    fn eq(x: &uint, y: &uint) -> bool { ret x == y; }
-    fn hash(u: &uint) -> uint {
+    fn eq(x: uint, y: uint) -> bool { ret x == y; }
+    fn hash(u: uint) -> uint {
         // This hash function intentionally causes collisions between
         // consecutive integer pairs.
 
diff --git a/src/test/stdtest/qsort.rs b/src/test/stdtest/qsort.rs
index 609adf3afe4..ad2a82ef426 100644
--- a/src/test/stdtest/qsort.rs
+++ b/src/test/stdtest/qsort.rs
@@ -5,9 +5,9 @@ import std::sort;
 import std::vec;
 import std::int;
 
-fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
+fn check_sort(v1: [mutable int], v2: [mutable int]) {
     let len = std::vec::len::<int>(v1);
-    fn ltequal(a: &int, b: &int) -> bool { ret a <= b; }
+    fn ltequal(a: int, b: int) -> bool { ret a <= b; }
     let f = ltequal;
     std::sort::quick_sort::<int>(f, v1);
     let i = 0u;
@@ -46,7 +46,7 @@ fn test_simple() {
 
     let expected = [1, 2, 3];
 
-    fn lteq(a: &int, b: &int) -> bool { int::le(a, b) }
+    fn lteq(a: int, b: int) -> bool { int::le(a, b) }
     sort::quick_sort(lteq, names);
 
     let immut_names = vec::from_mut(names);
diff --git a/src/test/stdtest/qsort3.rs b/src/test/stdtest/qsort3.rs
index 6c8df212218..6688a175e8d 100644
--- a/src/test/stdtest/qsort3.rs
+++ b/src/test/stdtest/qsort3.rs
@@ -1,10 +1,10 @@
 
 use std;
 
-fn check_sort(v1: &[mutable int], v2: &[mutable int]) {
+fn check_sort(v1: [mutable int], v2: [mutable int]) {
     let len = std::vec::len::<int>(v1);
-    fn lt(a: &int, b: &int) -> bool { ret a < b; }
-    fn equal(a: &int, b: &int) -> bool { ret a == b; }
+    fn lt(a: int, b: int) -> bool { ret a < b; }
+    fn equal(a: int, b: int) -> bool { ret a == b; }
     let f1 = lt;
     let f2 = equal;
     std::sort::quick_sort3::<int>(f1, f2, v1);
diff --git a/src/test/stdtest/run.rs b/src/test/stdtest/run.rs
index b60a3935500..218889c766b 100644
--- a/src/test/stdtest/run.rs
+++ b/src/test/stdtest/run.rs
@@ -45,7 +45,7 @@ fn test_pipes() {
     log actual;
     assert (expected == actual);
 
-    fn writeclose(fd: int, s: &str) {
+    fn writeclose(fd: int, s: str) {
         let writer = io::new_writer(io::fd_buf_writer(fd, option::none));
         writer.write_str(s);
 
diff --git a/src/test/stdtest/sha1.rs b/src/test/stdtest/sha1.rs
index 6b72be20dd5..9b47b7f1f09 100644
--- a/src/test/stdtest/sha1.rs
+++ b/src/test/stdtest/sha1.rs
@@ -50,7 +50,7 @@ fn test() {
                0xfau8, 0xd3u8, 0xe8u8, 0x5au8, 0x0bu8, 0xd1u8, 0x7du8, 0x9bu8,
                0x10u8, 0x0du8, 0xb4u8, 0xb3u8]}];
     let tests = fips_180_1_tests + wikipedia_tests;
-    fn check_vec_eq(v0: &[u8], v1: &[u8]) {
+    fn check_vec_eq(v0: [u8], v1: [u8]) {
         assert (vec::len::<u8>(v0) == vec::len::<u8>(v1));
         let len = vec::len::<u8>(v0);
         let i = 0u;
diff --git a/src/test/stdtest/sort.rs b/src/test/stdtest/sort.rs
index c42f950ce6b..e27124dd015 100644
--- a/src/test/stdtest/sort.rs
+++ b/src/test/stdtest/sort.rs
@@ -1,9 +1,9 @@
 
 use std;
 
-fn check_sort(v1: &[int], v2: &[int]) {
+fn check_sort(v1: [int], v2: [int]) {
     let len = std::vec::len::<int>(v1);
-    fn lteq(a: &int, b: &int) -> bool { ret a <= b; }
+    fn lteq(a: int, b: int) -> bool { ret a <= b; }
     let f = lteq;
     let v3 = std::sort::merge_sort::<int>(f, v1);
     let i = 0u;
diff --git a/src/test/stdtest/str.rs b/src/test/stdtest/str.rs
index 2852822f8d4..5e79bb6fc20 100644
--- a/src/test/stdtest/str.rs
+++ b/src/test/stdtest/str.rs
@@ -39,7 +39,7 @@ fn test_index_and_rindex() {
 
 #[test]
 fn test_split() {
-    fn t(s: &str, c: char, i: int, k: &str) {
+    fn t(s: str, c: char, i: int, k: str) {
         log "splitting: " + s;
         log i;
         let v = str::split(s, c as u8);
@@ -59,7 +59,7 @@ fn test_split() {
 
 #[test]
 fn test_find() {
-    fn t(haystack: &str, needle: &str, i: int) {
+    fn t(haystack: str, needle: str, i: int) {
         let j: int = str::find(haystack, needle);
         log "searched for " + needle;
         log j;
@@ -74,7 +74,7 @@ fn test_find() {
 
 #[test]
 fn test_substr() {
-    fn t(a: &str, b: &str, start: int) {
+    fn t(a: str, b: str, start: int) {
         assert (str::eq(str::substr(a, start as uint, str::byte_len(b)), b));
     }
     t("hello", "llo", 2);
@@ -84,7 +84,7 @@ fn test_substr() {
 
 #[test]
 fn test_concat() {
-    fn t(v: &[str], s: &str) { assert (str::eq(str::concat(v), s)); }
+    fn t(v: [str], s: str) { assert (str::eq(str::concat(v), s)); }
     t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
     let v: [str] = [];
     t(v, "");
@@ -93,7 +93,7 @@ fn test_concat() {
 
 #[test]
 fn test_connect() {
-    fn t(v: &[str], sep: &str, s: &str) {
+    fn t(v: [str], sep: str, s: str) {
         assert (str::eq(str::connect(v, sep), s));
     }
     t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
diff --git a/src/test/stdtest/treemap.rs b/src/test/stdtest/treemap.rs
index 0f4119c6c3d..3d7bd4fd747 100644
--- a/src/test/stdtest/treemap.rs
+++ b/src/test/stdtest/treemap.rs
@@ -40,7 +40,7 @@ fn traverse_in_order() {
     insert(m, 1, ());
 
     let n = 0;
-    fn t(n: &mutable int, k: &int, v: &()) { assert (n == k); n += 1; }
+    fn t(n: &mutable int, k: int, v: ()) { assert (n == k); n += 1; }
     traverse(m, bind t(n, _, _));
 }
 
diff --git a/src/test/stdtest/vec.rs b/src/test/stdtest/vec.rs
index 6194c461c15..a9cda6c73d6 100644
--- a/src/test/stdtest/vec.rs
+++ b/src/test/stdtest/vec.rs
@@ -8,15 +8,15 @@ import std::option::some;
 
 fn square(n: uint) -> uint { ret n * n; }
 
-fn square_alias(n: &uint) -> uint { ret n * n; }
+fn square_alias(n: uint) -> uint { ret n * n; }
 
-pure fn is_three(n: &uint) -> bool { ret n == 3u; }
+pure fn is_three(n: uint) -> bool { ret n == 3u; }
 
-fn square_if_odd(n: &uint) -> option::t<uint> {
+fn square_if_odd(n: uint) -> option::t<uint> {
     ret if n % 2u == 1u { some(n * n) } else { none };
 }
 
-fn add(x: &uint, y: &uint) -> uint { ret x + y; }
+fn add(x: uint, y: uint) -> uint { ret x + y; }
 
 #[test]
 fn test_unsafe_ptrs() {
@@ -228,7 +228,7 @@ fn test_map() {
 
 #[test]
 fn test_map2() {
-    fn times(x: &int, y: &int) -> int { ret x * y; }
+    fn times(x: int, y: int) -> int { ret x * y; }
     let f = times;
     let v0 = [1, 2, 3, 4, 5];
     let v1 = [5, 4, 3, 2, 1];
@@ -254,12 +254,12 @@ fn test_filter_map() {
     assert (w[1] == 9u);
     assert (w[2] == 25u);
 
-    fn halve(i: &int) -> option::t<int> {
+    fn halve(i: int) -> option::t<int> {
         if i % 2 == 0 {
             ret option::some::<int>(i / 2);
         } else { ret option::none::<int>; }
     }
-    fn halve_for_sure(i: &int) -> int { ret i / 2; }
+    fn halve_for_sure(i: int) -> int { ret i / 2; }
     let all_even: [int] = [0, 2, 8, 6];
     let all_odd1: [int] = [1, 7, 3];
     let all_odd2: [int] = [];
@@ -328,8 +328,8 @@ fn test_position() {
 
 #[test]
 fn test_position_pred() {
-    fn less_than_three(i: &int) -> bool { ret i < 3; }
-    fn is_eighteen(i: &int) -> bool { ret i == 18; }
+    fn less_than_three(i: int) -> bool { ret i < 3; }
+    fn is_eighteen(i: int) -> bool { ret i == 18; }
     let v1: [int] = [5, 4, 3, 2, 1];
     assert (position_pred(less_than_three, v1) == option::some::<uint>(3u));
     assert (position_pred(is_eighteen, v1) == option::none::<uint>);