Test fixes and rebase conflicts

diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 03634657a71b7da8a37dd15d86743d815d2bf0cc..820a3838978c0173c43aac5fc4d31a86c06c7b49 100644 (file)
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -600,6 +600,7 @@ mod tests {
     use std::option::Option::{Some, None};
     use std::str::Str;
     use std::sync::atomic;
+    use std::sync::atomic::Ordering::{Acquire, SeqCst};
     use std::task;
     use std::kinds::Send;
     use std::vec::Vec;

diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs
index 8f51b551700761f7454d8eedef15cf233b85409f..3907f28092a379ebf7bf5a4204e479106ab1779b 100644 (file)
--- a/src/libcollections/btree/node.rs
+++ b/src/libcollections/btree/node.rs
@@ -304,9 +304,9 @@ fn new_leaf(capacity: uint) -> Node<K, V> {
         let (vals_offset, _) = calculate_offsets_generic::<K, V>(capacity, true);
 
         Node {
-            keys: Unique(buffer as *mut K).
+            keys: Unique(buffer as *mut K),
             vals: Unique(unsafe { buffer.offset(vals_offset as int) as *mut V }),
-            edges: Unique(ptr::null_mut::<u8>()),
+            edges: Unique(ptr::null_mut()),
             _len: 0,
             _capacity: capacity,
         }
@@ -574,7 +574,7 @@ pub fn capacity(&self) -> uint {
 
     /// If the node has any children
     pub fn is_leaf(&self) -> bool {
-        self.edges.is_null()
+        self.edges.0.is_null()
     }
 
     /// if the node has too few elements
@@ -1058,7 +1058,7 @@ pub fn into_iter(self) -> MoveTraversal<K, V> {
                     vals: RawItems::from_slice(self.vals()),
                     edges: RawItems::from_slice(self.edges()),
 
-                    ptr: self.keys as *mut u8,
+                    ptr: self.keys.0 as *mut u8,
                     capacity: self.capacity(),
                     is_leaf: self.is_leaf()
                 },

diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index bbe6ecc8ea6b56f47e1350b33b969088f3b85636..02b70c0f169d88e9fdc39ea7e85f828b773c5d11 100644 (file)
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -1102,11 +1102,11 @@ fn to_owned(&self) -> Vec<T> { self.to_vec() }
 // Iterators
 ////////////////////////////////////////////////////////////////////////////////
 
-#[deriving(Copy)]
+#[deriving(Copy, Clone)]
 enum Direction { Pos, Neg }
 
 /// An `Index` and `Direction` together.
-#[deriving(Copy)]
+#[deriving(Copy, Clone)]
 struct SizeDirection {
     size: uint,
     dir: Direction,

diff --git a/src/libcoretest/atomic.rs b/src/libcoretest/atomic.rs
index ab9c7ab9f11da115e3e71cc15cdad0402ef1a2ba..1fee304a9764890281b6bf7ce4f3c2864a1aebed 100644 (file)
--- a/src/libcoretest/atomic.rs
+++ b/src/libcoretest/atomic.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use core::atomic::*;
+use core::atomic::Ordering::SeqCst;
 
 #[test]
 fn bool_() {

diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs
index a7d1d3a23bd1345c941e74a729001fc690f7f4f2..366e33d6384ba0888d805dae10cf8d7726c5021e 100644 (file)
--- a/src/librustc_back/sha2.rs
+++ b/src/librustc_back/sha2.rs
@@ -530,11 +530,12 @@ fn output_bits(&self) -> uint { 256 }
 mod tests {
     extern crate rand;
 
-    use super::{Digest, Sha256, FixedBuffer};
-    use self::rand::isaac::IsaacRng;
     use self::rand::Rng;
+    use self::rand::isaac::IsaacRng;
     use serialize::hex::FromHex;
+    use std::iter::repeat;
     use std::num::Int;
+    use super::{Digest, Sha256, FixedBuffer};
 
     // A normal addition - no overflow occurs
     #[test]

diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index 8181ea5253f9395faf18bca54b050dbdec1b61c7..3bfe2009f8b4b5fb250f72c0afaab66f71510cd2 100644 (file)
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -1320,9 +1320,9 @@ pub struct Iter<'a, K: 'a, V: 'a> {
 }
 
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
-impl<'a, K, V> Clone for Entries<'a, K, V> {
-    fn clone(&self) -> Entries<'a, K, V> {
-        Entries {
+impl<'a, K, V> Clone for Iter<'a, K, V> {
+    fn clone(&self) -> Iter<'a, K, V> {
+        Iter {
             inner: self.inner.clone()
         }
     }

diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
index f5fbfcabcfb71d7232044f846da6c4c036fe2290..6938ab9b0b6d7defb94ade8b0239e1c7c5463e10 100644 (file)
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -788,9 +788,9 @@ pub struct Iter<'a, K: 'a, V: 'a> {
 }
 
 // FIXME(#19839) Remove in favor of `#[deriving(Clone)]`
-impl<'a, K, V> Clone for Entries<'a, K, V> {
-    fn clone(&self) -> Entries<'a, K, V> {
-        Entries {
+impl<'a, K, V> Clone for Iter<'a, K, V> {
+    fn clone(&self) -> Iter<'a, K, V> {
+        Iter {
             iter: self.iter.clone(),
             elems_left: self.elems_left
         }

diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index a9d9607395ce52997ca3549ad2354776cd093459..df50b7f81afcf24d4c61c399cb90090d63a687d6 100644 (file)
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -716,6 +716,7 @@ fn real_args() -> Vec<String> {
 #[cfg(windows)]
 fn real_args() -> Vec<String> {
     use slice;
+    use iter::range;
 
     let mut nArgs: c_int = 0;
     let lpArgCount: *mut c_int = &mut nArgs;

diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs
index 235ebf211ac08e27879e662bfd41063cf40742d0..28eca9163f6e5a15ae008ed40b2f6922e7c1fb58 100644 (file)
--- a/src/libstd/sys/windows/os.rs
+++ b/src/libstd/sys/windows/os.rs
@@ -129,7 +129,7 @@ pub fn fill_utf16_buf_and_decode(f: |*mut u16, DWORD| -> DWORD) -> Option<String
         let mut res = None;
         let mut done = false;
         while !done {
-            let mut buf: Vec<u16> = repeat(0u16).take(n).collect();
+            let mut buf: Vec<u16> = repeat(0u16).take(n as uint).collect();
             let k = f(buf.as_mut_ptr(), n);
             if k == (0 as DWORD) {
                 done = true;

diff --git a/src/test/compile-fail/trait-object-safety.rs b/src/test/compile-fail/trait-object-safety.rs
index d594e3e17474bf0a81c2cd0e82d79d693f906118..761bcd4968abfba2459f2d06e6f40bd9df33091a 100644 (file)
--- a/src/test/compile-fail/trait-object-safety.rs
+++ b/src/test/compile-fail/trait-object-safety.rs
@@ -22,5 +22,4 @@ fn foo() {}
 
 fn main() {
     let _: &Tr = &St; //~ ERROR cannot convert to a trait object because trait `Tr` is not
-    //~^ NOTE cannot call a static method (`foo`) through a trait object
 }

diff --git a/src/test/run-pass/issue-12684.rs b/src/test/run-pass/issue-12684.rs
index e24cf5a0f26707d30cd760de1c8a0f793583af3b..856fbbd00b20b2ef6112a7bf30f0c9fd8fd2337d 100644 (file)
--- a/src/test/run-pass/issue-12684.rs
+++ b/src/test/run-pass/issue-12684.rs
@@ -9,9 +9,10 @@
 // except according to those terms.
 
 use std::time::Duration;
+use std::thread::Thread;
 
 fn main() {
-    std::task::spawn(move|| customtask());
+    Thread::spawn(move|| customtask()).join().ok().unwrap();
 }
 
 fn customtask() {