diff --git a/src/libsync/arc.rs b/src/libsync/arc.rs index 431d87323cd..ae76357a2be 100644 --- a/src/libsync/arc.rs +++ b/src/libsync/arc.rs @@ -46,7 +46,7 @@ use std::sync::atomics; /// ``` #[unsafe_no_drop_flag] pub struct Arc { - priv x: *mut ArcInner, + x: *mut ArcInner, } /// A weak pointer to an `Arc`. @@ -55,7 +55,7 @@ pub struct Arc { /// used to break cycles between `Arc` pointers. #[unsafe_no_drop_flag] pub struct Weak { - priv x: *mut ArcInner, + x: *mut ArcInner, } struct ArcInner { diff --git a/src/libsync/comm.rs b/src/libsync/comm.rs index 6413dccd96c..9e01b16ee9b 100644 --- a/src/libsync/comm.rs +++ b/src/libsync/comm.rs @@ -20,8 +20,8 @@ use std::comm; /// An extension of `pipes::stream` that allows both sending and receiving. pub struct DuplexStream { - priv tx: Sender, - priv rx: Receiver, + tx: Sender, + rx: Receiver, } /// Creates a bidirectional stream. diff --git a/src/libsync/future.rs b/src/libsync/future.rs index 94e78729aee..cfe942afc12 100644 --- a/src/libsync/future.rs +++ b/src/libsync/future.rs @@ -30,7 +30,7 @@ use std::mem::replace; /// A type encapsulating the result of a computation which may not be complete pub struct Future { - priv state: FutureState, + state: FutureState, } enum FutureState { diff --git a/src/libsync/lib.rs b/src/libsync/lib.rs index fa219009d41..4ecf8d32470 100644 --- a/src/libsync/lib.rs +++ b/src/libsync/lib.rs @@ -20,7 +20,11 @@ html_favicon_url = "http://www.rust-lang.org/favicon.ico", html_root_url = "http://static.rust-lang.org/doc/master")] #![feature(phase)] -#![deny(missing_doc, deprecated_owned_vector)] +#![deny(deprecated_owned_vector)] + +// #![deny(missing_doc)] // NOTE: uncomment after a stage0 snap +#![allow(missing_doc)] // NOTE: remove after a stage0 snap +#![allow(visible_private_types)] // NOTE: remove after a stage0 snap #[cfg(test)] #[phase(syntax, link)] extern crate log; diff --git a/src/libsync/lock.rs b/src/libsync/lock.rs index 6ddd0d400f2..67b725f040b 100644 --- a/src/libsync/lock.rs +++ b/src/libsync/lock.rs @@ -79,12 +79,12 @@ impl<'b> Inner<'b> { /// A condition variable, a mechanism for unlock-and-descheduling and /// signaling, for use with the lock types. pub struct Condvar<'a> { - priv name: &'static str, + name: &'static str, // n.b. Inner must be after PoisonOnFail because we must set the poison flag // *inside* the mutex, and struct fields are destroyed top-to-bottom // (destroy the lock guard last). - priv poison: PoisonOnFail<'a>, - priv inner: Inner<'a>, + poison: PoisonOnFail<'a>, + inner: Inner<'a>, } impl<'a> Condvar<'a> { @@ -166,18 +166,18 @@ impl<'a> Condvar<'a> { /// } /// ``` pub struct Mutex { - priv lock: raw::Mutex, - priv failed: Unsafe, - priv data: Unsafe, + lock: raw::Mutex, + failed: Unsafe, + data: Unsafe, } /// An guard which is created by locking a mutex. Through this guard the /// underlying data can be accessed. pub struct MutexGuard<'a, T> { - priv data: &'a mut T, + data: &'a mut T, /// Inner condition variable connected to the locked mutex that this guard /// was created from. This can be used for atomic-unlock-and-deschedule. - cond: Condvar<'a>, + pub cond: Condvar<'a>, } impl Mutex { @@ -265,25 +265,25 @@ impl<'a, T> DerefMut for MutexGuard<'a, T> { /// println!("{}", *val); /// ``` pub struct RWLock { - priv lock: raw::RWLock, - priv failed: Unsafe, - priv data: Unsafe, + lock: raw::RWLock, + failed: Unsafe, + data: Unsafe, } /// A guard which is created by locking an rwlock in write mode. Through this /// guard the underlying data can be accessed. pub struct RWLockWriteGuard<'a, T> { - priv data: &'a mut T, + data: &'a mut T, /// Inner condition variable that can be used to sleep on the write mode of /// this rwlock. - cond: Condvar<'a>, + pub cond: Condvar<'a>, } /// A guard which is created by locking an rwlock in read mode. Through this /// guard the underlying data can be accessed. pub struct RWLockReadGuard<'a, T> { - priv data: &'a T, - priv guard: raw::RWLockReadGuard<'a>, + data: &'a T, + guard: raw::RWLockReadGuard<'a>, } impl RWLock { @@ -397,8 +397,8 @@ impl<'a, T> DerefMut for RWLockWriteGuard<'a, T> { /// } /// ``` pub struct Barrier { - priv lock: Mutex, - priv num_tasks: uint, + lock: Mutex, + num_tasks: uint, } // The inner state of a double barrier diff --git a/src/libsync/mpsc_intrusive.rs b/src/libsync/mpsc_intrusive.rs index 12e8ca48ba1..14dfa8417fa 100644 --- a/src/libsync/mpsc_intrusive.rs +++ b/src/libsync/mpsc_intrusive.rs @@ -41,18 +41,18 @@ use std::ty::Unsafe; // initialization. pub struct Node { - next: atomics::AtomicUint, - data: T, + pub next: atomics::AtomicUint, + pub data: T, } pub struct DummyNode { - next: atomics::AtomicUint, + pub next: atomics::AtomicUint, } pub struct Queue { - head: atomics::AtomicUint, - tail: Unsafe<*mut Node>, - stub: DummyNode, + pub head: atomics::AtomicUint, + pub tail: Unsafe<*mut Node>, + pub stub: DummyNode, } impl Queue { diff --git a/src/libsync/mutex.rs b/src/libsync/mutex.rs index b01c82eb7ac..e41484c46bd 100644 --- a/src/libsync/mutex.rs +++ b/src/libsync/mutex.rs @@ -94,7 +94,7 @@ pub static NATIVE_BLOCKED: uint = 1 << 2; /// drop(guard); // unlock the lock /// ``` pub struct Mutex { - priv lock: StaticMutex, + lock: StaticMutex, } #[deriving(Eq, Show)] @@ -128,28 +128,28 @@ enum Flavor { /// ``` pub struct StaticMutex { /// Current set of flags on this mutex - priv state: atomics::AtomicUint, + state: atomics::AtomicUint, /// an OS mutex used by native threads - priv lock: mutex::StaticNativeMutex, + lock: mutex::StaticNativeMutex, /// Type of locking operation currently on this mutex - priv flavor: Unsafe, + flavor: Unsafe, /// uint-cast of the green thread waiting for this mutex - priv green_blocker: Unsafe, + green_blocker: Unsafe, /// uint-cast of the native thread waiting for this mutex - priv native_blocker: Unsafe, + native_blocker: Unsafe, /// A concurrent mpsc queue used by green threads, along with a count used /// to figure out when to dequeue and enqueue. - priv q: q::Queue, - priv green_cnt: atomics::AtomicUint, + q: q::Queue, + green_cnt: atomics::AtomicUint, } /// An RAII implementation of a "scoped lock" of a mutex. When this structure is /// dropped (falls out of scope), the lock will be unlocked. #[must_use] pub struct Guard<'a> { - priv lock: &'a StaticMutex, + lock: &'a StaticMutex, } /// Static initialization of a mutex. This constant can be used to initialize diff --git a/src/libsync/one.rs b/src/libsync/one.rs index 161f759ca2d..7da6f39b840 100644 --- a/src/libsync/one.rs +++ b/src/libsync/one.rs @@ -41,9 +41,9 @@ use mutex::{StaticMutex, MUTEX_INIT}; /// } /// ``` pub struct Once { - priv mutex: StaticMutex, - priv cnt: atomics::AtomicInt, - priv lock_cnt: atomics::AtomicInt, + mutex: StaticMutex, + cnt: atomics::AtomicInt, + lock_cnt: atomics::AtomicInt, } /// Initialization value for static `Once` values. diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs index ba53b3b2e95..9bb7a81a2ff 100644 --- a/src/libsync/raw.rs +++ b/src/libsync/raw.rs @@ -209,16 +209,16 @@ enum ReacquireOrderLock<'a> { pub struct Condvar<'a> { // The 'Sem' object associated with this condvar. This is the one that's // atomically-unlocked-and-descheduled upon and reacquired during wakeup. - priv sem: &'a Sem >, + sem: &'a Sem >, // This is (can be) an extra semaphore which is held around the reacquire // operation on the first one. This is only used in cvars associated with // rwlocks, and is needed to ensure that, when a downgrader is trying to // hand off the access lock (which would be the first field, here), a 2nd // writer waking up from a cvar wait can't race with a reader to steal it, // See the comment in write_cond for more detail. - priv order: ReacquireOrderLock<'a>, + order: ReacquireOrderLock<'a>, // Make sure condvars are non-copyable. - priv nocopy: marker::NoCopy, + nocopy: marker::NoCopy, } impl<'a> Condvar<'a> { @@ -362,14 +362,14 @@ struct SemCondGuard<'a> { /// A counting, blocking, bounded-waiting semaphore. pub struct Semaphore { - priv sem: Sem<()>, + sem: Sem<()>, } /// An RAII guard used to represent an acquired resource to a semaphore. When /// dropped, this value will release the resource back to the semaphore. #[must_use] pub struct SemaphoreGuard<'a> { - priv guard: SemGuard<'a, ()>, + guard: SemGuard<'a, ()>, } impl Semaphore { @@ -404,7 +404,7 @@ impl Semaphore { /// A task which fails while holding a mutex will unlock the mutex as it /// unwinds. pub struct Mutex { - priv sem: Sem>, + sem: Sem>, } /// An RAII structure which is used to gain access to a mutex's condition @@ -412,10 +412,10 @@ pub struct Mutex { /// corresponding mutex is also unlocked. #[must_use] pub struct MutexGuard<'a> { - priv guard: SemGuard<'a, Vec>, + guard: SemGuard<'a, Vec>, /// Inner condition variable which is connected to the outer mutex, and can /// be used for atomic-unlock-and-deschedule. - cond: Condvar<'a>, + pub cond: Condvar<'a>, } impl Mutex { @@ -452,8 +452,8 @@ impl Mutex { /// A task which fails while holding an rwlock will unlock the rwlock as it /// unwinds. pub struct RWLock { - priv order_lock: Semaphore, - priv access_lock: Sem>, + order_lock: Semaphore, + access_lock: Sem>, // The only way the count flag is ever accessed is with xadd. Since it is // a read-modify-write operation, multiple xadds on different cores will @@ -462,14 +462,14 @@ pub struct RWLock { // // FIXME(#6598): The atomics module has no relaxed ordering flag, so I use // acquire/release orderings superfluously. Change these someday. - priv read_count: atomics::AtomicUint, + read_count: atomics::AtomicUint, } /// An RAII helper which is created by acquiring a read lock on an RWLock. When /// dropped, this will unlock the RWLock. #[must_use] pub struct RWLockReadGuard<'a> { - priv lock: &'a RWLock, + lock: &'a RWLock, } /// An RAII helper which is created by acquiring a write lock on an RWLock. When @@ -478,10 +478,10 @@ pub struct RWLockReadGuard<'a> { /// A value of this type can also be consumed to downgrade to a read-only lock. #[must_use] pub struct RWLockWriteGuard<'a> { - priv lock: &'a RWLock, + lock: &'a RWLock, /// Inner condition variable that is connected to the write-mode of the /// outer rwlock. - cond: Condvar<'a>, + pub cond: Condvar<'a>, } impl RWLock { diff --git a/src/libsync/task_pool.rs b/src/libsync/task_pool.rs index d29e857cca6..fc249996882 100644 --- a/src/libsync/task_pool.rs +++ b/src/libsync/task_pool.rs @@ -21,8 +21,8 @@ enum Msg { } pub struct TaskPool { - priv channels: Vec>>, - priv next_index: uint, + channels: Vec>>, + next_index: uint, } #[unsafe_destructor]