Get these files compiling again

src/fuzzer/ast_match.rs

 use std;
 import vec;
 
-fn vec_equal<T>(v: [T], u: [T], element_equality_test: fn(T, T) -> bool) ->
+fn vec_equal<T>(v: [T], u: [T], element_equality_test: fn@(&&T, &&T) -> bool) ->
    bool {
     let Lv = vec::len(v);
     if Lv != vec::len(u) { ret false; }
@@ -13,15 +13,17 @@ fn vec_equal<T>(v: [T], u: [T], element_equality_test: fn(T, T) -> bool) ->
     ret true;
 }
 
-fn builtin_equal<T>(a: T, b: T) -> bool { ret a == b; }
+pure fn builtin_equal<T>(&&a: T, &&b: T) -> bool { ret a == b; }
+pure fn builtin_equal_int(&&a: int, &&b: int) -> bool { ret a == b; }
 
 fn main() {
     assert (builtin_equal(5, 5));
     assert (!builtin_equal(5, 4));
-    assert (!vec_equal([5, 5], [5], builtin_equal));
-    assert (!vec_equal([5, 5], [5, 4], builtin_equal));
-    assert (!vec_equal([5, 5], [4, 5], builtin_equal));
-    assert (vec_equal([5, 5], [5, 5], builtin_equal));
+    assert (!vec_equal([5, 5], [5], bind builtin_equal(_, _)));
+    assert (!vec_equal([5, 5], [5], builtin_equal_int));
+    assert (!vec_equal([5, 5], [5, 4], builtin_equal_int));
+    assert (!vec_equal([5, 5], [4, 5], builtin_equal_int));
+    assert (vec_equal([5, 5], [5, 5], builtin_equal_int));
 
     #error("Pass");
 }

src/fuzzer/cycles.rs

@@ -7,7 +7,7 @@
 fn under(r : rand::rng, n : uint) -> uint { assert n != 0u; r.next() as uint % n }
 
 // random choice from a vec
-fn choice<T>(r : rand::rng, v : [T]) -> T { assert vec::len(v) != 0u; v[under(r, vec::len(v))] }
+fn choice<T: copy>(r : rand::rng, v : [T]) -> T { assert vec::len(v) != 0u; v[under(r, vec::len(v))] }
 
 // 1 in n chance of being true
 fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u }
@@ -20,7 +20,7 @@ fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u }
 type pointy = {
   mutable x : maybe_pointy,
   mutable y : maybe_pointy,
-  mutable z : fn()->()
+  mutable z : fn@()->()
 };
 
 fn allunder(n: uint, it: block(uint)) {
@@ -36,8 +36,8 @@ fn test_cycles(r : rand::rng)
     const max : uint = 10u;
 
     let v : [mutable @pointy] = [mutable];
-    allunder(max) {|i|
-        v += [mutable @{ mutable x : no_pointy, mutable y : no_pointy, mutable z: nop }];
+    allunder(max) {|_i|
+        v += [mutable @{ mutable x : no_pointy, mutable y : no_pointy, mutable z: bind nop() }];
     }
 
     allunder(max) {|i|
@@ -48,7 +48,7 @@ fn test_cycles(r : rand::rng)
 
     // Drop refs one at a time
     allunder(max) {|i|
-        v[i] = @{ mutable x : no_pointy, mutable y : no_pointy, mutable z: nop };
+        v[i] = @{ mutable x : no_pointy, mutable y : no_pointy, mutable z: bind nop() };
     }
 }
 

src/fuzzer/ivec_fuzz.rs

@@ -22,22 +22,22 @@
 import vec::len;
 import int;
 
-fn vec_omit<T>(v: [T], i: uint) -> [T] {
+fn vec_omit<T: copy>(v: [T], i: uint) -> [T] {
     slice(v, 0u, i) + slice(v, i + 1u, len(v))
 }
-fn vec_dup<T>(v: [T], i: uint) -> [T] {
+fn vec_dup<T: copy>(v: [T], i: uint) -> [T] {
     slice(v, 0u, i) + [v[i]] + slice(v, i, len(v))
 }
-fn vec_swadj<T>(v: [T], i: uint) -> [T] {
+fn vec_swadj<T: copy>(v: [T], i: uint) -> [T] {
     slice(v, 0u, i) + [v[i + 1u], v[i]] + slice(v, i + 2u, len(v))
 }
-fn vec_prefix<T>(v: [T], i: uint) -> [T] { slice(v, 0u, i) }
-fn vec_suffix<T>(v: [T], i: uint) -> [T] { slice(v, i, len(v)) }
+fn vec_prefix<T: copy>(v: [T], i: uint) -> [T] { slice(v, 0u, i) }
+fn vec_suffix<T: copy>(v: [T], i: uint) -> [T] { slice(v, i, len(v)) }
 
-fn vec_poke<T>(v: [T], i: uint, x: T) -> [T] {
+fn vec_poke<T: copy>(v: [T], i: uint, x: T) -> [T] {
     slice(v, 0u, i) + [x] + slice(v, i + 1u, len(v))
 }
-fn vec_insert<T>(v: [T], i: uint, x: T) -> [T] {
+fn vec_insert<T: copy>(v: [T], i: uint, x: T) -> [T] {
     slice(v, 0u, i) + [x] + slice(v, i, len(v))
 }
 
@@ -48,7 +48,7 @@ fn ix(skip_low: uint, skip_high: uint, length: uint, it: block(uint)) {
 }
 
 // Returns a bunch of modified versions of v, some of which introduce new elements (borrowed from xs).
-fn vec_edits<T>(v: [T], xs: [T]) -> [[T]] {
+fn vec_edits<T: copy>(v: [T], xs: [T]) -> [[T]] {
     let edits: [[T]] = [];
     let Lv: uint = len(v);
 

src/fuzzer/rand_util.rs

@@ -6,7 +6,7 @@
 fn under(r : rand::rng, n : uint) -> uint { assert n != 0u; r.next() as uint % n }
 
 // random choice from a vec
-fn choice<T>(r : rand::rng, v : [T]) -> T { assert vec::len(v) != 0u; v[under(r, vec::len(v))] }
+fn choice<T: copy>(r : rand::rng, v : [T]) -> T { assert vec::len(v) != 0u; v[under(r, vec::len(v))] }
 
 // 1 in n chance of being true
 fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u }
@@ -22,7 +22,7 @@ fn shuffle<T>(r : rand::rng, &v : [mutable T]) {
 }
 
 // create a shuffled copy of a vec
-fn shuffled<T>(r : rand::rng, v : [T]) -> [T] {
+fn shuffled<T: copy>(r : rand::rng, v : [T]) -> [T] {
     let w = vec::to_mut(v);
     shuffle(r, w);
     vec::from_mut(w) // Shouldn't this happen automatically?
@@ -35,7 +35,7 @@ fn shuffled<T>(r : rand::rng, v : [T]) -> [T] {
 // * weighted_choice is O(number of choices) time
 // * weighted_vec is O(total weight) space
 type weighted<T> = { weight: uint, item: T };
-fn weighted_choice<T>(r : rand::rng, v : [weighted<T>]) -> T {
+fn weighted_choice<T: copy>(r : rand::rng, v : [weighted<T>]) -> T {
     assert vec::len(v) != 0u;
     let total = 0u;
     for {weight: weight, item: _} in v {
@@ -53,7 +53,7 @@ fn weighted_choice<T>(r : rand::rng, v : [weighted<T>]) -> T {
     std::util::unreachable();
 }
 
-fn weighted_vec<T>(v : [weighted<T>]) -> [T] {
+fn weighted_vec<T: copy>(v : [weighted<T>]) -> [T] {
     let r = [];
     for {weight: weight, item: item} in v {
         let i = 0u;