std: Add init and uninit to mem. Replace direct intrinsic usage

9 files changed, 31 insertions, 16 deletions

diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
index fdef7e36bd5..cc6cd7666d6 100644
--- a/src/libstd/c_str.rs
+++ b/src/libstd/c_str.rs
@@ -70,6 +70,7 @@ use kinds::marker;
 use ops::Drop;
 use cmp::Eq;
 use clone::Clone;
+use mem;
 use option::{Option, Some, None};
 use ptr::RawPtr;
 use ptr;
@@ -77,7 +78,6 @@ use str::StrSlice;
 use str;
 use vec::{ImmutableVector, MutableVector};
 use vec;
-use unstable::intrinsics;
 use rt::global_heap::malloc_raw;
 
 /// The representation of a C String.
@@ -327,7 +327,7 @@ impl<'a> ToCStr for &'a [u8] {
 // Unsafe function that handles possibly copying the &[u8] into a stack array.
 unsafe fn with_c_str<T>(v: &[u8], checked: bool, f: |*libc::c_char| -> T) -> T {
     if v.len() < BUF_LEN {
-        let mut buf: [u8, .. BUF_LEN] = intrinsics::uninit();
+        let mut buf: [u8, .. BUF_LEN] = mem::uninit();
         vec::bytes::copy_memory(buf, v);
         buf[v.len()] = 0;
 
diff --git a/src/libstd/cast.rs b/src/libstd/cast.rs
index eec7d28e134..258c0e23094 100644
--- a/src/libstd/cast.rs
+++ b/src/libstd/cast.rs
@@ -18,7 +18,7 @@ use ptr::copy_nonoverlapping_memory;
 /// Casts the value at `src` to U. The two types must have the same length.
 #[inline]
 pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = intrinsics::uninit();
+    let mut dest: U = mem::uninit();
     let dest_ptr: *mut u8 = transmute(&mut dest);
     let src_ptr: *u8 = transmute(src);
     copy_nonoverlapping_memory(dest_ptr, src_ptr, mem::size_of::<U>());
diff --git a/src/libstd/mem.rs b/src/libstd/mem.rs
index c4a546f71c3..05bc8ed9826 100644
--- a/src/libstd/mem.rs
+++ b/src/libstd/mem.rs
@@ -68,6 +68,21 @@ pub fn pref_align_of_val<T>(_val: &T) -> uint {
     pref_align_of::<T>()
 }
 
+/// Create a value initialized to zero.
+///
+/// `init` is unsafe because it returns a zeroed-out datum,
+/// which is unsafe unless T is Pod.
+#[inline]
+pub unsafe fn init<T>() -> T {
+    intrinsics::init()
+}
+
+/// Create an uninitialized value.
+#[inline]
+pub unsafe fn uninit<T>() -> T {
+    intrinsics::uninit()
+}
+
 #[cfg(test)]
 mod tests {
     use mem::*;
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index dcb6d2719d9..d22e91fb83e 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -15,6 +15,7 @@ use clone::Clone;
 #[cfg(not(test))]
 use cmp::Equiv;
 use iter::{range, Iterator};
+use mem;
 use option::{Option, Some, None};
 use unstable::intrinsics;
 use util::swap;
@@ -132,7 +133,7 @@ pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
 #[inline]
 pub unsafe fn swap_ptr<T>(x: *mut T, y: *mut T) {
     // Give ourselves some scratch space to work with
-    let mut tmp: T = intrinsics::uninit();
+    let mut tmp: T = mem::uninit();
     let t: *mut T = &mut tmp;
 
     // Perform the swap
@@ -160,7 +161,7 @@ pub unsafe fn replace_ptr<T>(dest: *mut T, mut src: T) -> T {
  */
 #[inline(always)]
 pub unsafe fn read_ptr<T>(src: *T) -> T {
-    let mut tmp: T = intrinsics::uninit();
+    let mut tmp: T = mem::uninit();
     copy_nonoverlapping_memory(&mut tmp, src, 1);
     tmp
 }
diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs
index b762c1173f5..b443182c157 100644
--- a/src/libstd/rt/thread.rs
+++ b/src/libstd/rt/thread.rs
@@ -205,17 +205,17 @@ mod imp {
     use cmp;
     use libc::consts::os::posix01::{PTHREAD_CREATE_JOINABLE, PTHREAD_STACK_MIN};
     use libc;
+    use mem;
     use os;
     use ptr;
-    use unstable::intrinsics;
     use unstable::stack::RED_ZONE;
 
     pub type rust_thread = libc::pthread_t;
     pub type rust_thread_return = *u8;
 
     pub unsafe fn create(stack: uint, p: ~proc()) -> rust_thread {
-        let mut native: libc::pthread_t = intrinsics::uninit();
-        let mut attr: libc::pthread_attr_t = intrinsics::uninit();
+        let mut native: libc::pthread_t = mem::uninit();
+        let mut attr: libc::pthread_attr_t = mem::uninit();
         assert_eq!(pthread_attr_init(&mut attr), 0);
         assert_eq!(pthread_attr_setdetachstate(&mut attr,
                                                PTHREAD_CREATE_JOINABLE), 0);
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index f1c3d7a7a91..624a5aa72de 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -16,7 +16,7 @@ use iter::{Extendable, FromIterator, Iterator};
 use mem;
 use uint;
 use util::replace;
-use unstable::intrinsics::init;
+use mem::init;
 use vec;
 use ptr::RawPtr;
 use vec::{ImmutableVector, Items, MutableVector, MutItems, OwnedVector};
diff --git a/src/libstd/unstable/intrinsics.rs b/src/libstd/unstable/intrinsics.rs
index 7ca28711504..8f313ed661d 100644
--- a/src/libstd/unstable/intrinsics.rs
+++ b/src/libstd/unstable/intrinsics.rs
@@ -288,8 +288,7 @@ extern "rust-intrinsic" {
     /// Create a value initialized to zero.
     ///
     /// `init` is unsafe because it returns a zeroed-out datum,
-    /// which is unsafe unless T is POD. We don't have a POD
-    /// kind yet. (See #4074).
+    /// which is unsafe unless T is Pod.
     pub fn init<T>() -> T;
 
     /// Create an uninitialized value.
diff --git a/src/libstd/unstable/mutex.rs b/src/libstd/unstable/mutex.rs
index e9df17ef514..3122e925e82 100644
--- a/src/libstd/unstable/mutex.rs
+++ b/src/libstd/unstable/mutex.rs
@@ -92,7 +92,7 @@ mod imp {
     use libc;
     use self::os::{PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER,
                    pthread_mutex_t, pthread_cond_t};
-    use unstable::intrinsics;
+    use mem;
 
     type pthread_mutexattr_t = libc::c_void;
     type pthread_condattr_t = libc::c_void;
@@ -208,8 +208,8 @@ mod imp {
     impl Mutex {
         pub unsafe fn new() -> Mutex {
             let mut m = Mutex {
-                lock: intrinsics::init(),
-                cond: intrinsics::init(),
+                lock: mem::init(),
+                cond: mem::init(),
             };
 
             pthread_mutex_init(&mut m.lock, 0 as *libc::c_void);
diff --git a/src/libstd/util.rs b/src/libstd/util.rs
index 715a10b9112..05c5d7e1588 100644
--- a/src/libstd/util.rs
+++ b/src/libstd/util.rs
@@ -11,8 +11,8 @@
 //! Miscellaneous helpers for common patterns
 
 use cast;
+use mem;
 use ptr;
-use unstable::intrinsics;
 
 /// The identity function.
 #[inline]
@@ -26,7 +26,7 @@ pub fn id<T>(x: T) -> T { x }
 pub fn swap<T>(x: &mut T, y: &mut T) {
     unsafe {
         // Give ourselves some scratch space to work with
-        let mut tmp: T = intrinsics::uninit();
+        let mut tmp: T = mem::uninit();
         let t: *mut T = &mut tmp;
 
         // Perform the swap, `&mut` pointers never alias