---

yaml
---
r: 54536
b: refs/heads/snap-stage3
c: f678d63
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 28f0782260ca2e83edd79aeb37888be3e45d23b1
+refs/heads/snap-stage3: f678d63507a779d81810c342dd1bdc828fb983ba
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial.md

@@ -1067,6 +1067,28 @@ 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
@@ -1081,6 +1103,16 @@ 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/snap-stage3/src/librust/rust.rc

@@ -64,7 +64,7 @@ static commands: &'static [Command<'static>] = &[
     Command{
         cmd: "run",
         action: Call(cmd_run),
-        usage_line: "build a executable, and run it",
+        usage_line: "build an executable, and run it",
         usage_full: UsgStr(
             "The run command is an shortcut for the command line \n\
              \"rustc <filename> -o <filestem>~ && ./<filestem>~\".\

branches/snap-stage3/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/snap-stage3/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/snap-stage3/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)
 }