Remove stdlib.rs

Since `core` and `alloc` are unconditionally available, there was no
need to use a facade module for most of std. The only exceptions were for
`Mutex` and `Once`, which are only available with the full standard
library. These had a `sync` module added to `tracing-core` which acts as
a facade, re-exporting `std` if available and `spin` if not.

tracing-core/src/callsite.rs

@@ -1,11 +1,11 @@
 //! Callsites represent the source locations from which spans or events
 //! originate.
-use crate::stdlib::{
+use core::{
     fmt,
     hash::{Hash, Hasher},
-    sync::Mutex,
-    vec::Vec,
 };
+use alloc::vec::Vec;
+use crate::sync::Mutex;
 use crate::{
     dispatcher::{self, Dispatch},
     metadata::{LevelFilter, Metadata},

tracing-core/src/dispatcher.rs

@@ -138,17 +138,17 @@ use crate::{
     Event, LevelFilter, Metadata,
 };
 
-use crate::stdlib::{
+use core::{
     any::Any,
     fmt,
     sync::{
         atomic::{AtomicBool, AtomicUsize, Ordering},
-        Arc, Weak,
     },
 };
+use alloc::sync::{Arc, Weak};
 
 #[cfg(feature = "std")]
-use crate::stdlib::{
+use std::{
     cell::{Cell, RefCell, RefMut},
     error,
 };
@@ -784,8 +784,6 @@ impl Drop for DefaultGuard {
 #[cfg(test)]
 mod test {
     use super::*;
-    #[cfg(feature = "std")]
-    use crate::stdlib::sync::atomic::{AtomicUsize, Ordering};
     use crate::{
         callsite::Callsite,
         metadata::{Kind, Level, Metadata},

tracing-core/src/field.rs

@@ -39,7 +39,7 @@
 //! [`Value::record`]: trait.Value.html#method.record
 //! [`Visit`]: trait.Visit.html
 use crate::callsite;
-use crate::stdlib::{
+use core::{
     borrow::Borrow,
     fmt,
     hash::{Hash, Hasher},
@@ -833,7 +833,7 @@ impl_valid_len! {
 mod test {
     use super::*;
     use crate::metadata::{Kind, Level, Metadata};
-    use crate::stdlib::{borrow::ToOwned, string::String};
+    use alloc::{borrow::ToOwned, string::String};
 
     struct TestCallsite1;
     static TEST_CALLSITE_1: TestCallsite1 = TestCallsite1;
@@ -934,7 +934,7 @@ mod test {
 
         struct MyVisitor;
         impl Visit for MyVisitor {
-            fn record_debug(&mut self, field: &Field, _: &dyn (crate::stdlib::fmt::Debug)) {
+            fn record_debug(&mut self, field: &Field, _: &dyn (core::fmt::Debug)) {
                 assert_eq!(field.callsite(), TEST_META_1.callsite())
             }
         }
@@ -953,7 +953,7 @@ mod test {
 
         struct MyVisitor;
         impl Visit for MyVisitor {
-            fn record_debug(&mut self, field: &Field, _: &dyn (crate::stdlib::fmt::Debug)) {
+            fn record_debug(&mut self, field: &Field, _: &dyn (core::fmt::Debug)) {
                 assert_eq!(field.name(), "bar")
             }
         }
@@ -972,7 +972,7 @@ mod test {
         let valueset = fields.value_set(values);
         let mut result = String::new();
         valueset.record(&mut |_: &Field, value: &dyn fmt::Debug| {
-            use crate::stdlib::fmt::Write;
+            use core::fmt::Write;
             write!(&mut result, "{:?}", value).unwrap();
         });
         assert_eq!(result, "123".to_owned());

tracing-core/src/lib.rs

@@ -114,7 +114,7 @@
     unused_parens,
     while_true
 )]
-#[cfg(not(feature = "std"))]
+
 extern crate alloc;
 
 /// Statically constructs an [`Identifier`] for the provided [`Callsite`].
@@ -240,17 +240,27 @@ extern crate lazy_static;
 #[macro_use]
 mod lazy_static;
 
-// Trimmed-down vendored version of spin 0.5.2 (0387621)
-// Dependency of no_std lazy_static, not required in a std build
+// Facade module: `no_std` uses spinlocks, `std` uses the mutexes in the standard library
 #[cfg(not(feature = "std"))]
-pub(crate) mod spin;
+mod sync {
+    #[doc(hidden)]
+    pub type Once = crate::spin::Once<()>;
+    pub(crate) use crate::spin::*;
+}
 
 #[cfg(not(feature = "std"))]
-#[doc(hidden)]
-pub type Once = self::spin::Once<()>;
+// Trimmed-down vendored version of spin 0.5.2 (0387621)
+// Dependency of no_std lazy_static, not required in a std build
+pub(crate) mod spin;
 
 #[cfg(feature = "std")]
-pub use stdlib::sync::Once;
+mod sync {
+    pub use std::sync::Once;
+    pub(crate) use std::sync::Mutex;
+}
+
+#[doc(hidden)]
+pub use self::sync::Once;
 
 pub mod callsite;
 pub mod dispatcher;
@@ -259,7 +269,6 @@ pub mod field;
 pub mod metadata;
 mod parent;
 pub mod span;
-pub(crate) mod stdlib;
 pub mod subscriber;
 
 #[doc(inline)]

tracing-core/src/metadata.rs

@@ -1,6 +1,6 @@
 //! Metadata describing trace data.
 use super::{callsite, field};
-use crate::stdlib::{
+use core::{
     cmp, fmt,
     str::FromStr,
     sync::atomic::{AtomicUsize, Ordering},
@@ -299,7 +299,7 @@ impl fmt::Display for Level {
 
 #[cfg(feature = "std")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-impl crate::stdlib::error::Error for ParseLevelError {}
+impl std::error::Error for ParseLevelError {}
 
 impl FromStr for Level {
     type Err = ParseLevelError;
@@ -481,7 +481,7 @@ impl LevelFilter {
                 // the inputs to `set_max` to the set of valid discriminants.
                 // Therefore, **as long as `MAX_VALUE` is only ever set by
                 // `set_max`**, this is safe.
-                crate::stdlib::hint::unreachable_unchecked()
+                core::hint::unreachable_unchecked()
             },
         }
     }
@@ -799,7 +799,7 @@ impl PartialOrd<Level> for LevelFilter {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::stdlib::mem;
+    use core::mem;
 
     #[test]
     fn level_from_str() {

tracing-core/src/span.rs

@@ -1,6 +1,6 @@
 //! Spans represent periods of time in the execution of a program.
 use crate::parent::Parent;
-use crate::stdlib::num::NonZeroU64;
+use core::num::NonZeroU64;
 use crate::{field, Metadata};
 
 /// Identifies a span within the context of a subscriber.

tracing-core/src/spin/mutex.rs

@@ -49,12 +49,12 @@ impl<T: ?Sized> Mutex<T> {
     ///
     /// The returned value may be dereferenced for data access
     /// and the lock will be dropped when the guard falls out of scope.
-    pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
+    pub(crate) fn lock(&self) -> Result<MutexGuard<'_, T>, core::convert::Infallible> {
         self.obtain_lock();
-        MutexGuard {
+        Ok(MutexGuard {
             lock: &self.lock,
             data: unsafe { &mut *self.data.get() },
-        }
+        })
     }
 
     /// Tries to lock the mutex. If it is already locked, it will return None. Otherwise it returns

tracing-core/src/subscriber.rs

@@ -1,7 +1,7 @@
 //! Subscribers collect and record trace data.
 use crate::{span, Event, LevelFilter, Metadata};
 
-use crate::stdlib::any::{Any, TypeId};
+use core::any::{Any, TypeId};
 
 /// Trait representing the functions required to collect trace data.
 ///

tracing-futures/src/executor/futures_preview.rs

@@ -1,4 +1,4 @@
-use crate::stdlib::future::Future;
+use core::future::Future;
 use crate::{Instrument, Instrumented, WithDispatch};
 use futures_core_preview::{
     future::FutureObj,

tracing-futures/src/lib.rs

@@ -105,10 +105,8 @@
 #[cfg(feature = "std-future")]
 use pin_project::pin_project;
 
-pub(crate) mod stdlib;
-
 #[cfg(feature = "std-future")]
-use crate::stdlib::{pin::Pin, task::Context};
+use core::{pin::Pin, task::Context};
 
 #[cfg(feature = "std")]
 use tracing::{dispatcher, Dispatch};
@@ -274,10 +272,10 @@ impl<T: Sized> Instrument for T {}
 
 #[cfg(feature = "std-future")]
 #[cfg_attr(docsrs, doc(cfg(feature = "std-future")))]
-impl<T: crate::stdlib::future::Future> crate::stdlib::future::Future for Instrumented<T> {
+impl<T: core::future::Future> core::future::Future for Instrumented<T> {
     type Output = T::Output;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> crate::stdlib::task::Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> core::task::Poll<Self::Output> {
         let this = self.project();
         let _enter = this.span.enter();
         this.inner.poll(cx)
@@ -445,10 +443,10 @@ impl<T: futures_01::Future> futures_01::Future for WithDispatch<T> {
 
 #[cfg(all(feature = "std-future", feature = "std"))]
 #[cfg_attr(docsrs, doc(cfg(all(feature = "std-future", feature = "std"))))]
-impl<T: crate::stdlib::future::Future> crate::stdlib::future::Future for WithDispatch<T> {
+impl<T: core::future::Future> core::future::Future for WithDispatch<T> {
     type Output = T::Output;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> crate::stdlib::task::Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> core::task::Poll<Self::Output> {
         let this = self.project();
         let dispatch = this.dispatch;
         let future = this.inner;

tracing/src/instrument.rs

@@ -1,6 +1,6 @@
-use crate::stdlib::pin::Pin;
-use crate::stdlib::task::{Context, Poll};
-use crate::stdlib::{future::Future, marker::Sized};
+use core::pin::Pin;
+use core::task::{Context, Poll};
+use core::{future::Future, marker::Sized};
 use crate::{dispatcher, span::Span, Dispatch};
 use pin_project_lite::pin_project;