---

yaml
---
r: 40810
b: refs/heads/dist-snap
c: c7f7be8
h: refs/heads/master
v: v3

Author: thestinger

[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: 1b9f740f2fe7d67d70ae5b49b741712706cccead
+refs/heads/dist-snap: c7f7be83f5f9c8ec86fbb753fbc301d63a9cd957
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/AUTHORS.txt

@@ -54,7 +54,6 @@ Gonçalo Cabrita <[email protected]>
 Graham Fawcett <[email protected]>
 Grahame Bowland <[email protected]>
 Haitao Li <[email protected]>
-Huon Wilson <[email protected]>
 Ian D. Bollinger <[email protected]>
 Ivano Coppola <[email protected]>
 Jacob Harris Cryer Kragh <[email protected]>

branches/dist-snap/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`

branches/dist-snap/doc/rust.md

@@ -847,25 +847,10 @@ fn main() {
 
 Like items, `use` declarations are private to the containing module, by default.
 Also like items, a `use` declaration can be public, if qualified by the `pub` keyword.
-Such a `use` declaration serves to _re-export_ a name.
 A public `use` declaration can therefore be used to _redirect_ some public name to a different target definition,
 even a definition with a private canonical path, inside a different module.
 If a sequence of such redirections form a cycle or cannot be unambiguously resolved, they represent a compile-time error.
 
-An example of re-exporting:
-~~~~
-mod quux {
-    mod foo {
-        pub fn bar() { }
-        pub fn baz() { }
-    }
-    
-    pub use foo::*;
-}
-~~~~
-
-In this example, the module `quux` re-exports all of the public names defined in `foo`.
-
 ### Functions
 
 A _function item_ defines a sequence of [statements](#statements) and an optional final [expression](#expressions), along with a name and a set of parameters.
@@ -2719,18 +2704,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 make_string() -> ~str;
+  fn to_str() -> ~str;
 }
 
 impl ~str: Printable {
-  fn make_string() -> ~str { copy self }
+  fn to_str() -> ~str { copy self }
 }
 ~~~~~~~~
 
 `self` refers to the value of type `~str` that is the receiver for a
-call to the method `make_string`.
+call to the method `to_str`.
 
 ## Type kinds
 
@@ -2740,11 +2725,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 +2818,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 +2956,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.

branches/dist-snap/doc/tutorial-tasks.md

@@ -150,7 +150,7 @@ come in a variety of forms, each one appropriate for a different use case. In
 what follows, we cover the most commonly used varieties.
 
 The simplest way to create a pipe is to use the `pipes::stream`
-function to create a `(Port, Chan)` pair. In Rust parlance, a *channel*
+function to create a `(Chan, Port)` pair. In Rust parlance, a *channel*
 is a sending endpoint of a pipe, and a *port* is the receiving
 endpoint. Consider the following example of calculating two results
 concurrently:
@@ -159,7 +159,7 @@ concurrently:
 use task::spawn;
 use pipes::{stream, Port, Chan};
 
-let (port, chan): (Port<int>, Chan<int>) = stream();
+let (chan, port): (Chan<int>, Port<int>) = stream();
 
 do spawn |move chan| {
     let result = some_expensive_computation();
@@ -179,7 +179,7 @@ a tuple into its component parts).
 
 ~~~~
 # use pipes::{stream, Chan, Port};
-let (port, chan): (Port<int>, Chan<int>) = stream();
+let (chan, port): (Chan<int>, Port<int>) = stream();
 ~~~~
 
 The child task will use the channel to send data to the parent task,
@@ -191,7 +191,7 @@ spawns the child task.
 # use task::spawn;
 # use pipes::{stream, Port, Chan};
 # fn some_expensive_computation() -> int { 42 }
-# let (port, chan) = stream();
+# let (chan, port) = stream();
 do spawn |move chan| {
     let result = some_expensive_computation();
     chan.send(result);
@@ -211,7 +211,7 @@ port:
 ~~~~
 # use pipes::{stream, Port, Chan};
 # fn some_other_expensive_computation() {}
-# let (port, chan) = stream::<int>();
+# let (chan, port) = stream::<int>();
 # chan.send(0);
 some_other_expensive_computation();
 let result = port.recv();
@@ -227,7 +227,7 @@ following program is ill-typed:
 # use task::{spawn};
 # use pipes::{stream, Port, Chan};
 # fn some_expensive_computation() -> int { 42 }
-let (port, chan) = stream();
+let (chan, port) = stream();
 
 do spawn |move chan| {
     chan.send(some_expensive_computation());
@@ -247,7 +247,7 @@ Instead we can use a `SharedChan`, a type that allows a single
 # use task::spawn;
 use pipes::{stream, SharedChan};
 
-let (port, chan) = stream();
+let (chan, port) = stream();
 let chan = SharedChan(move chan);
 
 for uint::range(0, 3) |init_val| {
@@ -282,7 +282,7 @@ might look like the example below.
 
 // Create a vector of ports, one for each child task
 let ports = do vec::from_fn(3) |init_val| {
-    let (port, chan) = stream();
+    let (chan, port) = stream();
     do spawn |move chan| {
         chan.send(some_expensive_computation(init_val));
     }
@@ -397,7 +397,7 @@ before returning. Hence:
 # use task::{spawn, try};
 # fn sleep_forever() { loop { task::yield() } }
 # do task::try {
-let (receiver, sender): (Port<int>, Chan<int>) = stream();
+let (sender, receiver): (Chan<int>, Port<int>) = stream();
 do spawn |move receiver| {  // Bidirectionally linked
     // Wait for the supervised child task to exist.
     let message = receiver.recv();

branches/dist-snap/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:
 

branches/dist-snap/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) \

branches/dist-snap/src/etc/vim/syntax/rust.vim

@@ -2,7 +2,7 @@
 " Language:     Rust
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
-" Last Change:  2012 Jul 06
+" Last Change:  2012 Dec 14
 
 if version < 600
   syntax clear
@@ -11,16 +11,16 @@ elseif exists("b:current_syntax")
 endif
 
 syn match     rustAssert      "\<assert\(\w\)*"
-syn keyword   rustKeyword     again as break
+syn keyword   rustKeyword     as break
 syn keyword   rustKeyword     const copy do drop else export extern fail
-syn keyword   rustKeyword     for if impl import in let log
-syn keyword   rustKeyword     loop match mod module move mut new of priv pure
+syn keyword   rustKeyword     for if impl let log
+syn keyword   rustKeyword     loop match mod move mut once priv pure
 syn match     rustKeyword     "\<pub\>"
-syn keyword   rustKeyword     ref return static to unchecked
+syn keyword   rustKeyword     ref return static
 syn match     rustKeyword     "\<unsafe\>" " Allows also matching unsafe::foo()
-syn keyword   rustKeyword     use while with
+syn keyword   rustKeyword     use while
 " FIXME: Scoped impl's name is also fallen in this category
-syn keyword   rustKeyword     mod trait class struct enum type nextgroup=rustIdentifier skipwhite
+syn keyword   rustKeyword     mod trait struct enum type nextgroup=rustIdentifier skipwhite
 syn keyword   rustKeyword     fn nextgroup=rustFuncName skipwhite
 
 syn match     rustIdentifier  contains=rustIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained

branches/dist-snap/src/libcargo/cargo.rc

@@ -42,25 +42,26 @@ extern mod std(vers = "0.5");
 extern mod rustc(vers = "0.5");
 extern mod syntax(vers = "0.5");
 
+use core::*;
+
 #[legacy_exports]
 mod pgp;
 
-use rustc::metadata::filesearch::{get_cargo_root, get_cargo_root_nearest};
-use rustc::metadata::filesearch::{get_cargo_sysroot, libdir};
-
-use core::*;
-
-use core::dvec::DVec;
-use core::io::WriterUtil;
-use core::result::{Ok, Err};
-use core::send_map::linear::LinearMap;
-use std::getopts::{optflag, optopt, opt_present};
-use std::map::HashMap;
-use std::{map, json, tempfile, term, sort, getopts};
-use syntax::codemap::span;
+use syntax::{ast, codemap, parse, visit, attr};
 use syntax::diagnostic::span_handler;
+use codemap::span;
+use rustc::metadata::filesearch::{get_cargo_root, get_cargo_root_nearest,
+                                     get_cargo_sysroot, libdir};
 use syntax::diagnostic;
-use syntax::{ast, codemap, parse, visit, attr};
+
+use result::{Ok, Err};
+use io::WriterUtil;
+use send_map::linear::LinearMap;
+use std::{map, json, tempfile, term, sort, getopts};
+use map::HashMap;
+use to_str::to_str;
+use getopts::{optflag, optopt, opt_present};
+use dvec::DVec;
 
 struct Package {
     name: ~str,

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

@@ -61,7 +61,7 @@ pub pure fn build_sized<A>(size: uint,
                            builder: &fn(push: pure fn(v: A))) -> @[A] {
     let mut vec: @[const A] = @[];
     unsafe { raw::reserve(&mut vec, size); }
-    builder(|+x| unsafe { raw::push(&mut vec, x) });
+    builder(|+x| unsafe { raw::push(&mut vec, move x) });
     return unsafe { transmute(vec) };
 }
 
@@ -178,10 +178,10 @@ pub mod raw {
         let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         if (**repr).unboxed.alloc > fill {
-            push_fast(v, initval);
+            push_fast(v, move initval);
         }
         else {
-            push_slow(v, initval);
+            push_slow(v, move initval);
         }
     }
 

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

@@ -130,11 +130,10 @@ pub mod tests {
 
     #[test]
     pub fn test_transmute() {
-        use managed::raw::BoxRepr;
         unsafe {
-            let x = @100u8;
-            let x: *BoxRepr = transmute(move x);
-            assert (*x).data == 100;
+            let x = @1;
+            let x: *int = transmute(move x);
+            assert *x == 1;
             let _x: @int = transmute(move x);
         }
     }

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

@@ -149,7 +149,7 @@ pub pure fn escape_unicode(c: char) -> ~str {
             { str::push_str(&mut out, ~"0"); }
         str::push_str(&mut out, s);
     }
-    out
+    move out
 }
 
 /**

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

@@ -152,7 +152,7 @@ pub unsafe fn annihilate() {
         assert (*box).header.prev == null();
 
         debug!("freeing box: %x", box as uint);
-        rt_free(transmute(box));
+        rt_free(transmute(move box));
     }
 }