---

yaml
---
r: 40791
b: refs/heads/dist-snap
c: ed4fac0
h: refs/heads/master
i:
  40789: 60ccd41
  40787: c4d78be
  40783: 8b09924
v: v3

Author: brson

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: a277081ee481174cd28f7e85aaf1c4de912cbf4f
+refs/heads/dist-snap: ed4fac01b5e207df0f0c7e0ea964bd3088826d27
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libcore/comm.rs

@@ -57,7 +57,7 @@ use libc::size_t;
  * transmitted. If a port value is copied, both copies refer to the same
  * port.  Ports may be associated with multiple `chan`s.
  */
-pub enum Port<T: Send> {
+pub enum Port<T: Owned> {
     Port_(@PortPtr<T>)
 }
 
@@ -73,16 +73,16 @@ pub enum Port<T: Send> {
  * data will be silently dropped.  Channels may be duplicated and
  * themselves transmitted over other channels.
  */
-pub enum Chan<T: Send> {
+pub enum Chan<T: Owned> {
     Chan_(port_id)
 }
 
 /// Constructs a port
-pub fn Port<T: Send>() -> Port<T> {
+pub fn Port<T: Owned>() -> Port<T> {
     Port_(@PortPtr(rustrt::new_port(sys::size_of::<T>() as size_t)))
 }
 
-impl<T: Send> Port<T> {
+impl<T: Owned> Port<T> {
 
     fn chan() -> Chan<T> { Chan(&self) }
     fn send(v: T) { self.chan().send(move v) }
@@ -91,7 +91,7 @@ impl<T: Send> Port<T> {
 
 }
 
-impl<T: Send> Chan<T> {
+impl<T: Owned> Chan<T> {
 
     fn chan() -> Chan<T> { self }
     fn send(v: T) { send(self, move v) }
@@ -101,12 +101,12 @@ impl<T: Send> Chan<T> {
 }
 
 /// Open a new receiving channel for the duration of a function
-pub fn listen<T: Send, U>(f: fn(Chan<T>) -> U) -> U {
+pub fn listen<T: Owned, U>(f: fn(Chan<T>) -> U) -> U {
     let po = Port();
     f(po.chan())
 }
 
-struct PortPtr<T:Send> {
+struct PortPtr<T:Owned> {
     po: *rust_port,
   drop unsafe {
       do task::unkillable {
@@ -130,7 +130,7 @@ struct PortPtr<T:Send> {
   }
 }
 
-fn PortPtr<T: Send>(po: *rust_port) -> PortPtr<T> {
+fn PortPtr<T: Owned>(po: *rust_port) -> PortPtr<T> {
     PortPtr {
         po: po
     }
@@ -144,7 +144,7 @@ fn PortPtr<T: Send>(po: *rust_port) -> PortPtr<T> {
  * Fails if the port is detached or dead. Fails if the port
  * is owned by a different task.
  */
-fn as_raw_port<T: Send, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
+fn as_raw_port<T: Owned, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
 
     struct PortRef {
         p: *rust_port,
@@ -176,15 +176,15 @@ fn as_raw_port<T: Send, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
  * Constructs a channel. The channel is bound to the port used to
  * construct it.
  */
-pub fn Chan<T: Send>(p: &Port<T>) -> Chan<T> {
+pub fn Chan<T: Owned>(p: &Port<T>) -> Chan<T> {
     Chan_(rustrt::get_port_id((**p).po))
 }
 
 /**
  * Sends data over a channel. The sent data is moved into the channel,
  * whereupon the caller loses access to it.
  */
-pub fn send<T: Send>(ch: Chan<T>, data: T) {
+pub fn send<T: Owned>(ch: Chan<T>, data: T) {
     let Chan_(p) = ch;
     let data_ptr = ptr::addr_of(&data) as *();
     let res = rustrt::rust_port_id_send(p, data_ptr);
@@ -199,22 +199,22 @@ pub fn send<T: Send>(ch: Chan<T>, data: T) {
  * Receive from a port.  If no data is available on the port then the
  * task will block until data becomes available.
  */
-pub fn recv<T: Send>(p: Port<T>) -> T { recv_((**p).po) }
+pub fn recv<T: Owned>(p: Port<T>) -> T { recv_((**p).po) }
 
 /// Returns true if there are messages available
-pub fn peek<T: Send>(p: Port<T>) -> bool { peek_((**p).po) }
+pub fn peek<T: Owned>(p: Port<T>) -> bool { peek_((**p).po) }
 
 #[doc(hidden)]
-pub fn recv_chan<T: Send>(ch: comm::Chan<T>) -> T {
+pub fn recv_chan<T: Owned>(ch: comm::Chan<T>) -> T {
     as_raw_port(ch, |x|recv_(x))
 }
 
-fn peek_chan<T: Send>(ch: comm::Chan<T>) -> bool {
+fn peek_chan<T: Owned>(ch: comm::Chan<T>) -> bool {
     as_raw_port(ch, |x|peek_(x))
 }
 
 /// Receive on a raw port pointer
-fn recv_<T: Send>(p: *rust_port) -> T {
+fn recv_<T: Owned>(p: *rust_port) -> T {
     let yield = 0;
     let yieldp = ptr::addr_of(&yield);
     let mut res;
@@ -240,7 +240,7 @@ fn peek_(p: *rust_port) -> bool {
 }
 
 /// Receive on one of two ports
-pub fn select2<A: Send, B: Send>(p_a: Port<A>, p_b: Port<B>)
+pub fn select2<A: Owned, B: Owned>(p_a: Port<A>, p_b: Port<B>)
     -> Either<A, B> {
     let ports = ~[(**p_a).po, (**p_b).po];
     let yield = 0, yieldp = ptr::addr_of(&yield);

branches/dist-snap/src/libcore/core.rc

@@ -167,7 +167,7 @@ pub mod util;
 
 /* Reexported core operators */
 
-pub use kinds::{Const, Copy, Send, Durable};
+pub use kinds::{Const, Copy, Owned, Durable};
 pub use ops::{Drop};
 pub use ops::{Add, Sub, Mul, Div, Modulo, Neg};
 pub use ops::{BitAnd, BitOr, BitXor};

branches/dist-snap/src/libcore/kinds.rs

@@ -24,7 +24,7 @@ The 4 kinds are
   scalar types and managed pointers, and exludes owned pointers. It
   also excludes types that implement `Drop`.
 
-* Send - owned types and types containing owned types.  These types
+* Owned - owned types and types containing owned types.  These types
   may be transferred across task boundaries.
 
 * Const - types that are deeply immutable. Const types are used for
@@ -44,8 +44,17 @@ pub trait Copy {
     // Empty.
 }
 
+#[cfg(stage0)]
 #[lang="send"]
-pub trait Send {
+pub trait Owned {
+    // Empty.
+}
+
+#[cfg(stage1)]
+#[cfg(stage2)]
+#[cfg(stage3)]
+#[lang="owned"]
+pub trait Owned {
     // Empty.
 }