---

yaml
---
r: 24166
b: refs/heads/master
c: 264e1b2
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: a7db161eed68566db4ab8502f73e397fdf6b8e7c
+refs/heads/master: 264e1b2edbba5fcb4dc0866fa168f434fe54876b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/libcore/at_vec.rs

@@ -4,6 +4,7 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+use cast::transmute;
 use ptr::addr_of;
 
 /// Code for dealing with @-vectors. This is pretty incomplete, and
@@ -48,10 +49,10 @@ pub pure fn capacity<T>(v: @[const T]) -> uint {
 #[inline(always)]
 pub pure fn build_sized<A>(size: uint,
                            builder: &fn(push: pure fn(+v: A))) -> @[A] {
-    let mut vec = @[];
-    unsafe { raw::reserve(vec, size); }
-    builder(|+x| unsafe { raw::push(vec, move x) });
-    return vec;
+    let mut vec: @[const A] = @[];
+    unsafe { raw::reserve(&mut vec, size); }
+    builder(|+x| unsafe { raw::push(&mut vec, move x) });
+    return unsafe { transmute(vec) };
 }
 
 /**
@@ -125,10 +126,10 @@ pub pure fn from_fn<T>(n_elts: uint, op: iter::InitOp<T>) -> @[T] {
  * Creates an immutable vector of size `n_elts` and initializes the elements
  * to the value `t`.
  */
-pub pure fn from_elem<T: Copy>(n_elts: uint, t: &T) -> @[T] {
+pub pure fn from_elem<T: Copy>(n_elts: uint, +t: T) -> @[T] {
     do build_sized(n_elts) |push| {
         let mut i: uint = 0u;
-        while i < n_elts { push(copy *t); i += 1u; }
+        while i < n_elts { push(copy t); i += 1u; }
     }
 }
 
@@ -165,8 +166,8 @@ pub mod raw {
     }
 
     #[inline(always)]
-    pub unsafe fn push<T>(v: @[const T], +initval: T) {
-        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(v));
+    pub unsafe fn push<T>(v: &mut @[const T], +initval: T) {
+        let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         if (**repr).unboxed.alloc > fill {
             push_fast(v, move initval);
@@ -177,16 +178,16 @@ pub mod raw {
     }
     // This doesn't bother to make sure we have space.
     #[inline(always)] // really pretty please
-    pub unsafe fn push_fast<T>(v: @[const T], +initval: T) {
-        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(v));
+    pub unsafe fn push_fast<T>(v: &mut @[const T], +initval: T) {
+        let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
         let p = ptr::addr_of((**repr).unboxed.data);
         let p = ptr::offset(p, fill) as *mut T;
         rusti::move_val_init(*p, move initval);
     }
 
-    pub unsafe fn push_slow<T>(v: @[const T], +initval: T) {
+    pub unsafe fn push_slow<T>(v: &mut @[const T], +initval: T) {
         reserve_at_least(v, v.len() + 1u);
         push_fast(v, move initval);
     }
@@ -202,10 +203,10 @@ pub mod raw {
      * * v - A vector
      * * n - The number of elements to reserve space for
      */
-    pub unsafe fn reserve<T>(v: @[const T], n: uint) {
+    pub unsafe fn reserve<T>(v: &mut @[const T], n: uint) {
         // Only make the (slow) call into the runtime if we have to
-        if capacity(v) < n {
-            let ptr = addr_of(v) as **VecRepr;
+        if capacity(*v) < n {
+            let ptr: **VecRepr = transmute(copy v);
             rustrt::vec_reserve_shared_actual(sys::get_type_desc::<T>(),
                                               ptr, n as libc::size_t);
         }
@@ -226,7 +227,7 @@ pub mod raw {
      * * v - A vector
      * * n - The number of elements to reserve space for
      */
-    pub unsafe fn reserve_at_least<T>(v: @[const T], n: uint) {
+    pub unsafe fn reserve_at_least<T>(v: &mut @[const T], n: uint) {
         reserve(v, uint::next_power_of_two(n));
     }
 

trunk/src/libstd/arena.rs

@@ -70,9 +70,9 @@ struct Arena {
 }
 
 fn chunk(size: uint, is_pod: bool) -> Chunk {
-    let mut v = @[];
-    unsafe { at_vec::raw::reserve(v, size); }
-    { data: v, mut fill: 0u, is_pod: is_pod }
+    let mut v: @[const u8] = @[];
+    unsafe { at_vec::raw::reserve(&mut v, size); }
+    { data: unsafe { cast::transmute(v) }, mut fill: 0u, is_pod: is_pod }
 }
 
 fn arena_with_size(initial_size: uint) -> Arena {