librustc: Change "Owned" to "Send" everywhere

src/libextra/arc.rs

@@ -112,15 +112,15 @@ impl<'self> Condvar<'self> {
 pub struct ARC<T> { x: UnsafeAtomicRcBox<T> }
 
 /// Create an atomically reference counted wrapper.
-pub fn ARC<T:Freeze + Owned>(data: T) -> ARC<T> {
+pub fn ARC<T:Freeze + Send>(data: T) -> ARC<T> {
     ARC { x: UnsafeAtomicRcBox::new(data) }
 }
 
 /**
  * Access the underlying data in an atomically reference counted
  * wrapper.
  */
-impl<T:Freeze+Owned> ARC<T> {
+impl<T:Freeze+Send> ARC<T> {
     pub fn get<'a>(&'a self) -> &'a T {
         unsafe { &*self.x.get_immut() }
     }
@@ -133,7 +133,7 @@ impl<T:Freeze+Owned> ARC<T> {
  * object. However, one of the `arc` objects can be sent to another task,
  * allowing them to share the underlying data.
  */
-impl<T:Freeze + Owned> Clone for ARC<T> {
+impl<T:Freeze + Send> Clone for ARC<T> {
     fn clone(&self) -> ARC<T> {
         ARC { x: self.x.clone() }
     }
@@ -149,22 +149,22 @@ struct MutexARCInner<T> { lock: Mutex, failed: bool, data: T }
 struct MutexARC<T> { x: UnsafeAtomicRcBox<MutexARCInner<T>> }
 
 /// Create a mutex-protected ARC with the supplied data.
-pub fn MutexARC<T:Owned>(user_data: T) -> MutexARC<T> {
+pub fn MutexARC<T:Send>(user_data: T) -> MutexARC<T> {
     mutex_arc_with_condvars(user_data, 1)
 }
 /**
  * Create a mutex-protected ARC with the supplied data and a specified number
  * of condvars (as sync::mutex_with_condvars).
  */
-pub fn mutex_arc_with_condvars<T:Owned>(user_data: T,
+pub fn mutex_arc_with_condvars<T:Send>(user_data: T,
                                     num_condvars: uint) -> MutexARC<T> {
     let data =
         MutexARCInner { lock: mutex_with_condvars(num_condvars),
                           failed: false, data: user_data };
     MutexARC { x: UnsafeAtomicRcBox::new(data) }
 }
 
-impl<T:Owned> Clone for MutexARC<T> {
+impl<T:Send> Clone for MutexARC<T> {
     /// Duplicate a mutex-protected ARC, as arc::clone.
     fn clone(&self) -> MutexARC<T> {
         // NB: Cloning the underlying mutex is not necessary. Its reference
@@ -173,7 +173,7 @@ impl<T:Owned> Clone for MutexARC<T> {
     }
 }
 
-impl<T:Owned> MutexARC<T> {
+impl<T:Send> MutexARC<T> {
 
     /**
      * Access the underlying mutable data with mutual exclusion from other
@@ -282,14 +282,14 @@ struct RWARC<T> {
 }
 
 /// Create a reader/writer ARC with the supplied data.
-pub fn RWARC<T:Freeze + Owned>(user_data: T) -> RWARC<T> {
+pub fn RWARC<T:Freeze + Send>(user_data: T) -> RWARC<T> {
     rw_arc_with_condvars(user_data, 1)
 }
 /**
  * Create a reader/writer ARC with the supplied data and a specified number
  * of condvars (as sync::rwlock_with_condvars).
  */
-pub fn rw_arc_with_condvars<T:Freeze + Owned>(
+pub fn rw_arc_with_condvars<T:Freeze + Send>(
     user_data: T,
     num_condvars: uint) -> RWARC<T>
 {
@@ -299,7 +299,7 @@ pub fn rw_arc_with_condvars<T:Freeze + Owned>(
     RWARC { x: UnsafeAtomicRcBox::new(data), }
 }
 
-impl<T:Freeze + Owned> RWARC<T> {
+impl<T:Freeze + Send> RWARC<T> {
     /// Duplicate a rwlock-protected ARC, as arc::clone.
     pub fn clone(&self) -> RWARC<T> {
         RWARC {
@@ -309,7 +309,7 @@ impl<T:Freeze + Owned> RWARC<T> {
 
 }
 
-impl<T:Freeze + Owned> RWARC<T> {
+impl<T:Freeze + Send> RWARC<T> {
     /**
      * Access the underlying data mutably. Locks the rwlock in write mode;
      * other readers and writers will block.
@@ -435,7 +435,7 @@ impl<T:Freeze + Owned> RWARC<T> {
 // lock it. This wraps the unsafety, with the justification that the 'lock'
 // field is never overwritten; only 'failed' and 'data'.
 #[doc(hidden)]
-fn borrow_rwlock<T:Freeze + Owned>(state: *const RWARCInner<T>) -> *RWlock {
+fn borrow_rwlock<T:Freeze + Send>(state: *const RWARCInner<T>) -> *RWlock {
     unsafe { cast::transmute(&const (*state).lock) }
 }
 
@@ -452,7 +452,7 @@ pub struct RWReadMode<'self, T> {
     token: sync::RWlockReadMode<'self>,
 }
 
-impl<'self, T:Freeze + Owned> RWWriteMode<'self, T> {
+impl<'self, T:Freeze + Send> RWWriteMode<'self, T> {
     /// Access the pre-downgrade RWARC in write mode.
     pub fn write<U>(&mut self, blk: &fn(x: &mut T) -> U) -> U {
         match *self {
@@ -493,7 +493,7 @@ impl<'self, T:Freeze + Owned> RWWriteMode<'self, T> {
     }
 }
 
-impl<'self, T:Freeze + Owned> RWReadMode<'self, T> {
+impl<'self, T:Freeze + Send> RWReadMode<'self, T> {
     /// Access the post-downgrade rwlock in read mode.
     pub fn read<U>(&self, blk: &fn(x: &T) -> U) -> U {
         match *self {

src/libextra/comm.rs

@@ -30,7 +30,7 @@ pub struct DuplexStream<T, U> {
 }
 
 // Allow these methods to be used without import:
-impl<T:Owned,U:Owned> DuplexStream<T, U> {
+impl<T:Send,U:Send> DuplexStream<T, U> {
     pub fn send(&self, x: T) {
         self.chan.send(x)
     }
@@ -48,19 +48,19 @@ impl<T:Owned,U:Owned> DuplexStream<T, U> {
     }
 }
 
-impl<T:Owned,U:Owned> GenericChan<T> for DuplexStream<T, U> {
+impl<T:Send,U:Send> GenericChan<T> for DuplexStream<T, U> {
     fn send(&self, x: T) {
         self.chan.send(x)
     }
 }
 
-impl<T:Owned,U:Owned> GenericSmartChan<T> for DuplexStream<T, U> {
+impl<T:Send,U:Send> GenericSmartChan<T> for DuplexStream<T, U> {
     fn try_send(&self, x: T) -> bool {
         self.chan.try_send(x)
     }
 }
 
-impl<T:Owned,U:Owned> GenericPort<U> for DuplexStream<T, U> {
+impl<T:Send,U:Send> GenericPort<U> for DuplexStream<T, U> {
     fn recv(&self) -> U {
         self.port.recv()
     }
@@ -70,20 +70,20 @@ impl<T:Owned,U:Owned> GenericPort<U> for DuplexStream<T, U> {
     }
 }
 
-impl<T:Owned,U:Owned> Peekable<U> for DuplexStream<T, U> {
+impl<T:Send,U:Send> Peekable<U> for DuplexStream<T, U> {
     fn peek(&self) -> bool {
         self.port.peek()
     }
 }
 
-impl<T:Owned,U:Owned> Selectable for DuplexStream<T, U> {
+impl<T:Send,U:Send> Selectable for DuplexStream<T, U> {
     fn header(&mut self) -> *mut pipes::PacketHeader {
         self.port.header()
     }
 }
 
 /// Creates a bidirectional stream.
-pub fn DuplexStream<T:Owned,U:Owned>()
+pub fn DuplexStream<T:Send,U:Send>()
     -> (DuplexStream<T, U>, DuplexStream<U, T>)
 {
     let (p1, c2) = comm::stream();

src/libextra/flatpipes.rs

@@ -166,8 +166,8 @@ Constructors for flat pipes that send POD types using memcpy.
 
 # Safety Note
 
-This module is currently unsafe because it uses `Copy Owned` as a type
-parameter bounds meaning POD (plain old data), but `Copy Owned` and
+This module is currently unsafe because it uses `Copy Send` as a type
+parameter bounds meaning POD (plain old data), but `Copy Send` and
 POD are not equivelant.
 
 */
@@ -191,7 +191,7 @@ pub mod pod {
     pub type PipeChan<T> = FlatChan<T, PodFlattener<T>, PipeByteChan>;
 
     /// Create a `FlatPort` from a `Reader`
-    pub fn reader_port<T:Copy + Owned,R:Reader>(
+    pub fn reader_port<T:Copy + Send,R:Reader>(
         reader: R
     ) -> ReaderPort<T, R> {
         let unflat: PodUnflattener<T> = PodUnflattener::new();
@@ -200,7 +200,7 @@ pub mod pod {
     }
 
     /// Create a `FlatChan` from a `Writer`
-    pub fn writer_chan<T:Copy + Owned,W:Writer>(
+    pub fn writer_chan<T:Copy + Send,W:Writer>(
         writer: W
     ) -> WriterChan<T, W> {
         let flat: PodFlattener<T> = PodFlattener::new();
@@ -209,21 +209,21 @@ pub mod pod {
     }
 
     /// Create a `FlatPort` from a `Port<~[u8]>`
-    pub fn pipe_port<T:Copy + Owned>(port: Port<~[u8]>) -> PipePort<T> {
+    pub fn pipe_port<T:Copy + Send>(port: Port<~[u8]>) -> PipePort<T> {
         let unflat: PodUnflattener<T> = PodUnflattener::new();
         let byte_port = PipeBytePort::new(port);
         FlatPort::new(unflat, byte_port)
     }
 
     /// Create a `FlatChan` from a `Chan<~[u8]>`
-    pub fn pipe_chan<T:Copy + Owned>(chan: Chan<~[u8]>) -> PipeChan<T> {
+    pub fn pipe_chan<T:Copy + Send>(chan: Chan<~[u8]>) -> PipeChan<T> {
         let flat: PodFlattener<T> = PodFlattener::new();
         let byte_chan = PipeByteChan::new(chan);
         FlatChan::new(flat, byte_chan)
     }
 
     /// Create a pair of `FlatChan` and `FlatPort`, backed by pipes
-    pub fn pipe_stream<T:Copy + Owned>() -> (PipePort<T>, PipeChan<T>) {
+    pub fn pipe_stream<T:Copy + Send>() -> (PipePort<T>, PipeChan<T>) {
         let (port, chan) = comm::stream();
         return (pipe_port(port), pipe_chan(chan));
     }
@@ -352,7 +352,7 @@ pub mod flatteners {
     use core::sys::size_of;
     use core::vec;
 
-    // FIXME #4074: Copy + Owned != POD
+    // FIXME #4074: Copy + Send != POD
     pub struct PodUnflattener<T> {
         bogus: ()
     }
@@ -361,7 +361,7 @@ pub mod flatteners {
         bogus: ()
     }
 
-    impl<T:Copy + Owned> Unflattener<T> for PodUnflattener<T> {
+    impl<T:Copy + Send> Unflattener<T> for PodUnflattener<T> {
         fn unflatten(&self, buf: ~[u8]) -> T {
             assert!(size_of::<T>() != 0);
             assert_eq!(size_of::<T>(), buf.len());
@@ -371,7 +371,7 @@ pub mod flatteners {
         }
     }
 
-    impl<T:Copy + Owned> Flattener<T> for PodFlattener<T> {
+    impl<T:Copy + Send> Flattener<T> for PodFlattener<T> {
         fn flatten(&self, val: T) -> ~[u8] {
             assert!(size_of::<T>() != 0);
             let val: *T = ptr::to_unsafe_ptr(&val);
@@ -380,15 +380,15 @@ pub mod flatteners {
         }
     }
 
-    impl<T:Copy + Owned> PodUnflattener<T> {
+    impl<T:Copy + Send> PodUnflattener<T> {
         pub fn new() -> PodUnflattener<T> {
             PodUnflattener {
                 bogus: ()
             }
         }
     }
 
-    impl<T:Copy + Owned> PodFlattener<T> {
+    impl<T:Copy + Send> PodFlattener<T> {
         pub fn new() -> PodFlattener<T> {
             PodFlattener {
                 bogus: ()

src/libextra/future.rs

@@ -101,7 +101,7 @@ pub fn from_value<A>(val: A) -> Future<A> {
     Future {state: Forced(val)}
 }
 
-pub fn from_port<A:Owned>(port: PortOne<A>) -> Future<A> {
+pub fn from_port<A:Send>(port: PortOne<A>) -> Future<A> {
     /*!
      * Create a future from a port
      *
@@ -127,7 +127,7 @@ pub fn from_fn<A>(f: ~fn() -> A) -> Future<A> {
     Future {state: Pending(f)}
 }
 
-pub fn spawn<A:Owned>(blk: ~fn() -> A) -> Future<A> {
+pub fn spawn<A:Send>(blk: ~fn() -> A) -> Future<A> {
     /*!
      * Create a future from a unique closure.
      *

src/libextra/par.rs

@@ -33,7 +33,7 @@ static min_granularity : uint = 1024u;
  * This is used to build most of the other parallel vector functions,
  * like map or alli.
  */
-fn map_slices<A:Copy + Owned,B:Copy + Owned>(
+fn map_slices<A:Copy + Send,B:Copy + Send>(
     xs: &[A],
     f: &fn() -> ~fn(uint, v: &[A]) -> B)
     -> ~[B] {
@@ -88,7 +88,7 @@ fn map_slices<A:Copy + Owned,B:Copy + Owned>(
 }
 
 /// A parallel version of map.
-pub fn map<A:Copy + Owned,B:Copy + Owned>(
+pub fn map<A:Copy + Send,B:Copy + Send>(
     xs: &[A], fn_factory: &fn() -> ~fn(&A) -> B) -> ~[B] {
     vec::concat(map_slices(xs, || {
         let f = fn_factory();
@@ -99,7 +99,7 @@ pub fn map<A:Copy + Owned,B:Copy + Owned>(
 }
 
 /// A parallel version of mapi.
-pub fn mapi<A:Copy + Owned,B:Copy + Owned>(
+pub fn mapi<A:Copy + Send,B:Copy + Send>(
         xs: &[A],
         fn_factory: &fn() -> ~fn(uint, &A) -> B) -> ~[B] {
     let slices = map_slices(xs, || {
@@ -118,7 +118,7 @@ pub fn mapi<A:Copy + Owned,B:Copy + Owned>(
 }
 
 /// Returns true if the function holds for all elements in the vector.
-pub fn alli<A:Copy + Owned>(
+pub fn alli<A:Copy + Send>(
     xs: &[A],
     fn_factory: &fn() -> ~fn(uint, &A) -> bool) -> bool
 {
@@ -133,7 +133,7 @@ pub fn alli<A:Copy + Owned>(
 }
 
 /// Returns true if the function holds for any elements in the vector.
-pub fn any<A:Copy + Owned>(
+pub fn any<A:Copy + Send>(
     xs: &[A],
     fn_factory: &fn() -> ~fn(&A) -> bool) -> bool {
     let mapped = map_slices(xs, || {

src/libextra/rc.rs

@@ -13,10 +13,10 @@
 /** Task-local reference counted smart pointers
 
 Task-local reference counted smart pointers are an alternative to managed boxes with deterministic
-destruction. They are restricted to containing types that are either `Owned` or `Freeze` (or both) to
+destruction. They are restricted to containing types that are either `Send` or `Freeze` (or both) to
 prevent cycles.
 
-Neither `Rc<T>` or `RcMut<T>` is ever `Owned` and `RcMut<T>` is never `Freeze`. If `T` is `Freeze`, a
+Neither `Rc<T>` or `RcMut<T>` is ever `Send` and `RcMut<T>` is never `Freeze`. If `T` is `Freeze`, a
 cycle cannot be created with `Rc<T>` because there is no way to modify it after creation.
 
 */
@@ -51,7 +51,7 @@ impl<T> Rc<T> {
 }
 
 // FIXME: #6516: should be a static method
-pub fn rc_from_owned<T: Owned>(value: T) -> Rc<T> {
+pub fn rc_from_owned<T: Send>(value: T) -> Rc<T> {
     unsafe { Rc::new(value) }
 }
 
@@ -185,7 +185,7 @@ impl<T> RcMut<T> {
 }
 
 // FIXME: #6516: should be a static method
-pub fn rc_mut_from_owned<T: Owned>(value: T) -> RcMut<T> {
+pub fn rc_mut_from_owned<T: Send>(value: T) -> RcMut<T> {
     unsafe { RcMut::new(value) }
 }
 

src/libextra/sync.rs

@@ -86,7 +86,7 @@ struct SemInner<Q> {
 struct Sem<Q>(Exclusive<SemInner<Q>>);
 
 #[doc(hidden)]
-fn new_sem<Q:Owned>(count: int, q: Q) -> Sem<Q> {
+fn new_sem<Q:Send>(count: int, q: Q) -> Sem<Q> {
     Sem(exclusive(SemInner {
         count: count, waiters: new_waitqueue(), blocked: q }))
 }
@@ -101,7 +101,7 @@ fn new_sem_and_signal(count: int, num_condvars: uint)
 }
 
 #[doc(hidden)]
-impl<Q:Owned> Sem<Q> {
+impl<Q:Send> Sem<Q> {
     pub fn acquire(&self) {
         unsafe {
             let mut waiter_nobe = None;
@@ -175,7 +175,7 @@ struct SemReleaseGeneric<'self, Q> { sem: &'self Sem<Q> }
 
 #[doc(hidden)]
 #[unsafe_destructor]
-impl<'self, Q:Owned> Drop for SemReleaseGeneric<'self, Q> {
+impl<'self, Q:Send> Drop for SemReleaseGeneric<'self, Q> {
     fn drop(&self) {
         self.sem.release();
     }