---

yaml
---
r: 42831
b: refs/heads/try
c: 0336a86
h: refs/heads/master
i:
  42829: 8661f21
  42827: 2910ee5
  42823: bad9ef0
  42815: b839827
v: v3

Author: bstrie

[refs]

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

branches/try/src/libcore/dvec.rs

@@ -46,7 +46,7 @@ use vec;
  * # WARNING
  *
  * For maximum performance, this type is implemented using some rather
- * unsafe code.  In particular, this innocent looking `~[mut A]` pointer
+ * unsafe code.  In particular, this innocent looking `~[A]` pointer
  * *may be null!*  Therefore, it is important you not reach into the
  * data structure manually but instead use the provided extensions.
  *
@@ -143,7 +143,7 @@ impl<A> DVec<A> {
      * and return a new vector to replace it with.
      */
     #[inline(always)]
-    fn swap_mut(f: &fn(v: ~[mut A]) -> ~[mut A]) {
+    fn swap_mut(f: &fn(v: ~[A]) -> ~[A]) {
         do self.swap |v| {
             vec::cast_from_mut(f(vec::cast_to_mut(move v)))
         }

branches/try/src/libcore/vec.rs

@@ -206,12 +206,12 @@ pub pure fn build_sized_opt<A>(size: Option<uint>,
 }
 
 /// Produces a mut vector from an immutable vector.
-pub pure fn cast_to_mut<T>(v: ~[T]) -> ~[mut T] {
+pub pure fn cast_to_mut<T>(v: ~[T]) -> ~[T] {
     unsafe { ::cast::transmute(v) }
 }
 
 /// Produces an immutable vector from a mut vector.
-pub pure fn cast_from_mut<T>(v: ~[mut T]) -> ~[T] {
+pub pure fn cast_from_mut<T>(v: ~[T]) -> ~[T] {
     unsafe { ::cast::transmute(v) }
 }
 
@@ -562,7 +562,7 @@ pub fn consume<T>(v: ~[T], f: fn(uint, v: T)) {
     }
 }
 
-pub fn consume_mut<T>(v: ~[mut T], f: fn(uint, v: T)) {
+pub fn consume_mut<T>(v: ~[T], f: fn(uint, v: T)) {
     consume(vec::cast_from_mut(v), f)
 }
 
@@ -731,7 +731,7 @@ pub pure fn append_one<T>(lhs: ~[T], x: T) -> ~[T] {
 }
 
 #[inline(always)]
-pub pure fn append_mut<T: Copy>(lhs: ~[mut T], rhs: &[const T]) -> ~[mut T] {
+pub pure fn append_mut<T: Copy>(lhs: ~[T], rhs: &[const T]) -> ~[T] {
     cast_to_mut(append(cast_from_mut(lhs), rhs))
 }
 
@@ -1640,9 +1640,9 @@ pub mod traits {
         }
     }
 
-    impl<T: Copy> ~[mut T] : Add<&[const T],~[mut T]> {
+    impl<T: Copy> ~[T] : Add<&[const T],~[T]> {
         #[inline(always)]
-        pure fn add(&self, rhs: & &self/[const T]) -> ~[mut T] {
+        pure fn add(&self, rhs: & &self/[const T]) -> ~[T] {
             append_mut(copy *self, (*rhs))
         }
     }

branches/try/src/libfuzzer/cycles.rs

@@ -43,7 +43,7 @@ type pointy = {
     mut g : fn~()->(),
 
     mut m : ~[maybe_pointy],
-    mut n : ~[mut maybe_pointy],
+    mut n : ~[maybe_pointy],
     mut o : {x : int, y : maybe_pointy}
 };
 // To add: objects; traits; anything type-parameterized?

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 : ~[mut T]) {
+fn shuffle<T>(r : rand::rng, &v : ~[T]) {
     let i = vec::len(v);
     while i >= 2u {
         // Loop invariant: elements with index >= i have been locked in place.

branches/try/src/libstd/bitv.rs

@@ -109,7 +109,7 @@ struct BigBitv {
     mut storage: ~[uint]
 }
 
-fn BigBitv(storage: ~[mut uint]) -> BigBitv {
+fn BigBitv(storage: ~[uint]) -> BigBitv {
     BigBitv {storage: move storage}
 }
 

branches/try/src/libstd/map.rs

@@ -458,7 +458,7 @@ pub mod chained {
         }
     }
 
-    fn chains<K,V>(nchains: uint) -> ~[mut Option<@Entry<K,V>>] {
+    fn chains<K,V>(nchains: uint) -> ~[Option<@Entry<K,V>>] {
         vec::cast_to_mut(vec::from_elem(nchains, None))
     }
 

branches/try/src/libstd/sha1.rs

@@ -67,13 +67,13 @@ const k3: u32 = 0xCA62C1D6u32;
 /// Construct a `sha` object
 pub fn sha1() -> Sha1 {
     type Sha1State =
-        {h: ~[mut u32],
+        {h: ~[u32],
          mut len_low: u32,
          mut len_high: u32,
          mut msg_block: ~[u8],
          mut msg_block_idx: uint,
          mut computed: bool,
-         work_buf: @~[mut u32]};
+         work_buf: @~[u32]};
 
     fn add_input(st: &Sha1State, msg: &[const u8]) {
         assert (!st.computed);

branches/try/src/libstd/sort.rs

@@ -1019,7 +1019,7 @@ mod big_tests {
         tabulate_managed(low, high);
     }
 
-    fn multiplyVec<T: Copy>(arr: &[const T], num: uint) -> ~[mut T] {
+    fn multiplyVec<T: Copy>(arr: &[const T], num: uint) -> ~[T] {
         let size = arr.len();
         let res = do vec::from_fn(num) |i| {
             arr[i % size]

branches/try/src/libstd/sync.rs

@@ -92,7 +92,7 @@ fn new_sem<Q: Owned>(count: int, q: Q) -> Sem<Q> {
 }
 #[doc(hidden)]
 fn new_sem_and_signal(count: int, num_condvars: uint)
-        -> Sem<~[mut Waitqueue]> {
+        -> Sem<~[Waitqueue]> {
     let mut queues = ~[];
     for num_condvars.times {
         queues.push(new_waitqueue());
@@ -150,7 +150,7 @@ impl &Sem<()> {
     }
 }
 #[doc(hidden)]
-impl &Sem<~[mut Waitqueue]> {
+impl &Sem<~[Waitqueue]> {
     fn access<U>(blk: fn() -> U) -> U {
         let mut release = None;
         unsafe {
@@ -166,7 +166,7 @@ impl &Sem<~[mut Waitqueue]> {
 // FIXME(#3588) should go inside of access()
 #[doc(hidden)]
 type SemRelease = SemReleaseGeneric<()>;
-type SemAndSignalRelease = SemReleaseGeneric<~[mut Waitqueue]>;
+type SemAndSignalRelease = SemReleaseGeneric<~[Waitqueue]>;
 struct SemReleaseGeneric<Q> { sem: &Sem<Q> }
 
 impl<Q: Owned> SemReleaseGeneric<Q> : Drop {
@@ -181,15 +181,15 @@ fn SemRelease(sem: &r/Sem<()>) -> SemRelease/&r {
     }
 }
 
-fn SemAndSignalRelease(sem: &r/Sem<~[mut Waitqueue]>)
+fn SemAndSignalRelease(sem: &r/Sem<~[Waitqueue]>)
     -> SemAndSignalRelease/&r {
     SemReleaseGeneric {
         sem: sem
     }
 }
 
 /// A mechanism for atomic-unlock-and-deschedule blocking and signalling.
-pub struct Condvar { priv sem: &Sem<~[mut Waitqueue]> }
+pub struct Condvar { priv sem: &Sem<~[Waitqueue]> }
 
 impl Condvar : Drop { fn finalize(&self) {} }
 
@@ -259,7 +259,7 @@ impl &Condvar {
         // mutex during unwinding. As long as the wrapper (mutex, etc) is
         // bounded in when it gets released, this shouldn't hang forever.
         struct SemAndSignalReacquire {
-            sem: &Sem<~[mut Waitqueue]>,
+            sem: &Sem<~[Waitqueue]>,
         }
 
         impl SemAndSignalReacquire : Drop {
@@ -273,7 +273,7 @@ impl &Condvar {
             }
         }
 
-        fn SemAndSignalReacquire(sem: &r/Sem<~[mut Waitqueue]>)
+        fn SemAndSignalReacquire(sem: &r/Sem<~[Waitqueue]>)
             -> SemAndSignalReacquire/&r {
             SemAndSignalReacquire {
                 sem: sem
@@ -345,7 +345,7 @@ fn check_cvar_bounds<U>(out_of_bounds: Option<uint>, id: uint, act: &str,
 }
 
 #[doc(hidden)]
-impl &Sem<~[mut Waitqueue]> {
+impl &Sem<~[Waitqueue]> {
     // The only other place that condvars get built is rwlock_write_mode.
     fn access_cond<U>(blk: fn(c: &Condvar) -> U) -> U {
         do self.access { blk(&Condvar { sem: self }) }
@@ -400,7 +400,7 @@ impl &Semaphore {
  * A task which fails while holding a mutex will unlock the mutex as it
  * unwinds.
  */
-struct Mutex { priv sem: Sem<~[mut Waitqueue]> }
+struct Mutex { priv sem: Sem<~[Waitqueue]> }
 
 /// Create a new mutex, with one associated condvar.
 pub fn Mutex() -> Mutex { mutex_with_condvars(1) }
@@ -450,7 +450,7 @@ struct RWlockInner {
  */
 struct RWlock {
     priv order_lock:  Semaphore,
-    priv access_lock: Sem<~[mut Waitqueue]>,
+    priv access_lock: Sem<~[Waitqueue]>,
     priv state:       Exclusive<RWlockInner>
 }
 

branches/try/src/libsyntax/print/pp.rs

@@ -119,7 +119,7 @@ pub fn tok_str(++t: token) -> ~str {
     }
 }
 
-pub fn buf_str(toks: ~[mut token], szs: ~[mut int], left: uint, right: uint,
+pub fn buf_str(toks: ~[token], szs: ~[int], left: uint, right: uint,
                lim: uint) -> ~str {
     let n = vec::len(toks);
     assert (n == vec::len(szs));

branches/try/src/test/bench/sudoku.rs

@@ -32,7 +32,7 @@ use io::{ReaderUtil, WriterUtil};
 export grid_t, read_grid, solve_grid, write_grid;
 
 // internal type of sudoku grids
-type grid = ~[~[mut u8]];
+type grid = ~[~[u8]];
 
 // exported type of sudoku grids
 enum grid_t { grid_ctor(grid), }

branches/try/src/test/compile-fail/borrowck-mut-vec-as-imm-slice-bad.rs

@@ -14,11 +14,11 @@ fn want_slice(v: &[int]) -> int {
     return sum;
 }
 
-fn has_mut_vec(+v: @~[mut int]) -> int {
+fn has_mut_vec(+v: @~[int]) -> int {
     want_slice(*v) //~ ERROR illegal borrow unless pure
         //~^ NOTE impure due to access to impure function
 }
 
 fn main() {
-    assert has_mut_vec(@~[mut 1, 2, 3]) == 6;
+    assert has_mut_vec(@~[1, 2, 3]) == 6;
 }

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

@@ -34,7 +34,7 @@ fn main() {
         let mut res = foo(x);
 
         let mut v = ~[];
-        v = move ~[mut (move res)] + v; //~ ERROR instantiating a type parameter with an incompatible type (needs `copy`, got `&static`, missing `copy`)
+        v = move ~[(move res)] + v; //~ ERROR instantiating a type parameter with an incompatible type (needs `copy`, got `&static`, missing `copy`)
         assert (v.len() == 2);
     }
 

branches/try/src/test/compile-fail/mutable-huh-variance-box.rs

@@ -14,7 +14,7 @@ fn main() {
     let v = @mut ~[0];
 
     fn f(&&v: @mut ~[const int]) {
-        *v = ~[mut 3]
+        *v = ~[3]
     }
 
     f(v);

branches/try/src/test/compile-fail/mutable-huh-variance-deep.rs

@@ -13,7 +13,7 @@
 fn main() {
     let mut v = ~[@mut ~mut ~[0]];
 
-    fn f(&&v: ~[mut @mut ~mut ~[const int]]) {
+    fn f(&&v: ~[@mut ~mut ~[const int]]) {
     }
 
     f(v);

branches/try/src/test/compile-fail/mutable-huh-variance-ptr.rs

@@ -18,7 +18,7 @@ fn main() {
 
     fn f(&&v: *mut ~[const int]) {
         unsafe {
-            *v = ~[mut 3]
+            *v = ~[3]
         }
     }
 

branches/try/src/test/compile-fail/mutable-huh-variance-rec.rs

@@ -14,7 +14,7 @@ fn main() {
     let v = {mut g: ~[0]};
 
     fn f(&&v: {mut g: ~[const int]}) {
-        v.g = ~[mut 3]
+        v.g = ~[3]
     }
 
     f(v);

branches/try/src/test/compile-fail/mutable-huh-variance-unique.rs

@@ -14,7 +14,7 @@ fn main() {
     let v = ~mut ~[0];
 
     fn f(&&v: ~mut ~[const int]) {
-        *v = ~[mut 3]
+        *v = ~[3]
     }
 
     f(v);

branches/try/src/test/compile-fail/mutable-huh-variance-vec1.rs

@@ -11,11 +11,11 @@
 fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
-    // and assigns a type of ~[mut ~[const int]].
+    // and assigns a type of ~[~[const int]].
     let mut v: ~[~[int]] = ~[~[0]];
 
-    fn f(&&v: ~[mut ~[const int]]) {
-        v[0] = ~[mut 3]
+    fn f(&&v: ~[~[const int]]) {
+        v[0] = ~[3]
     }
 
     f(v); //~ ERROR (values differ in mutability)

branches/try/src/test/compile-fail/mutable-huh-variance-vec2.rs

@@ -11,10 +11,10 @@
 fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
-    // and assigns a type of ~[mut ~[const int]].
-    let mut v: ~[~[mut int]] = ~[~[0]];
+    // and assigns a type of ~[~[const int]].
+    let mut v: ~[~[int]] = ~[~[0]];
 
-    fn f(&&v: ~[mut ~[const int]]) {
+    fn f(&&v: ~[~[const int]]) {
         v[0] = ~[3]
     }
 

branches/try/src/test/compile-fail/mutable-huh-variance-vec3.rs

@@ -11,11 +11,11 @@
 fn main() {
     // Note: explicit type annot is required here
     // because otherwise the inference gets smart
-    // and assigns a type of ~[mut ~[const int]].
-    let mut v: ~[~[mut ~[int]]] = ~[~[~[0]]];
+    // and assigns a type of ~[~[const int]].
+    let mut v: ~[~[~[int]]] = ~[~[~[0]]];
 
-    fn f(&&v: ~[mut ~[mut ~[const int]]]) {
-        v[0][1] = ~[mut 3]
+    fn f(&&v: ~[~[~[const int]]]) {
+        v[0][1] = ~[3]
     }
 
     f(v); //~ ERROR (values differ in mutability)

branches/try/src/test/compile-fail/mutable-huh-variance-vec4.rs

@@ -17,19 +17,19 @@ fn main() {
     let mut w = ~[~[0]];
     let mut x = ~[~[0]];
 
-    fn f(&&v: ~[mut ~[int]]) {
+    fn f(&&v: ~[~[int]]) {
         v[0] = ~[3]
     }
 
     fn g(&&v: ~[const ~[const int]]) {
     }
 
-    fn h(&&v: ~[mut ~[mut int]]) {
-        v[0] = ~[mut 3]
+    fn h(&&v: ~[~[int]]) {
+        v[0] = ~[3]
     }
 
-    fn i(&&v: ~[mut ~[const int]]) {
-        v[0] = ~[mut 3]
+    fn i(&&v: ~[~[const int]]) {
+        v[0] = ~[3]
     }
 
     fn j(&&v: ~[~[const int]]) {
@@ -48,7 +48,7 @@ fn main() {
     j(w); //~ ERROR (values differ in mutability)
 
     // Note that without adding f() or h() to the mix, it is valid for
-    // x to have the type ~[mut ~[const int]], and thus we can safely
+    // x to have the type ~[~[const int]], and thus we can safely
     // call g() and i() but not j():
     g(x);
     i(x);

branches/try/src/test/compile-fail/non-const.rs

@@ -44,7 +44,7 @@ fn main() {
     foo({f: 3});
     foo({mut f: 3}); //~ ERROR missing `const`
     foo(~[1]);
-    foo(~[mut 1]); //~ ERROR missing `const`
+    foo(~[1]); //~ ERROR missing `const`
     foo(~1);
     foo(~mut 1); //~ ERROR missing `const`
     foo(@1);