auto merge of #9896 : brson/rust/stdmem, r=alexcrichton

This is progress toward removing std::sys.

Author: bors

doc/po/ja/rust.md.po

@@ -1842,7 +1842,7 @@ msgid ""
 "The type parameters can also be explicitly supplied in a trailing [path]"
 "(#paths) component after the function name. This might be necessary if there "
 "is not sufficient context to determine the type parameters. For example, "
-"`sys::size_of::<u32>() == 4`."
+"`mem::size_of::<u32>() == 4`."
 msgstr ""
 
 #. type: Plain text

doc/po/ja/tutorial-ffi.md.po

@@ -327,7 +327,7 @@ msgid ""
 "impl<T: Send> Unique<T> {\n"
 "    pub fn new(value: T) -> Unique<T> {\n"
 "        unsafe {\n"
-"            let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;\n"
+"            let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;\n"
 "            assert!(!ptr::is_null(ptr));\n"
 "            // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it\n"
 "            intrinsics::move_val_init(&mut *ptr, value);\n"

doc/po/rust.md.pot

@@ -1842,7 +1842,7 @@ msgid ""
 "The type parameters can also be explicitly supplied in a trailing [path]"
 "(#paths) component after the function name. This might be necessary if there "
 "is not sufficient context to determine the type parameters. For example, "
-"`sys::size_of::<u32>() == 4`."
+"`mem::size_of::<u32>() == 4`."
 msgstr ""
 
 #. type: Plain text

doc/po/tutorial-ffi.md.pot

@@ -327,7 +327,7 @@ msgid ""
 "impl<T: Send> Unique<T> {\n"
 "    pub fn new(value: T) -> Unique<T> {\n"
 "        unsafe {\n"
-"            let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;\n"
+"            let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;\n"
 "            assert!(!ptr::is_null(ptr));\n"
 "            // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it\n"
 "            intrinsics::move_val_init(&mut *ptr, value);\n"

doc/rust.md

@@ -975,7 +975,7 @@ with `int`, and require the closure parameter to have type
 The type parameters can also be explicitly supplied in a trailing
 [path](#paths) component after the function name. This might be necessary
 if there is not sufficient context to determine the type parameters. For
-example, `sys::size_of::<u32>() == 4`.
+example, `mem::size_of::<u32>() == 4`.
 
 Since a parameter type is opaque to the generic function, the set of
 operations that can be performed on it is limited. Values of parameter

doc/tutorial-ffi.md

@@ -300,7 +300,7 @@ impl<T: Send> Unique<T> {
         #[inline(never)];
 
         unsafe {
-            let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;
+            let ptr = malloc(std::mem::size_of::<T>() as size_t) as *mut T;
             assert!(!ptr::is_null(ptr));
             // `*ptr` is uninitialized, and `*ptr = value` would attempt to destroy it
             intrinsics::move_val_init(&mut *ptr, value);

src/libextra/arena.rs

@@ -42,7 +42,7 @@ use std::cast::{transmute, transmute_mut, transmute_mut_region};
 use std::cast;
 use std::num;
 use std::ptr;
-use std::sys;
+use std::mem;
 use std::uint;
 use std::vec;
 use std::unstable::intrinsics;
@@ -123,7 +123,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
         let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
         let (size, align) = ((*tydesc).size, (*tydesc).align);
 
-        let after_tydesc = idx + sys::size_of::<*TyDesc>();
+        let after_tydesc = idx + mem::size_of::<*TyDesc>();
 
         let start = round_up_to(after_tydesc, align);
 
@@ -134,7 +134,7 @@ unsafe fn destroy_chunk(chunk: &Chunk) {
         }
 
         // Find where the next tydesc lives
-        idx = round_up_to(start + size, sys::pref_align_of::<*TyDesc>());
+        idx = round_up_to(start + size, mem::pref_align_of::<*TyDesc>());
     }
 }
 
@@ -220,7 +220,7 @@ impl Arena {
                 let head = transmute_mut_region(&mut self.head);
 
                 tydesc_start = head.fill;
-                after_tydesc = head.fill + sys::size_of::<*TyDesc>();
+                after_tydesc = head.fill + mem::size_of::<*TyDesc>();
                 start = round_up_to(after_tydesc, align);
                 end = start + n_bytes;
             }
@@ -230,7 +230,7 @@ impl Arena {
             }
 
             let head = transmute_mut_region(&mut self.head);
-            head.fill = round_up_to(end, sys::pref_align_of::<*TyDesc>());
+            head.fill = round_up_to(end, mem::pref_align_of::<*TyDesc>());
 
             //debug2!("idx = {}, size = {}, align = {}, fill = {}",
             //       start, n_bytes, align, head.fill);

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);
                 }

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
 }
 

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