Merge remote-tracking branch 'mozilla/master'

Conflicts:
	src/libextra/test.rs
	src/libstd/at_vec.rs
	src/libstd/cleanup.rs
	src/libstd/rt/comm.rs
	src/libstd/rt/global_heap.rs
	src/libstd/task/spawn.rs
	src/libstd/unstable/lang.rs
	src/libstd/vec.rs
	src/rt/rustrt.def.in
	src/test/run-pass/extern-pub.rs

1 files changed, 50 insertions, 50 deletions

diff --git a/src/libstd/comm.rs b/src/libstd/comm.rs
index 00c33c8ab32..1bb0ff044fe 100644
--- a/src/libstd/comm.rs
+++ b/src/libstd/comm.rs
@@ -17,7 +17,7 @@ Message passing
 use cast::{transmute, transmute_mut};
 use container::Container;
 use either::{Either, Left, Right};
-use kinds::Owned;
+use kinds::Send;
 use option::{Option, Some, None};
 use uint;
 use vec::OwnedVector;
@@ -77,7 +77,7 @@ pub struct Port<T> {
 These allow sending or receiving an unlimited number of messages.
 
 */
-pub fn stream<T:Owned>() -> (Port<T>, Chan<T>) {
+pub fn stream<T:Send>() -> (Port<T>, Chan<T>) {
     let (port, chan) = match rt::context() {
         rt::OldTaskContext => match pipesy::stream() {
             (p, c) => (Left(p), Left(c))
@@ -91,7 +91,7 @@ pub fn stream<T:Owned>() -> (Port<T>, Chan<T>) {
     return (port, chan);
 }
 
-impl<T: Owned> GenericChan<T> for Chan<T> {
+impl<T: Send> GenericChan<T> for Chan<T> {
     fn send(&self, x: T) {
         match self.inner {
             Left(ref chan) => chan.send(x),
@@ -100,7 +100,7 @@ impl<T: Owned> GenericChan<T> for Chan<T> {
     }
 }
 
-impl<T: Owned> GenericSmartChan<T> for Chan<T> {
+impl<T: Send> GenericSmartChan<T> for Chan<T> {
     fn try_send(&self, x: T) -> bool {
         match self.inner {
             Left(ref chan) => chan.try_send(x),
@@ -109,7 +109,7 @@ impl<T: Owned> GenericSmartChan<T> for Chan<T> {
     }
 }
 
-impl<T: Owned> GenericPort<T> for Port<T> {
+impl<T: Send> GenericPort<T> for Port<T> {
     fn recv(&self) -> T {
         match self.inner {
             Left(ref port) => port.recv(),
@@ -125,7 +125,7 @@ impl<T: Owned> GenericPort<T> for Port<T> {
     }
 }
 
-impl<T: Owned> Peekable<T> for Port<T> {
+impl<T: Send> Peekable<T> for Port<T> {
     fn peek(&self) -> bool {
         match self.inner {
             Left(ref port) => port.peek(),
@@ -134,7 +134,7 @@ impl<T: Owned> Peekable<T> for Port<T> {
     }
 }
 
-impl<T: Owned> Selectable for Port<T> {
+impl<T: Send> Selectable for Port<T> {
     fn header(&mut self) -> *mut PacketHeader {
         match self.inner {
             Left(ref mut port) => port.header(),
@@ -149,7 +149,7 @@ pub struct PortSet<T> {
     ports: ~[pipesy::Port<T>],
 }
 
-impl<T: Owned> PortSet<T> {
+impl<T: Send> PortSet<T> {
     pub fn new() -> PortSet<T> {
         PortSet {
             ports: ~[]
@@ -175,7 +175,7 @@ impl<T: Owned> PortSet<T> {
     }
 }
 
-impl<T:Owned> GenericPort<T> for PortSet<T> {
+impl<T:Send> GenericPort<T> for PortSet<T> {
     fn try_recv(&self) -> Option<T> {
         unsafe {
             let self_ports = transmute_mut(&self.ports);
@@ -204,7 +204,7 @@ impl<T:Owned> GenericPort<T> for PortSet<T> {
     }
 }
 
-impl<T: Owned> Peekable<T> for PortSet<T> {
+impl<T: Send> Peekable<T> for PortSet<T> {
     fn peek(&self) -> bool {
         // It'd be nice to use self.port.each, but that version isn't
         // pure.
@@ -223,7 +223,7 @@ pub struct SharedChan<T> {
     inner: Either<Exclusive<pipesy::Chan<T>>, rtcomm::SharedChan<T>>
 }
 
-impl<T: Owned> SharedChan<T> {
+impl<T: Send> SharedChan<T> {
     /// Converts a `chan` into a `shared_chan`.
     pub fn new(c: Chan<T>) -> SharedChan<T> {
         let Chan { inner } = c;
@@ -235,7 +235,7 @@ impl<T: Owned> SharedChan<T> {
     }
 }
 
-impl<T: Owned> GenericChan<T> for SharedChan<T> {
+impl<T: Send> GenericChan<T> for SharedChan<T> {
     fn send(&self, x: T) {
         match self.inner {
             Left(ref chan) => {
@@ -252,7 +252,7 @@ impl<T: Owned> GenericChan<T> for SharedChan<T> {
     }
 }
 
-impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
+impl<T: Send> GenericSmartChan<T> for SharedChan<T> {
     fn try_send(&self, x: T) -> bool {
         match self.inner {
             Left(ref chan) => {
@@ -269,7 +269,7 @@ impl<T: Owned> GenericSmartChan<T> for SharedChan<T> {
     }
 }
 
-impl<T: Owned> ::clone::Clone for SharedChan<T> {
+impl<T: Send> ::clone::Clone for SharedChan<T> {
     fn clone(&self) -> SharedChan<T> {
         SharedChan { inner: self.inner.clone() }
     }
@@ -283,7 +283,7 @@ pub struct ChanOne<T> {
     inner: Either<pipesy::ChanOne<T>, rtcomm::ChanOne<T>>
 }
 
-pub fn oneshot<T: Owned>() -> (PortOne<T>, ChanOne<T>) {
+pub fn oneshot<T: Send>() -> (PortOne<T>, ChanOne<T>) {
     let (port, chan) = match rt::context() {
         rt::OldTaskContext => match pipesy::oneshot() {
             (p, c) => (Left(p), Left(c)),
@@ -297,7 +297,7 @@ pub fn oneshot<T: Owned>() -> (PortOne<T>, ChanOne<T>) {
     return (port, chan);
 }
 
-impl<T: Owned> PortOne<T> {
+impl<T: Send> PortOne<T> {
     pub fn recv(self) -> T {
         let PortOne { inner } = self;
         match inner {
@@ -315,7 +315,7 @@ impl<T: Owned> PortOne<T> {
     }
 }
 
-impl<T: Owned> ChanOne<T> {
+impl<T: Send> ChanOne<T> {
     pub fn send(self, data: T) {
         let ChanOne { inner } = self;
         match inner {
@@ -333,7 +333,7 @@ impl<T: Owned> ChanOne<T> {
     }
 }
 
-pub fn recv_one<T: Owned>(port: PortOne<T>) -> T {
+pub fn recv_one<T: Send>(port: PortOne<T>) -> T {
     let PortOne { inner } = port;
     match inner {
         Left(p) => pipesy::recv_one(p),
@@ -341,7 +341,7 @@ pub fn recv_one<T: Owned>(port: PortOne<T>) -> T {
     }
 }
 
-pub fn try_recv_one<T: Owned>(port: PortOne<T>) -> Option<T> {
+pub fn try_recv_one<T: Send>(port: PortOne<T>) -> Option<T> {
     let PortOne { inner } = port;
     match inner {
         Left(p) => pipesy::try_recv_one(p),
@@ -349,7 +349,7 @@ pub fn try_recv_one<T: Owned>(port: PortOne<T>) -> Option<T> {
     }
 }
 
-pub fn send_one<T: Owned>(chan: ChanOne<T>, data: T) {
+pub fn send_one<T: Send>(chan: ChanOne<T>, data: T) {
     let ChanOne { inner } = chan;
     match inner {
         Left(c) => pipesy::send_one(c, data),
@@ -357,7 +357,7 @@ pub fn send_one<T: Owned>(chan: ChanOne<T>, data: T) {
     }
 }
 
-pub fn try_send_one<T: Owned>(chan: ChanOne<T>, data: T) -> bool {
+pub fn try_send_one<T: Send>(chan: ChanOne<T>, data: T) -> bool {
     let ChanOne { inner } = chan;
     match inner {
         Left(c) => pipesy::try_send_one(c, data),
@@ -367,7 +367,7 @@ pub fn try_send_one<T: Owned>(chan: ChanOne<T>, data: T) -> bool {
 
 mod pipesy {
 
-    use kinds::Owned;
+    use kinds::Send;
     use option::{Option, Some, None};
     use pipes::{recv, try_recv, peek, PacketHeader};
     use super::{GenericChan, GenericSmartChan, GenericPort, Peekable, Selectable};
@@ -375,17 +375,17 @@ mod pipesy {
     use util::replace;
 
     /*proto! oneshot (
-        Oneshot:send<T:Owned> {
+        Oneshot:send<T:Send> {
             send(T) -> !
         }
     )*/
 
     #[allow(non_camel_case_types)]
     pub mod oneshot {
-        priv use core::kinds::Owned;
+        priv use core::kinds::Send;
         use ptr::to_mut_unsafe_ptr;
 
-        pub fn init<T: Owned>() -> (server::Oneshot<T>, client::Oneshot<T>) {
+        pub fn init<T: Send>() -> (server::Oneshot<T>, client::Oneshot<T>) {
             pub use core::pipes::HasBuffer;
 
             let buffer = ~::core::pipes::Buffer {
@@ -409,10 +409,10 @@ mod pipesy {
         #[allow(non_camel_case_types)]
         pub mod client {
 
-            priv use core::kinds::Owned;
+            priv use core::kinds::Send;
 
             #[allow(non_camel_case_types)]
-            pub fn try_send<T: Owned>(pipe: Oneshot<T>, x_0: T) ->
+            pub fn try_send<T: Send>(pipe: Oneshot<T>, x_0: T) ->
                 ::core::option::Option<()> {
                 {
                     use super::send;
@@ -424,7 +424,7 @@ mod pipesy {
             }
 
             #[allow(non_camel_case_types)]
-            pub fn send<T: Owned>(pipe: Oneshot<T>, x_0: T) {
+            pub fn send<T: Send>(pipe: Oneshot<T>, x_0: T) {
                 {
                     use super::send;
                     let message = send(x_0);
@@ -474,12 +474,12 @@ mod pipesy {
     }
 
     /// Initialiase a (send-endpoint, recv-endpoint) oneshot pipe pair.
-    pub fn oneshot<T: Owned>() -> (PortOne<T>, ChanOne<T>) {
+    pub fn oneshot<T: Send>() -> (PortOne<T>, ChanOne<T>) {
         let (port, chan) = oneshot::init();
         (PortOne::new(port), ChanOne::new(chan))
     }
 
-    impl<T: Owned> PortOne<T> {
+    impl<T: Send> PortOne<T> {
         pub fn recv(self) -> T { recv_one(self) }
         pub fn try_recv(self) -> Option<T> { try_recv_one(self) }
         pub fn unwrap(self) -> oneshot::server::Oneshot<T> {
@@ -489,7 +489,7 @@ mod pipesy {
         }
     }
 
-    impl<T: Owned> ChanOne<T> {
+    impl<T: Send> ChanOne<T> {
         pub fn send(self, data: T) { send_one(self, data) }
         pub fn try_send(self, data: T) -> bool { try_send_one(self, data) }
         pub fn unwrap(self) -> oneshot::client::Oneshot<T> {
@@ -503,7 +503,7 @@ mod pipesy {
     * Receive a message from a oneshot pipe, failing if the connection was
     * closed.
     */
-    pub fn recv_one<T: Owned>(port: PortOne<T>) -> T {
+    pub fn recv_one<T: Send>(port: PortOne<T>) -> T {
         match port {
             PortOne { contents: port } => {
                 let oneshot::send(message) = recv(port);
@@ -513,7 +513,7 @@ mod pipesy {
     }
 
     /// Receive a message from a oneshot pipe unless the connection was closed.
-    pub fn try_recv_one<T: Owned> (port: PortOne<T>) -> Option<T> {
+    pub fn try_recv_one<T: Send> (port: PortOne<T>) -> Option<T> {
         match port {
             PortOne { contents: port } => {
                 let message = try_recv(port);
@@ -529,7 +529,7 @@ mod pipesy {
     }
 
     /// Send a message on a oneshot pipe, failing if the connection was closed.
-    pub fn send_one<T: Owned>(chan: ChanOne<T>, data: T) {
+    pub fn send_one<T: Send>(chan: ChanOne<T>, data: T) {
         match chan {
             ChanOne { contents: chan } => oneshot::client::send(chan, data),
         }
@@ -539,7 +539,7 @@ mod pipesy {
     * Send a message on a oneshot pipe, or return false if the connection was
     * closed.
     */
-    pub fn try_send_one<T: Owned>(chan: ChanOne<T>, data: T) -> bool {
+    pub fn try_send_one<T: Send>(chan: ChanOne<T>, data: T) -> bool {
         match chan {
             ChanOne { contents: chan } => {
                 oneshot::client::try_send(chan, data).is_some()
@@ -550,16 +550,16 @@ mod pipesy {
     // Streams - Make pipes a little easier in general.
 
     /*proto! streamp (
-        Open:send<T: Owned> {
+        Open:send<T: Send> {
             data(T) -> Open<T>
         }
     )*/
 
     #[allow(non_camel_case_types)]
     pub mod streamp {
-        priv use core::kinds::Owned;
+        priv use core::kinds::Send;
 
-        pub fn init<T: Owned>() -> (server::Open<T>, client::Open<T>) {
+        pub fn init<T: Send>() -> (server::Open<T>, client::Open<T>) {
             pub use core::pipes::HasBuffer;
             ::core::pipes::entangle()
         }
@@ -569,10 +569,10 @@ mod pipesy {
 
         #[allow(non_camel_case_types)]
         pub mod client {
-            priv use core::kinds::Owned;
+            priv use core::kinds::Send;
 
             #[allow(non_camel_case_types)]
-            pub fn try_data<T: Owned>(pipe: Open<T>, x_0: T) ->
+            pub fn try_data<T: Send>(pipe: Open<T>, x_0: T) ->
                 ::core::option::Option<Open<T>> {
                 {
                     use super::data;
@@ -585,7 +585,7 @@ mod pipesy {
             }
 
             #[allow(non_camel_case_types)]
-            pub fn data<T: Owned>(pipe: Open<T>, x_0: T) -> Open<T> {
+            pub fn data<T: Send>(pipe: Open<T>, x_0: T) -> Open<T> {
                 {
                     use super::data;
                     let (s, c) = ::core::pipes::entangle();
@@ -623,7 +623,7 @@ mod pipesy {
     These allow sending or receiving an unlimited number of messages.
 
     */
-    pub fn stream<T:Owned>() -> (Port<T>, Chan<T>) {
+    pub fn stream<T:Send>() -> (Port<T>, Chan<T>) {
         let (s, c) = streamp::init();
 
         (Port {
@@ -633,7 +633,7 @@ mod pipesy {
         })
     }
 
-    impl<T: Owned> GenericChan<T> for Chan<T> {
+    impl<T: Send> GenericChan<T> for Chan<T> {
         #[inline]
         fn send(&self, x: T) {
             unsafe {
@@ -644,7 +644,7 @@ mod pipesy {
         }
     }
 
-    impl<T: Owned> GenericSmartChan<T> for Chan<T> {
+    impl<T: Send> GenericSmartChan<T> for Chan<T> {
         #[inline]
         fn try_send(&self, x: T) -> bool {
             unsafe {
@@ -661,7 +661,7 @@ mod pipesy {
         }
     }
 
-    impl<T: Owned> GenericPort<T> for Port<T> {
+    impl<T: Send> GenericPort<T> for Port<T> {
         #[inline]
         fn recv(&self) -> T {
             unsafe {
@@ -689,7 +689,7 @@ mod pipesy {
         }
     }
 
-    impl<T: Owned> Peekable<T> for Port<T> {
+    impl<T: Send> Peekable<T> for Port<T> {
         #[inline]
         fn peek(&self) -> bool {
             unsafe {
@@ -705,7 +705,7 @@ mod pipesy {
         }
     }
 
-    impl<T: Owned> Selectable for Port<T> {
+    impl<T: Send> Selectable for Port<T> {
         fn header(&mut self) -> *mut PacketHeader {
             match self.endp {
                 Some(ref mut endp) => endp.header(),
@@ -733,15 +733,15 @@ pub fn select2i<A:Selectable, B:Selectable>(a: &mut A, b: &mut B)
 }
 
 /// Receive a message from one of two endpoints.
-pub trait Select2<T: Owned, U: Owned> {
+pub trait Select2<T: Send, U: Send> {
     /// Receive a message or return `None` if a connection closes.
     fn try_select(&mut self) -> Either<Option<T>, Option<U>>;
     /// Receive a message or fail if a connection closes.
     fn select(&mut self) -> Either<T, U>;
 }
 
-impl<T:Owned,
-     U:Owned,
+impl<T:Send,
+     U:Send,
      Left:Selectable + GenericPort<T>,
      Right:Selectable + GenericPort<U>>
      Select2<T, U>