Refactored macro to change nightly-cfg behavior pre-expansion.

This is a breaking change.

Author: Kimundi

src/lazy.rs

@@ -0,0 +1,29 @@
+use std::sync::Once;
+
+pub struct Lazy<T: Sync>(pub *const T, pub Once);
+
+impl<T: Sync> Lazy<T> {
+    #[inline(always)]
+    pub fn get<F>(&'static mut self, f: F) -> &T
+        where F: FnOnce() -> T
+    {
+        unsafe {
+            let r = &mut self.0;
+            self.1.call_once(|| {
+                *r = Box::into_raw(Box::new(f()));
+            });
+
+            &*self.0
+        }
+    }
+}
+
+unsafe impl<T: Sync> Sync for Lazy<T> {}
+
+#[macro_export]
+macro_rules! lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        use std::sync::ONCE_INIT;
+        static mut $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy(0 as *const $T, ONCE_INIT);
+    }
+}

src/lib.rs

@@ -69,7 +69,13 @@ The `Deref` implementation uses a hidden static variable that is guarded by a at
 */
 
 #![cfg_attr(feature="nightly", feature(const_fn, core_intrinsics))]
-#![crate_type = "dylib"]
+
+#[cfg(not(feature="nightly"))]
+pub mod lazy;
+
+#[cfg(feature="nightly")]
+#[path="nightly_lazy.rs"]
+pub mod lazy;
 
 #[macro_export]
 macro_rules! lazy_static {
@@ -84,52 +90,15 @@ macro_rules! lazy_static {
         impl ::std::ops::Deref for $N {
             type Target = $T;
             fn deref<'a>(&'a self) -> &'a $T {
-                #[inline(always)]
-                fn __static_ref_initialize() -> $T { $e }
-
                 unsafe {
-                    use std::sync::{Once, ONCE_INIT};
-
-                    #[inline(always)]
-                    fn require_sync<T: Sync>(_: &T) { }
-
                     #[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 => ::std::intrinsics::unreachable(),
-                        }
-                    }
+                    fn __static_ref_initialize() -> $T { $e }
 
-                    #[inline(always)]
-                    #[cfg(not(feature="nightly"))]
                     unsafe fn __stability() -> &'static $T {
-                        use std::mem::transmute;
-                        use std::boxed::Box;
-
-                        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
+                        lazy_static_create!(LAZY, $T);
+                        LAZY.get(__static_ref_initialize)
                     }
-
-                    let static_ref = __stability();
-                    require_sync(static_ref);
-                    static_ref
+                    __stability()
                 }
             }
         }

src/nightly_lazy.rs

@@ -0,0 +1,38 @@
+use std::sync::Once;
+
+use std::cell::UnsafeCell;
+use std::sync::ONCE_INIT;
+
+pub struct Lazy<T: Sync>(UnsafeCell<Option<T>>, Once);
+
+impl<T: Sync> Lazy<T> {
+    #[inline(always)]
+    pub const fn new() -> Self {
+        Lazy(UnsafeCell::new(None), ONCE_INIT)
+    }
+
+    #[inline(always)]
+    pub fn get<F>(&'static self, f: F) -> &T
+        where F: FnOnce() -> T
+    {
+        unsafe {
+            self.1.call_once(|| {
+                *self.0.get() = Some(f());
+            });
+
+            match *self.0.get() {
+                Some(ref x) => x,
+                None => ::std::intrinsics::unreachable(),
+            }
+        }
+    }
+}
+
+unsafe impl<T: Sync> Sync for Lazy<T> {}
+
+#[macro_export]
+macro_rules! lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        static $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy::new();
+    }
+}