tests: remove uses of Gc.

src/test/bench/task-perf-alloc-unwind.rs

@@ -10,18 +10,15 @@
 
 #![feature(unsafe_destructor)]
 
-extern crate collections;
 extern crate time;
 
 use time::precise_time_s;
 use std::os;
 use std::task;
-use std::vec;
-use std::gc::{Gc, GC};
 
 #[deriving(Clone)]
 enum List<T> {
-    Nil, Cons(T, Gc<List<T>>)
+    Nil, Cons(T, Box<List<T>>)
 }
 
 enum UniqueList {
@@ -53,15 +50,13 @@ type nillist = List<()>;
 // Filled with things that have to be unwound
 
 struct State {
-    managed: Gc<nillist>,
     unique: Box<nillist>,
-    tuple: (Gc<nillist>, Box<nillist>),
-    vec: Vec<Gc<nillist>>,
+    vec: Vec<Box<nillist>>,
     res: r
 }
 
 struct r {
-  _l: Gc<nillist>,
+  _l: Box<nillist>,
 }
 
 #[unsafe_destructor]
@@ -69,7 +64,7 @@ impl Drop for r {
     fn drop(&mut self) {}
 }
 
-fn r(l: Gc<nillist>) -> r {
+fn r(l: Box<nillist>) -> r {
     r {
         _l: l
     }
@@ -85,22 +80,17 @@ fn recurse_or_fail(depth: int, st: Option<State>) {
         let st = match st {
           None => {
             State {
-                managed: box(GC) Nil,
                 unique: box Nil,
-                tuple: (box(GC) Nil, box Nil),
-                vec: vec!(box(GC) Nil),
-                res: r(box(GC) Nil)
+                vec: vec!(box Nil),
+                res: r(box Nil)
             }
           }
           Some(st) => {
             State {
-                managed: box(GC) Cons((), st.managed),
-                unique: box Cons((), box(GC) *st.unique),
-                tuple: (box(GC) Cons((), st.tuple.ref0().clone()),
-                        box Cons((), box(GC) *st.tuple.ref1().clone())),
+                unique: box Cons((), box *st.unique),
                 vec: st.vec.clone().append(
-                        &[box(GC) Cons((), *st.vec.last().unwrap())]),
-                res: r(box(GC) Cons((), st.res._l))
+                        &[box Cons((), *st.vec.last().unwrap())]),
+                res: r(box Cons((), st.res._l))
             }
           }
         };