---

yaml
---
r: 42958
b: refs/heads/try
c: 7d5322c
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 19dfec2aaf746535de1521f68421f9980dbf25de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
-refs/heads/try: e08a805b306398b316a489f76960569ac19b25b2
+refs/heads/try: 7d5322cf09900816d40618b70d329b8bd386ee3b
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/doc/rust.md

@@ -1719,12 +1719,15 @@ vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 
 A [_vector_](#vector-types) _expression_ is written by enclosing zero or
 more comma-separated expressions of uniform type in square brackets.
+The keyword `mut` can be written after the opening bracket to
+indicate that the elements of the resulting vector may be mutated.
+When no mutability is specified, the vector is immutable.
 
 ~~~~
 [1, 2, 3, 4];
 ["a", "b", "c", "d"];
 [0, ..128];             // vector with 128 zeros
-[0u8, 0u8, 0u8, 0u8];
+[mut 0u8, 0u8, 0u8, 0u8];
 ~~~~
 
 ### Index expressions
@@ -1746,6 +1749,7 @@ task in a _failing state_.
 # do task::spawn_unlinked {
 
 ([1, 2, 3, 4])[0];
+([mut 'x', 'y'])[1] = 'z';
 (["a", "b"])[10]; // fails
 
 # }
@@ -1908,8 +1912,8 @@ No allocation or destruction is entailed.
 An example of three different swap expressions:
 
 ~~~~~~~~
-# let mut x = &mut [0];
-# let mut a = &mut [0];
+# let mut x = &[mut 0];
+# let mut a = &[mut 0];
 # let i = 0;
 # let y = {mut z: 0};
 # let b = {mut c: 0};
@@ -2004,11 +2008,11 @@ the unary copy operator is typically only used to cause an argument to a functio
 An example of a copy expression:
 
 ~~~~
-fn mutate(mut vec: ~[int]) {
+fn mutate(vec: ~[mut int]) {
    vec[0] = 10;
 }
 
-let v = ~[1,2,3];
+let v = ~[mut 1,2,3];
 
 mutate(copy v);   // Pass a copy
 

branches/try/doc/tutorial.md

@@ -1795,7 +1795,7 @@ Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 type Set<T> = HashMap<T, ()>;
 
 struct Stack<T> {
-    elements: ~[T]
+    elements: ~[mut T]
 }
 
 enum Option<T> {

branches/try/src/libcore/io.rs

@@ -490,25 +490,25 @@ pub fn FILERes(f: *libc::FILE) -> FILERes {
     }
 }
 
-pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> Reader {
+pub fn FILE_reader(f: *libc::FILE, cleanup: bool) -> @Reader {
     if cleanup {
-        Wrapper { base: f, cleanup: FILERes(f) } as Reader
+        @Wrapper { base: f, cleanup: FILERes(f) } as @Reader
     } else {
-        f as Reader
+        @f as @Reader
     }
 }
 
 // FIXME (#2004): this should either be an trait-less impl, a set of
 // top-level functions that take a reader, or a set of default methods on
 // reader (which can then be called reader)
 
-pub fn stdin() -> Reader {
+pub fn stdin() -> @Reader {
     unsafe {
-        rustrt::rust_get_stdin() as Reader
+        rustrt::rust_get_stdin() as @Reader
     }
 }
 
-pub fn file_reader(path: &Path) -> Result<Reader, ~str> {
+pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
     unsafe {
         let f = os::as_c_charp(path.to_str(), |pathbuf| {
             os::as_c_charp("r", |modebuf|
@@ -555,11 +555,11 @@ impl BytesReader: Reader {
     fn tell(&self) -> uint { self.pos }
 }
 
-pub pure fn with_bytes_reader<t>(bytes: &[u8], f: fn(Reader) -> t) -> t {
-    f(BytesReader { bytes: bytes, pos: 0u } as Reader)
+pub pure fn with_bytes_reader<t>(bytes: &[u8], f: fn(@Reader) -> t) -> t {
+    f(@BytesReader { bytes: bytes, pos: 0u } as @Reader)
 }
 
-pub pure fn with_str_reader<T>(s: &str, f: fn(Reader) -> T) -> T {
+pub pure fn with_str_reader<T>(s: &str, f: fn(@Reader) -> T) -> T {
     str::byte_slice(s, |bytes| with_bytes_reader(bytes, f))
 }
 

branches/try/src/libcore/num/f32.rs

@@ -439,7 +439,7 @@ pub pure fn to_str_digits(num: f32, dig: uint) -> ~str {
 
 impl f32: to_str::ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
+    pure fn to_str() -> ~str { to_str_digits(self, 8) }
 }
 
 impl f32: num::ToStrRadix {

branches/try/src/libcore/num/f64.rs

@@ -463,7 +463,7 @@ pub pure fn to_str_digits(num: f64, dig: uint) -> ~str {
 
 impl f64: to_str::ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
+    pure fn to_str() -> ~str { to_str_digits(self, 8) }
 }
 
 impl f64: num::ToStrRadix {

branches/try/src/libcore/num/float.rs

@@ -206,7 +206,7 @@ pub pure fn to_str_digits(num: float, digits: uint) -> ~str {
 
 impl float: to_str::ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { to_str_digits(*self, 8) }
+    pure fn to_str() -> ~str { to_str_digits(self, 8) }
 }
 
 impl float: num::ToStrRadix {

branches/try/src/libcore/num/int-template.rs

@@ -287,8 +287,8 @@ pub pure fn str(i: T) -> ~str { to_str(i) }
 
 impl T : ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str {
-        to_str(*self)
+    pure fn to_str() -> ~str {
+        to_str(self)
     }
 }
 

branches/try/src/libcore/num/uint-template.rs

@@ -249,8 +249,8 @@ pub pure fn str(i: T) -> ~str { to_str(i) }
 
 impl T : ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str {
-        to_str(*self)
+    pure fn to_str() -> ~str {
+        to_str(self)
     }
 }
 

branches/try/src/libcore/path.rs

@@ -368,7 +368,7 @@ impl Path {
 }
 
 impl PosixPath : ToStr {
-    pure fn to_str(&self) -> ~str {
+    pure fn to_str() -> ~str {
         let mut s = ~"";
         if self.is_absolute {
             s += "/";
@@ -531,7 +531,7 @@ impl PosixPath : GenericPath {
 
 
 impl WindowsPath : ToStr {
-    pure fn to_str(&self) -> ~str {
+    pure fn to_str() -> ~str {
         let mut s = ~"";
         match self.host {
           Some(ref h) => { s += "\\\\"; s += *h; }

branches/try/src/libcore/to_str.rs

@@ -22,68 +22,52 @@ use kinds::Copy;
 use str;
 use vec;
 
-pub trait ToStr {
-    pure fn to_str(&self) -> ~str;
-}
+pub trait ToStr { pub pure fn to_str() -> ~str; }
 
 impl bool: ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { ::bool::to_str(*self) }
+    pure fn to_str() -> ~str { ::bool::to_str(self) }
 }
 impl (): ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { ~"()" }
+    pure fn to_str() -> ~str { ~"()" }
 }
 impl ~str: ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { copy *self }
+    pure fn to_str() -> ~str { copy self }
 }
 impl &str: ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { ::str::from_slice(*self) }
+    pure fn to_str() -> ~str { ::str::from_slice(self) }
 }
 impl @str: ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { ::str::from_slice(*self) }
+    pure fn to_str() -> ~str { ::str::from_slice(self) }
 }
 
-impl<A: ToStr, B: ToStr> (A, B): ToStr {
+impl<A: ToStr Copy, B: ToStr Copy> (A, B): ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str {
-        // FIXME(#4760): this causes an llvm assertion
-        //let &(ref a, ref b) = self;
-        match *self {
-            (ref a, ref b) => {
-                ~"(" + a.to_str() + ~", " + b.to_str() + ~")"
-            }
-        }
+    pure fn to_str() -> ~str {
+        let (a, b) = self;
+        ~"(" + a.to_str() + ~", " + b.to_str() + ~")"
     }
 }
-impl<A: ToStr, B: ToStr, C: ToStr> (A, B, C): ToStr {
+impl<A: ToStr Copy, B: ToStr Copy, C: ToStr Copy> (A, B, C): ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str {
-        // FIXME(#4760): this causes an llvm assertion
-        //let &(ref a, ref b, ref c) = self;
-        match *self {
-            (ref a, ref b, ref c) => {
-                fmt!("(%s, %s, %s)",
-                    (*a).to_str(),
-                    (*b).to_str(),
-                    (*c).to_str()
-                )
-            }
-        }
+    pure fn to_str() -> ~str {
+        let (a, b, c) = self;
+        ~"(" + a.to_str() + ~", " + b.to_str() + ~", " + c.to_str() + ~")"
     }
 }
 
 impl<A: ToStr> ~[A]: ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str {
+    pure fn to_str() -> ~str {
         unsafe {
             // Bleh -- not really unsafe
             // push_str and push_char
             let mut acc = ~"[", first = true;
-            for self.each |elt| {
+            for vec::each(self) |elt| {
                 unsafe {
                     if first { first = false; }
                     else { str::push_str(&mut acc, ~", "); }
@@ -98,11 +82,11 @@ impl<A: ToStr> ~[A]: ToStr {
 
 impl<A: ToStr> @A: ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { ~"@" + (**self).to_str() }
+    pure fn to_str() -> ~str { ~"@" + (*self).to_str() }
 }
 impl<A: ToStr> ~A: ToStr {
     #[inline(always)]
-    pure fn to_str(&self) -> ~str { ~"~" + (**self).to_str() }
+    pure fn to_str() -> ~str { ~"~" + (*self).to_str() }
 }
 
 #[cfg(test)]

branches/try/src/libfuzzer/cycles.rs

@@ -43,7 +43,7 @@ type pointy = {
     mut g : fn~()->(),
 
     mut m : ~[maybe_pointy],
-    mut n : ~[maybe_pointy],
+    mut n : ~[mut maybe_pointy],
     mut o : {x : int, y : maybe_pointy}
 };
 // To add: objects; traits; anything type-parameterized?
@@ -58,7 +58,7 @@ fn empty_pointy() -> @pointy {
         mut g : fn~()->(){},
 
         mut m : ~[],
-        mut n : ~[],
+        mut n : ~[mut],
         mut o : {x : 0, y : none}
     }
 }
@@ -68,7 +68,7 @@ fn nop<T>(_x: T) { }
 
 fn test_cycles(r : rand::rng, k: uint, n: uint)
 {
-    let mut v : ~[@pointy] = ~[];
+    let v : ~[mut @pointy] = ~[mut];
 
     // Create a graph with no edges
     range(0u, vlen) {|_i|

branches/try/src/libfuzzer/rand_util.rs

@@ -25,7 +25,7 @@ fn choice<T: copy>(r : rand::rng, v : ~[T]) -> T {
 fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u }
 
 // shuffle a vec in place
-fn shuffle<T>(r : rand::rng, &v : ~[T]) {
+fn shuffle<T>(r : rand::rng, &v : ~[mut T]) {
     let i = vec::len(v);
     while i >= 2u {
         // Loop invariant: elements with index >= i have been locked in place.
@@ -86,7 +86,7 @@ fn main()
     log(error, choice(r, ~[10, 20, 30]));
     log(error, if unlikely(r, 5u) { "unlikely" } else { "likely" });
 
-    let mut a = ~[1, 2, 3];
+    let a = ~[mut 1, 2, 3];
     shuffle(r, a);
     log(error, a);
 

branches/try/src/librustc/middle/liveness.rs

@@ -222,11 +222,11 @@ pub fn check_crate(tcx: ty::ctxt,
 }
 
 impl LiveNode: to_str::ToStr {
-    pure fn to_str(&self) -> ~str { fmt!("ln(%u)", **self) }
+    pure fn to_str() -> ~str { fmt!("ln(%u)", *self) }
 }
 
 impl Variable: to_str::ToStr {
-    pure fn to_str(&self) -> ~str { fmt!("v(%u)", **self) }
+    pure fn to_str() -> ~str { fmt!("v(%u)", *self) }
 }
 
 // ______________________________________________________________________

branches/try/src/librustc/middle/trans/closure.rs

@@ -121,8 +121,8 @@ pub struct EnvValue {
 }
 
 pub impl EnvAction {
-    fn to_str(&self) -> ~str {
-        match *self {
+    fn to_str() -> ~str {
+        match self {
             EnvCopy => ~"EnvCopy",
             EnvMove => ~"EnvMove",
             EnvRef => ~"EnvRef"

branches/try/src/librustc/middle/trans/common.rs

@@ -720,7 +720,7 @@ pub impl block {
     fn ty_to_str(t: ty::t) -> ~str {
         ty_to_str(self.tcx(), t)
     }
-    fn to_str(&self) -> ~str {
+    fn to_str() -> ~str {
         match self.node_info {
           Some(node_info) => {
             fmt!("[block %d]", node_info.id)

branches/try/src/librustc/middle/trans/datum.rs

@@ -841,7 +841,7 @@ pub impl DatumBlock {
         self.bcx.tcx()
     }
 
-    fn to_str(&self) -> ~str {
+    fn to_str() -> ~str {
         self.datum.to_str(self.ccx())
     }
 }