replace uninitialized() with homemade MaybeUninit

Resolves #12

Author: andylokandy

build.rs

@@ -0,0 +1,81 @@
+use std::env;
+use std::io::Write;
+use std::process::{Command, Stdio};
+
+fn main() {
+    // we need to output *some* file to opt out of the default
+    println!("cargo:rerun-if-changed=build.rs");
+
+    detect_maybe_uninit();
+}
+
+fn detect_maybe_uninit() {
+    let has_unstable_union_with_md = probe(&maybe_uninit_code(true));
+    if has_unstable_union_with_md {
+        println!("cargo:rustc-cfg=has_manually_drop_in_union");
+        println!("cargo:rustc-cfg=has_union_feature");
+        return;
+    }
+
+    let has_stable_union_with_md = probe(&maybe_uninit_code(false));
+    if has_stable_union_with_md {
+        println!("cargo:rustc-cfg=has_manually_drop_in_union");
+    }
+}
+
+// To guard against changes in this currently unstable feature, use
+// a detection tests instead of a Rustc version and/or date test.
+fn maybe_uninit_code(use_feature: bool) -> String {
+    let feature = if use_feature {
+        "#![feature(untagged_unions)]"
+    } else {
+        ""
+    };
+
+    let code = "
+    #![allow(warnings)]
+    use std::mem::ManuallyDrop;
+
+    #[derive(Copy)]
+    pub union MaybeUninit<T> {
+        empty: (),
+        value: ManuallyDrop<T>,
+    }
+
+    impl<T> Clone for MaybeUninit<T> where T: Copy
+    {
+        fn clone(&self) -> Self { *self }
+    }
+
+    fn main() {
+        let value1 = MaybeUninit::<[i32; 3]> { empty: () };
+        let value2 = MaybeUninit { value: ManuallyDrop::new([1, 2, 3]) };
+    }
+    ";
+
+    [feature, code].concat()
+}
+
+/// Test if a code snippet can be compiled
+fn probe(code: &str) -> bool {
+    let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
+    let out_dir = env::var_os("OUT_DIR").expect("environment variable OUT_DIR");
+
+    let mut child = Command::new(rustc)
+        .arg("--out-dir")
+        .arg(out_dir)
+        .arg("--emit=obj")
+        .arg("-")
+        .stdin(Stdio::piped())
+        .spawn()
+        .expect("rustc probe");
+
+    child
+        .stdin
+        .as_mut()
+        .expect("rustc stdin")
+        .write_all(code.as_bytes())
+        .expect("write rustc stdin");
+
+    child.wait().expect("rustc probe").success()
+}

src/array.rs

@@ -93,19 +93,19 @@ macro_rules! fix_array_impl {
     ($index_type:ty, $len:expr) => {
         unsafe impl<T> Array for [T; $len] {
             type Item = T;
-
+        
             type Index = $index_type;
-
+        
             #[inline(always)]
             fn as_ptr(&self) -> *const T {
-                self as *const _ as *const _
+                self as *const _ as *const T
             }
-
+        
             #[inline(always)]
             fn as_mut_ptr(&mut self) -> *mut T {
-                self as *mut _ as *mut _
+                self as *mut _ as *mut T
             }
-            
+        
             #[inline(always)]
             fn capacity() -> usize {
                 $len

src/error.rs

@@ -1,6 +1,6 @@
-use std::fmt;
 #[cfg(feature = "std")]
 use std::error::Error;
+use std::fmt;
 
 /// Error value indicating insufficient capacity
 ///

src/lib.rs

@@ -50,36 +50,38 @@
 //! See the [behavior module documentation](behavior/index.html) for more.
 
 #![cfg_attr(not(any(feature = "std", test)), no_std)]
+#![cfg_attr(has_union_feature, feature(untagged_unions))]
 #![deny(missing_docs)]
 
 #[cfg(not(any(feature = "std", test)))]
 extern crate core as std;
 #[cfg(feature = "use_generic_array")]
 extern crate generic_array;
 
-use std::mem;
-use std::mem::ManuallyDrop;
 use std::cmp;
 use std::cmp::Ordering;
-use std::hash::{Hash, Hasher};
-use std::marker;
 use std::fmt;
-use std::ptr;
+use std::hash::{Hash, Hasher};
 use std::iter::FromIterator;
+use std::marker;
 use std::ops::Index;
 use std::ops::IndexMut;
+use std::ptr;
+
+use array::Index as ArrayIndex;
+use behavior::Behavior;
+use maybe_uninit::MaybeUninit;
 
 mod array;
+pub mod behavior;
 mod error;
+mod maybe_uninit;
 mod range;
-pub mod behavior;
 
 pub use array::Array;
+pub use behavior::{Saturating, Wrapping};
 pub use error::CapacityError;
 pub use range::RangeArgument;
-pub use behavior::{Saturating, Wrapping};
-use behavior::Behavior;
-use array::Index as ArrayIndex;
 
 /// A fixed capacity ring buffer.
 ///
@@ -89,7 +91,7 @@ use array::Index as ArrayIndex;
 /// the queue, and `pop_front` to remove from the queue. Iterating over `ArrayDeque` goes front
 /// to back.
 pub struct ArrayDeque<A: Array, B: Behavior = Saturating> {
-    xs: ManuallyDrop<A>,
+    xs: MaybeUninit<A>,
     tail: A::Index,
     len: A::Index,
     marker: marker::PhantomData<B>,
@@ -1011,7 +1013,7 @@ impl<A: Array, B: Behavior> ArrayDeque<A, B> {
     pub fn new() -> ArrayDeque<A, B> {
         unsafe {
             ArrayDeque {
-                xs: ManuallyDrop::new(mem::uninitialized()),
+                xs: MaybeUninit::uninitialized(),
                 tail: ArrayIndex::from(0),
                 len: ArrayIndex::from(0),
                 marker: marker::PhantomData,
@@ -2023,11 +2025,7 @@ where
     }
 }
 
-impl<A: Array, B: Behavior> Eq for ArrayDeque<A, B>
-where
-    A::Item: Eq,
-{
-}
+impl<A: Array, B: Behavior> Eq for ArrayDeque<A, B> where A::Item: Eq {}
 
 impl<A: Array, B: Behavior> PartialOrd for ArrayDeque<A, B>
 where
@@ -2072,8 +2070,7 @@ impl<A: Array, B: Behavior> Index<usize> for ArrayDeque<A, B> {
                     "index out of bounds: the len is {} but the index is {}",
                     len, index
                 )
-            })
-            .unwrap()
+            }).unwrap()
     }
 }
 
@@ -2087,8 +2084,7 @@ impl<A: Array, B: Behavior> IndexMut<usize> for ArrayDeque<A, B> {
                     "index out of bounds: the len is {} but the index is {}",
                     len, index
                 )
-            })
-            .unwrap()
+            }).unwrap()
     }
 }
 
@@ -2357,8 +2353,7 @@ where
     A: Array,
     A::Item: 'a,
     B: Behavior,
-{
-}
+{}
 
 #[cfg(test)]
 mod tests {
@@ -2368,7 +2363,7 @@ mod tests {
     #[test]
     fn test_simple() {
         macro_rules! test {
-            ($behavior:ident) => ({
+            ($behavior:ident) => {{
                 let mut tester: ArrayDeque<[_; 7], $behavior> = ArrayDeque::new();
                 assert_eq!(tester.capacity(), 7);
                 assert_eq!(tester.len(), 0);
@@ -2384,7 +2379,7 @@ mod tests {
                 assert_eq!(tester.pop_front(), Some(3));
                 assert_eq!(tester.pop_front(), Some(4));
                 assert_eq!(tester.pop_front(), None);
-            })
+            }};
         }
 
         test!(Saturating);
@@ -2394,7 +2389,7 @@ mod tests {
     #[test]
     fn test_simple_reversely() {
         macro_rules! test {
-            ($behavior:ident) => ({
+            ($behavior:ident) => {{
                 let mut tester: ArrayDeque<[_; 7], $behavior> = ArrayDeque::new();
                 assert_eq!(tester.capacity(), 7);
                 assert_eq!(tester.len(), 0);
@@ -2410,7 +2405,7 @@ mod tests {
                 assert_eq!(tester.pop_back(), Some(3));
                 assert_eq!(tester.pop_back(), Some(4));
                 assert_eq!(tester.pop_back(), None);
-            })
+            }};
         }
 
         test!(Saturating);
@@ -2835,6 +2830,12 @@ mod tests {
         assert_eq!(tester, cloned)
     }
 
+    #[test]
+    fn test_option_encoding() {
+        let tester: ArrayDeque<[Box<()>; 100]> = ArrayDeque::new();
+        assert!(Some(tester).is_some());
+    }
+
     #[test]
     fn test_insert_unchecked() {
         const CAP: usize = 16;

src/maybe_uninit/maybe_uninit.rs

@@ -0,0 +1,35 @@
+use array::Array;
+use std::mem::ManuallyDrop;
+use std::ops::{Deref, DerefMut};
+
+/// A combination of ManuallyDrop and “maybe uninitialized”;
+/// this wraps a value that can be wholly or partially uninitialized;
+/// it also has no drop regardless of the type of Array.
+#[repr(C)] // for cast from self ptr to value
+pub union MaybeUninit<A: Array> {
+    empty: (),
+    value: ManuallyDrop<A>,
+}
+
+impl<A: Array> MaybeUninit<A> {
+    /// Create a new MaybeUninit with uninitialized interior
+    pub unsafe fn uninitialized() -> Self {
+        MaybeUninit { empty: () }
+    }
+}
+
+impl<A: Array> Deref for MaybeUninit<A> {
+    type Target = A;
+
+    #[inline(always)]
+    fn deref(&self) -> &A {
+        unsafe { &self.value }
+    }
+}
+
+impl<A: Array> DerefMut for MaybeUninit<A> {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut A {
+        unsafe { &mut self.value }
+    }
+}

src/maybe_uninit/maybe_uninit_nodrop.rs

@@ -0,0 +1,38 @@
+use super::nodrop::NoDrop;
+use array::Array;
+use std::mem;
+use std::ops::{Deref, DerefMut};
+
+/// A combination of NoDrop and “maybe uninitialized”;
+/// this wraps a value that can be wholly or partially uninitialized.
+///
+/// NOTE: This is known to not be a good solution, but it's the one we have kept
+/// working on stable Rust. Stable improvements are encouraged, in any form,
+/// but of course we are waiting for a real, stable, MaybeUninit.
+#[repr(C)] // for cast from self ptr to value
+pub struct MaybeUninit<T>(NoDrop<T>);
+// why don't we use ManuallyDrop here: It doesn't inhibit
+// enum layout optimizations that depend on T, and we support older Rust.
+
+impl<T> MaybeUninit<T> {
+    /// Create a new MaybeUninit with uninitialized interior
+    pub unsafe fn uninitialized() -> Self {
+        Self(NoDrop::new(mem::uninitialized()))
+    }
+}
+
+impl<A: Array> Deref for MaybeUninit<A> {
+    type Target = A;
+
+    #[inline(always)]
+    fn deref(&self) -> &A {
+        &self.0
+    }
+}
+
+impl<A: Array> DerefMut for MaybeUninit<A> {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut A {
+        &mut self.0
+    }
+}

src/maybe_uninit/mod.rs

@@ -0,0 +1,9 @@
+#[cfg(has_manually_drop_in_union)]
+mod maybe_uninit;
+#[cfg(not(has_manually_drop_in_union))]
+#[path = "maybe_uninit_nodrop.rs"]
+mod maybe_uninit;
+#[cfg(not(has_manually_drop_in_union))]
+mod nodrop;
+
+pub use self::maybe_uninit::MaybeUninit;