---

yaml
---
r: 114011
b: refs/heads/master
c: a40b971
h: refs/heads/master
i:
  114009: e716b0a
  114007: 2b66b0f
v: v3

Author: SSheldon

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f483aa3a91ff9baf290ddf22209b984ec1f74b0c
+refs/heads/master: a40b971aaf64f9ba189ac07eebf1890d995ae2dc
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/src/doc/guide-unsafe.md

@@ -66,11 +66,11 @@ restrictions is undefined behaviour. For example, the following
 creates two aliasing `&mut` pointers, and is invalid.
 
 ```
-use std::mem;
+use std::cast;
 let mut x: u8 = 1;
 
 let ref_1: &mut u8 = &mut x;
-let ref_2: &mut u8 = unsafe { mem::transmute(&mut *ref_1) };
+let ref_2: &mut u8 = unsafe { cast::transmute_mut_lifetime(ref_1) };
 
 // oops, ref_1 and ref_2 point to the same piece of data (x) and are
 // both usable

trunk/src/doc/rust.md

@@ -1402,7 +1402,7 @@ to pointers to the trait name, used as a type.
 let myshape: Box<Shape> = box mycircle as Box<Shape>;
 ~~~~
 
-The resulting value is a box containing the value that was cast,
+The resulting value is a managed box containing the value that was cast,
 along with information that identifies the methods of the implementation that was used.
 Values with a trait type can have [methods called](#method-call-expressions) on them,
 for any method in the trait,

trunk/src/doc/tutorial.md

@@ -2385,7 +2385,7 @@ fn print_all<T: Printable>(printable_things: ~[T]) {
 Declaring `T` as conforming to the `Printable` trait (as we earlier
 did with `Clone`) makes it possible to call methods from that trait
 on values of type `T` inside the function. It will also cause a
-compile-time error when anyone tries to call `print_all` on a vector
+compile-time error when anyone tries to call `print_all` on an array
 whose element type does not have a `Printable` implementation.
 
 Type parameters can have multiple bounds by separating them with `+`,
@@ -2428,9 +2428,9 @@ fn draw_all<T: Drawable>(shapes: ~[T]) {
 # draw_all(~[c]);
 ~~~~
 
-You can call that on a vector of circles, or a vector of rectangles
+You can call that on an array of circles, or an array of rectangles
 (assuming those have suitable `Drawable` traits defined), but not on
-a vector containing both circles and rectangles. When such behavior is
+an array containing both circles and rectangles. When such behavior is
 needed, a trait name can alternately be used as a type, called
 an _object_.
 

trunk/src/libarena/lib.rs

@@ -26,6 +26,8 @@
 
 extern crate collections;
 
+use std::cast::{transmute, transmute_mut_lifetime};
+use std::cast;
 use std::cell::{Cell, RefCell};
 use std::cmp;
 use std::intrinsics::{TyDesc, get_tydesc};
@@ -135,7 +137,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
     let fill = chunk.fill.get();
 
     while idx < fill {
-        let tydesc_data: *uint = mem::transmute(buf.offset(idx as int));
+        let tydesc_data: *uint = transmute(buf.offset(idx as int));
         let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
         let (size, align) = ((*tydesc).size, (*tydesc).align);
 
@@ -185,27 +187,28 @@ impl Arena {
     #[inline]
     fn alloc_copy_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
         unsafe {
-            let start = round_up(self.copy_head.fill.get(), align);
+            let this = transmute_mut_lifetime(self);
+            let start = round_up(this.copy_head.fill.get(), align);
             let end = start + n_bytes;
             if end > self.chunk_size() {
-                return self.alloc_copy_grow(n_bytes, align);
+                return this.alloc_copy_grow(n_bytes, align);
             }
-            self.copy_head.fill.set(end);
+            this.copy_head.fill.set(end);
 
             //debug!("idx = {}, size = {}, align = {}, fill = {}",
             //       start, n_bytes, align, head.fill.get());
 
-            self.copy_head.as_ptr().offset(start as int)
+            this.copy_head.as_ptr().offset(start as int)
         }
     }
 
     #[inline]
     fn alloc_copy<'a, T>(&'a mut self, op: || -> T) -> &'a T {
         unsafe {
             let ptr = self.alloc_copy_inner(mem::size_of::<T>(), min_align_of::<T>());
-            let ptr = ptr as *mut T;
+            let ptr: *mut T = transmute(ptr);
             mem::move_val_init(&mut (*ptr), op());
-            return &*ptr;
+            return transmute(ptr);
         }
     }
 
@@ -225,16 +228,26 @@ impl Arena {
     fn alloc_noncopy_inner(&mut self, n_bytes: uint, align: uint)
                           -> (*u8, *u8) {
         unsafe {
-            let tydesc_start = self.head.fill.get();
-            let after_tydesc = self.head.fill.get() + mem::size_of::<*TyDesc>();
-            let start = round_up(after_tydesc, align);
-            let end = start + n_bytes;
+            let start;
+            let end;
+            let tydesc_start;
+            let after_tydesc;
+
+            {
+                let head = transmute_mut_lifetime(&mut self.head);
+
+                tydesc_start = head.fill.get();
+                after_tydesc = head.fill.get() + mem::size_of::<*TyDesc>();
+                start = round_up(after_tydesc, align);
+                end = start + n_bytes;
+            }
 
             if end > self.head.capacity() {
                 return self.alloc_noncopy_grow(n_bytes, align);
             }
 
-            self.head.fill.set(round_up(end, mem::pref_align_of::<*TyDesc>()));
+            let head = transmute_mut_lifetime(&mut self.head);
+            head.fill.set(round_up(end, mem::pref_align_of::<*TyDesc>()));
 
             //debug!("idx = {}, size = {}, align = {}, fill = {}",
             //       start, n_bytes, align, head.fill);
@@ -250,18 +263,18 @@ impl Arena {
             let tydesc = get_tydesc::<T>();
             let (ty_ptr, ptr) =
                 self.alloc_noncopy_inner(mem::size_of::<T>(), min_align_of::<T>());
-            let ty_ptr = ty_ptr as *mut uint;
-            let ptr = ptr as *mut T;
+            let ty_ptr: *mut uint = transmute(ty_ptr);
+            let ptr: *mut T = transmute(ptr);
             // Write in our tydesc along with a bit indicating that it
             // has *not* been initialized yet.
-            *ty_ptr = mem::transmute(tydesc);
+            *ty_ptr = transmute(tydesc);
             // Actually initialize it
             mem::move_val_init(&mut(*ptr), op());
             // Now that we are done, update the tydesc to indicate that
             // the object is there.
             *ty_ptr = bitpack_tydesc_ptr(tydesc, true);
 
-            return &*ptr;
+            return transmute(ptr);
         }
     }
 
@@ -270,7 +283,7 @@ impl Arena {
     pub fn alloc<'a, T>(&'a self, op: || -> T) -> &'a T {
         unsafe {
             // FIXME #13933: Remove/justify all `&T` to `&mut T` transmutes
-            let this: &mut Arena = mem::transmute::<&_, &mut _>(self);
+            let this: &mut Arena = transmute::<&_, &mut _>(self);
             if intrinsics::needs_drop::<T>() {
                 this.alloc_noncopy(op)
             } else {
@@ -353,7 +366,7 @@ impl<T> TypedArenaChunk<T> {
 
         let mut chunk = unsafe {
             let chunk = exchange_malloc(size);
-            let mut chunk: Box<TypedArenaChunk<T>> = mem::transmute(chunk);
+            let mut chunk: Box<TypedArenaChunk<T>> = cast::transmute(chunk);
             mem::move_val_init(&mut chunk.next, next);
             chunk
         };
@@ -374,7 +387,7 @@ impl<T> TypedArenaChunk<T> {
 
         let mut chunk = unsafe {
             let chunk = exchange_malloc(size, min_align_of::<TypedArenaChunk<T>>());
-            let mut chunk: Box<TypedArenaChunk<T>> = mem::transmute(chunk);
+            let mut chunk: Box<TypedArenaChunk<T>> = cast::transmute(chunk);
             mem::move_val_init(&mut chunk.next, next);
             chunk
         };
@@ -412,7 +425,7 @@ impl<T> TypedArenaChunk<T> {
     fn start(&self) -> *u8 {
         let this: *TypedArenaChunk<T> = self;
         unsafe {
-            mem::transmute(round_up(this.offset(1) as uint, min_align_of::<T>()))
+            cast::transmute(round_up(this.offset(1) as uint, min_align_of::<T>()))
         }
     }
 
@@ -450,12 +463,12 @@ impl<T> TypedArena<T> {
     pub fn alloc<'a>(&'a self, object: T) -> &'a T {
         unsafe {
             // FIXME #13933: Remove/justify all `&T` to `&mut T` transmutes
-            let this: &mut TypedArena<T> = mem::transmute::<&_, &mut _>(self);
+            let this: &mut TypedArena<T> = cast::transmute::<&_, &mut _>(self);
             if this.ptr == this.end {
                 this.grow()
             }
 
-            let ptr: &'a mut T = mem::transmute(this.ptr);
+            let ptr: &'a mut T = cast::transmute(this.ptr);
             mem::move_val_init(ptr, object);
             this.ptr = this.ptr.offset(1);
             let ptr: &'a T = ptr;

trunk/src/libcollections/dlist.rs

@@ -21,9 +21,10 @@
 // Backlinks over DList::prev are raw pointers that form a full chain in
 // the reverse direction.
 
+use std::cast;
 use std::iter::Rev;
 use std::iter;
-use std::mem;
+use std::mem::{replace, swap};
 use std::ptr;
 
 use deque::Deque;
@@ -92,13 +93,13 @@ impl<T> Rawlink<T> {
         if self.p.is_null() {
             None
         } else {
-            Some(unsafe { mem::transmute(self.p) })
+            Some(unsafe { cast::transmute(self.p) })
         }
     }
 
     /// Return the `Rawlink` and replace with `Rawlink::none()`
     fn take(&mut self) -> Rawlink<T> {
-        mem::replace(self, Rawlink::none())
+        replace(self, Rawlink::none())
     }
 }
 
@@ -158,7 +159,7 @@ impl<T> DList<T> {
             Some(ref mut head) => {
                 new_head.prev = Rawlink::none();
                 head.prev = Rawlink::some(new_head);
-                mem::swap(head, &mut new_head);
+                swap(head, &mut new_head);
                 head.next = Some(new_head);
             }
         }
@@ -316,7 +317,7 @@ impl<T> DList<T> {
     /// O(1)
     #[inline]
     pub fn prepend(&mut self, mut other: DList<T>) {
-        mem::swap(self, &mut other);
+        swap(self, &mut other);
         self.append(other);
     }
 

trunk/src/libcollections/enum_set.rs

@@ -137,7 +137,7 @@ impl<E:CLike> Iterator<E> for Items<E> {
 #[cfg(test)]
 mod test {
 
-    use std::mem;
+    use std::cast;
 
     use enum_set::{EnumSet, CLike};
 
@@ -153,7 +153,7 @@ mod test {
         }
 
         fn from_uint(v: uint) -> Foo {
-            unsafe { mem::transmute(v) }
+            unsafe { cast::transmute(v) }
         }
     }
 

trunk/src/libcollections/hashmap.rs

@@ -30,6 +30,8 @@ use std::result::{Ok, Err};
 use std::slice::ImmutableVector;
 
 mod table {
+    extern crate libc;
+
     use std::clone::Clone;
     use std::cmp;
     use std::cmp::Eq;
@@ -40,10 +42,10 @@ mod table {
     use std::prelude::Drop;
     use std::ptr;
     use std::ptr::RawPtr;
-    use std::mem::{min_align_of, size_of};
-    use std::intrinsics::{move_val_init, set_memory, transmute};
+    use std::rt::libc_heap;
+    use std::intrinsics::{size_of, min_align_of, transmute};
+    use std::intrinsics::{move_val_init, set_memory};
     use std::iter::{Iterator, range_step_inclusive};
-    use std::rt::heap::{allocate, deallocate};
 
     static EMPTY_BUCKET: u64 = 0u64;
 
@@ -183,6 +185,10 @@ mod table {
         assert_eq!(round_up_to_next(5, 4), 8);
     }
 
+    fn has_alignment(n: uint, alignment: uint) -> bool {
+        round_up_to_next(n, alignment) == n
+    }
+
     // Returns a tuple of (minimum required malloc alignment, hash_offset,
     // key_offset, val_offset, array_size), from the start of a mallocated array.
     fn calculate_offsets(
@@ -237,7 +243,12 @@ mod table {
                     keys_size,   min_align_of::< K >(),
                     vals_size,   min_align_of::< V >());
 
-            let buffer = allocate(size, malloc_alignment);
+            let buffer = libc_heap::malloc_raw(size) as *mut u8;
+
+            // FIXME #13094: If malloc was not at as aligned as we expected,
+            // our offset calculations are just plain wrong. We could support
+            // any alignment if we switched from `malloc` to `posix_memalign`.
+            assert!(has_alignment(buffer as uint, malloc_alignment));
 
             let hashes = buffer.offset(hash_offset as int) as *mut u64;
             let keys   = buffer.offset(keys_offset as int) as *mut K;
@@ -407,7 +418,7 @@ mod table {
     // modified to no longer assume this.
     #[test]
     fn can_alias_safehash_as_u64() {
-        assert_eq!(size_of::<SafeHash>(), size_of::<u64>())
+        unsafe { assert_eq!(size_of::<SafeHash>(), size_of::<u64>()) };
     }
 
     pub struct Entries<'a, K, V> {
@@ -549,15 +560,8 @@ mod table {
 
             assert_eq!(self.size, 0);
 
-            let hashes_size = self.capacity * size_of::<u64>();
-            let keys_size = self.capacity * size_of::<K>();
-            let vals_size = self.capacity * size_of::<V>();
-            let (align, _, _, _, size) = calculate_offsets(hashes_size, min_align_of::<u64>(),
-                                                           keys_size, min_align_of::<K>(),
-                                                           vals_size, min_align_of::<V>());
-
             unsafe {
-                deallocate(self.hashes as *mut u8, size, align);
+                libc::free(self.hashes as *mut libc::c_void);
                 // Remember how everything was allocated out of one buffer
                 // during initialization? We only need one call to free here.
             }

trunk/src/libcollections/lru_cache.rs

@@ -37,6 +37,7 @@
 //! assert!(cache.get(&2).is_none());
 //! ```
 
+use std::cast;
 use std::container::Container;
 use std::hash::Hash;
 use std::fmt;
@@ -92,7 +93,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
         let cache = LruCache {
             map: HashMap::new(),
             max_size: capacity,
-            head: unsafe{ mem::transmute(box mem::uninit::<LruEntry<K, V>>()) },
+            head: unsafe{ cast::transmute(box mem::uninit::<LruEntry<K, V>>()) },
         };
         unsafe {
             (*cache.head).next = cache.head;
@@ -240,11 +241,11 @@ impl<K: Hash + TotalEq, V> Mutable for LruCache<K, V> {
 impl<K, V> Drop for LruCache<K, V> {
     fn drop(&mut self) {
         unsafe {
-            let node: Box<LruEntry<K, V>> = mem::transmute(self.head);
+            let node: Box<LruEntry<K, V>> = cast::transmute(self.head);
             // Prevent compiler from trying to drop the un-initialized field in the sigil node.
             let box LruEntry { key: k, value: v, .. } = node;
-            mem::forget(k);
-            mem::forget(v);
+            cast::forget(k);
+            cast::forget(v);
         }
     }
 }

trunk/src/libcore/any.rs

@@ -20,7 +20,7 @@
 //! value. `Box<Any>` adds the `move` method, which will unwrap a `Box<T>` from the object.  See
 //! the extension traits (`*Ext`) for the full details.
 
-use mem::{transmute, transmute_copy};
+use cast::{transmute, transmute_copy};
 use option::{Option, Some, None};
 use owned::Box;
 use raw::TraitObject;