---

yaml
---
r: 56703
b: refs/heads/try
c: 28f0782
h: refs/heads/master
i:
  56701: 7f7ac4b
  56699: 7b09b1f
  56695: e662760
  56687: b59ca77
  56671: 878e652
  56639: 27c16bd
  56575: d8da569
v: v3

Author: huonw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c081ffbd1e845687202a975ea2e698b623e5722f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 79a2b2eafc3c766cecec8a5f76317693bae9ed17
-refs/heads/try: 614d6da828969389871e01d1b8a17b3ccc1a5caa
+refs/heads/try: 28f0782260ca2e83edd79aeb37888be3e45d23b1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/tutorial.md

@@ -1067,28 +1067,6 @@ let mut d = @mut 5; // mutable variable, mutable box
 d = @mut 15;
 ~~~~
 
-A mutable variable and an immutable variable can refer to the same box, given 
-that their types are compatible. Mutability of a box is a property of its type, 
-however, so for example a mutable handle to an immutable box cannot be 
-assigned a reference to a mutable box.
-
-~~~~
-let a = @1;     // immutable box
-let b = @mut 2; // mutable box
-
-let mut c : @int;       // declare a variable with type managed immutable int
-let mut d : @mut int;   // and one of type managed mutable int
-
-c = a;          // box type is the same, okay
-d = b;          // box type is the same, okay
-~~~~
-
-~~~~ {.xfail-test}
-// but b cannot be assigned to c, or a to d
-c = b;          // error
-~~~~
-
-
 # Move semantics
 
 Rust uses a shallow copy for parameter passing, assignment and returning values
@@ -1103,16 +1081,6 @@ let y = x.clone(); // y is a newly allocated box
 let z = x; // no new memory allocated, x can no longer be used
 ~~~~
 
-Since in owned boxes mutability is a property of the owner, not the 
-box, mutable boxes may become immutable when they are moved, and vice-versa.
-
-~~~~
-let r = ~13;
-let mut s = r; // box becomes mutable
-*s += 1;
-let t = s; // box becomes immutable
-~~~~
-
 # Borrowed pointers
 
 Rust's borrowed pointers are a general purpose reference type. In contrast with

branches/try/src/librustc/util/ppaux.rs

@@ -248,7 +248,7 @@ pub fn trait_store_to_str(cx: ctxt, s: ty::TraitStore) -> ~str {
 pub fn vstore_ty_to_str(cx: ctxt, ty: ~str, vs: ty::vstore) -> ~str {
     match vs {
       ty::vstore_fixed(_) => {
-        fmt!("[%s * %s]", ty, vstore_to_str(cx, vs))
+        fmt!("[%s, .. %s]", ty, vstore_to_str(cx, vs))
       }
       ty::vstore_slice(_) => {
         fmt!("%s %s", vstore_to_str(cx, vs), ty)

branches/try/src/test/compile-fail/issue-2149.rs

@@ -22,6 +22,6 @@ impl<A> vec_monad<A> for ~[A] {
 }
 fn main() {
     ["hi"].bind(|x| [x] );
-    //~^ ERROR type `[&'static str * 1]` does not implement any method in scope named `bind`
+    //~^ ERROR type `[&'static str, .. 1]` does not implement any method in scope named `bind`
     //~^^ ERROR Unconstrained region variable
 }

branches/try/src/test/compile-fail/issue-4517.rs

@@ -2,5 +2,5 @@ fn bar(int_param: int) {}
 
 fn main() {
      let foo: [u8, ..4] = [1u8, ..4u8];
-     bar(foo); //~ ERROR mismatched types: expected `int` but found `[u8 * 4]` (expected int but found vector)
+     bar(foo); //~ ERROR mismatched types: expected `int` but found `[u8, .. 4]` (expected int but found vector)
 }