feat: Extract serde_core out of serde crate

.github/workflows/ci.yml

@@ -62,8 +62,9 @@ jobs:
       - run: cd serde && cargo build --no-default-features
       - run: cd serde && cargo build --no-default-features --features alloc
       - run: cd serde && cargo build --no-default-features --features rc,alloc
+      - run: cd serde && cargo build --no-default-features --features result
       - run: cd serde && cargo build --no-default-features --features unstable
-      - run: cd serde && cargo test --features derive,rc,unstable
+      - run: cd serde && cargo test --features derive,rc,result,unstable
       - run: cd test_suite/no_std && cargo build
         if: matrix.os != 'windows'
       - run: cd serde_derive && cargo check --tests
@@ -157,7 +158,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@miri
       - run: cargo miri setup
-      - run: cd serde && cargo miri test --features derive,rc,unstable
+      - run: cd serde && cargo miri test --features derive,rc,result,unstable
         env:
           MIRIFLAGS: -Zmiri-strict-provenance
       - run: cd test_suite && cargo miri test --features unstable

Cargo.toml

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

serde/Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "serde"
 version = "1.0.204"
-authors = ["Erick Tryzelaar <[email protected]>", "David Tolnay <[email protected]>"]
+authors = [
+    "Erick Tryzelaar <[email protected]>",
+    "David Tolnay <[email protected]>",
+]
 build = "build.rs"
 categories = ["encoding", "no-std", "no-std::no-alloc"]
 description = "A generic serialization/deserialization framework"
@@ -16,6 +19,7 @@ rust-version = "1.31"
 
 [dependencies]
 serde_derive = { version = "1", optional = true, path = "../serde_derive" }
+serde_core = { version = "=1.0.204", path = "../serde_core", default-features = false }
 
 [dev-dependencies]
 serde_derive = { version = "1", path = "../serde_derive" }
@@ -27,9 +31,9 @@ doc-scrape-examples = false
 features = ["derive", "rc"]
 
 [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"]
+rustdoc-args = ["--cfg", "doc_cfg", "--generate-link-to-definition"]
 
 # This cfg cannot be enabled, but it still forces Cargo to keep serde_derive's
 # version in lockstep with serde's, even if someone depends on the two crates
@@ -43,27 +47,32 @@ serde_derive = { version = "=1.0.204", 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

@@ -28,62 +28,10 @@ fn main() {
         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";
-
-    // TryFrom, Atomic types, non-zero signed integers, and SystemTime::checked_add
-    // stabilized in Rust 1.34:
+    // TryFrom was stabilized in Rust 1.34:
     // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#tryfrom-and-tryinto
-    // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#library-stabilizations
     if minor < 34 {
         println!("cargo:rustc-cfg=no_core_try_from");
-        println!("cargo:rustc-cfg=no_num_nonzero_signed");
-        println!("cargo:rustc-cfg=no_systemtime_checked_add");
-        println!("cargo:rustc-cfg=no_relaxed_trait_bounds");
-    }
-
-    // f32::copysign and f64::copysign stabilized in Rust 1.35.
-    // https://blog.rust-lang.org/2019/05/23/Rust-1.35.0.html#copy-the-sign-of-a-floating-point-number-onto-another
-    if minor < 35 {
-        println!("cargo:rustc-cfg=no_float_copysign");
-    }
-
-    // Current minimum supported version of serde_derive crate is Rust 1.56.
-    if minor < 56 {
-        println!("cargo:rustc-cfg=no_serde_derive");
-    }
-
-    // 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");
-        }
-    }
-
-    // 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 the `#[diagnostic]` tool attribute namespace

serde/src/lib.rs

@@ -92,8 +92,6 @@
 //! [Hjson]: https://github.com/Canop/deser-hjson
 //! [CSV]: https://docs.rs/csv
 
-////////////////////////////////////////////////////////////////////////////////
-
 // Serde types in rustdoc of other crates get linked to here.
 #![doc(html_root_url = "https://docs.rs/serde/1.0.204")]
 // Support using Serde without the standard library!
@@ -157,13 +155,27 @@
 #![deny(missing_docs, unused_imports)]
 
 ////////////////////////////////////////////////////////////////////////////////
+#[doc(inline)]
+pub use serde_core::*;
+// Used by generated code and doc tests. Not public API.
+#[doc(hidden)]
+#[path = "private/mod.rs"]
+pub mod __private;
+
+// Re-export #[derive(Serialize, Deserialize)].
+//
+// The reason re-exporting is not enabled by default is that disabling it would
+// be annoying for crates that provide handwritten impls or data formats. They
+// would need to disable default features and then explicitly re-enable std.
+#[cfg(feature = "serde_derive")]
+extern crate serde_derive;
 
+/// Derive macro available if serde is built with `features = ["derive"]`.
+#[cfg(feature = "serde_derive")]
+#[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
+pub use serde_derive::{Deserialize, Serialize};
 #[cfg(feature = "alloc")]
 extern crate alloc;
-
-/// A facade around all the types we need from the `std`, `core`, and `alloc`
-/// crates. This avoids elaborate import wrangling having to happen in every
-/// module.
 mod lib {
     mod core {
         #[cfg(not(feature = "std"))]
@@ -173,30 +185,25 @@ mod lib {
     }
 
     pub use self::core::{f32, f64};
-    pub use self::core::{i16, i32, i64, i8, isize};
-    pub use self::core::{iter, num, ptr, str};
+    pub use self::core::{i16, i32, i64, i8};
+    pub use self::core::{ptr, str};
     pub use self::core::{u16, u32, u64, u8, usize};
 
     #[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};
     #[cfg(feature = "std")]
-    pub use std::borrow::{Cow, ToOwned};
+    pub use std::borrow::Cow;
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::string::{String, ToString};
@@ -213,48 +220,11 @@ 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;
+    pub use std::error;
 
-    #[cfg(feature = "std")]
-    pub use std::{error, net};
-
-    #[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::{
@@ -263,28 +233,14 @@ mod lib {
     };
     #[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 `?`.
+#[doc(hidden)]
+#[macro_export]
 macro_rules! tri {
     ($expr:expr) => {
         match $expr {
@@ -293,48 +249,3 @@ macro_rules! tri {
         }
     };
 }
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[macro_use]
-mod macros;
-
-#[macro_use]
-mod integer128;
-
-pub mod de;
-pub mod ser;
-
-#[doc(inline)]
-pub use crate::de::{Deserialize, Deserializer};
-#[doc(inline)]
-pub use crate::ser::{Serialize, Serializer};
-
-// 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(not(any(feature = "std", feature = "unstable")))]
-mod std_error;
-
-// Re-export #[derive(Serialize, Deserialize)].
-//
-// The reason re-exporting is not enabled by default is that disabling it would
-// be annoying for crates that provide handwritten impls or data formats. They
-// would need to disable default features and then explicitly re-enable std.
-#[cfg(feature = "serde_derive")]
-extern crate serde_derive;
-
-/// Derive macro available if serde is built with `features = ["derive"]`.
-#[cfg(feature = "serde_derive")]
-#[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
-pub use serde_derive::{Deserialize, Serialize};
-
-#[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
-mod actually_private {
-    pub struct T;
-}