Made macro more hygenic by re-arranging items inside the expansion to not be

visible inside the user-provided code.

Author: Kimundi

src/lazy_static.rs

@@ -83,22 +83,22 @@ macro_rules! lazy_static {
         impl ::std::ops::Deref for $N {
             type Target = $T;
             fn deref<'a>(&'a self) -> &'a $T {
-                use std::sync::{Once, ONCE_INIT};
-                use std::mem::transmute;
-
-                #[inline(always)]
-                fn require_sync<T: Sync>(_: &T) { }
-
                 #[inline(always)]
-                fn initialize() -> Box<$T> { Box::new($e) }
+                fn __static_ref_initialize() -> Box<$T> { Box::new($e) }
 
                 unsafe {
-                    static mut __static: *const $T = 0 as *const $T;
-                    static mut __ONCE: Once = ONCE_INIT;
-                    __ONCE.call_once(|| {
-                        __static = transmute::<Box<$T>, *const $T>(initialize());
+                    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 = &*__static;
+                    let static_ref = &*DATA;
                     require_sync(static_ref);
                     static_ref
                 }

tests/test.rs

@@ -19,6 +19,7 @@ lazy_static! {
     };
     // This *should* triggger warn(dead_code) by design.
     static ref UNUSED: () = ();
+
 }
 
 fn times_two(n: u32) -> u32 {
@@ -57,3 +58,30 @@ fn test_visibility() {
 lazy_static! {
     pub static ref VAR: i32 = { 0 };
 }
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+struct X;
+struct Once(X);
+const ONCE_INIT: Once = Once(X);
+static DATA: X = X;
+static ONCE: X = X;
+fn require_sync() -> X { X }
+fn transmute() -> X { X }
+fn __static_ref_initialize() -> X { X }
+fn test(_: Vec<X>) -> X { X }
+
+// All these names should not be shadowed
+lazy_static! {
+    static ref ITEM_NAME_TEST: X = {
+        test(vec![X, Once(X).0, ONCE_INIT.0, DATA, ONCE,
+                  require_sync(), transmute(),
+                  // Except this, which will sadly be shadowed by internals:
+                  // __static_ref_initialize()
+                  ])
+    };
+}
+
+#[test]
+fn item_name_shadowing() {
+    assert_eq!(*ITEM_NAME_TEST, X);
+}