auto merge of #19255 : aturon/rust/merge-sync, r=alexcrichton,alexcrichton

bors · bors · commit a0846893d4ff · 2014-11-25T18:13:23.000Z
This patch merges the `libsync` crate into `libstd`, undoing part of the facade. This is in preparation for ultimately merging `librustrt`, as well as the upcoming rewrite of `sync`. Because this removes the `libsync` crate, it is a: [breaking-change] However, all uses of `libsync` should be able to reroute through `std::sync` and `std::comm` instead. r? @alexcrichton
diff --git a/mk/crates.mk b/mk/crates.mk
@@ -50,7 +50,7 @@
 ################################################################################
 
 TARGET_CRATES := libc std flate arena term \
-                 serialize sync getopts collections test time rand \
+                 serialize getopts collections test time rand \
                  log regex graphviz core rbml alloc rustrt \
                  unicode
 HOST_CRATES := syntax rustc rustc_trans rustdoc regex_macros fmt_macros \
@@ -63,7 +63,7 @@ DEPS_libc := core
 DEPS_unicode := core
 DEPS_alloc := core libc native:jemalloc
 DEPS_rustrt := alloc core libc collections native:rustrt_native
-DEPS_std := core libc rand alloc collections rustrt sync unicode \
+DEPS_std := core libc rand alloc collections rustrt unicode \
 	native:rust_builtin native:backtrace
 DEPS_graphviz := std
 DEPS_syntax := std term serialize log fmt_macros arena libc
@@ -81,7 +81,6 @@ DEPS_glob := std
 DEPS_serialize := std log
 DEPS_rbml := std log serialize
 DEPS_term := std log
-DEPS_sync := core alloc rustrt collections
 DEPS_getopts := std
 DEPS_collections := core alloc unicode
 DEPS_num := std
diff --git a/src/etc/licenseck.py b/src/etc/licenseck.py
@@ -38,10 +38,9 @@
     "rt/isaac/randport.cpp", # public domain
     "rt/isaac/rand.h", # public domain
     "rt/isaac/standard.h", # public domain
-    "libsync/mpsc_queue.rs", # BSD
-    "libsync/spsc_queue.rs", # BSD
-    "libsync/mpmc_bounded_queue.rs", # BSD
-    "libsync/mpsc_intrusive.rs", # BSD
+    "libstd/sync/mpsc_queue.rs", # BSD
+    "libstd/sync/spsc_queue.rs", # BSD
+    "libstd/sync/mpmc_bounded_queue.rs", # BSD
     "test/bench/shootout-binarytrees.rs", # BSD
     "test/bench/shootout-chameneos-redux.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD
diff --git a/src/libstd/comm/mod.rs b/src/libstd/comm/mod.rs
@@ -338,12 +338,11 @@ macro_rules! test (
 
             extern crate rustrt;
 
-            use std::prelude::*;
+            use prelude::*;
 
             use comm::*;
             use super::*;
-            use super::super::*;
-            use std::task;
+            use task;
 
             $(#[$a])* #[test] fn f() { $b }
         }
@@ -1019,9 +1018,9 @@ impl<T: Send> Drop for Receiver<T> {
 
 #[cfg(test)]
 mod test {
-    use std::prelude::*;
+    use prelude::*;
 
-    use std::os;
+    use os;
     use super::*;
 
     pub fn stress_factor() -> uint {
@@ -1554,8 +1553,8 @@ mod test {
 
 #[cfg(test)]
 mod sync_tests {
-    use std::prelude::*;
-    use std::os;
+    use prelude::*;
+    use os;
 
     pub fn stress_factor() -> uint {
         match os::getenv("RUST_TEST_STRESS") {
diff --git a/src/libstd/comm/oneshot.rs b/src/libstd/comm/oneshot.rs
@@ -44,7 +44,7 @@ use core::mem;
 use rustrt::local::Local;
 use rustrt::task::{Task, BlockedTask};
 
-use atomic;
+use sync::atomic;
 use comm::Receiver;
 
 // Various states you can find a port in.
diff --git a/src/libstd/comm/select.rs b/src/libstd/comm/select.rs
@@ -325,9 +325,9 @@ impl Iterator<*mut Handle<'static, ()>> for Packets {
 #[cfg(test)]
 #[allow(unused_imports)]
 mod test {
-    use std::prelude::*;
+    use prelude::*;
 
-    use super::super::*;
+    use super::*;
 
     // Don't use the libstd version so we can pull in the right Select structure
     // (std::comm points at the wrong one)
diff --git a/src/libstd/comm/shared.rs b/src/libstd/comm/shared.rs
@@ -30,8 +30,8 @@ use rustrt::mutex::NativeMutex;
 use rustrt::task::{Task, BlockedTask};
 use rustrt::thread::Thread;
 
-use atomic;
-use mpsc_queue as mpsc;
+use sync::atomic;
+use sync::mpsc_queue as mpsc;
 
 const DISCONNECTED: int = int::MIN;
 const FUDGE: int = 1024;
diff --git a/src/libstd/comm/stream.rs b/src/libstd/comm/stream.rs
@@ -31,9 +31,9 @@ use rustrt::local::Local;
 use rustrt::task::{Task, BlockedTask};
 use rustrt::thread::Thread;
 
-use atomic;
+use sync::atomic;
+use sync::spsc_queue as spsc;
 use comm::Receiver;
-use spsc_queue as spsc;
 
 const DISCONNECTED: int = int::MIN;
 #[cfg(test)]
diff --git a/src/libstd/comm/sync.rs b/src/libstd/comm/sync.rs
@@ -39,14 +39,14 @@ pub use self::Failure::*;
 use self::Blocker::*;
 
 use alloc::boxed::Box;
-use collections::Vec;
+use vec::Vec;
 use core::mem;
 use core::cell::UnsafeCell;
 use rustrt::local::Local;
 use rustrt::mutex::{NativeMutex, LockGuard};
 use rustrt::task::{Task, BlockedTask};
 
-use atomic;
+use sync::atomic;
 
 pub struct Packet<T> {
     /// Only field outside of the mutex. Just done for kicks, but mainly because
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
@@ -124,7 +124,6 @@ extern crate unicode;
 extern crate core;
 extern crate "collections" as core_collections;
 extern crate "rand" as core_rand;
-extern crate "sync" as core_sync;
 extern crate libc;
 extern crate rustrt;
 
@@ -173,8 +172,6 @@ pub use rustrt::c_str;
 
 pub use unicode::char;
 
-pub use core_sync::comm;
-
 /* Exported macros */
 
 pub mod macros;
@@ -236,6 +233,7 @@ pub mod hash;
 
 pub mod task;
 pub mod sync;
+pub mod comm;
 
 #[cfg(unix)]
 #[path = "sys/unix/mod.rs"] mod sys;
diff --git a/src/libstd/sync/atomic.rs b/src/libstd/sync/atomic.rs
@@ -178,7 +178,7 @@ impl<T: Send> Drop for AtomicOption<T> {
 
 #[cfg(test)]
 mod test {
-    use std::prelude::*;
+    use prelude::*;
     use super::*;
 
     #[test]
diff --git a/src/libstd/sync/deque.rs b/src/libstd/sync/deque.rs
@@ -57,13 +57,13 @@ use core::prelude::*;
 use alloc::arc::Arc;
 use alloc::heap::{allocate, deallocate};
 use alloc::boxed::Box;
-use collections::Vec;
+use vec::Vec;
 use core::kinds::marker;
 use core::mem::{forget, min_align_of, size_of, transmute};
 use core::ptr;
 use rustrt::exclusive::Exclusive;
 
-use atomic::{AtomicInt, AtomicPtr, SeqCst};
+use sync::atomic::{AtomicInt, AtomicPtr, SeqCst};
 
 // Once the queue is less than 1/K full, then it will be downsized. Note that
 // the deque requires that this number be less than 2.
@@ -410,16 +410,16 @@ impl<T: Send> Drop for Buffer<T> {
 
 #[cfg(test)]
 mod tests {
-    use std::prelude::*;
+    use prelude::*;
     use super::{Data, BufferPool, Abort, Empty, Worker, Stealer};
 
-    use std::mem;
+    use mem;
     use rustrt::thread::Thread;
-    use std::rand;
-    use std::rand::Rng;
-    use atomic::{AtomicBool, INIT_ATOMIC_BOOL, SeqCst,
-                  AtomicUint, INIT_ATOMIC_UINT};
-    use std::vec;
+    use rand;
+    use rand::Rng;
+    use sync::atomic::{AtomicBool, INIT_ATOMIC_BOOL, SeqCst,
+                       AtomicUint, INIT_ATOMIC_UINT};
+    use vec;
 
     #[test]
     fn smoke() {
diff --git a/src/libstd/sync/lock.rs b/src/libstd/sync/lock.rs
@@ -27,7 +27,7 @@ use core::cell::UnsafeCell;
 use rustrt::local::Local;
 use rustrt::task::Task;
 
-use raw;
+use super::raw;
 
 /****************************************************************************
  * Poisoning helpers
@@ -158,7 +158,7 @@ impl<'a> Condvar<'a> {
 /// # Example
 ///
 /// ```
-/// use sync::{Mutex, Arc};
+/// use std::sync::{Mutex, Arc};
 ///
 /// let mutex = Arc::new(Mutex::new(1i));
 /// let mutex2 = mutex.clone();
@@ -259,7 +259,7 @@ impl<'a, T: Send> DerefMut<T> for MutexGuard<'a, T> {
 /// # Example
 ///
 /// ```
-/// use sync::{RWLock, Arc};
+/// use std::sync::{RWLock, Arc};
 ///
 /// let lock1 = Arc::new(RWLock::new(1i));
 /// let lock2 = lock1.clone();
@@ -395,7 +395,7 @@ impl<'a, T: Send + Sync> DerefMut<T> for RWLockWriteGuard<'a, T> {
 /// of some computation.
 ///
 /// ```rust
-/// use sync::{Arc, Barrier};
+/// use std::sync::{Arc, Barrier};
 ///
 /// let barrier = Arc::new(Barrier::new(10));
 /// for _ in range(0u, 10) {
@@ -458,12 +458,12 @@ impl Barrier {
 
 #[cfg(test)]
 mod tests {
-    use std::prelude::*;
-    use std::comm::Empty;
-    use std::task;
-    use std::task::try_future;
+    use prelude::*;
+    use comm::Empty;
+    use task;
+    use task::try_future;
+    use sync::Arc;
 
-    use Arc;
     use super::{Mutex, Barrier, RWLock};
 
     #[test]
diff --git a/src/libstd/sync/mod.rs b/src/libstd/sync/mod.rs
@@ -17,17 +17,41 @@
 
 #![experimental]
 
-#[stable]
-pub use core_sync::atomic;
+pub use self::one::{Once, ONCE_INIT};
+
+pub use alloc::arc::{Arc, Weak};
+pub use self::lock::{Mutex, MutexGuard, Condvar, Barrier,
+                     RWLock, RWLockReadGuard, RWLockWriteGuard};
 
-pub use core_sync::{deque, mpmc_bounded_queue, mpsc_queue, spsc_queue};
-pub use core_sync::{Arc, Weak, Mutex, MutexGuard, Condvar, Barrier};
-pub use core_sync::{RWLock, RWLockReadGuard, RWLockWriteGuard};
-pub use core_sync::{Semaphore, SemaphoreGuard};
-pub use core_sync::one::{Once, ONCE_INIT};
+// The mutex/rwlock in this module are not meant for reexport
+pub use self::raw::{Semaphore, SemaphoreGuard};
 
 pub use self::future::Future;
 pub use self::task_pool::TaskPool;
 
+// Core building blocks for all primitives in this crate
+
+#[stable]
+pub mod atomic;
+
+// Concurrent data structures
+
+pub mod spsc_queue;
+pub mod mpsc_queue;
+pub mod mpmc_bounded_queue;
+pub mod deque;
+
+// Low-level concurrency primitives
+
+mod raw;
+mod mutex;
+mod one;
+
+// Higher level primitives based on those above
+
+mod lock;
+
+// Task management
+
 mod future;
 mod task_pool;
diff --git a/src/libstd/sync/mpmc_bounded_queue.rs b/src/libstd/sync/mpmc_bounded_queue.rs
@@ -33,11 +33,11 @@
 use core::prelude::*;
 
 use alloc::arc::Arc;
-use collections::Vec;
+use vec::Vec;
 use core::num::UnsignedInt;
 use core::cell::UnsafeCell;
 
-use atomic::{AtomicUint,Relaxed,Release,Acquire};
+use sync::atomic::{AtomicUint,Relaxed,Release,Acquire};
 
 struct Node<T> {
     sequence: AtomicUint,
@@ -165,7 +165,7 @@ impl<T: Send> Clone for Queue<T> {
 
 #[cfg(test)]
 mod tests {
-    use std::prelude::*;
+    use prelude::*;
     use super::Queue;
 
     #[test]
diff --git a/src/libstd/sync/mpsc_queue.rs b/src/libstd/sync/mpsc_queue.rs
@@ -48,7 +48,7 @@ use alloc::boxed::Box;
 use core::mem;
 use core::cell::UnsafeCell;
 
-use atomic::{AtomicPtr, Release, Acquire, AcqRel, Relaxed};
+use sync::atomic::{AtomicPtr, Release, Acquire, AcqRel, Relaxed};
 
 /// A result of the `pop` function.
 pub enum PopResult<T> {
@@ -159,7 +159,7 @@ impl<T: Send> Drop for Queue<T> {
 
 #[cfg(test)]
 mod tests {
-    use std::prelude::*;
+    use prelude::*;
 
     use alloc::arc::Arc;
 
diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
@@ -28,8 +28,8 @@ pub const BLOCKED: uint = 1 << 1;
 ///
 /// # Example
 ///
-/// ```rust
-/// use sync::mutex::Mutex;
+/// ```rust,ignore
+/// use std::sync::mutex::Mutex;
 ///
 /// let m = Mutex::new();
 /// let guard = m.lock();
@@ -57,8 +57,8 @@ pub struct Mutex {
 ///
 /// # Example
 ///
-/// ```rust
-/// use sync::mutex::{StaticMutex, MUTEX_INIT};
+/// ```rust,ignore
+/// use std::sync::mutex::{StaticMutex, MUTEX_INIT};
 ///
 /// static LOCK: StaticMutex = MUTEX_INIT;
 ///
@@ -156,7 +156,7 @@ impl Drop for Mutex {
 
 #[cfg(test)]
 mod test {
-    use std::prelude::*;
+    use prelude::*;
     use super::{Mutex, StaticMutex, MUTEX_INIT};
 
     #[test]
diff --git a/src/libstd/sync/one.rs b/src/libstd/sync/one.rs
diff --git a/src/libstd/sync/raw.rs b/src/libstd/sync/raw.rs
diff --git a/src/libstd/sync/spsc_queue.rs b/src/libstd/sync/spsc_queue.rs
diff --git a/src/libsync/lib.rs b/src/libsync/lib.rs
