---

yaml
---
r: 151545
b: refs/heads/try2
c: b40c3e9
h: refs/heads/master
i:
  151543: c962146
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: a40b971aaf64f9ba189ac07eebf1890d995ae2dc
+refs/heads/try2: b40c3e9d3dd0a6be4d048389d33435f82205d376
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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::cast;
+use std::mem;
 let mut x: u8 = 1;
 
 let ref_1: &mut u8 = &mut x;
-let ref_2: &mut u8 = unsafe { cast::transmute_mut_lifetime(ref_1) };
+let ref_2: &mut u8 = unsafe { mem::transmute(&mut *ref_1) };
 
 // oops, ref_1 and ref_2 point to the same piece of data (x) and are
 // both usable

branches/try2/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 managed box containing the value that was cast,
+The resulting value is a 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,

branches/try2/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 an array
+compile-time error when anyone tries to call `print_all` on a vector
 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 an array of circles, or an array of rectangles
+You can call that on a vector of circles, or a vector of rectangles
 (assuming those have suitable `Drawable` traits defined), but not on
-an array containing both circles and rectangles. When such behavior is
+a vector containing both circles and rectangles. When such behavior is
 needed, a trait name can alternately be used as a type, called
 an _object_.
 

branches/try2/src/libarena/lib.rs

@@ -26,8 +26,6 @@
 
 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};
@@ -137,7 +135,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
     let fill = chunk.fill.get();
 
     while idx < fill {
-        let tydesc_data: *uint = transmute(buf.offset(idx as int));
+        let tydesc_data: *uint = mem::transmute(buf.offset(idx as int));
         let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
         let (size, align) = ((*tydesc).size, (*tydesc).align);
 
@@ -187,28 +185,27 @@ impl Arena {
     #[inline]
     fn alloc_copy_inner(&mut self, n_bytes: uint, align: uint) -> *u8 {
         unsafe {
-            let this = transmute_mut_lifetime(self);
-            let start = round_up(this.copy_head.fill.get(), align);
+            let start = round_up(self.copy_head.fill.get(), align);
             let end = start + n_bytes;
             if end > self.chunk_size() {
-                return this.alloc_copy_grow(n_bytes, align);
+                return self.alloc_copy_grow(n_bytes, align);
             }
-            this.copy_head.fill.set(end);
+            self.copy_head.fill.set(end);
 
             //debug!("idx = {}, size = {}, align = {}, fill = {}",
             //       start, n_bytes, align, head.fill.get());
 
-            this.copy_head.as_ptr().offset(start as int)
+            self.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: *mut T = transmute(ptr);
+            let ptr = ptr as *mut T;
             mem::move_val_init(&mut (*ptr), op());
-            return transmute(ptr);
+            return &*ptr;
         }
     }
 
@@ -228,26 +225,16 @@ impl Arena {
     fn alloc_noncopy_inner(&mut self, n_bytes: uint, align: uint)
                           -> (*u8, *u8) {
         unsafe {
-            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;
-            }
+            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;
 
             if end > self.head.capacity() {
                 return self.alloc_noncopy_grow(n_bytes, align);
             }
 
-            let head = transmute_mut_lifetime(&mut self.head);
-            head.fill.set(round_up(end, mem::pref_align_of::<*TyDesc>()));
+            self.head.fill.set(round_up(end, mem::pref_align_of::<*TyDesc>()));
 
             //debug!("idx = {}, size = {}, align = {}, fill = {}",
             //       start, n_bytes, align, head.fill);
@@ -263,18 +250,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: *mut uint = transmute(ty_ptr);
-            let ptr: *mut T = transmute(ptr);
+            let ty_ptr = ty_ptr as *mut uint;
+            let ptr = ptr as *mut T;
             // Write in our tydesc along with a bit indicating that it
             // has *not* been initialized yet.
-            *ty_ptr = transmute(tydesc);
+            *ty_ptr = mem::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 transmute(ptr);
+            return &*ptr;
         }
     }
 
@@ -283,7 +270,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 = transmute::<&_, &mut _>(self);
+            let this: &mut Arena = mem::transmute::<&_, &mut _>(self);
             if intrinsics::needs_drop::<T>() {
                 this.alloc_noncopy(op)
             } else {
@@ -366,7 +353,7 @@ impl<T> TypedArenaChunk<T> {
 
         let mut chunk = unsafe {
             let chunk = exchange_malloc(size);
-            let mut chunk: Box<TypedArenaChunk<T>> = cast::transmute(chunk);
+            let mut chunk: Box<TypedArenaChunk<T>> = mem::transmute(chunk);
             mem::move_val_init(&mut chunk.next, next);
             chunk
         };
@@ -387,7 +374,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>> = cast::transmute(chunk);
+            let mut chunk: Box<TypedArenaChunk<T>> = mem::transmute(chunk);
             mem::move_val_init(&mut chunk.next, next);
             chunk
         };
@@ -425,7 +412,7 @@ impl<T> TypedArenaChunk<T> {
     fn start(&self) -> *u8 {
         let this: *TypedArenaChunk<T> = self;
         unsafe {
-            cast::transmute(round_up(this.offset(1) as uint, min_align_of::<T>()))
+            mem::transmute(round_up(this.offset(1) as uint, min_align_of::<T>()))
         }
     }
 
@@ -463,12 +450,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> = cast::transmute::<&_, &mut _>(self);
+            let this: &mut TypedArena<T> = mem::transmute::<&_, &mut _>(self);
             if this.ptr == this.end {
                 this.grow()
             }
 
-            let ptr: &'a mut T = cast::transmute(this.ptr);
+            let ptr: &'a mut T = mem::transmute(this.ptr);
             mem::move_val_init(ptr, object);
             this.ptr = this.ptr.offset(1);
             let ptr: &'a T = ptr;

branches/try2/src/libcollections/dlist.rs

@@ -21,10 +21,9 @@
 // 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::{replace, swap};
+use std::mem;
 use std::ptr;
 
 use deque::Deque;
@@ -93,13 +92,13 @@ impl<T> Rawlink<T> {
         if self.p.is_null() {
             None
         } else {
-            Some(unsafe { cast::transmute(self.p) })
+            Some(unsafe { mem::transmute(self.p) })
         }
     }
 
     /// Return the `Rawlink` and replace with `Rawlink::none()`
     fn take(&mut self) -> Rawlink<T> {
-        replace(self, Rawlink::none())
+        mem::replace(self, Rawlink::none())
     }
 }
 
@@ -159,7 +158,7 @@ impl<T> DList<T> {
             Some(ref mut head) => {
                 new_head.prev = Rawlink::none();
                 head.prev = Rawlink::some(new_head);
-                swap(head, &mut new_head);
+                mem::swap(head, &mut new_head);
                 head.next = Some(new_head);
             }
         }
@@ -317,7 +316,7 @@ impl<T> DList<T> {
     /// O(1)
     #[inline]
     pub fn prepend(&mut self, mut other: DList<T>) {
-        swap(self, &mut other);
+        mem::swap(self, &mut other);
         self.append(other);
     }
 

branches/try2/src/libcollections/enum_set.rs

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

branches/try2/src/libcollections/hashmap.rs

@@ -30,8 +30,6 @@ 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;
@@ -42,10 +40,10 @@ mod table {
     use std::prelude::Drop;
     use std::ptr;
     use std::ptr::RawPtr;
-    use std::rt::libc_heap;
-    use std::intrinsics::{size_of, min_align_of, transmute};
-    use std::intrinsics::{move_val_init, set_memory};
+    use std::mem::{min_align_of, size_of};
+    use std::intrinsics::{move_val_init, set_memory, transmute};
     use std::iter::{Iterator, range_step_inclusive};
+    use std::rt::heap::{allocate, deallocate};
 
     static EMPTY_BUCKET: u64 = 0u64;
 
@@ -185,10 +183,6 @@ 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(
@@ -243,12 +237,7 @@ mod table {
                     keys_size,   min_align_of::< K >(),
                     vals_size,   min_align_of::< V >());
 
-            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 buffer = allocate(size, malloc_alignment);
 
             let hashes = buffer.offset(hash_offset as int) as *mut u64;
             let keys   = buffer.offset(keys_offset as int) as *mut K;
@@ -418,7 +407,7 @@ mod table {
     // modified to no longer assume this.
     #[test]
     fn can_alias_safehash_as_u64() {
-        unsafe { assert_eq!(size_of::<SafeHash>(), size_of::<u64>()) };
+        assert_eq!(size_of::<SafeHash>(), size_of::<u64>())
     }
 
     pub struct Entries<'a, K, V> {
@@ -560,8 +549,15 @@ 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 {
-                libc::free(self.hashes as *mut libc::c_void);
+                deallocate(self.hashes as *mut u8, size, align);
                 // Remember how everything was allocated out of one buffer
                 // during initialization? We only need one call to free here.
             }

branches/try2/src/libcollections/lru_cache.rs

@@ -37,7 +37,6 @@
 //! assert!(cache.get(&2).is_none());
 //! ```
 
-use std::cast;
 use std::container::Container;
 use std::hash::Hash;
 use std::fmt;
@@ -93,7 +92,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
         let cache = LruCache {
             map: HashMap::new(),
             max_size: capacity,
-            head: unsafe{ cast::transmute(box mem::uninit::<LruEntry<K, V>>()) },
+            head: unsafe{ mem::transmute(box mem::uninit::<LruEntry<K, V>>()) },
         };
         unsafe {
             (*cache.head).next = cache.head;
@@ -241,11 +240,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>> = cast::transmute(self.head);
+            let node: Box<LruEntry<K, V>> = mem::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;
-            cast::forget(k);
-            cast::forget(v);
+            mem::forget(k);
+            mem::forget(v);
         }
     }
 }

branches/try2/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 cast::{transmute, transmute_copy};
+use mem::{transmute, transmute_copy};
 use option::{Option, Some, None};
 use owned::Box;
 use raw::TraitObject;