---

yaml
---
r: 35513
b: refs/heads/master
c: 08b1c84
h: refs/heads/master
i:
  35511: 5d9d9dc
v: v3

Author: andrew-d

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 885bdf71796120dfc222a4985a80aba70edaa5f9
+refs/heads/master: 08b1c841daa401afb9516987ceb07906615c4a1d
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024

trunk/RELEASES.txt

@@ -1,7 +1,7 @@
 Version 0.5 (December 2012)
 ---------------------------
 
-   * ~800 changes, numerous bugfixes
+   * ~700 changes, numerous bugfixes
 
    * Syntax changes
       * Removed `<-` move operator
@@ -13,7 +13,6 @@ Version 0.5 (December 2012)
       * `Eq` and `IterBytes` implementations can be automatically generated
         with `#[deriving_eq]` and `#[deriving_iter_bytes]` respectively
       * Removed the special crate language for `.rc` files
-      * Function arguments may consist of any irrefutable pattern
 
    * Semantic changes
       * `&` and `~` pointers may point to objects
@@ -25,15 +24,13 @@ Version 0.5 (December 2012)
         without writing `move` explicitly
       * `&T` may now be coerced to `*T`
       * Coercions happen in `let` statements as well as function calls
-      * `use` statements now take crate-relative paths
 
    * Improved support for language features
       * Trait inheritance is much more complete
+      * Traits may declare default methods for the implementations to use
       * More support for explicit self arguments in methods - `self`, `&self`
         `@self`, and `~self` all generally work as expected
       * Static methods work in more situations
-      * Experimental: Traits may declare default methods for the implementations
-        to use
 
    * Libraries
       * New condition handling system in `core::condition`

trunk/doc/rust.md

@@ -2719,18 +2719,18 @@ The special type `self` has a meaning within methods inside an
 impl item. It refers to the type of the implicit `self` argument. For
 example, in:
 
-~~~~~~~~{.xfail-test}
+~~~~~~~~
 trait Printable {
-  fn to_str() -> ~str;
+  fn make_string() -> ~str;
 }
 
 impl ~str: Printable {
-  fn to_str() -> ~str { copy self }
+  fn make_string() -> ~str { copy self }
 }
 ~~~~~~~~
 
 `self` refers to the value of type `~str` that is the receiver for a
-call to the method `to_str`.
+call to the method `make_string`.
 
 ## Type kinds
 
@@ -2740,11 +2740,11 @@ The kinds are:
 `Const`
   : Types of this kind are deeply immutable;
     they contain no mutable memory locations directly or indirectly via pointers.
-`Owned`
+`Send`
   : Types of this kind can be safely sent between tasks.
     This kind includes scalars, owning pointers, owned closures, and
-    structural types containing only other owned types. All `Owned` types are `Static`.
-`Static`
+    structural types containing only other sendable types.
+`Owned`
   : Types of this kind do not contain any borrowed pointers;
     this can be a useful guarantee for code that breaks borrowing assumptions using [`unsafe` operations](#unsafe-functions).
 `Copy`
@@ -2833,10 +2833,10 @@ frame they are allocated within.
 A task owns all memory it can *safely* reach through local variables,
 as well as managed, owning and borrowed pointers.
 
-When a task sends a value that has the `Owned` trait to another task,
+When a task sends a value that has the `Send` trait to another task,
 it loses ownership of the value sent and can no longer refer to it.
 This is statically guaranteed by the combined use of "move semantics",
-and the compiler-checked _meaning_ of the `Owned` trait:
+and the compiler-checked _meaning_ of the `Send` trait:
 it is only instantiated for (transitively) sendable kinds of data constructor and pointers,
 never including managed or borrowed pointers.
 
@@ -2971,7 +2971,7 @@ These include:
   - read-only and read-write shared variables with various safe mutual exclusion patterns
   - simple locks and semaphores
 
-When such facilities carry values, the values are restricted to the [`Owned` type-kind](#type-kinds).
+When such facilities carry values, the values are restricted to the [`Send` type-kind](#type-kinds).
 Restricting communication interfaces to this kind ensures that no borrowed or managed pointers move between tasks.
 Thus access to an entire data structure can be mediated through its owning "root" value;
 no further locking or copying is required to avoid data races within the substructure of such a value.

trunk/doc/tutorial.md

@@ -1914,9 +1914,9 @@ types by the compiler, and may not be overridden:
   `copy` operator. All types are copyable unless they have destructors or
   contain types with destructors.
 
-* `Owned` - Owned types. Types are owned unless they contain managed
-  boxes, managed closures, or borrowed pointers.  Owned types may or
-  may not be copyable.
+* `Send` - Sendable (owned) types. All types are sendable unless they
+  contain managed boxes, managed closures, or otherwise managed
+  types. Sendable types may or may not be copyable.
 
 * `Const` - Constant (immutable) types. These are types that do not contain
   mutable fields.
@@ -1949,7 +1949,7 @@ may call it.
 ## Declaring and implementing traits
 
 A trait consists of a set of methods, without bodies, or may be empty,
-as is the case with `Copy`, `Owned`, and `Const`. For example, we could
+as is the case with `Copy`, `Send`, and `Const`. For example, we could
 declare the trait `Printable` for things that can be printed to the
 console, with a single method:
 

trunk/mk/clean.mk

@@ -49,7 +49,7 @@ clean-misc:
 	$(Q)rm -Rf $(DOCS)
 	$(Q)rm -Rf $(GENERATED)
 	$(Q)rm -f tmp/*.log tmp/*.rc tmp/*.rs
-	$(Q)rm -Rf rust-stage0-*.tar.bz2 $(PKG_NAME)-*.tar.gz dist
+	$(Q)rm -Rf $(PKG_NAME)-*.tar.gz dist
 	$(Q)rm -Rf $(foreach ext, \
                  html aux cp fn ky log pdf pg toc tp vr cps, \
                  $(wildcard doc/*.$(ext) \

trunk/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: Owned> {
+pub enum Port<T: Send> {
     Port_(@PortPtr<T>)
 }
 
@@ -73,16 +73,16 @@ pub enum Port<T: Owned> {
  * data will be silently dropped.  Channels may be duplicated and
  * themselves transmitted over other channels.
  */
-pub enum Chan<T: Owned> {
+pub enum Chan<T: Send> {
     Chan_(port_id)
 }
 
 /// Constructs a port
-pub fn Port<T: Owned>() -> Port<T> {
+pub fn Port<T: Send>() -> Port<T> {
     Port_(@PortPtr(rustrt::new_port(sys::size_of::<T>() as size_t)))
 }
 
-impl<T: Owned> Port<T> {
+impl<T: Send> Port<T> {
 
     fn chan() -> Chan<T> { Chan(&self) }
     fn send(v: T) { self.chan().send(move v) }
@@ -91,7 +91,7 @@ impl<T: Owned> Port<T> {
 
 }
 
-impl<T: Owned> Chan<T> {
+impl<T: Send> Chan<T> {
 
     fn chan() -> Chan<T> { self }
     fn send(v: T) { send(self, move v) }
@@ -101,12 +101,12 @@ impl<T: Owned> Chan<T> {
 }
 
 /// Open a new receiving channel for the duration of a function
-pub fn listen<T: Owned, U>(f: fn(Chan<T>) -> U) -> U {
+pub fn listen<T: Send, U>(f: fn(Chan<T>) -> U) -> U {
     let po = Port();
     f(po.chan())
 }
 
-struct PortPtr<T:Owned> {
+struct PortPtr<T:Send> {
     po: *rust_port,
   drop unsafe {
       do task::unkillable {
@@ -130,7 +130,7 @@ struct PortPtr<T:Owned> {
   }
 }
 
-fn PortPtr<T: Owned>(po: *rust_port) -> PortPtr<T> {
+fn PortPtr<T: Send>(po: *rust_port) -> PortPtr<T> {
     PortPtr {
         po: po
     }
@@ -144,7 +144,7 @@ fn PortPtr<T: Owned>(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: Owned, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
+fn as_raw_port<T: Send, 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: Owned, 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: Owned>(p: &Port<T>) -> Chan<T> {
+pub fn Chan<T: Send>(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: Owned>(ch: Chan<T>, data: T) {
+pub fn send<T: Send>(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: Owned>(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: Owned>(p: Port<T>) -> T { recv_((**p).po) }
+pub fn recv<T: Send>(p: Port<T>) -> T { recv_((**p).po) }
 
 /// Returns true if there are messages available
-pub fn peek<T: Owned>(p: Port<T>) -> bool { peek_((**p).po) }
+pub fn peek<T: Send>(p: Port<T>) -> bool { peek_((**p).po) }
 
 #[doc(hidden)]
-pub fn recv_chan<T: Owned>(ch: comm::Chan<T>) -> T {
+pub fn recv_chan<T: Send>(ch: comm::Chan<T>) -> T {
     as_raw_port(ch, |x|recv_(x))
 }
 
-fn peek_chan<T: Owned>(ch: comm::Chan<T>) -> bool {
+fn peek_chan<T: Send>(ch: comm::Chan<T>) -> bool {
     as_raw_port(ch, |x|peek_(x))
 }
 
 /// Receive on a raw port pointer
-fn recv_<T: Owned>(p: *rust_port) -> T {
+fn recv_<T: Send>(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: Owned, B: Owned>(p_a: Port<A>, p_b: Port<B>)
+pub fn select2<A: Send, B: Send>(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);

trunk/src/libcore/core.rc

@@ -167,7 +167,7 @@ pub mod util;
 
 /* Reexported core operators */
 
-pub use kinds::{Const, Copy, Owned, Durable};
+pub use kinds::{Const, Copy, Send, Owned};
 pub use ops::{Drop};
 pub use ops::{Add, Sub, Mul, Div, Modulo, Neg};
 pub use ops::{BitAnd, BitOr, BitXor};
@@ -240,8 +240,6 @@ mod core {
     pub const warn : u32 = 2_u32;
     pub const info : u32 = 3_u32;
     pub const debug : u32 = 4_u32;
-
-    pub use cmp;
 }
 
 

trunk/src/libcore/either.rs

@@ -18,7 +18,6 @@ use cmp::Eq;
 use result::Result;
 
 /// The either type
-#[deriving_eq]
 pub enum Either<T, U> {
     Left(T),
     Right(U)
@@ -142,6 +141,26 @@ pub pure fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
     }
 }
 
+impl<T:Eq,U:Eq> Either<T,U> : Eq {
+    pure fn eq(&self, other: &Either<T,U>) -> bool {
+        match (*self) {
+            Left(ref a) => {
+                match (*other) {
+                    Left(ref b) => (*a).eq(b),
+                    Right(_) => false
+                }
+            }
+            Right(ref a) => {
+                match (*other) {
+                    Left(_) => false,
+                    Right(ref b) => (*a).eq(b)
+                }
+            }
+        }
+    }
+    pure fn ne(&self, other: &Either<T,U>) -> bool { !(*self).eq(other) }
+}
+
 #[test]
 fn test_either_left() {
     let val = Left(10);

trunk/src/libcore/extfmt.rs

@@ -445,9 +445,24 @@ pub mod rt {
             };
     }
 
-    #[deriving_eq]
     pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat }
 
+    pub impl PadMode : Eq {
+        pure fn eq(&self, other: &PadMode) -> bool {
+            match ((*self), (*other)) {
+                (PadSigned, PadSigned) => true,
+                (PadUnsigned, PadUnsigned) => true,
+                (PadNozero, PadNozero) => true,
+                (PadFloat, PadFloat) => true,
+                (PadSigned, _) => false,
+                (PadUnsigned, _) => false,
+                (PadNozero, _) => false,
+                (PadFloat, _) => false
+            }
+        }
+        pure fn ne(&self, other: &PadMode) -> bool { !(*self).eq(other) }
+    }
+
     pub fn pad(cv: Conv, s: ~str, mode: PadMode) -> ~str {
         let mut s = move s; // sadtimes
         let uwidth : uint = match cv.width {

trunk/src/libcore/float.rs

@@ -36,7 +36,7 @@ pub use f64::{modf, pow, round, sinh, tanh, tgamma, trunc};
 pub use f64::signbit;
 pub use f64::{j0, j1, jn, y0, y1, yn};
 use cmp::{Eq, Ord};
-use num::Num::from_int;
+use num::from_int;
 
 pub const NaN: float = 0.0/0.0;
 

trunk/src/libcore/int-template.rs

@@ -20,7 +20,7 @@ use T = self::inst::T;
 
 use cmp::{Eq, Ord};
 use from_str::FromStr;
-use num::Num::from_int;
+use num::from_int;
 
 pub const bits : uint = inst::bits;
 pub const bytes : uint = (inst::bits / 8);

trunk/src/libcore/io.rs

@@ -523,9 +523,18 @@ pub pure fn with_str_reader<T>(s: &str, f: fn(Reader) -> T) -> T {
 pub enum FileFlag { Append, Create, Truncate, NoFlag, }
 
 // What type of writer are we?
-#[deriving_eq]
 pub enum WriterType { Screen, File }
 
+pub impl WriterType : Eq {
+    pure fn eq(&self, other: &WriterType) -> bool {
+        match ((*self), (*other)) {
+            (Screen, Screen) | (File, File) => true,
+            (Screen, _) | (File, _) => false
+        }
+    }
+    pure fn ne(&self, other: &WriterType) -> bool { !(*self).eq(other) }
+}
+
 // FIXME (#2004): Seekable really should be orthogonal.
 // FIXME (#2004): eventually u64
 /// The raw underlying writer trait. All writers must implement this.