---

yaml
---
r: 120821
b: refs/heads/dist-snap
c: 3bc76d2
h: refs/heads/master
i:
  120819: b970bb0
v: v3

Author: Cameron Zwarich

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 1813e5aa1a03b0596b8de7abd1af31edf5d6098f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: bcf3464827e7caebbbdb2404838fbb588cf304f0
+refs/heads/dist-snap: 3bc76d27ae8fd02667a337825127266c8f62c6a9
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/mk/crates.mk

@@ -51,7 +51,7 @@
 
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
-                 url log regex graphviz core rlibc alloc debug
+		 workcache url log regex graphviz core rlibc alloc debug
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -88,6 +88,7 @@ DEPS_test := std collections getopts serialize term time regex
 DEPS_time := std serialize sync
 DEPS_rand := core
 DEPS_url := std collections
+DEPS_workcache := std serialize collections log
 DEPS_log := std sync
 DEPS_regex := std collections
 DEPS_regex_macros = syntax std regex

branches/dist-snap/src/compiletest/common.rs

@@ -12,7 +12,7 @@ use std::from_str::FromStr;
 use std::fmt;
 use regex::Regex;
 
-#[deriving(Clone, PartialEq)]
+#[deriving(Clone, Eq)]
 pub enum Mode {
     CompileFail,
     RunFail,

branches/dist-snap/src/doc/complement-cheatsheet.md

@@ -53,8 +53,9 @@ To return a Borrowed String Slice (&str) use the str helper function
 ~~~
 use std::str;
 
-let bytes = &[104u8,105u8];
-let x: &str = str::from_utf8(bytes).unwrap();
+let bytes = ~[104u8,105u8];
+let x: Option<&str> = str::from_utf8(bytes);
+let y: &str = x.unwrap();
 ~~~
 
 To return an Owned String use the str helper function
@@ -135,7 +136,7 @@ let index: Option<uint> = str.find_str("rand");
 The [`Container`](../std/container/trait.Container.html) trait provides the `len` method.
 
 ~~~
-let u: Vec<u32> = vec![0, 1, 2];
+let u: ~[u32] = ~[0, 1, 2];
 let v: &[u32] = &[0, 1, 2, 3];
 let w: [u32, .. 5] = [0, 1, 2, 3, 4];
 
@@ -147,7 +148,7 @@ println!("u: {}, v: {}, w: {}", u.len(), v.len(), w.len()); // 3, 4, 5
 Use the [`iter`](../std/vec/trait.ImmutableVector.html#tymethod.iter) method.
 
 ~~~
-let values: Vec<int> = vec![1, 2, 3, 4, 5];
+let values: ~[int] = ~[1, 2, 3, 4, 5];
 for value in values.iter() {  // value: &int
     println!("{}", *value);
 }

branches/dist-snap/src/doc/guide-ffi.md

@@ -2,11 +2,11 @@
 
 # Introduction
 
-This guide will use the [snappy](https://github.com/google/snappy)
+This guide will use the [snappy](https://code.google.com/p/snappy/)
 compression/decompression library as an introduction to writing bindings for
 foreign code. Rust is currently unable to call directly into a C++ library, but
 snappy includes a C interface (documented in
-[`snappy-c.h`](https://github.com/google/snappy/blob/master/snappy-c.h)).
+[`snappy-c.h`](https://code.google.com/p/snappy/source/browse/trunk/snappy-c.h)).
 
 The following is a minimal example of calling a foreign function which will
 compile if snappy is installed:

branches/dist-snap/src/doc/guide-macros.md

@@ -85,7 +85,7 @@ To take as an argument a fragment of Rust code, write `$` followed by a name
   `foo`.)
 * `expr` (an expression. Examples: `2 + 2`; `if true then { 1 } else { 2 }`;
   `f(42)`.)
-* `ty` (a type. Examples: `int`, `Vec<(char, String)>`, `&T`.)
+* `ty` (a type. Examples: `int`, `~[(char, String)]`, `&T`.)
 * `pat` (a pattern, usually appearing in a `match` or on the left-hand side of
   a declaration. Examples: `Some(t)`; `(17, 'a')`; `_`.)
 * `block` (a sequence of actions. Example: `{ log(error, "hi"); return 12; }`)

branches/dist-snap/src/doc/intro.md

@@ -198,14 +198,14 @@ Typically, tasks do not share memory but instead communicate amongst each other
 
 ```
 fn main() {
-    let numbers = vec![1,2,3];
+    let numbers = ~[1,2,3];
 
     let (tx, rx)  = channel();
     tx.send(numbers);
 
     spawn(proc() {
         let numbers = rx.recv();
-        println!("{}", *numbers.get(0));
+        println!("{}", numbers[0]);
     })
 }
 ```
@@ -237,26 +237,26 @@ try to modify the previous example to continue using the variable `numbers`:
 
 ```ignore
 fn main() {
-    let numbers = vec![1,2,3];
+    let numbers = ~[1,2,3];
 
     let (tx, rx)  = channel();
     tx.send(numbers);
 
     spawn(proc() {
         let numbers = rx.recv();
-        println!("{}", numbers.get(0));
+        println!("{}", numbers[0]);
     });
 
     // Try to print a number from the original task
-    println!("{}", *numbers.get(0));
+    println!("{}", numbers[0]);
 }
 ```
 
 This will result an error indicating that the value is no longer in scope:
 
 ```notrust
 concurrency.rs:12:20: 12:27 error: use of moved value: 'numbers'
-concurrency.rs:12     println!("{}", numbers.get(0));
+concurrency.rs:12     println!("{}", numbers[0]);
                                      ^~~~~~~
 ```
 
@@ -267,7 +267,7 @@ Let's see an example that uses the `clone` method to create copies of the data:
 
 ```
 fn main() {
-    let numbers = vec![1,2,3];
+    let numbers = ~[1,2,3];
 
     for num in range(0, 3) {
         let (tx, rx)  = channel();
@@ -276,7 +276,7 @@ fn main() {
 
         spawn(proc() {
             let numbers = rx.recv();
-            println!("{:d}", *numbers.get(num as uint));
+            println!("{:d}", numbers[num as uint]);
         })
     }
 }
@@ -301,7 +301,7 @@ extern crate sync;
 use sync::Arc;
 
 fn main() {
-    let numbers = vec![1,2,3];
+    let numbers = ~[1,2,3];
     let numbers = Arc::new(numbers);
 
     for num in range(0, 3) {
@@ -310,7 +310,7 @@ fn main() {
 
         spawn(proc() {
             let numbers = rx.recv();
-            println!("{:d}", *numbers.get(num as uint));
+            println!("{:d}", numbers[num as uint]);
         })
     }
 }
@@ -348,7 +348,7 @@ extern crate sync;
 use sync::{Arc, Mutex};
 
 fn main() {
-    let numbers = vec![1,2,3];
+    let numbers = ~[1,2,3];
     let numbers_lock = Arc::new(Mutex::new(numbers));
 
     for num in range(0, 3) {
@@ -360,13 +360,9 @@ fn main() {
 
             // Take the lock, along with exclusive access to the underlying array
             let mut numbers = numbers_lock.lock();
+            numbers[num as uint] += 1;
 
-            // This is ugly for now, but will be replaced by
-            // `numbers[num as uint] += 1` in the near future.
-            // See: https://github.com/mozilla/rust/issues/6515
-            *numbers.get_mut(num as uint) = *numbers.get_mut(num as uint) + 1;
-
-            println!("{}", *numbers.get(num as uint));
+            println!("{}", numbers[num as uint]);
 
             // When `numbers` goes out of scope the lock is dropped
         })

branches/dist-snap/src/doc/rust.md

@@ -886,8 +886,8 @@ fn main() {
     // Equivalent to 'std::iter::range_step(0, 10, 2);'
     range_step(0, 10, 2);
 
-    // Equivalent to 'foo(vec![std::option::Some(1.0), std::option::None]);'
-    foo(vec![Some(1.0), None]);
+    // Equivalent to 'foo(~[std::option::Some(1.0), std::option::None]);'
+    foo(~[Some(1.0), None]);
 }
 ~~~~
 
@@ -995,8 +995,8 @@ the function name.
 fn iter<T>(seq: &[T], f: |T|) {
     for elt in seq.iter() { f(elt); }
 }
-fn map<T, U>(seq: &[T], f: |T| -> U) -> Vec<U> {
-    let mut acc = vec![];
+fn map<T, U>(seq: &[T], f: |T| -> U) -> ~[U] {
+    let mut acc = ~[];
     for elt in seq.iter() { acc.push(f(elt)); }
     acc
 }
@@ -1159,19 +1159,19 @@ except that they have the `extern` modifier.
 
 ~~~~
 // Declares an extern fn, the ABI defaults to "C"
-extern fn new_int() -> int { 0 }
+extern fn new_vec() -> ~[int] { ~[] }
 
 // Declares an extern fn with "stdcall" ABI
-extern "stdcall" fn new_int_stdcall() -> int { 0 }
+extern "stdcall" fn new_vec_stdcall() -> ~[int] { ~[] }
 ~~~~
 
 Unlike normal functions, extern fns have an `extern "ABI" fn()`.
 This is the same type as the functions declared in an extern
 block.
 
 ~~~~
-# extern fn new_int() -> int { 0 }
-let fptr: extern "C" fn() -> int = new_int;
+# extern fn new_vec() -> ~[int] { ~[] }
+let fptr: extern "C" fn() -> ~[int] = new_vec;
 ~~~~
 
 Extern functions may be called directly from Rust code as Rust uses large,
@@ -1436,7 +1436,7 @@ trait Circle : Shape { fn radius() -> f64; }
 ~~~~
 
 the syntax `Circle : Shape` means that types that implement `Circle` must also have an implementation for `Shape`.
-Multiple supertraits are separated by `+`, `trait Circle : Shape + PartialEq { }`.
+Multiple supertraits are separated by `+`, `trait Circle : Shape + Eq { }`.
 In an implementation of `Circle` for a given type `T`, methods can refer to `Shape` methods,
 since the typechecker checks that any type with an implementation of `Circle` also has an implementation of `Shape`.
 
@@ -1509,7 +1509,7 @@ Implementation parameters are written after the `impl` keyword.
 
 ~~~~
 # trait Seq<T> { }
-impl<T> Seq<T> for Vec<T> {
+impl<T> Seq<T> for ~[T] {
    /* ... */
 }
 impl Seq<bool> for u32 {
@@ -2159,23 +2159,23 @@ There are three different types of inline attributes:
 
 The `deriving` attribute allows certain traits to be automatically
 implemented for data structures. For example, the following will
-create an `impl` for the `PartialEq` and `Clone` traits for `Foo`, the type
-parameter `T` will be given the `PartialEq` or `Clone` constraints for the
+create an `impl` for the `Eq` and `Clone` traits for `Foo`, the type
+parameter `T` will be given the `Eq` or `Clone` constraints for the
 appropriate `impl`:
 
 ~~~~
-#[deriving(PartialEq, Clone)]
+#[deriving(Eq, Clone)]
 struct Foo<T> {
     a: int,
     b: T
 }
 ~~~~
 
-The generated `impl` for `PartialEq` is equivalent to
+The generated `impl` for `Eq` is equivalent to
 
 ~~~~
 # struct Foo<T> { a: int, b: T }
-impl<T: PartialEq> PartialEq for Foo<T> {
+impl<T: Eq> Eq for Foo<T> {
     fn eq(&self, other: &Foo<T>) -> bool {
         self.a == other.a && self.b == other.b
     }
@@ -2188,7 +2188,7 @@ impl<T: PartialEq> PartialEq for Foo<T> {
 
 Supported traits for `deriving` are:
 
-* Comparison traits: `PartialEq`, `TotalEq`, `PartialOrd`, `TotalOrd`.
+* Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
 * Serialization: `Encodable`, `Decodable`. These require `serialize`.
 * `Clone`, to create `T` from `&T` via a copy.
 * `Hash`, to iterate over the bytes in a data type.
@@ -2734,22 +2734,22 @@ The default meaning of the operators on standard types is given here.
 
 * `==`
   : Equal to.
-    Calls the `eq` method on the `std::cmp::PartialEq` trait.
+    Calls the `eq` method on the `std::cmp::Eq` trait.
 * `!=`
   : Unequal to.
-    Calls the `ne` method on the `std::cmp::PartialEq` trait.
+    Calls the `ne` method on the `std::cmp::Eq` trait.
 * `<`
   : Less than.
-    Calls the `lt` method on the `std::cmp::PartialOrd` trait.
+    Calls the `lt` method on the `std::cmp::Ord` trait.
 * `>`
   : Greater than.
-    Calls the `gt` method on the `std::cmp::PartialOrd` trait.
+    Calls the `gt` method on the `std::cmp::Ord` trait.
 * `<=`
   : Less than or equal.
-    Calls the `le` method on the `std::cmp::PartialOrd` trait.
+    Calls the `le` method on the `std::cmp::Ord` trait.
 * `>=`
   : Greater than or equal.
-    Calls the `ge` method on the `std::cmp::PartialOrd` trait.
+    Calls the `ge` method on the `std::cmp::Ord` trait.
 
 #### Type cast expressions
 
@@ -3347,7 +3347,7 @@ Such a definite-sized vector type is a first-class type, since its size is known
 A vector without such a size is said to be of _indefinite_ size,
 and is therefore not a _first-class_ type.
 An indefinite-size vector can only be instantiated through a pointer type,
-such as `&[T]` or `Vec<T>`.
+such as `&[T]` or `~[T]`.
 The kind of a vector type depends on the kind of its element type,
 as with other simple structural types.