---

yaml
---
r: 113991
b: refs/heads/master
c: 0621cca
h: refs/heads/master
i:
  113989: 35fe20e
  113987: 0f0a429
  113983: 4239aab
v: v3

Author: thestinger

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: f8e92cbbe3337974caca28b801efa26734b3c6f9
+refs/heads/master: 0621ccac626ef4ca15e2cdf0aceed13ad0d3f848
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/src/libstd/vec.rs

@@ -403,11 +403,11 @@ impl<T> Container for Vec<T> {
 
 // FIXME: #13996: need a way to mark the return value as `noalias`
 #[inline(never)]
-unsafe fn alloc_or_realloc(ptr: *mut u8, size: uint, align: uint, old_size: uint) -> *mut u8 {
+unsafe fn alloc_or_realloc<T>(ptr: *mut T, size: uint, old_size: uint) -> *mut T {
     if old_size == 0 {
-        allocate(size, align)
+        allocate(size, min_align_of::<T>()) as *mut T
     } else {
-        reallocate(ptr, size, align, old_size)
+        reallocate(ptr as *mut u8, size, min_align_of::<T>(), old_size) as *mut T
     }
 }
 
@@ -491,8 +491,7 @@ impl<T> Vec<T> {
         if capacity > self.cap {
             let size = capacity.checked_mul(&size_of::<T>()).expect("capacity overflow");
             unsafe {
-                self.ptr = alloc_or_realloc(self.ptr as *mut u8, size, min_align_of::<T>(),
-                                            self.cap * size_of::<T>()) as *mut T;
+                self.ptr = alloc_or_realloc(self.ptr, size, self.cap * size_of::<T>());
             }
             self.cap = capacity;
         }
@@ -573,8 +572,7 @@ impl<T> Vec<T> {
             let size = max(old_size, 2 * size_of::<T>()) * 2;
             if old_size > size { fail!("capacity overflow") }
             unsafe {
-                self.ptr = alloc_or_realloc(self.ptr as *mut u8, size, min_align_of::<T>(),
-                                            self.cap * size_of::<T>()) as *mut u8 as *mut T;
+                self.ptr = alloc_or_realloc(self.ptr, size, self.cap * size_of::<T>());
             }
             self.cap = max(self.cap, 2) * 2;
         }