auto merge of #7430 : huonw/rust/vec-kill, r=thestinger

15 files changed, 95 insertions, 123 deletions

diff --git a/src/libextra/arc.rs b/src/libextra/arc.rs
index c04ee63880e..5e3b60bb3a8 100644
--- a/src/libextra/arc.rs
+++ b/src/libextra/arc.rs
@@ -517,7 +517,6 @@ mod tests {
 
     use arc::*;
 
-    use core::vec;
     use core::cell::Cell;
     use core::comm;
     use core::task;
diff --git a/src/libextra/c_vec.rs b/src/libextra/c_vec.rs
index 84593630cab..79ef5bf2b7e 100644
--- a/src/libextra/c_vec.rs
+++ b/src/libextra/c_vec.rs
@@ -159,8 +159,7 @@ mod tests {
 
             assert!(mem as int != 0);
 
-            return c_vec_with_dtor(mem as *mut u8, n as uint,
-                                   || unsafe { free(mem) });
+            c_vec_with_dtor(mem as *mut u8, n as uint, || free(mem))
         }
     }
 
diff --git a/src/libextra/crypto/sha2.rs b/src/libextra/crypto/sha2.rs
index dd179fde70f..e9c6ac72212 100644
--- a/src/libextra/crypto/sha2.rs
+++ b/src/libextra/crypto/sha2.rs
@@ -11,7 +11,6 @@
 use core::prelude::*;
 
 use core::uint;
-use core::vec;
 
 use digest::Digest;
 
@@ -118,7 +117,7 @@ impl Engine512 {
         }
 
         while in.len() - i >= 8 {
-            let w = to_u64(vec::slice(in, i, i + 8));
+            let w = to_u64(in.slice(i, i + 8));
             self.process_word(w);
             self.bit_counter.add_bytes(8);
             i += 8;
@@ -274,43 +273,43 @@ impl Engine512 {
     fn result_512(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u64(self.H0, vec::mut_slice(out, 0, 8));
-        from_u64(self.H1, vec::mut_slice(out, 8, 16));
-        from_u64(self.H2, vec::mut_slice(out, 16, 24));
-        from_u64(self.H3, vec::mut_slice(out, 24, 32));
-        from_u64(self.H4, vec::mut_slice(out, 32, 40));
-        from_u64(self.H5, vec::mut_slice(out, 40, 48));
-        from_u64(self.H6, vec::mut_slice(out, 48, 56));
-        from_u64(self.H7, vec::mut_slice(out, 56, 64));
+        from_u64(self.H0, out.mut_slice(0, 8));
+        from_u64(self.H1, out.mut_slice(8, 16));
+        from_u64(self.H2, out.mut_slice(16, 24));
+        from_u64(self.H3, out.mut_slice(24, 32));
+        from_u64(self.H4, out.mut_slice(32, 40));
+        from_u64(self.H5, out.mut_slice(40, 48));
+        from_u64(self.H6, out.mut_slice(48, 56));
+        from_u64(self.H7, out.mut_slice(56, 64));
     }
 
     fn result_384(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u64(self.H0, vec::mut_slice(out, 0, 8));
-        from_u64(self.H1, vec::mut_slice(out, 8, 16));
-        from_u64(self.H2, vec::mut_slice(out, 16, 24));
-        from_u64(self.H3, vec::mut_slice(out, 24, 32));
-        from_u64(self.H4, vec::mut_slice(out, 32, 40));
-        from_u64(self.H5, vec::mut_slice(out, 40, 48));
+        from_u64(self.H0, out.mut_slice(0, 8));
+        from_u64(self.H1, out.mut_slice(8, 16));
+        from_u64(self.H2, out.mut_slice(16, 24));
+        from_u64(self.H3, out.mut_slice(24, 32));
+        from_u64(self.H4, out.mut_slice(32, 40));
+        from_u64(self.H5, out.mut_slice(40, 48));
     }
 
     fn result_256(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u64(self.H0, vec::mut_slice(out, 0, 8));
-        from_u64(self.H1, vec::mut_slice(out, 8, 16));
-        from_u64(self.H2, vec::mut_slice(out, 16, 24));
-        from_u64(self.H3, vec::mut_slice(out, 24, 32));
+        from_u64(self.H0, out.mut_slice(0, 8));
+        from_u64(self.H1, out.mut_slice(8, 16));
+        from_u64(self.H2, out.mut_slice(16, 24));
+        from_u64(self.H3, out.mut_slice(24, 32));
     }
 
     fn result_224(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u64(self.H0, vec::mut_slice(out, 0, 8));
-        from_u64(self.H1, vec::mut_slice(out, 8, 16));
-        from_u64(self.H2, vec::mut_slice(out, 16, 24));
-        from_u32((self.H3 >> 32) as u32, vec::mut_slice(out, 24, 28));
+        from_u64(self.H0, out.mut_slice(0, 8));
+        from_u64(self.H1, out.mut_slice(8, 16));
+        from_u64(self.H2, out.mut_slice(16, 24));
+        from_u32((self.H3 >> 32) as u32, out.mut_slice(24, 28));
     }
 }
 
@@ -400,7 +399,7 @@ impl Engine256 {
         }
 
         while in.len() - i >= 4 {
-            let w = to_u32(vec::slice(in, i, i + 4));
+            let w = to_u32(in.slice(i, i + 4));
             self.process_word(w);
             self.length_bytes += 4;
             i += 4;
@@ -556,26 +555,26 @@ impl Engine256 {
     fn result_256(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u32(self.H0, vec::mut_slice(out, 0, 4));
-        from_u32(self.H1, vec::mut_slice(out, 4, 8));
-        from_u32(self.H2, vec::mut_slice(out, 8, 12));
-        from_u32(self.H3, vec::mut_slice(out, 12, 16));
-        from_u32(self.H4, vec::mut_slice(out, 16, 20));
-        from_u32(self.H5, vec::mut_slice(out, 20, 24));
-        from_u32(self.H6, vec::mut_slice(out, 24, 28));
-        from_u32(self.H7, vec::mut_slice(out, 28, 32));
+        from_u32(self.H0, out.mut_slice(0, 4));
+        from_u32(self.H1, out.mut_slice(4, 8));
+        from_u32(self.H2, out.mut_slice(8, 12));
+        from_u32(self.H3, out.mut_slice(12, 16));
+        from_u32(self.H4, out.mut_slice(16, 20));
+        from_u32(self.H5, out.mut_slice(20, 24));
+        from_u32(self.H6, out.mut_slice(24, 28));
+        from_u32(self.H7, out.mut_slice(28, 32));
     }
 
     fn result_224(&mut self, out: &mut [u8]) {
         self.finish();
 
-        from_u32(self.H0, vec::mut_slice(out, 0, 4));
-        from_u32(self.H1, vec::mut_slice(out, 4, 8));
-        from_u32(self.H2, vec::mut_slice(out, 8, 12));
-        from_u32(self.H3, vec::mut_slice(out, 12, 16));
-        from_u32(self.H4, vec::mut_slice(out, 16, 20));
-        from_u32(self.H5, vec::mut_slice(out, 20, 24));
-        from_u32(self.H6, vec::mut_slice(out, 24, 28));
+        from_u32(self.H0, out.mut_slice(0, 4));
+        from_u32(self.H1, out.mut_slice(4, 8));
+        from_u32(self.H2, out.mut_slice(8, 12));
+        from_u32(self.H3, out.mut_slice(12, 16));
+        from_u32(self.H4, out.mut_slice(16, 20));
+        from_u32(self.H5, out.mut_slice(20, 24));
+        from_u32(self.H6, out.mut_slice(24, 28));
     }
 }
 
diff --git a/src/libextra/deque.rs b/src/libextra/deque.rs
index e6a7dd64837..c70c87b6ea1 100644
--- a/src/libextra/deque.rs
+++ b/src/libextra/deque.rs
@@ -137,7 +137,7 @@ impl<T> Deque<T> {
     ///
     /// * n - The number of elements to reserve space for
     pub fn reserve(&mut self, n: uint) {
-        vec::reserve(&mut self.elts, n);
+        self.elts.reserve(n);
     }
 
     /// Reserve capacity for at least `n` elements in the given deque,
@@ -151,7 +151,7 @@ impl<T> Deque<T> {
     ///
     /// * n - The number of elements to reserve space for
     pub fn reserve_at_least(&mut self, n: uint) {
-        vec::reserve_at_least(&mut self.elts, n);
+        self.elts.reserve_at_least(n);
     }
 
     /// Front-to-back iterator.
@@ -256,7 +256,6 @@ mod tests {
     use super::*;
     use core::cmp::Eq;
     use core::kinds::Copy;
-    use core::vec::capacity;
     use core;
 
     #[test]
@@ -442,11 +441,11 @@ mod tests {
         let mut d = Deque::new();
         d.add_back(0u64);
         d.reserve(50);
-        assert_eq!(capacity(&mut d.elts), 50);
+        assert_eq!(d.elts.capacity(), 50);
         let mut d = Deque::new();
         d.add_back(0u32);
         d.reserve(50);
-        assert_eq!(capacity(&mut d.elts), 50);
+        assert_eq!(d.elts.capacity(), 50);
     }
 
     #[test]
@@ -454,11 +453,11 @@ mod tests {
         let mut d = Deque::new();
         d.add_back(0u64);
         d.reserve_at_least(50);
-        assert_eq!(capacity(&mut d.elts), 64);
+        assert_eq!(d.elts.capacity(), 64);
         let mut d = Deque::new();
         d.add_back(0u32);
         d.reserve_at_least(50);
-        assert_eq!(capacity(&mut d.elts), 64);
+        assert_eq!(d.elts.capacity(), 64);
     }
 
     #[test]
diff --git a/src/libextra/dlist.rs b/src/libextra/dlist.rs
index 1767aa8c397..ee86340e47b 100644
--- a/src/libextra/dlist.rs
+++ b/src/libextra/dlist.rs
@@ -526,8 +526,6 @@ mod tests {
 
     use super::*;
 
-    use core::vec;
-
     #[test]
     fn test_dlist_concat() {
         let a = from_vec([1,2]);
diff --git a/src/libextra/ebml.rs b/src/libextra/ebml.rs
index dd08f23a7a1..92a027100da 100644
--- a/src/libextra/ebml.rs
+++ b/src/libextra/ebml.rs
@@ -85,7 +85,6 @@ pub mod reader {
     use core::ptr::offset;
     use core::str;
     use core::unstable::intrinsics::bswap32;
-    use core::vec;
 
     // ebml reading
 
@@ -248,7 +247,7 @@ pub mod reader {
     }
 
     pub fn with_doc_data<T>(d: Doc, f: &fn(x: &[u8]) -> T) -> T {
-        f(vec::slice(*d.data, d.start, d.end))
+        f(d.data.slice(d.start, d.end))
     }
 
 
diff --git a/src/libextra/net_tcp.rs b/src/libextra/net_tcp.rs
index 6ad51931c67..f3f6ffde660 100644
--- a/src/libextra/net_tcp.rs
+++ b/src/libextra/net_tcp.rs
@@ -976,9 +976,7 @@ impl io::Writer for TcpSocketBuf {
         let socket_data_ptr: *TcpSocketData =
             &(*((*(self.data)).sock).socket_data);
         let w_result = write_common_impl(socket_data_ptr,
-                                         vec::slice(data,
-                                                    0,
-                                                    data.len()).to_owned());
+                                         data.slice(0, data.len()).to_owned());
         if w_result.is_err() {
             let err_data = w_result.get_err();
             debug!(
@@ -1459,33 +1457,23 @@ mod test {
 
             #[test]
             fn test_gl_tcp_server_and_client_ipv4() {
-                unsafe {
-                    impl_gl_tcp_ipv4_server_and_client();
-                }
+                impl_gl_tcp_ipv4_server_and_client();
             }
             #[test]
             fn test_gl_tcp_get_peer_addr() {
-                unsafe {
-                    impl_gl_tcp_ipv4_get_peer_addr();
-                }
+                impl_gl_tcp_ipv4_get_peer_addr();
             }
             #[test]
             fn test_gl_tcp_ipv4_client_error_connection_refused() {
-                unsafe {
-                    impl_gl_tcp_ipv4_client_error_connection_refused();
-                }
+                impl_gl_tcp_ipv4_client_error_connection_refused();
             }
             #[test]
             fn test_gl_tcp_server_address_in_use() {
-                unsafe {
-                    impl_gl_tcp_ipv4_server_address_in_use();
-                }
+                impl_gl_tcp_ipv4_server_address_in_use();
             }
             #[test]
             fn test_gl_tcp_server_access_denied() {
-                unsafe {
-                    impl_gl_tcp_ipv4_server_access_denied();
-                }
+                impl_gl_tcp_ipv4_server_access_denied();
             }
             // Strange failure on Windows. --pcwalton
             #[test]
diff --git a/src/libextra/num/bigint.rs b/src/libextra/num/bigint.rs
index 4b080e0153c..1ac913e8a00 100644
--- a/src/libextra/num/bigint.rs
+++ b/src/libextra/num/bigint.rs
@@ -298,9 +298,8 @@ impl Mul<BigUint, BigUint> for BigUint {
 
         fn cut_at(a: &BigUint, n: uint) -> (BigUint, BigUint) {
             let mid = uint::min(a.data.len(), n);
-            return (BigUint::from_slice(vec::slice(a.data, mid,
-                                                   a.data.len())),
-                    BigUint::from_slice(vec::slice(a.data, 0, mid)));
+            return (BigUint::from_slice(a.data.slice(mid, a.data.len())),
+                    BigUint::from_slice(a.data.slice(0, mid)));
         }
 
 
@@ -413,7 +412,7 @@ impl Integer for BigUint {
                 return (Zero::zero(), Zero::zero(), copy *a);
             }
 
-            let an = vec::slice(a.data, a.data.len() - n, a.data.len());
+            let an = a.data.slice(a.data.len() - n, a.data.len());
             let bn = *b.data.last();
             let mut d = ~[];
             let mut carry = 0;
@@ -578,7 +577,7 @@ impl BigUint {
         let mut power: BigUint  = One::one();
         loop {
             let start = uint::max(end, unit_len) - unit_len;
-            match uint::parse_bytes(vec::slice(buf, start, end), radix) {
+            match uint::parse_bytes(buf.slice(start, end), radix) {
                 // FIXME(#6102): Assignment operator for BigInt causes ICE
                 // Some(d) => n += BigUint::from_uint(d) * power,
                 Some(d) => n = n + BigUint::from_uint(d) * power,
@@ -634,7 +633,7 @@ impl BigUint {
         if n_unit == 0 { return copy *self; }
         if self.data.len() < n_unit { return Zero::zero(); }
         return BigUint::from_slice(
-            vec::slice(self.data, n_unit, self.data.len())
+            self.data.slice(n_unit, self.data.len())
         );
     }
 
@@ -1132,7 +1131,7 @@ impl BigInt {
             sign  = Minus;
             start = 1;
         }
-        return BigUint::parse_bytes(vec::slice(buf, start, buf.len()), radix)
+        return BigUint::parse_bytes(buf.slice(start, buf.len()), radix)
             .map_consume(|bu| BigInt::from_biguint(sign, bu));
     }
 
@@ -1176,7 +1175,7 @@ mod biguint_tests {
         let data = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1]  ]
             .map(|v| BigUint::from_slice(*v));
         for data.iter().enumerate().advance |(i, ni)| {
-            for vec::slice(data, i, data.len()).iter().enumerate().advance |(j0, nj)| {
+            for data.slice(i, data.len()).iter().enumerate().advance |(j0, nj)| {
                 let j = j0 + i;
                 if i == j {
                     assert_eq!(ni.cmp(nj), Equal);
@@ -1654,7 +1653,7 @@ mod bigint_tests {
         nums.push_all_move(vs.map(|s| BigInt::from_slice(Plus, *s)));
 
         for nums.iter().enumerate().advance |(i, ni)| {
-            for vec::slice(nums, i, nums.len()).iter().enumerate().advance |(j0, nj)| {
+            for nums.slice(i, nums.len()).iter().enumerate().advance |(j0, nj)| {
                 let j = i + j0;
                 if i == j {
                     assert_eq!(ni.cmp(nj), Equal);
diff --git a/src/libextra/priority_queue.rs b/src/libextra/priority_queue.rs
index af891edf9e5..fbb4be0febb 100644
--- a/src/libextra/priority_queue.rs
+++ b/src/libextra/priority_queue.rs
@@ -52,12 +52,12 @@ impl<T:Ord> PriorityQueue<T> {
     }
 
     /// Returns the number of elements the queue can hold without reallocating
-    pub fn capacity(&self) -> uint { vec::capacity(&self.data) }
+    pub fn capacity(&self) -> uint { self.data.capacity() }
 
-    pub fn reserve(&mut self, n: uint) { vec::reserve(&mut self.data, n) }
+    pub fn reserve(&mut self, n: uint) { self.data.reserve(n) }
 
     pub fn reserve_at_least(&mut self, n: uint) {
-        vec::reserve_at_least(&mut self.data, n)
+        self.data.reserve_at_least(n)
     }
 
     /// Pop the greatest item from the queue - fails if empty
diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs
index 3c872d64ca0..5377dfadbaa 100644
--- a/src/libextra/sort.rs
+++ b/src/libextra/sort.rs
@@ -57,8 +57,8 @@ pub fn merge_sort<T:Copy>(v: &[T], le: Le<T>) -> ~[T] {
                 a_ix += 1;
             } else { rs.push(copy b[b_ix]); b_ix += 1; }
         }
-        rs.push_all(vec::slice(a, a_ix, a_len));
-        rs.push_all(vec::slice(b, b_ix, b_len));
+        rs.push_all(a.slice(a_ix, a_len));
+        rs.push_all(b.slice(b_ix, b_len));
         rs
     }
 }
@@ -201,12 +201,12 @@ pub fn tim_sort<T:Copy + Ord>(array: &mut [T]) {
     loop {
         let run_len: uint = {
             // This scope contains the slice `arr` here:
-            let arr = vec::mut_slice(array, idx, size);
+            let arr = array.mut_slice(idx, size);
             let mut run_len: uint = count_run_ascending(arr);
 
             if run_len < min_run {
                 let force = if remaining <= min_run {remaining} else {min_run};
-                let slice = vec::mut_slice(arr, 0, force);
+                let slice = arr.mut_slice(0, force);
                 binarysort(slice, run_len);
                 run_len = force;
             }
@@ -443,14 +443,14 @@ impl<T:Copy + Ord> MergeState<T> {
         }
 
         let k = { // constrain lifetime of slice below
-            let slice = vec::slice(array, b1, b1+l1);
+            let slice = array.slice(b1, b1+l1);
             gallop_right(&array[b2], slice, 0)
         };
         b1 += k;
         l1 -= k;
         if l1 != 0 {
             let l2 = { // constrain lifetime of slice below
-                let slice = vec::slice(array, b2, b2+l2);
+                let slice = array.slice(b2, b2+l2);
                 gallop_left(&array[b1+l1-1],slice,l2-1)
             };
             if l2 > 0 {
@@ -526,7 +526,7 @@ impl<T:Copy + Ord> MergeState<T> {
                 assert!(len1 > 1 && len2 != 0);
 
                 count1 = {
-                    let tmp_view = vec::slice(tmp, c1, c1+len1);
+                    let tmp_view = tmp.slice(c1, c1+len1);
                     gallop_right(&array[c2], tmp_view, 0)
                 };
                 if count1 != 0 {
@@ -539,7 +539,7 @@ impl<T:Copy + Ord> MergeState<T> {
                 if len2 == 0 { break_outer = true; break; }
 
                 count2 = {
-                    let tmp_view = vec::slice(array, c2, c2+len2);
+                    let tmp_view = array.slice(c2, c2+len2);
                     gallop_left(&tmp[c1], tmp_view, 0)
                 };
                 if count2 != 0 {
@@ -638,7 +638,7 @@ impl<T:Copy + Ord> MergeState<T> {
                 assert!(len2 > 1 && len1 != 0);
 
                 { // constrain scope of tmp_view:
-                    let tmp_view = vec::mut_slice (array, base1, base1+len1);
+                    let tmp_view = array.mut_slice(base1, base1+len1);
                     count1 = len1 - gallop_right(
                         &tmp[c2], tmp_view, len1-1);
                 }
@@ -655,7 +655,7 @@ impl<T:Copy + Ord> MergeState<T> {
 
                 let count2;
                 { // constrain scope of tmp_view
-                    let tmp_view = vec::mut_slice(tmp, 0, len2);
+                    let tmp_view = tmp.mut_slice(0, len2);
                     count2 = len2 - gallop_left(&array[c1],
                                                 tmp_view,
                                                 len2-1);
@@ -1111,7 +1111,7 @@ mod big_tests {
             isSorted(arr);
 
             let mut arr = if n > 4 {
-                let part = vec::slice(arr, 0, 4);
+                let part = arr.slice(0, 4);
                 multiplyVec(part, n)
             } else { arr };
             tim_sort(arr); // ~sort
@@ -1183,7 +1183,7 @@ mod big_tests {
             isSorted(arr);
 
             let mut arr = if n > 4 {
-                let part = vec::slice(arr, 0, 4);
+                let part = arr.slice(0, 4);
                 multiplyVec(part, n)
             } else { arr };
             tim_sort(arr); // ~sort
diff --git a/src/libextra/sync.rs b/src/libextra/sync.rs
index 8cfe39c5ef2..817e1ab1226 100644
--- a/src/libextra/sync.rs
+++ b/src/libextra/sync.rs
@@ -808,7 +808,6 @@ mod tests {
     use core::comm;
     use core::result;
     use core::task;
-    use core::vec;
 
     /************************************************************************
      * Semaphore tests
diff --git a/src/libextra/test.rs b/src/libextra/test.rs
index 72e70943ce1..7b68298a8dd 100644
--- a/src/libextra/test.rs
+++ b/src/libextra/test.rs
@@ -139,7 +139,7 @@ type OptRes = Either<TestOpts, ~str>;
 
 // Parses command line arguments into test options
 pub fn parse_opts(args: &[~str]) -> OptRes {
-    let args_ = vec::tail(args);
+    let args_ = args.tail();
     let opts = ~[getopts::optflag("ignored"),
                  getopts::optflag("test"),
                  getopts::optflag("bench"),
@@ -431,7 +431,7 @@ fn run_tests(opts: &TestOpts,
     callback(TeFiltered(filtered_descs));
 
     let (filtered_tests, filtered_benchs) =
-        do vec::partition(filtered_tests) |e| {
+        do filtered_tests.partition |e| {
         match e.testfn {
             StaticTestFn(_) | DynTestFn(_) => true,
             StaticBenchFn(_) | DynBenchFn(_) => false
diff --git a/src/libextra/treemap.rs b/src/libextra/treemap.rs
index 33ec4ae94ba..4622b8c7284 100644
--- a/src/libextra/treemap.rs
+++ b/src/libextra/treemap.rs
@@ -695,7 +695,6 @@ mod test_treemap {
 
     use core::rand::RngUtil;
     use core::rand;
-    use core::vec;
 
     #[test]
     fn find_empty() {
@@ -848,7 +847,7 @@ mod test_treemap {
 
             for 30.times {
                 let r = rng.gen_uint_range(0, ctrl.len());
-                let (key, _) = vec::remove(&mut ctrl, r);
+                let (key, _) = ctrl.remove(r);
                 assert!(map.remove(&key));
                 check_structure(&map);
                 check_equal(ctrl, &map);
diff --git a/src/libextra/uv_global_loop.rs b/src/libextra/uv_global_loop.rs
index 286863bef64..f1dde1b8cb4 100644
--- a/src/libextra/uv_global_loop.rs
+++ b/src/libextra/uv_global_loop.rs
@@ -150,9 +150,7 @@ mod test {
             let hl_loop = &get_gl();
             do iotask::interact(hl_loop) |_loop_ptr| {
                 debug!(~"closing timer");
-                unsafe {
-                    ll::close(timer_ptr, simple_timer_close_cb);
-                }
+                ll::close(timer_ptr, simple_timer_close_cb);
                 debug!(~"about to deref exit_ch_ptr");
                 debug!(~"after msg sent on deref'd exit_ch");
             };
@@ -169,24 +167,22 @@ mod test {
             let timer_handle = ll::timer_t();
             let timer_ptr: *ll::uv_timer_t = &timer_handle;
             do iotask::interact(iotask) |loop_ptr| {
-                unsafe {
-                    debug!(~"user code inside interact loop!!!");
-                    let init_status = ll::timer_init(loop_ptr, timer_ptr);
-                    if(init_status == 0i32) {
-                        ll::set_data_for_uv_handle(
-                            timer_ptr as *libc::c_void,
-                            exit_ch_ptr);
-                        let start_status = ll::timer_start(timer_ptr,
-                                                           simple_timer_cb,
-                                                           1u, 0u);
-                        if(start_status != 0i32) {
-                            fail!("failure on ll::timer_start()");
-                        }
-                    }
-                    else {
-                        fail!("failure on ll::timer_init()");
+                debug!(~"user code inside interact loop!!!");
+                let init_status = ll::timer_init(loop_ptr, timer_ptr);
+                if(init_status == 0i32) {
+                    ll::set_data_for_uv_handle(
+                        timer_ptr as *libc::c_void,
+                        exit_ch_ptr);
+                    let start_status = ll::timer_start(timer_ptr,
+                                                       simple_timer_cb,
+                                                       1u, 0u);
+                    if(start_status != 0i32) {
+                        fail!("failure on ll::timer_start()");
                     }
                 }
+                else {
+                    fail!("failure on ll::timer_init()");
+                }
             };
             exit_po.recv();
             debug!(
diff --git a/src/libextra/uv_ll.rs b/src/libextra/uv_ll.rs
index 744f4555d5c..58b477d4ccf 100644
--- a/src/libextra/uv_ll.rs
+++ b/src/libextra/uv_ll.rs
@@ -1767,9 +1767,7 @@ mod test {
         mod impl64 {
             #[test]
             fn test_uv_ll_tcp_server_and_request() {
-                unsafe {
-                    super::super::impl_uv_tcp_server_and_request();
-                }
+                super::super::impl_uv_tcp_server_and_request();
             }
         }
         #[cfg(target_arch="x86")]