Made macro not use a heap allocation on nightly

Author: Kimundi

src/lib.rs

@@ -71,6 +71,7 @@ define uninitialized `static mut` values.
 
 */
 
+#![cfg_attr(feature="nightly", feature(const_fn))]
 #![crate_type = "dylib"]
 
 #[macro_export]
@@ -87,21 +88,48 @@ macro_rules! lazy_static {
             type Target = $T;
             fn deref<'a>(&'a self) -> &'a $T {
                 #[inline(always)]
-                fn __static_ref_initialize() -> Box<$T> { Box::new($e) }
+                fn __static_ref_initialize() -> $T { $e }
 
                 unsafe {
                     use std::sync::{Once, ONCE_INIT};
-                    use std::mem::transmute;
 
                     #[inline(always)]
                     fn require_sync<T: Sync>(_: &T) { }
 
-                    static mut DATA: *const $T = 0 as *const $T;
-                    static mut ONCE: Once = ONCE_INIT;
-                    ONCE.call_once(|| {
-                        DATA = transmute::<Box<$T>, *const $T>(__static_ref_initialize());
-                    });
-                    let static_ref = &*DATA;
+                    #[inline(always)]
+                    #[cfg(feature="nightly")]
+                    unsafe fn __stability() -> &'static $T {
+                        use std::cell::UnsafeCell;
+
+                        struct SyncCell(UnsafeCell<Option<$T>>);
+                        unsafe impl Sync for SyncCell {}
+
+                        static DATA: SyncCell = SyncCell(UnsafeCell::new(None));
+                        static ONCE: Once = ONCE_INIT;
+                        ONCE.call_once(|| {
+                            *DATA.0.get() = Some(__static_ref_initialize());
+                        });
+                        match *DATA.0.get() {
+                            Some(ref x) => x,
+                            None => loop { /* unreachable */ },
+                        }
+                    }
+
+                    #[inline(always)]
+                    #[cfg(not(feature="nightly"))]
+                    unsafe fn __stability() -> &'static $T {
+                        use std::mem::transmute;
+
+                        static mut DATA: *const $T = 0 as *const $T;
+                        static mut ONCE: Once = ONCE_INIT;
+                        ONCE.call_once(|| {
+                            DATA = transmute::<Box<$T>, *const $T>(
+                                Box::new(__static_ref_initialize()));
+                        });
+                        &*DATA
+                    }
+
+                    let static_ref = __stability();
                     require_sync(static_ref);
                     static_ref
                 }

tests/test.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(feature="nightly", feature(const_fn))]
+
 #[macro_use]
 extern crate lazy_static;
 use std::collections::HashMap;