Merge pull request #2608 from osiewicz/extract_serde_core

feat: Extract serde_core out of serde crate

Author: dtolnay

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
     "serde",
+    "serde_core",
     "serde_derive",
     "serde_derive_internals",
     "test_suite",

serde/Cargo.toml

@@ -15,16 +15,17 @@ repository = "https://github.com/serde-rs/serde"
 rust-version = "1.56"
 
 [dependencies]
+serde_core = { version = "=1.0.219", path = "../serde_core", default-features = false }
 serde_derive = { version = "1", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1", path = "../serde_derive" }
 
 [package.metadata.playground]
-features = ["derive", "rc"]
+features = ["derive", "rc", "result"]
 
 [package.metadata.docs.rs]
-features = ["derive", "rc", "unstable"]
+features = ["derive", "rc", "result", "unstable"]
 targets = ["x86_64-unknown-linux-gnu"]
 rustdoc-args = [
     "--generate-link-to-definition",
@@ -45,27 +46,32 @@ serde_derive = { version = "=1.0.219", path = "../serde_derive" }
 ### FEATURES #################################################################
 
 [features]
-default = ["std"]
+default = ["std", "result"]
 
 # Provide derive(Serialize, Deserialize) macros.
 derive = ["serde_derive"]
 
 # Provide impls for common standard library types like Vec<T> and HashMap<K, V>.
 # Requires a dependency on the Rust standard library.
-std = []
+std = ["serde_core/std"]
 
 # Provide impls for types that require unstable functionality. For tracking and
 # discussion of unstable functionality please refer to this issue:
 #
 #    https://github.com/serde-rs/serde/issues/812
-unstable = []
+unstable = ["serde_core/unstable"]
 
 # Provide impls for types in the Rust core allocation and collections library
 # including String, Box<T>, Vec<T>, and Cow<T>. This is a subset of std but may
 # be enabled without depending on all of std.
-alloc = []
+alloc = ["serde_core/alloc"]
 
 # Opt into impls for Rc<T> and Arc<T>. Serializing and deserializing these types
 # does not preserve identity and may result in multiple copies of the same data.
 # Be sure that this is what you want before enabling this feature.
-rc = []
+rc = ["serde_core/rc"]
+
+# Provide impls for Result<T, E>. Enabling these impls allows for serialization
+# and deserialization of Result types, which may be useful in certain contexts
+# but could lead to confusion if ? or unwrap are overused.
+result = ["serde_core/result"]

serde/build.rs

@@ -14,75 +14,13 @@ fn main() {
     };
 
     if minor >= 77 {
-        println!("cargo:rustc-check-cfg=cfg(no_core_cstr)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_error)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_net)");
-        println!("cargo:rustc-check-cfg=cfg(no_core_num_saturating)");
-        println!("cargo:rustc-check-cfg=cfg(no_diagnostic_namespace)");
         println!("cargo:rustc-check-cfg=cfg(no_serde_derive)");
-        println!("cargo:rustc-check-cfg=cfg(no_std_atomic)");
-        println!("cargo:rustc-check-cfg=cfg(no_std_atomic64)");
-        println!("cargo:rustc-check-cfg=cfg(no_target_has_atomic)");
-    }
-
-    let target = env::var("TARGET").unwrap();
-    let emscripten = target == "asmjs-unknown-emscripten" || target == "wasm32-unknown-emscripten";
-
-    // Support for #[cfg(target_has_atomic = "...")] stabilized in Rust 1.60.
-    if minor < 60 {
-        println!("cargo:rustc-cfg=no_target_has_atomic");
-        // Allowlist of archs that support std::sync::atomic module. This is
-        // based on rustc's compiler/rustc_target/src/spec/*.rs.
-        let has_atomic64 = target.starts_with("x86_64")
-            || target.starts_with("i686")
-            || target.starts_with("aarch64")
-            || target.starts_with("powerpc64")
-            || target.starts_with("sparc64")
-            || target.starts_with("mips64el")
-            || target.starts_with("riscv64");
-        let has_atomic32 = has_atomic64 || emscripten;
-        if minor < 34 || !has_atomic64 {
-            println!("cargo:rustc-cfg=no_std_atomic64");
-        }
-        if minor < 34 || !has_atomic32 {
-            println!("cargo:rustc-cfg=no_std_atomic");
-        }
     }
 
     // Current minimum supported version of serde_derive crate is Rust 1.61.
     if minor < 61 {
         println!("cargo:rustc-cfg=no_serde_derive");
     }
-
-    // Support for core::ffi::CStr and alloc::ffi::CString stabilized in Rust 1.64.
-    // https://blog.rust-lang.org/2022/09/22/Rust-1.64.0.html#c-compatible-ffi-types-in-core-and-alloc
-    if minor < 64 {
-        println!("cargo:rustc-cfg=no_core_cstr");
-    }
-
-    // Support for core::num::Saturating and std::num::Saturating stabilized in Rust 1.74
-    // https://blog.rust-lang.org/2023/11/16/Rust-1.74.0.html#stabilized-apis
-    if minor < 74 {
-        println!("cargo:rustc-cfg=no_core_num_saturating");
-    }
-
-    // Support for core::net stabilized in Rust 1.77.
-    // https://blog.rust-lang.org/2024/03/21/Rust-1.77.0.html
-    if minor < 77 {
-        println!("cargo:rustc-cfg=no_core_net");
-    }
-
-    // Support for the `#[diagnostic]` tool attribute namespace
-    // https://blog.rust-lang.org/2024/05/02/Rust-1.78.0.html#diagnostic-attributes
-    if minor < 78 {
-        println!("cargo:rustc-cfg=no_diagnostic_namespace");
-    }
-
-    // The Error trait became available in core in 1.81.
-    // https://blog.rust-lang.org/2024/09/05/Rust-1.81.0.html#coreerrorerror
-    if minor < 81 {
-        println!("cargo:rustc-cfg=no_core_error");
-    }
 }
 
 fn rustc_minor_version() -> Option<u32> {

serde/src/lib.rs

@@ -180,23 +180,18 @@ mod lib {
     }
 
     pub use self::core::{f32, f64};
-    pub use self::core::{iter, num, ptr, str};
+    pub use self::core::{ptr, str};
 
     #[cfg(any(feature = "std", feature = "alloc"))]
-    pub use self::core::{cmp, mem, slice};
+    pub use self::core::slice;
 
-    pub use self::core::cell::{Cell, RefCell};
     pub use self::core::clone;
-    pub use self::core::cmp::Reverse;
     pub use self::core::convert;
     pub use self::core::default;
     pub use self::core::fmt::{self, Debug, Display, Write as FmtWrite};
     pub use self::core::marker::{self, PhantomData};
-    pub use self::core::num::Wrapping;
-    pub use self::core::ops::{Bound, Range, RangeFrom, RangeInclusive, RangeTo};
     pub use self::core::option;
     pub use self::core::result;
-    pub use self::core::time::Duration;
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::borrow::{Cow, ToOwned};
@@ -218,83 +213,15 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::boxed::Box;
 
-    #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-    pub use alloc::rc::{Rc, Weak as RcWeak};
-    #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::rc::{Rc, Weak as RcWeak};
-
-    #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-    pub use alloc::sync::{Arc, Weak as ArcWeak};
-    #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::sync::{Arc, Weak as ArcWeak};
-
-    #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
-    #[cfg(feature = "std")]
-    pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
-
-    #[cfg(all(not(no_core_cstr), not(feature = "std")))]
-    pub use self::core::ffi::CStr;
-    #[cfg(feature = "std")]
-    pub use std::ffi::CStr;
-
-    #[cfg(all(not(no_core_cstr), feature = "alloc", not(feature = "std")))]
-    pub use alloc::ffi::CString;
-    #[cfg(feature = "std")]
-    pub use std::ffi::CString;
-
-    #[cfg(all(not(no_core_net), not(feature = "std")))]
-    pub use self::core::net;
-    #[cfg(feature = "std")]
-    pub use std::net;
-
     #[cfg(feature = "std")]
     pub use std::error;
-
-    #[cfg(feature = "std")]
-    pub use std::collections::{HashMap, HashSet};
-    #[cfg(feature = "std")]
-    pub use std::ffi::{OsStr, OsString};
-    #[cfg(feature = "std")]
-    pub use std::hash::{BuildHasher, Hash};
-    #[cfg(feature = "std")]
-    pub use std::io::Write;
-    #[cfg(feature = "std")]
-    pub use std::path::{Path, PathBuf};
-    #[cfg(feature = "std")]
-    pub use std::sync::{Mutex, RwLock};
-    #[cfg(feature = "std")]
-    pub use std::time::{SystemTime, UNIX_EPOCH};
-
-    #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic)))]
-    pub use std::sync::atomic::{
-        AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
-        AtomicUsize, Ordering,
-    };
-    #[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic64)))]
-    pub use std::sync::atomic::{AtomicI64, AtomicU64};
-
-    #[cfg(all(feature = "std", not(no_target_has_atomic)))]
-    pub use std::sync::atomic::Ordering;
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "8"))]
-    pub use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "16"))]
-    pub use std::sync::atomic::{AtomicI16, AtomicU16};
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "32"))]
-    pub use std::sync::atomic::{AtomicI32, AtomicU32};
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "64"))]
-    pub use std::sync::atomic::{AtomicI64, AtomicU64};
-    #[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "ptr"))]
-    pub use std::sync::atomic::{AtomicIsize, AtomicUsize};
-
-    #[cfg(not(no_core_num_saturating))]
-    pub use self::core::num::Saturating;
 }
 
 // None of this crate's error handling needs the `From::from` error conversion
 // performed implicitly by the `?` operator or the standard library's `try!`
 // macro. This simplified macro gives a 5.5% improvement in compile time
 // compared to standard `try!`, and 9% improvement compared to `?`.
+#[allow(unused_macros)]
 macro_rules! tri {
     ($expr:expr) => {
         match $expr {
@@ -306,33 +233,17 @@ macro_rules! tri {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[macro_use]
-mod macros;
-
-#[macro_use]
-mod integer128;
-
-pub mod de;
-pub mod ser;
-
-mod format;
-
 #[doc(inline)]
 pub use crate::de::{Deserialize, Deserializer};
 #[doc(inline)]
 pub use crate::ser::{Serialize, Serializer};
+pub use serde_core::*;
 
 // Used by generated code and doc tests. Not public API.
 #[doc(hidden)]
 #[path = "private/mod.rs"]
 pub mod __private;
 
-#[path = "de/seed.rs"]
-mod seed;
-
-#[cfg(all(not(feature = "std"), no_core_error))]
-mod std_error;
-
 // Re-export #[derive(Serialize, Deserialize)].
 //
 // The reason re-exporting is not enabled by default is that disabling it would

serde/src/private/de.rs

@@ -16,7 +16,7 @@ pub use self::content::{
     TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor, UntaggedUnitVisitor,
 };
 
-pub use crate::seed::InPlaceSeed;
+pub use serde_core::de::InPlaceSeed;
 
 /// If the missing field is of type `Option<T>` then treat is as `None`,
 /// otherwise it is an error.
@@ -47,7 +47,7 @@ where
             visitor.visit_none()
         }
 
-        forward_to_deserialize_any! {
+        serde_core::forward_to_deserialize_any! {
             bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
             bytes byte_buf unit unit_struct newtype_struct seq tuple
             tuple_struct map struct enum identifier ignored_any
@@ -297,7 +297,7 @@ mod content {
             // Untagged and internally tagged enums are only supported in
             // self-describing formats.
             let visitor = ContentVisitor { value: PhantomData };
-            deserializer.__deserialize_content(visitor)
+            deserializer.deserialize_any(visitor)
         }
     }
 
@@ -1496,14 +1496,6 @@ mod content {
             drop(self);
             visitor.visit_unit()
         }
-
-        fn __deserialize_content<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de, Value = Content<'de>>,
-        {
-            let _ = visitor;
-            Ok(self.content)
-        }
     }
 
     impl<'de, E> ContentDeserializer<'de, E> {
@@ -2085,14 +2077,6 @@ mod content {
         {
             visitor.visit_unit()
         }
-
-        fn __deserialize_content<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de, Value = Content<'de>>,
-        {
-            let _ = visitor;
-            Ok(self.content.clone())
-        }
     }
 
     impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E> {
@@ -2397,7 +2381,7 @@ where
         visitor.visit_str(self.value)
     }
 
-    forward_to_deserialize_any! {
+    serde_core::forward_to_deserialize_any! {
         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
         bytes byte_buf option unit unit_struct newtype_struct seq tuple
         tuple_struct map struct enum identifier ignored_any
@@ -2422,7 +2406,7 @@ where
         visitor.visit_borrowed_str(self.value)
     }
 
-    forward_to_deserialize_any! {
+    serde_core::forward_to_deserialize_any! {
         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
         bytes byte_buf option unit unit_struct newtype_struct seq tuple
         tuple_struct map struct enum identifier ignored_any

serde/src/private/mod.rs

@@ -21,25 +21,5 @@ pub use self::string::from_utf8_lossy;
 pub use crate::lib::{ToString, Vec};
 
 mod string {
-    use crate::lib::*;
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
-        String::from_utf8_lossy(bytes)
-    }
-
-    // The generated code calls this like:
-    //
-    //     let value = &_serde::__private::from_utf8_lossy(bytes);
-    //     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
-    //
-    // so it is okay for the return type to be different from the std case as long
-    // as the above works.
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
-        // Three unicode replacement characters if it fails. They look like a
-        // white-on-black question mark. The user will recognize it as invalid
-        // UTF-8.
-        str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
-    }
+    pub use serde_core::from_utf8_lossy;
 }