Restructure and rename thread local things in std.

6 files changed, 283 insertions, 311 deletions

diff --git a/library/std/src/sys/common/thread_local/fast_local.rs b/library/std/src/sys/common/thread_local/fast_local.rs
index e229eb16aa1..914e017f7ff 100644
--- a/library/std/src/sys/common/thread_local/fast_local.rs
+++ b/library/std/src/sys/common/thread_local/fast_local.rs
@@ -1,13 +1,14 @@
+use super::lazy::LazyKeyInner;
+use crate::cell::Cell;
+use crate::sys::thread_local_dtor::register_dtor;
+use crate::{fmt, mem, panic};
+
 #[doc(hidden)]
-#[macro_export]
-#[allow_internal_unstable(
-    thread_local_internals,
-    cfg_target_thread_local,
-    thread_local,
-    libstd_thread_internals
-)]
+#[allow_internal_unstable(thread_local_internals, cfg_target_thread_local, thread_local)]
 #[allow_internal_unsafe]
-macro_rules! __thread_local_inner {
+#[unstable(feature = "thread_local_internals", issue = "none")]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro thread_local_inner {
     // used to generate the `LocalKey` value for const-initialized thread locals
     (@key $t:ty, const $init:expr) => {{
         #[cfg_attr(not(bootstrap), inline)]
@@ -49,7 +50,7 @@ macro_rules! __thread_local_inner {
                     // 0 == we haven't registered a destructor, so do
                     //   so now.
                     0 => {
-                        $crate::thread::__LocalKeyInner::<$t>::register_dtor(
+                        $crate::thread::local_impl::Key::<$t>::register_dtor(
                             $crate::ptr::addr_of_mut!(VAL) as *mut $crate::primitive::u8,
                             destroy,
                         );
@@ -69,7 +70,7 @@ macro_rules! __thread_local_inner {
         unsafe {
             $crate::thread::LocalKey::new(__getit)
         }
-    }};
+    }},
 
     // used to generate the `LocalKey` value for `thread_local!`
     (@key $t:ty, $init:expr) => {
@@ -82,8 +83,8 @@ macro_rules! __thread_local_inner {
                 init: $crate::option::Option<&mut $crate::option::Option<$t>>,
             ) -> $crate::option::Option<&'static $t> {
                 #[thread_local]
-                static __KEY: $crate::thread::__LocalKeyInner<$t> =
-                    $crate::thread::__LocalKeyInner::<$t>::new();
+                static __KEY: $crate::thread::local_impl::Key<$t> =
+                    $crate::thread::local_impl::Key::<$t>::new();
 
                 // FIXME: remove the #[allow(...)] marker when macros don't
                 // raise warning for missing/extraneous unsafe blocks anymore.
@@ -107,148 +108,140 @@ macro_rules! __thread_local_inner {
                 $crate::thread::LocalKey::new(__getit)
             }
         }
-    };
+    },
     ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
         $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::__thread_local_inner!(@key $t, $($init)*);
-    }
+            $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
+    },
 }
 
-#[doc(hidden)]
-pub mod fast {
-    use super::super::lazy::LazyKeyInner;
-    use crate::cell::Cell;
-    use crate::sys::thread_local_dtor::register_dtor;
-    use crate::{fmt, mem, panic};
-
-    #[derive(Copy, Clone)]
-    enum DtorState {
-        Unregistered,
-        Registered,
-        RunningOrHasRun,
-    }
+#[derive(Copy, Clone)]
+enum DtorState {
+    Unregistered,
+    Registered,
+    RunningOrHasRun,
+}
 
-    // This data structure has been carefully constructed so that the fast path
-    // only contains one branch on x86. That optimization is necessary to avoid
-    // duplicated tls lookups on OSX.
+// This data structure has been carefully constructed so that the fast path
+// only contains one branch on x86. That optimization is necessary to avoid
+// duplicated tls lookups on OSX.
+//
+// LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
+pub struct Key<T> {
+    // If `LazyKeyInner::get` returns `None`, that indicates either:
+    //   * The value has never been initialized
+    //   * The value is being recursively initialized
+    //   * The value has already been destroyed or is being destroyed
+    // To determine which kind of `None`, check `dtor_state`.
     //
-    // LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
-    pub struct Key<T> {
-        // If `LazyKeyInner::get` returns `None`, that indicates either:
-        //   * The value has never been initialized
-        //   * The value is being recursively initialized
-        //   * The value has already been destroyed or is being destroyed
-        // To determine which kind of `None`, check `dtor_state`.
-        //
-        // This is very optimizer friendly for the fast path - initialized but
-        // not yet dropped.
-        inner: LazyKeyInner<T>,
+    // This is very optimizer friendly for the fast path - initialized but
+    // not yet dropped.
+    inner: LazyKeyInner<T>,
 
-        // Metadata to keep track of the state of the destructor. Remember that
-        // this variable is thread-local, not global.
-        dtor_state: Cell<DtorState>,
-    }
+    // Metadata to keep track of the state of the destructor. Remember that
+    // this variable is thread-local, not global.
+    dtor_state: Cell<DtorState>,
+}
 
-    impl<T> fmt::Debug for Key<T> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.debug_struct("Key").finish_non_exhaustive()
-        }
+impl<T> fmt::Debug for Key<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Key").finish_non_exhaustive()
     }
+}
 
-    impl<T> Key<T> {
-        pub const fn new() -> Key<T> {
-            Key { inner: LazyKeyInner::new(), dtor_state: Cell::new(DtorState::Unregistered) }
-        }
+impl<T> Key<T> {
+    pub const fn new() -> Key<T> {
+        Key { inner: LazyKeyInner::new(), dtor_state: Cell::new(DtorState::Unregistered) }
+    }
 
-        // note that this is just a publicly-callable function only for the
-        // const-initialized form of thread locals, basically a way to call the
-        // free `register_dtor` function defined elsewhere in std.
-        pub unsafe fn register_dtor(a: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
-            unsafe {
-                register_dtor(a, dtor);
-            }
+    // note that this is just a publicly-callable function only for the
+    // const-initialized form of thread locals, basically a way to call the
+    // free `register_dtor` function defined elsewhere in std.
+    pub unsafe fn register_dtor(a: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
+        unsafe {
+            register_dtor(a, dtor);
         }
+    }
 
-        pub unsafe fn get<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
-            // SAFETY: See the definitions of `LazyKeyInner::get` and
-            // `try_initialize` for more information.
-            //
-            // The caller must ensure no mutable references are ever active to
-            // the inner cell or the inner T when this is called.
-            // The `try_initialize` is dependant on the passed `init` function
-            // for this.
-            unsafe {
-                match self.inner.get() {
-                    Some(val) => Some(val),
-                    None => self.try_initialize(init),
-                }
+    pub unsafe fn get<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
+        // SAFETY: See the definitions of `LazyKeyInner::get` and
+        // `try_initialize` for more information.
+        //
+        // The caller must ensure no mutable references are ever active to
+        // the inner cell or the inner T when this is called.
+        // The `try_initialize` is dependant on the passed `init` function
+        // for this.
+        unsafe {
+            match self.inner.get() {
+                Some(val) => Some(val),
+                None => self.try_initialize(init),
             }
         }
+    }
 
-        // `try_initialize` is only called once per fast thread local variable,
-        // except in corner cases where thread_local dtors reference other
-        // thread_local's, or it is being recursively initialized.
-        //
-        // Macos: Inlining this function can cause two `tlv_get_addr` calls to
-        // be performed for every call to `Key::get`.
-        // LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
-        #[inline(never)]
-        unsafe fn try_initialize<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
+    // `try_initialize` is only called once per fast thread local variable,
+    // except in corner cases where thread_local dtors reference other
+    // thread_local's, or it is being recursively initialized.
+    //
+    // Macos: Inlining this function can cause two `tlv_get_addr` calls to
+    // be performed for every call to `Key::get`.
+    // LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
+    #[inline(never)]
+    unsafe fn try_initialize<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
+        // SAFETY: See comment above (this function doc).
+        if !mem::needs_drop::<T>() || unsafe { self.try_register_dtor() } {
             // SAFETY: See comment above (this function doc).
-            if !mem::needs_drop::<T>() || unsafe { self.try_register_dtor() } {
-                // SAFETY: See comment above (this function doc).
-                Some(unsafe { self.inner.initialize(init) })
-            } else {
-                None
-            }
+            Some(unsafe { self.inner.initialize(init) })
+        } else {
+            None
         }
+    }
 
-        // `try_register_dtor` is only called once per fast thread local
-        // variable, except in corner cases where thread_local dtors reference
-        // other thread_local's, or it is being recursively initialized.
-        unsafe fn try_register_dtor(&self) -> bool {
-            match self.dtor_state.get() {
-                DtorState::Unregistered => {
-                    // SAFETY: dtor registration happens before initialization.
-                    // Passing `self` as a pointer while using `destroy_value<T>`
-                    // is safe because the function will build a pointer to a
-                    // Key<T>, which is the type of self and so find the correct
-                    // size.
-                    unsafe { register_dtor(self as *const _ as *mut u8, destroy_value::<T>) };
-                    self.dtor_state.set(DtorState::Registered);
-                    true
-                }
-                DtorState::Registered => {
-                    // recursively initialized
-                    true
-                }
-                DtorState::RunningOrHasRun => false,
+    // `try_register_dtor` is only called once per fast thread local
+    // variable, except in corner cases where thread_local dtors reference
+    // other thread_local's, or it is being recursively initialized.
+    unsafe fn try_register_dtor(&self) -> bool {
+        match self.dtor_state.get() {
+            DtorState::Unregistered => {
+                // SAFETY: dtor registration happens before initialization.
+                // Passing `self` as a pointer while using `destroy_value<T>`
+                // is safe because the function will build a pointer to a
+                // Key<T>, which is the type of self and so find the correct
+                // size.
+                unsafe { register_dtor(self as *const _ as *mut u8, destroy_value::<T>) };
+                self.dtor_state.set(DtorState::Registered);
+                true
             }
+            DtorState::Registered => {
+                // recursively initialized
+                true
+            }
+            DtorState::RunningOrHasRun => false,
         }
     }
+}
 
-    unsafe extern "C" fn destroy_value<T>(ptr: *mut u8) {
-        let ptr = ptr as *mut Key<T>;
+unsafe extern "C" fn destroy_value<T>(ptr: *mut u8) {
+    let ptr = ptr as *mut Key<T>;
 
-        // SAFETY:
-        //
-        // The pointer `ptr` has been built just above and comes from
-        // `try_register_dtor` where it is originally a Key<T> coming from `self`,
-        // making it non-NUL and of the correct type.
-        //
-        // Right before we run the user destructor be sure to set the
-        // `Option<T>` to `None`, and `dtor_state` to `RunningOrHasRun`. This
-        // causes future calls to `get` to run `try_initialize_drop` again,
-        // which will now fail, and return `None`.
-        //
-        // Wrap the call in a catch to ensure unwinding is caught in the event
-        // a panic takes place in a destructor.
-        if let Err(_) = panic::catch_unwind(panic::AssertUnwindSafe(|| unsafe {
-            let value = (*ptr).inner.take();
-            (*ptr).dtor_state.set(DtorState::RunningOrHasRun);
-            drop(value);
-        })) {
-            rtabort!("thread local panicked on drop");
-        }
+    // SAFETY:
+    //
+    // The pointer `ptr` has been built just above and comes from
+    // `try_register_dtor` where it is originally a Key<T> coming from `self`,
+    // making it non-NUL and of the correct type.
+    //
+    // Right before we run the user destructor be sure to set the
+    // `Option<T>` to `None`, and `dtor_state` to `RunningOrHasRun`. This
+    // causes future calls to `get` to run `try_initialize_drop` again,
+    // which will now fail, and return `None`.
+    //
+    // Wrap the call in a catch to ensure unwinding is caught in the event
+    // a panic takes place in a destructor.
+    if let Err(_) = panic::catch_unwind(panic::AssertUnwindSafe(|| unsafe {
+        let value = (*ptr).inner.take();
+        (*ptr).dtor_state.set(DtorState::RunningOrHasRun);
+        drop(value);
+    })) {
+        rtabort!("thread local panicked on drop");
     }
 }
diff --git a/library/std/src/sys/common/thread_local/mod.rs b/library/std/src/sys/common/thread_local/mod.rs
index 1fee84a0434..a7528c06c9d 100644
--- a/library/std/src/sys/common/thread_local/mod.rs
+++ b/library/std/src/sys/common/thread_local/mod.rs
@@ -1,35 +1,24 @@
-//! The following module declarations are outside cfg_if because the internal
-//! `__thread_local_internal` macro does not seem to be exported properly when using cfg_if
 #![unstable(feature = "thread_local_internals", reason = "should not be necessary", issue = "none")]
 
-#[cfg(all(target_thread_local, not(all(target_family = "wasm", not(target_feature = "atomics")))))]
-mod fast_local;
-#[cfg(all(
-    not(target_thread_local),
-    not(all(target_family = "wasm", not(target_feature = "atomics")))
-))]
-mod os_local;
-#[cfg(all(target_family = "wasm", not(target_feature = "atomics")))]
-mod static_local;
-
-#[cfg(not(test))]
 cfg_if::cfg_if! {
     if #[cfg(all(target_family = "wasm", not(target_feature = "atomics")))] {
         #[doc(hidden)]
-        pub use static_local::statik::Key;
-    } else if #[cfg(all(target_thread_local, not(all(target_family = "wasm", not(target_feature = "atomics")))))] {
+        mod static_local;
+        #[doc(hidden)]
+        pub use static_local::{Key, thread_local_inner};
+    } else if #[cfg(all(target_thread_local))] {
+        #[doc(hidden)]
+        mod fast_local;
         #[doc(hidden)]
-        pub use fast_local::fast::Key;
-    } else if #[cfg(all(not(target_thread_local), not(all(target_family = "wasm", not(target_feature = "atomics")))))] {
+        pub use fast_local::{Key, thread_local_inner};
+    } else {
         #[doc(hidden)]
-        pub use os_local::os::Key;
+        mod os_local;
+        #[doc(hidden)]
+        pub use os_local::{Key, thread_local_inner};
     }
 }
 
-#[doc(hidden)]
-#[cfg(test)]
-pub use realstd::thread::__LocalKeyInner as Key;
-
 mod lazy {
     use crate::cell::UnsafeCell;
     use crate::hint;
diff --git a/library/std/src/sys/common/thread_local/os_local.rs b/library/std/src/sys/common/thread_local/os_local.rs
index 1442a397e76..e9516f9983f 100644
--- a/library/std/src/sys/common/thread_local/os_local.rs
+++ b/library/std/src/sys/common/thread_local/os_local.rs
@@ -1,13 +1,14 @@
+use super::lazy::LazyKeyInner;
+use crate::cell::Cell;
+use crate::sys_common::thread_local_key::StaticKey as OsStaticKey;
+use crate::{fmt, marker, panic, ptr};
+
 #[doc(hidden)]
-#[macro_export]
-#[allow_internal_unstable(
-    thread_local_internals,
-    cfg_target_thread_local,
-    thread_local,
-    libstd_thread_internals
-)]
+#[allow_internal_unstable(thread_local_internals)]
 #[allow_internal_unsafe]
-macro_rules! __thread_local_inner {
+#[unstable(feature = "thread_local_internals", issue = "none")]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro thread_local_inner {
     // used to generate the `LocalKey` value for const-initialized thread locals
     (@key $t:ty, const $init:expr) => {{
         #[cfg_attr(not(bootstrap), inline)]
@@ -21,8 +22,8 @@ macro_rules! __thread_local_inner {
             // same implementation as below for os thread locals.
             #[inline]
             const fn __init() -> $t { INIT_EXPR }
-            static __KEY: $crate::thread::__LocalKeyInner<$t> =
-                $crate::thread::__LocalKeyInner::new();
+            static __KEY: $crate::thread::local_impl::Key<$t> =
+                $crate::thread::local_impl::Key::new();
             #[allow(unused_unsafe)]
             unsafe {
                 __KEY.get(move || {
@@ -41,7 +42,7 @@ macro_rules! __thread_local_inner {
         unsafe {
             $crate::thread::LocalKey::new(__getit)
         }
-    }};
+    }},
 
     // used to generate the `LocalKey` value for `thread_local!`
     (@key $t:ty, $init:expr) => {
@@ -55,8 +56,8 @@ macro_rules! __thread_local_inner {
             unsafe fn __getit(
                 init: $crate::option::Option<&mut $crate::option::Option<$t>>,
             ) -> $crate::option::Option<&'static $t> {
-                static __KEY: $crate::thread::__LocalKeyInner<$t> =
-                    $crate::thread::__LocalKeyInner::new();
+                static __KEY: $crate::thread::local_impl::Key<$t> =
+                    $crate::thread::local_impl::Key::new();
 
                 // FIXME: remove the #[allow(...)] marker when macros don't
                 // raise warning for missing/extraneous unsafe blocks anymore.
@@ -80,118 +81,110 @@ macro_rules! __thread_local_inner {
                 $crate::thread::LocalKey::new(__getit)
             }
         }
-    };
+    },
     ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
         $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::__thread_local_inner!(@key $t, $($init)*);
-    }
+            $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
+    },
 }
 
-#[doc(hidden)]
-pub mod os {
-    use super::super::lazy::LazyKeyInner;
-    use crate::cell::Cell;
-    use crate::sys_common::thread_local_key::StaticKey as OsStaticKey;
-    use crate::{fmt, marker, panic, ptr};
-
-    /// Use a regular global static to store this key; the state provided will then be
-    /// thread-local.
-    pub struct Key<T> {
-        // OS-TLS key that we'll use to key off.
-        os: OsStaticKey,
-        marker: marker::PhantomData<Cell<T>>,
-    }
+/// Use a regular global static to store this key; the state provided will then be
+/// thread-local.
+pub struct Key<T> {
+    // OS-TLS key that we'll use to key off.
+    os: OsStaticKey,
+    marker: marker::PhantomData<Cell<T>>,
+}
 
-    impl<T> fmt::Debug for Key<T> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.debug_struct("Key").finish_non_exhaustive()
-        }
+impl<T> fmt::Debug for Key<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Key").finish_non_exhaustive()
     }
+}
 
-    unsafe impl<T> Sync for Key<T> {}
+unsafe impl<T> Sync for Key<T> {}
 
-    struct Value<T: 'static> {
-        inner: LazyKeyInner<T>,
-        key: &'static Key<T>,
+struct Value<T: 'static> {
+    inner: LazyKeyInner<T>,
+    key: &'static Key<T>,
+}
+
+impl<T: 'static> Key<T> {
+    #[rustc_const_unstable(feature = "thread_local_internals", issue = "none")]
+    pub const fn new() -> Key<T> {
+        Key { os: OsStaticKey::new(Some(destroy_value::<T>)), marker: marker::PhantomData }
     }
 
-    impl<T: 'static> Key<T> {
-        #[rustc_const_unstable(feature = "thread_local_internals", issue = "none")]
-        pub const fn new() -> Key<T> {
-            Key { os: OsStaticKey::new(Some(destroy_value::<T>)), marker: marker::PhantomData }
+    /// It is a requirement for the caller to ensure that no mutable
+    /// reference is active when this method is called.
+    pub unsafe fn get(&'static self, init: impl FnOnce() -> T) -> Option<&'static T> {
+        // SAFETY: See the documentation for this method.
+        let ptr = unsafe { self.os.get() as *mut Value<T> };
+        if ptr.addr() > 1 {
+            // SAFETY: the check ensured the pointer is safe (its destructor
+            // is not running) + it is coming from a trusted source (self).
+            if let Some(ref value) = unsafe { (*ptr).inner.get() } {
+                return Some(value);
+            }
         }
+        // SAFETY: At this point we are sure we have no value and so
+        // initializing (or trying to) is safe.
+        unsafe { self.try_initialize(init) }
+    }
 
-        /// It is a requirement for the caller to ensure that no mutable
-        /// reference is active when this method is called.
-        pub unsafe fn get(&'static self, init: impl FnOnce() -> T) -> Option<&'static T> {
-            // SAFETY: See the documentation for this method.
-            let ptr = unsafe { self.os.get() as *mut Value<T> };
-            if ptr.addr() > 1 {
-                // SAFETY: the check ensured the pointer is safe (its destructor
-                // is not running) + it is coming from a trusted source (self).
-                if let Some(ref value) = unsafe { (*ptr).inner.get() } {
-                    return Some(value);
-                }
-            }
-            // SAFETY: At this point we are sure we have no value and so
-            // initializing (or trying to) is safe.
-            unsafe { self.try_initialize(init) }
+    // `try_initialize` is only called once per os thread local variable,
+    // except in corner cases where thread_local dtors reference other
+    // thread_local's, or it is being recursively initialized.
+    unsafe fn try_initialize(&'static self, init: impl FnOnce() -> T) -> Option<&'static T> {
+        // SAFETY: No mutable references are ever handed out meaning getting
+        // the value is ok.
+        let ptr = unsafe { self.os.get() as *mut Value<T> };
+        if ptr.addr() == 1 {
+            // destructor is running
+            return None;
         }
 
-        // `try_initialize` is only called once per os thread local variable,
-        // except in corner cases where thread_local dtors reference other
-        // thread_local's, or it is being recursively initialized.
-        unsafe fn try_initialize(&'static self, init: impl FnOnce() -> T) -> Option<&'static T> {
-            // SAFETY: No mutable references are ever handed out meaning getting
-            // the value is ok.
-            let ptr = unsafe { self.os.get() as *mut Value<T> };
-            if ptr.addr() == 1 {
-                // destructor is running
-                return None;
+        let ptr = if ptr.is_null() {
+            // If the lookup returned null, we haven't initialized our own
+            // local copy, so do that now.
+            let ptr = Box::into_raw(Box::new(Value { inner: LazyKeyInner::new(), key: self }));
+            // SAFETY: At this point we are sure there is no value inside
+            // ptr so setting it will not affect anyone else.
+            unsafe {
+                self.os.set(ptr as *mut u8);
             }
-
-            let ptr = if ptr.is_null() {
-                // If the lookup returned null, we haven't initialized our own
-                // local copy, so do that now.
-                let ptr = Box::into_raw(Box::new(Value { inner: LazyKeyInner::new(), key: self }));
-                // SAFETY: At this point we are sure there is no value inside
-                // ptr so setting it will not affect anyone else.
-                unsafe {
-                    self.os.set(ptr as *mut u8);
-                }
-                ptr
-            } else {
-                // recursive initialization
-                ptr
-            };
-
-            // SAFETY: ptr has been ensured as non-NUL just above an so can be
-            // dereferenced safely.
-            unsafe { Some((*ptr).inner.initialize(init)) }
-        }
+            ptr
+        } else {
+            // recursive initialization
+            ptr
+        };
+
+        // SAFETY: ptr has been ensured as non-NUL just above an so can be
+        // dereferenced safely.
+        unsafe { Some((*ptr).inner.initialize(init)) }
     }
+}
 
-    unsafe extern "C" fn destroy_value<T: 'static>(ptr: *mut u8) {
-        // SAFETY:
-        //
-        // The OS TLS ensures that this key contains a null value when this
-        // destructor starts to run. We set it back to a sentinel value of 1 to
-        // ensure that any future calls to `get` for this thread will return
-        // `None`.
-        //
-        // Note that to prevent an infinite loop we reset it back to null right
-        // before we return from the destructor ourselves.
-        //
-        // Wrap the call in a catch to ensure unwinding is caught in the event
-        // a panic takes place in a destructor.
-        if let Err(_) = panic::catch_unwind(|| unsafe {
-            let ptr = Box::from_raw(ptr as *mut Value<T>);
-            let key = ptr.key;
-            key.os.set(ptr::invalid_mut(1));
-            drop(ptr);
-            key.os.set(ptr::null_mut());
-        }) {
-            rtabort!("thread local panicked on drop");
-        }
+unsafe extern "C" fn destroy_value<T: 'static>(ptr: *mut u8) {
+    // SAFETY:
+    //
+    // The OS TLS ensures that this key contains a null value when this
+    // destructor starts to run. We set it back to a sentinel value of 1 to
+    // ensure that any future calls to `get` for this thread will return
+    // `None`.
+    //
+    // Note that to prevent an infinite loop we reset it back to null right
+    // before we return from the destructor ourselves.
+    //
+    // Wrap the call in a catch to ensure unwinding is caught in the event
+    // a panic takes place in a destructor.
+    if let Err(_) = panic::catch_unwind(|| unsafe {
+        let ptr = Box::from_raw(ptr as *mut Value<T>);
+        let key = ptr.key;
+        key.os.set(ptr::invalid_mut(1));
+        drop(ptr);
+        key.os.set(ptr::null_mut());
+    }) {
+        rtabort!("thread local panicked on drop");
     }
 }
diff --git a/library/std/src/sys/common/thread_local/static_local.rs b/library/std/src/sys/common/thread_local/static_local.rs
index ec4f2a12b7e..80322a97864 100644
--- a/library/std/src/sys/common/thread_local/static_local.rs
+++ b/library/std/src/sys/common/thread_local/static_local.rs
@@ -1,13 +1,12 @@
+use super::lazy::LazyKeyInner;
+use crate::fmt;
+
 #[doc(hidden)]
-#[macro_export]
-#[allow_internal_unstable(
-    thread_local_internals,
-    cfg_target_thread_local,
-    thread_local,
-    libstd_thread_internals
-)]
+#[allow_internal_unstable(thread_local_internals)]
 #[allow_internal_unsafe]
-macro_rules! __thread_local_inner {
+#[unstable(feature = "thread_local_internals", issue = "none")]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro thread_local_inner {
     // used to generate the `LocalKey` value for const-initialized thread locals
     (@key $t:ty, const $init:expr) => {{
         #[inline] // see comments below
@@ -30,7 +29,7 @@ macro_rules! __thread_local_inner {
         unsafe {
             $crate::thread::LocalKey::new(__getit)
         }
-    }};
+    }},
 
     // used to generate the `LocalKey` value for `thread_local!`
     (@key $t:ty, $init:expr) => {
@@ -41,8 +40,8 @@ macro_rules! __thread_local_inner {
             unsafe fn __getit(
                 init: $crate::option::Option<&mut $crate::option::Option<$t>>,
             ) -> $crate::option::Option<&'static $t> {
-                static __KEY: $crate::thread::__LocalKeyInner<$t> =
-                    $crate::thread::__LocalKeyInner::new();
+                static __KEY: $crate::thread::local_impl::Key<$t> =
+                    $crate::thread::local_impl::Key::new();
 
                 // FIXME: remove the #[allow(...)] marker when macros don't
                 // raise warning for missing/extraneous unsafe blocks anymore.
@@ -66,50 +65,45 @@ macro_rules! __thread_local_inner {
                 $crate::thread::LocalKey::new(__getit)
             }
         }
-    };
+    },
     ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
         $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
-            $crate::__thread_local_inner!(@key $t, $($init)*);
-    }
+            $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
+    },
 }
 
 /// On some targets like wasm there's no threads, so no need to generate
 /// thread locals and we can instead just use plain statics!
-#[doc(hidden)]
-pub mod statik {
-    use super::super::lazy::LazyKeyInner;
-    use crate::fmt;
 
-    pub struct Key<T> {
-        inner: LazyKeyInner<T>,
-    }
+pub struct Key<T> {
+    inner: LazyKeyInner<T>,
+}
 
-    unsafe impl<T> Sync for Key<T> {}
+unsafe impl<T> Sync for Key<T> {}
 
-    impl<T> fmt::Debug for Key<T> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.debug_struct("Key").finish_non_exhaustive()
-        }
+impl<T> fmt::Debug for Key<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Key").finish_non_exhaustive()
     }
+}
 
-    impl<T> Key<T> {
-        pub const fn new() -> Key<T> {
-            Key { inner: LazyKeyInner::new() }
-        }
+impl<T> Key<T> {
+    pub const fn new() -> Key<T> {
+        Key { inner: LazyKeyInner::new() }
+    }
 
-        pub unsafe fn get(&self, init: impl FnOnce() -> T) -> Option<&'static T> {
-            // SAFETY: The caller must ensure no reference is ever handed out to
-            // the inner cell nor mutable reference to the Option<T> inside said
-            // cell. This make it safe to hand a reference, though the lifetime
-            // of 'static is itself unsafe, making the get method unsafe.
-            let value = unsafe {
-                match self.inner.get() {
-                    Some(ref value) => value,
-                    None => self.inner.initialize(init),
-                }
-            };
+    pub unsafe fn get(&self, init: impl FnOnce() -> T) -> Option<&'static T> {
+        // SAFETY: The caller must ensure no reference is ever handed out to
+        // the inner cell nor mutable reference to the Option<T> inside said
+        // cell. This make it safe to hand a reference, though the lifetime
+        // of 'static is itself unsafe, making the get method unsafe.
+        let value = unsafe {
+            match self.inner.get() {
+                Some(ref value) => value,
+                None => self.inner.initialize(init),
+            }
+        };
 
-            Some(value)
-        }
+        Some(value)
     }
 }
diff --git a/library/std/src/thread/local.rs b/library/std/src/thread/local.rs
index 7fdf03acc14..fa08fdc1653 100644
--- a/library/std/src/thread/local.rs
+++ b/library/std/src/thread/local.rs
@@ -153,23 +153,23 @@ macro_rules! thread_local {
     () => {};
 
     ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = const { $init:expr }; $($rest:tt)*) => (
-        $crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
+        $crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
         $crate::thread_local!($($rest)*);
     );
 
     ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = const { $init:expr }) => (
-        $crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
+        $crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, const $init);
     );
 
     // process multiple declarations
     ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr; $($rest:tt)*) => (
-        $crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
+        $crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
         $crate::thread_local!($($rest)*);
     );
 
     // handle a single declaration
     ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr) => (
-        $crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
+        $crate::thread::local_impl::thread_local_inner!($(#[$attr])* $vis $name, $t, $init);
     );
 }
 
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 13b845b25c9..e8dc7cf9281 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -204,9 +204,12 @@ pub use self::local::{AccessError, LocalKey};
 // by the elf linker. "static" is for single-threaded platforms where a global
 // static is sufficient.
 
+// Implementation details used by the thread_local!{} macro.
 #[doc(hidden)]
-#[unstable(feature = "libstd_thread_internals", issue = "none")]
-pub use crate::sys::common::thread_local::Key as __LocalKeyInner;
+#[unstable(feature = "thread_local_internals", issue = "none")]
+pub mod local_impl {
+    pub use crate::sys::common::thread_local::{thread_local_inner, Key};
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // Builder