std: Move size/align functions to std::mem. #2240

21 files changed, 221 insertions, 202 deletions

diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index f6669893170..8607710edc3 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -14,7 +14,7 @@ use clone::Clone;
 use container::Container;
 use iter::Iterator;
 use option::{Option, Some, None};
-use sys;
+use mem;
 use unstable::raw::Repr;
 use vec::{ImmutableVector, OwnedVector};
 
@@ -26,7 +26,7 @@ use vec::{ImmutableVector, OwnedVector};
 pub fn capacity<T>(v: @[T]) -> uint {
     unsafe {
         let box = v.repr();
-        (*box).data.alloc / sys::size_of::<T>()
+        (*box).data.alloc / mem::size_of::<T>()
     }
 }
 
@@ -160,7 +160,7 @@ pub mod raw {
     use cast::{transmute, transmute_copy};
     use libc;
     use ptr;
-    use sys;
+    use mem;
     use uint;
     use unstable::intrinsics::{move_val_init, TyDesc};
     use unstable::intrinsics;
@@ -176,7 +176,7 @@ pub mod raw {
     #[inline]
     pub unsafe fn set_len<T>(v: &mut @[T], new_len: uint) {
         let repr: *mut Box<Vec<T>> = cast::transmute_copy(v);
-        (*repr).data.fill = new_len * sys::size_of::<T>();
+        (*repr).data.fill = new_len * mem::size_of::<T>();
     }
 
     /**
@@ -199,7 +199,7 @@ pub mod raw {
     unsafe fn push_fast<T>(v: &mut @[T], initval: T) {
         let repr: *mut Box<Vec<T>> = cast::transmute_copy(v);
         let amt = v.len();
-        (*repr).data.fill += sys::size_of::<T>();
+        (*repr).data.fill += mem::size_of::<T>();
         let p = ptr::offset(&(*repr).data.data as *T, amt as int) as *mut T;
         move_val_init(&mut(*p), initval);
     }
@@ -236,7 +236,7 @@ pub mod raw {
         unsafe {
             if n > (**ptr).data.alloc / (*ty).size {
                 let alloc = n * (*ty).size;
-                let total_size = alloc + sys::size_of::<Vec<()>>();
+                let total_size = alloc + mem::size_of::<Vec<()>>();
                 if alloc / (*ty).size != n || total_size < alloc {
                     fail2!("vector size is too large: {}", n);
                 }
diff --git a/src/libstd/cast.rs b/src/libstd/cast.rs
index e028bbeac68..a4f2ee0d09c 100644
--- a/src/libstd/cast.rs
+++ b/src/libstd/cast.rs
@@ -11,7 +11,7 @@
 //! Unsafe casting functions
 
 use ptr::RawPtr;
-use sys;
+use mem;
 use unstable::intrinsics;
 
 /// Casts the value at `src` to U. The two types must have the same length.
@@ -21,7 +21,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = intrinsics::uninit();
     let dest_ptr: *mut u8 = transmute(&mut dest);
     let src_ptr: *u8 = transmute(src);
-    intrinsics::memcpy32(dest_ptr, src_ptr, sys::size_of::<U>() as u32);
+    intrinsics::memcpy32(dest_ptr, src_ptr, mem::size_of::<U>() as u32);
     dest
 }
 
@@ -32,7 +32,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
     let mut dest: U = intrinsics::uninit();
     let dest_ptr: *mut u8 = transmute(&mut dest);
     let src_ptr: *u8 = transmute(src);
-    intrinsics::memcpy64(dest_ptr, src_ptr, sys::size_of::<U>() as u64);
+    intrinsics::memcpy64(dest_ptr, src_ptr, mem::size_of::<U>() as u64);
     dest
 }
 
diff --git a/src/libstd/cleanup.rs b/src/libstd/cleanup.rs
index 38925621f12..a8c4d9fdca3 100644
--- a/src/libstd/cleanup.rs
+++ b/src/libstd/cleanup.rs
@@ -68,7 +68,7 @@ fn debug_mem() -> bool {
 /// Destroys all managed memory (i.e. @ boxes) held by the current task.
 pub unsafe fn annihilate() {
     use rt::local_heap::local_free;
-    use sys;
+    use mem;
     use managed;
 
     let mut stats = AnnihilateStats {
@@ -115,7 +115,7 @@ pub unsafe fn annihilate() {
         if !uniq {
             stats.n_bytes_freed +=
                 (*((*box).type_desc)).size
-                + sys::size_of::<raw::Box<()>>();
+                + mem::size_of::<raw::Box<()>>();
             local_free(box as *i8);
         }
         true
diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs
new file mode 100644
index 00000000000..311bf5f6bc8
--- /dev/null
+++ b/src/libstd/mem.rs
@@ -0,0 +1,158 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Functions relating to memory layout
+
+use unstable::intrinsics;
+
+/// Returns the size of a type
+#[inline]
+pub fn size_of<T>() -> uint {
+    unsafe { intrinsics::size_of::<T>() }
+}
+
+/// Returns the size of the type that `_val` points to
+#[inline]
+pub fn size_of_val<T>(_val: &T) -> uint {
+    size_of::<T>()
+}
+
+/**
+ * Returns the size of a type, or 1 if the actual size is zero.
+ *
+ * Useful for building structures containing variable-length arrays.
+ */
+#[inline]
+pub fn nonzero_size_of<T>() -> uint {
+    let s = size_of::<T>();
+    if s == 0 { 1 } else { s }
+}
+
+/// Returns the size of the type of the value that `_val` points to
+#[inline]
+pub fn nonzero_size_of_val<T>(_val: &T) -> uint {
+    nonzero_size_of::<T>()
+}
+
+
+/**
+ * Returns the ABI-required minimum alignment of a type
+ *
+ * This is the alignment used for struct fields. It may be smaller
+ * than the preferred alignment.
+ */
+#[inline]
+pub fn min_align_of<T>() -> uint {
+    unsafe { intrinsics::min_align_of::<T>() }
+}
+
+/// Returns the ABI-required minimum alignment of the type of the value that
+/// `_val` points to
+#[inline]
+pub fn min_align_of_val<T>(_val: &T) -> uint {
+    min_align_of::<T>()
+}
+
+/// Returns the preferred alignment of a type
+#[inline]
+pub fn pref_align_of<T>() -> uint {
+    unsafe { intrinsics::pref_align_of::<T>() }
+}
+
+/// Returns the preferred alignment of the type of the value that
+/// `_val` points to
+#[inline]
+pub fn pref_align_of_val<T>(_val: &T) -> uint {
+    pref_align_of::<T>()
+}
+
+#[cfg(test)]
+mod tests {
+    use cast;
+    use mem::*;
+
+    #[test]
+    fn size_of_basic() {
+        assert_eq!(size_of::<u8>(), 1u);
+        assert_eq!(size_of::<u16>(), 2u);
+        assert_eq!(size_of::<u32>(), 4u);
+        assert_eq!(size_of::<u64>(), 8u);
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86")]
+    #[cfg(target_arch = "arm")]
+    #[cfg(target_arch = "mips")]
+    fn size_of_32() {
+        assert_eq!(size_of::<uint>(), 4u);
+        assert_eq!(size_of::<*uint>(), 4u);
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86_64")]
+    fn size_of_64() {
+        assert_eq!(size_of::<uint>(), 8u);
+        assert_eq!(size_of::<*uint>(), 8u);
+    }
+
+    #[test]
+    fn size_of_val_basic() {
+        assert_eq!(size_of_val(&1u8), 1);
+        assert_eq!(size_of_val(&1u16), 2);
+        assert_eq!(size_of_val(&1u32), 4);
+        assert_eq!(size_of_val(&1u64), 8);
+    }
+
+    #[test]
+    fn nonzero_size_of_basic() {
+        type Z = [i8, ..0];
+        assert_eq!(size_of::<Z>(), 0u);
+        assert_eq!(nonzero_size_of::<Z>(), 1u);
+        assert_eq!(nonzero_size_of::<uint>(), size_of::<uint>());
+    }
+
+    #[test]
+    fn nonzero_size_of_val_basic() {
+        let z = [0u8, ..0];
+        assert_eq!(size_of_val(&z), 0u);
+        assert_eq!(nonzero_size_of_val(&z), 1u);
+        assert_eq!(nonzero_size_of_val(&1u), size_of_val(&1u));
+    }
+
+    #[test]
+    fn align_of_basic() {
+        assert_eq!(pref_align_of::<u8>(), 1u);
+        assert_eq!(pref_align_of::<u16>(), 2u);
+        assert_eq!(pref_align_of::<u32>(), 4u);
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86")]
+    #[cfg(target_arch = "arm")]
+    #[cfg(target_arch = "mips")]
+    fn align_of_32() {
+        assert_eq!(pref_align_of::<uint>(), 4u);
+        assert_eq!(pref_align_of::<*uint>(), 4u);
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86_64")]
+    fn align_of_64() {
+        assert_eq!(pref_align_of::<uint>(), 8u);
+        assert_eq!(pref_align_of::<*uint>(), 8u);
+    }
+
+    #[test]
+    fn align_of_val_basic() {
+        assert_eq!(pref_align_of_val(&1u8), 1u);
+        assert_eq!(pref_align_of_val(&1u16), 2u);
+        assert_eq!(pref_align_of_val(&1u32), 4u);
+    }
+}
diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs
index 2b4a636e1ad..e99dcd6b2eb 100644
--- a/src/libstd/num/f32.rs
+++ b/src/libstd/num/f32.rs
@@ -928,7 +928,7 @@ mod tests {
 
     use num::*;
     use num;
-    use sys;
+    use mem;
 
     #[test]
     fn test_num() {
@@ -1198,8 +1198,8 @@ mod tests {
     #[test]
     fn test_primitive() {
         let none: Option<f32> = None;
-        assert_eq!(Primitive::bits(none), sys::size_of::<f32>() * 8);
-        assert_eq!(Primitive::bytes(none), sys::size_of::<f32>());
+        assert_eq!(Primitive::bits(none), mem::size_of::<f32>() * 8);
+        assert_eq!(Primitive::bytes(none), mem::size_of::<f32>());
     }
 
     #[test]
diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index d4442e5b34f..f367de376d4 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -976,7 +976,7 @@ mod tests {
 
     use num::*;
     use num;
-    use sys;
+    use mem;
 
     #[test]
     fn test_num() {
@@ -1249,8 +1249,8 @@ mod tests {
     #[test]
     fn test_primitive() {
         let none: Option<f64> = None;
-        assert_eq!(Primitive::bits(none), sys::size_of::<f64>() * 8);
-        assert_eq!(Primitive::bytes(none), sys::size_of::<f64>());
+        assert_eq!(Primitive::bits(none), mem::size_of::<f64>() * 8);
+        assert_eq!(Primitive::bytes(none), mem::size_of::<f64>());
     }
 
     #[test]
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 7fae567809b..694e5e7f6bf 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -456,7 +456,7 @@ mod tests {
     use int;
     use i32;
     use num;
-    use sys;
+    use mem;
 
     #[test]
     fn test_num() {
@@ -653,8 +653,8 @@ mod tests {
     #[test]
     fn test_primitive() {
         let none: Option<$T> = None;
-        assert_eq!(Primitive::bits(none), sys::size_of::<$T>() * 8);
-        assert_eq!(Primitive::bytes(none), sys::size_of::<$T>());
+        assert_eq!(Primitive::bits(none), mem::size_of::<$T>() * 8);
+        assert_eq!(Primitive::bytes(none), mem::size_of::<$T>());
     }
 
     #[test]
diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs
index 38a4df270fc..2ecbb79407e 100644
--- a/src/libstd/num/uint.rs
+++ b/src/libstd/num/uint.rs
@@ -14,7 +14,7 @@ use num;
 use num::{CheckedAdd, CheckedSub, CheckedMul};
 use option::{Option, Some, None};
 use unstable::intrinsics;
-use sys;
+use mem;
 
 pub use self::generated::*;
 
@@ -97,7 +97,7 @@ impl num::Times for uint {
 /// Returns the smallest power of 2 greater than or equal to `n`
 #[inline]
 pub fn next_power_of_two(n: uint) -> uint {
-    let halfbits: uint = sys::size_of::<uint>() * 4u;
+    let halfbits: uint = mem::size_of::<uint>() * 4u;
     let mut tmp: uint = n - 1u;
     let mut shift: uint = 1u;
     while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
@@ -107,7 +107,7 @@ pub fn next_power_of_two(n: uint) -> uint {
 /// Returns the smallest power of 2 greater than or equal to `n`
 #[inline]
 pub fn next_power_of_two_opt(n: uint) -> Option<uint> {
-    let halfbits: uint = sys::size_of::<uint>() * 4u;
+    let halfbits: uint = mem::size_of::<uint>() * 4u;
     let mut tmp: uint = n - 1u;
     let mut shift: uint = 1u;
     while shift <= halfbits { tmp |= tmp >> shift; shift <<= 1u; }
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index f52feced67c..2974b402d4a 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -337,7 +337,7 @@ mod tests {
     use super::*;
 
     use num;
-    use sys;
+    use mem;
     use u16;
 
     #[test]
@@ -431,8 +431,8 @@ mod tests {
     #[test]
     fn test_primitive() {
         let none: Option<$T> = None;
-        assert_eq!(Primitive::bits(none), sys::size_of::<$T>() * 8);
-        assert_eq!(Primitive::bytes(none), sys::size_of::<$T>());
+        assert_eq!(Primitive::bits(none), mem::size_of::<$T>() * 8);
+        assert_eq!(Primitive::bytes(none), mem::size_of::<$T>());
     }
 
     #[test]
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 1e76effd0d2..954db42c89b 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -52,7 +52,7 @@ fn main () {
  ```
 */
 
-use sys::size_of;
+use mem::size_of;
 use unstable::raw::Slice;
 use cast;
 use container::Container;
@@ -952,7 +952,7 @@ mod test {
 mod bench {
     use extra::test::BenchHarness;
     use rand::*;
-    use sys::size_of;
+    use mem::size_of;
 
     #[bench]
     fn rand_xorshift(bh: &mut BenchHarness) {
diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs
index 292330de7b5..1cd76727716 100644
--- a/src/libstd/reflect.rs
+++ b/src/libstd/reflect.rs
@@ -18,7 +18,7 @@ Runtime type reflection
 
 use unstable::intrinsics::{Opaque, TyDesc, TyVisitor};
 use libc::c_void;
-use sys;
+use mem;
 use unstable::raw;
 
 /**
@@ -64,12 +64,12 @@ impl<V:TyVisitor + MovePtr> MovePtrAdaptor<V> {
 
     #[inline]
     pub fn align_to<T>(&mut self) {
-        self.align(sys::min_align_of::<T>());
+        self.align(mem::min_align_of::<T>());
     }
 
     #[inline]
     pub fn bump_past<T>(&mut self) {
-        self.bump(sys::size_of::<T>());
+        self.bump(mem::size_of::<T>());
     }
 }
 
diff --git a/src/libstd/rt/context.rs b/src/libstd/rt/context.rs
index 853cc08a0ba..222f9a44b17 100644
--- a/src/libstd/rt/context.rs
+++ b/src/libstd/rt/context.rs
@@ -233,6 +233,6 @@ fn align_down(sp: *mut uint) -> *mut uint {
 // ptr::mut_offset is positive ints only
 #[inline]
 pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T {
-    use std::sys::size_of;
+    use mem::size_of;
     (ptr as int + count * (size_of::<T>() as int)) as *mut T
 }
diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs
index 7d3f5f91774..446efbd9047 100644
--- a/src/libstd/rt/global_heap.rs
+++ b/src/libstd/rt/global_heap.rs
@@ -11,7 +11,7 @@
 use libc::{c_void, c_char, size_t, uintptr_t, free, malloc, realloc};
 use unstable::intrinsics::TyDesc;
 use unstable::raw;
-use sys::size_of;
+use mem::size_of;
 
 extern {
     #[rust_stack]
diff --git a/src/libstd/rt/io/native/process.rs b/src/libstd/rt/io/native/process.rs
index d338192c664..57367beacd8 100644
--- a/src/libstd/rt/io/native/process.rs
+++ b/src/libstd/rt/io/native/process.rs
@@ -271,12 +271,12 @@ fn spawn_process_os(prog: &str, args: &[~str],
     };
     use libc::funcs::extra::msvcrt::get_osfhandle;
 
-    use sys;
+    use mem;
 
     unsafe {
 
         let mut si = zeroed_startupinfo();
-        si.cb = sys::size_of::<STARTUPINFO>() as DWORD;
+        si.cb = mem::size_of::<STARTUPINFO>() as DWORD;
         si.dwFlags = STARTF_USESTDHANDLES;
 
         let cur_proc = GetCurrentProcess();
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index 0a4622bc65e..7724f58153e 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -857,7 +857,7 @@ fn new_sched_rng() -> XorShiftRng {
 #[fixed_stack_segment] #[inline(never)]
 fn new_sched_rng() -> XorShiftRng {
     use libc;
-    use sys;
+    use mem;
     use c_str::ToCStr;
     use vec::MutableVector;
     use iter::Iterator;
@@ -871,7 +871,7 @@ fn new_sched_rng() -> XorShiftRng {
     }
 
     let mut seeds = [0u32, .. 4];
-    let size = sys::size_of_val(&seeds);
+    let size = mem::size_of_val(&seeds);
     loop {
         let nbytes = do seeds.as_mut_buf |buf, _| {
             unsafe {
diff --git a/src/libstd/rt/test.rs b/src/libstd/rt/test.rs
index 1178bfdaa80..9f4e6558ac5 100644
--- a/src/libstd/rt/test.rs
+++ b/src/libstd/rt/test.rs
@@ -103,7 +103,7 @@ mod darwin_fd_limit {
         // The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc
         // sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value.
         use ptr::{to_unsafe_ptr, to_mut_unsafe_ptr, mut_null};
-        use sys::size_of_val;
+        use mem::size_of_val;
         use os::last_os_error;
 
         // Fetch the kern.maxfilesperproc value
diff --git a/src/libstd/std.rs b/src/libstd/std.rs
index 73cb6a5645d..c446fe3d94f 100644
--- a/src/libstd/std.rs
+++ b/src/libstd/std.rs
@@ -189,6 +189,7 @@ pub mod condition;
 pub mod logging;
 pub mod util;
 pub mod routine;
+pub mod mem;
 
 /* Unsupported interfaces */
 
diff --git a/src/libstd/sys.rs b/src/libstd/sys.rs
index 10c3fed1d54..0299ca0b49a 100644
--- a/src/libstd/sys.rs
+++ b/src/libstd/sys.rs
@@ -19,68 +19,6 @@ use libc;
 use repr;
 use rt::task;
 use str;
-use unstable::intrinsics;
-
-/// Returns the size of a type
-#[inline]
-pub fn size_of<T>() -> uint {
-    unsafe { intrinsics::size_of::<T>() }
-}
-
-/// Returns the size of the type that `_val` points to
-#[inline]
-pub fn size_of_val<T>(_val: &T) -> uint {
-    size_of::<T>()
-}
-
-/**
- * Returns the size of a type, or 1 if the actual size is zero.
- *
- * Useful for building structures containing variable-length arrays.
- */
-#[inline]
-pub fn nonzero_size_of<T>() -> uint {
-    let s = size_of::<T>();
-    if s == 0 { 1 } else { s }
-}
-
-/// Returns the size of the type of the value that `_val` points to
-#[inline]
-pub fn nonzero_size_of_val<T>(_val: &T) -> uint {
-    nonzero_size_of::<T>()
-}
-
-
-/**
- * Returns the ABI-required minimum alignment of a type
- *
- * This is the alignment used for struct fields. It may be smaller
- * than the preferred alignment.
- */
-#[inline]
-pub fn min_align_of<T>() -> uint {
-    unsafe { intrinsics::min_align_of::<T>() }
-}
-
-/// Returns the ABI-required minimum alignment of the type of the value that
-/// `_val` points to
-#[inline]
-pub fn min_align_of_val<T>(_val: &T) -> uint {
-    min_align_of::<T>()
-}
-
-/// Returns the preferred alignment of a type
-#[inline]
-pub fn pref_align_of<T>() -> uint {
-    unsafe { intrinsics::pref_align_of::<T>() }
-}
-
-/// Returns the preferred alignment of the type of the value that
-/// `_val` points to
-#[inline]
-pub fn pref_align_of_val<T>(_val: &T) -> uint {
-    pref_align_of::<T>()
-}
 
 /// Returns the refcount of a shared box (as just before calling this)
 #[inline]
@@ -132,84 +70,6 @@ mod tests {
     use sys::*;
 
     #[test]
-    fn size_of_basic() {
-        assert_eq!(size_of::<u8>(), 1u);
-        assert_eq!(size_of::<u16>(), 2u);
-        assert_eq!(size_of::<u32>(), 4u);
-        assert_eq!(size_of::<u64>(), 8u);
-    }
-
-    #[test]
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "arm")]
-    #[cfg(target_arch = "mips")]
-    fn size_of_32() {
-        assert_eq!(size_of::<uint>(), 4u);
-        assert_eq!(size_of::<*uint>(), 4u);
-    }
-
-    #[test]
-    #[cfg(target_arch = "x86_64")]
-    fn size_of_64() {
-        assert_eq!(size_of::<uint>(), 8u);
-        assert_eq!(size_of::<*uint>(), 8u);
-    }
-
-    #[test]
-    fn size_of_val_basic() {
-        assert_eq!(size_of_val(&1u8), 1);
-        assert_eq!(size_of_val(&1u16), 2);
-        assert_eq!(size_of_val(&1u32), 4);
-        assert_eq!(size_of_val(&1u64), 8);
-    }
-
-    #[test]
-    fn nonzero_size_of_basic() {
-        type Z = [i8, ..0];
-        assert_eq!(size_of::<Z>(), 0u);
-        assert_eq!(nonzero_size_of::<Z>(), 1u);
-        assert_eq!(nonzero_size_of::<uint>(), size_of::<uint>());
-    }
-
-    #[test]
-    fn nonzero_size_of_val_basic() {
-        let z = [0u8, ..0];
-        assert_eq!(size_of_val(&z), 0u);
-        assert_eq!(nonzero_size_of_val(&z), 1u);
-        assert_eq!(nonzero_size_of_val(&1u), size_of_val(&1u));
-    }
-
-    #[test]
-    fn align_of_basic() {
-        assert_eq!(pref_align_of::<u8>(), 1u);
-        assert_eq!(pref_align_of::<u16>(), 2u);
-        assert_eq!(pref_align_of::<u32>(), 4u);
-    }
-
-    #[test]
-    #[cfg(target_arch = "x86")]
-    #[cfg(target_arch = "arm")]
-    #[cfg(target_arch = "mips")]
-    fn align_of_32() {
-        assert_eq!(pref_align_of::<uint>(), 4u);
-        assert_eq!(pref_align_of::<*uint>(), 4u);
-    }
-
-    #[test]
-    #[cfg(target_arch = "x86_64")]
-    fn align_of_64() {
-        assert_eq!(pref_align_of::<uint>(), 8u);
-        assert_eq!(pref_align_of::<*uint>(), 8u);
-    }
-
-    #[test]
-    fn align_of_val_basic() {
-        assert_eq!(pref_align_of_val(&1u8), 1u);
-        assert_eq!(pref_align_of_val(&1u16), 2u);
-        assert_eq!(pref_align_of_val(&1u32), 4u);
-    }
-
-    #[test]
     fn synthesize_closure() {
         use unstable::raw::Closure;
         unsafe {
diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs
index f3945d8f3c9..0b28497e640 100644
--- a/src/libstd/unstable/sync.rs
+++ b/src/libstd/unstable/sync.rs
@@ -425,7 +425,7 @@ mod tests {
     use super::{Exclusive, UnsafeArc, atomically};
     use task;
     use util;
-    use sys::size_of;
+    use mem::size_of;
 
     //#[unsafe_no_drop_flag] FIXME: #9758
     #[ignore]
diff --git a/src/libstd/util.rs b/src/libstd/util.rs
index 44cfdb86057..3e44a30e47b 100644
--- a/src/libstd/util.rs
+++ b/src/libstd/util.rs
@@ -93,7 +93,7 @@ mod tests {
     use ops::Drop;
     use option::{None, Some};
     use either::{Either, Left, Right};
-    use sys::size_of;
+    use mem::size_of;
 
     #[test]
     fn identity_crisis() {
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 60c569e75d0..d298507aa8c 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -116,8 +116,8 @@ use ptr;
 use ptr::RawPtr;
 use rt::global_heap::malloc_raw;
 use rt::global_heap::realloc_raw;
-use sys;
-use sys::size_of;
+use mem;
+use mem::size_of;
 use uint;
 use unstable::finally::Finally;
 use unstable::intrinsics;
@@ -185,8 +185,8 @@ pub fn with_capacity<T>(capacity: uint) -> ~[T] {
             vec.reserve(capacity);
             vec
         } else {
-            let alloc = capacity * sys::nonzero_size_of::<T>();
-            let ptr = malloc_raw(alloc + sys::size_of::<Vec<()>>()) as *mut Vec<()>;
+            let alloc = capacity * mem::nonzero_size_of::<T>();
+            let ptr = malloc_raw(alloc + mem::size_of::<Vec<()>>()) as *mut Vec<()>;
             (*ptr).alloc = alloc;
             (*ptr).fill = 0;
             cast::transmute(ptr)
@@ -1002,7 +1002,7 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
     fn iter(self) -> VecIterator<'self, T> {
         unsafe {
             let p = vec::raw::to_ptr(self);
-            if sys::size_of::<T>() == 0 {
+            if mem::size_of::<T>() == 0 {
                 VecIterator{ptr: p,
                             end: (p as uint + self.len()) as *T,
                             lifetime: None}
@@ -1406,9 +1406,9 @@ impl<T> OwnedVector<T> for ~[T] {
                     ::at_vec::raw::reserve_raw(td, ptr, n);
                 } else {
                     let ptr: *mut *mut Vec<()> = cast::transmute(self);
-                    let alloc = n * sys::nonzero_size_of::<T>();
-                    let size = alloc + sys::size_of::<Vec<()>>();
-                    if alloc / sys::nonzero_size_of::<T>() != n || size < alloc {
+                    let alloc = n * mem::nonzero_size_of::<T>();
+                    let size = alloc + mem::size_of::<Vec<()>>();
+                    if alloc / mem::nonzero_size_of::<T>() != n || size < alloc {
                         fail2!("vector size is too large: {}", n);
                     }
                     *ptr = realloc_raw(*ptr as *mut c_void, size)
@@ -1439,10 +1439,10 @@ impl<T> OwnedVector<T> for ~[T] {
         unsafe {
             if contains_managed::<T>() {
                 let repr: **Box<Vec<()>> = cast::transmute(self);
-                (**repr).data.alloc / sys::nonzero_size_of::<T>()
+                (**repr).data.alloc / mem::nonzero_size_of::<T>()
             } else {
                 let repr: **Vec<()> = cast::transmute(self);
-                (**repr).alloc / sys::nonzero_size_of::<T>()
+                (**repr).alloc / mem::nonzero_size_of::<T>()
             }
         }
     }
@@ -1451,7 +1451,7 @@ impl<T> OwnedVector<T> for ~[T] {
         unsafe {
             let ptr: *mut *mut Vec<()> = cast::transmute(self);
             let alloc = (**ptr).fill;
-            let size = alloc + sys::size_of::<Vec<()>>();
+            let size = alloc + mem::size_of::<Vec<()>>();
             *ptr = realloc_raw(*ptr as *mut c_void, size) as *mut Vec<()>;
             (**ptr).alloc = alloc;
         }
@@ -1485,14 +1485,14 @@ impl<T> OwnedVector<T> for ~[T] {
             if contains_managed::<T>() {
                 let repr: **mut Box<Vec<u8>> = cast::transmute(this);
                 let fill = (**repr).data.fill;
-                (**repr).data.fill += sys::nonzero_size_of::<T>();
+                (**repr).data.fill += mem::nonzero_size_of::<T>();
                 let p = to_unsafe_ptr(&((**repr).data.data));
                 let p = ptr::offset(p, fill as int) as *mut T;
                 intrinsics::move_val_init(&mut(*p), t);
             } else {
                 let repr: **mut Vec<u8> = cast::transmute(this);
                 let fill = (**repr).fill;
-                (**repr).fill += sys::nonzero_size_of::<T>();
+                (**repr).fill += mem::nonzero_size_of::<T>();
                 let p = to_unsafe_ptr(&((**repr).data));
                 let p = ptr::offset(p, fill as int) as *mut T;
                 intrinsics::move_val_init(&mut(*p), t);
@@ -1957,7 +1957,7 @@ impl<'self,T> MutableVector<'self, T> for &'self mut [T] {
     fn mut_iter(self) -> VecMutIterator<'self, T> {
         unsafe {
             let p = vec::raw::to_mut_ptr(self);
-            if sys::size_of::<T>() == 0 {
+            if mem::size_of::<T>() == 0 {
                 VecMutIterator{ptr: p,
                                end: (p as uint + self.len()) as *mut T,
                                lifetime: None}
@@ -2054,7 +2054,7 @@ pub mod raw {
     use clone::Clone;
     use option::Some;
     use ptr;
-    use sys;
+    use mem;
     use unstable::intrinsics;
     use vec::{with_capacity, ImmutableVector, MutableVector};
     use unstable::intrinsics::contains_managed;
@@ -2071,10 +2071,10 @@ pub mod raw {
     pub unsafe fn set_len<T>(v: &mut ~[T], new_len: uint) {
         if contains_managed::<T>() {
             let repr: **mut Box<Vec<()>> = cast::transmute(v);
-            (**repr).data.fill = new_len * sys::nonzero_size_of::<T>();
+            (**repr).data.fill = new_len * mem::nonzero_size_of::<T>();
         } else {
             let repr: **mut Vec<()> = cast::transmute(v);
-            (**repr).fill = new_len * sys::nonzero_size_of::<T>();
+            (**repr).fill = new_len * mem::nonzero_size_of::<T>();
         }
     }
 
@@ -2323,7 +2323,7 @@ macro_rules! iterator {
                         None
                     } else {
                         let old = self.ptr;
-                        self.ptr = if sys::size_of::<T>() == 0 {
+                        self.ptr = if mem::size_of::<T>() == 0 {
                             // purposefully don't use 'ptr.offset' because for
                             // vectors with 0-size elements this would return the
                             // same pointer.
@@ -2340,7 +2340,7 @@ macro_rules! iterator {
             #[inline]
             fn size_hint(&self) -> (uint, Option<uint>) {
                 let diff = (self.end as uint) - (self.ptr as uint);
-                let exact = diff / sys::nonzero_size_of::<T>();
+                let exact = diff / mem::nonzero_size_of::<T>();
                 (exact, Some(exact))
             }
         }
@@ -2357,7 +2357,7 @@ macro_rules! double_ended_iterator {
                     if self.end == self.ptr {
                         None
                     } else {
-                        self.end = if sys::size_of::<T>() == 0 {
+                        self.end = if mem::size_of::<T>() == 0 {
                             // See above for why 'ptr.offset' isn't used
                             cast::transmute(self.end as uint - 1)
                         } else {
@@ -2497,7 +2497,7 @@ impl<A> Extendable<A> for ~[A] {
 #[cfg(test)]
 mod tests {
     use option::{None, Option, Some};
-    use sys;
+    use mem;
     use vec::*;
     use cmp::*;
     use prelude::*;
@@ -2597,7 +2597,7 @@ mod tests {
         let v0 : &[Z] = &[];
         let v1 : &[Z] = &[[]];
         let v2 : &[Z] = &[[], []];
-        assert_eq!(sys::size_of::<Z>(), 0);
+        assert_eq!(mem::size_of::<Z>(), 0);
         assert_eq!(v0.len(), 0);
         assert_eq!(v1.len(), 1);
         assert_eq!(v2.len(), 2);