pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-12 09:41:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix wasm32v1-none target compilation with Cargo feature unification

Browse Source 
When building for wasm32v1-none with Cargo, the 'std' feature gets
unified across the dependency graph, meaning serde_core sees
feature="std" even on a no_std target. This caused compilation failures
because the crate tried to use std:: imports.

This commit fixes the issue by checking target_os = "none" in addition
to the std feature flag:
- lib.rs: Force no_std when target_os = "none"
- crate_root.rs: Use core/alloc instead of std on target_os = "none"
- All std-only cfg blocks now include not(target_os = "none")
- Add explicit prelude imports for wasm32v1-none compatibility
This commit is contained in:
Kurdistan Tech Ministry
2026-01-09 15:36:07 +03:00
parent d99c876120
commit 679af0fb4b
10 changed files with 116 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_core/src/crate_root.rs
+55 -46
View File
@@ -3,28 +3,35 @@ macro_rules! crate_root {
/// A facade around all the types we need from the `std`, `core`, and `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 /// crates. This avoids elaborate import wrangling having to happen in every
/// module. /// module.
///
/// NOTE: On targets where std is not available (target_os = "none", e.g. wasm32v1-none),
/// we always use core/alloc even if the "std" feature is enabled due to Cargo feature
/// unification. This is handled by checking `target_os = "none"` in all cfg conditions.
mod lib { mod lib {
mod core { mod core {
#[cfg(not(feature = "std"))] // On wasm32v1-none (target_os = "none"), always use ::core even if std feature is enabled
// This handles Cargo feature unification where std gets enabled for no_std targets
#[cfg(any(not(feature = "std"), target_os = "none"))]
pub use ::core::*; pub use ::core::*;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use ::std::*; pub use ::std::*;
} }
// Re-export the full prelude for wasm32v1-none and other targets // Re-export the full prelude for wasm32v1-none and other no_std targets
#[cfg(not(feature = "std"))] // On target_os = "none", always use ::core::prelude even with std feature
#[cfg(any(not(feature = "std"), target_os = "none"))]
pub use ::core::prelude::rust_2021::*; pub use ::core::prelude::rust_2021::*;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use ::std::prelude::rust_2021::*; pub use ::std::prelude::rust_2021::*;
// Prelude items that may not be re-exported by glob import // Prelude items that may not be re-exported by glob import
#[cfg(not(feature = "std"))] #[cfg(any(not(feature = "std"), target_os = "none"))]
pub use ::core::option::Option::{self, None, Some}; pub use ::core::option::Option::{self, None, Some};
#[cfg(not(feature = "std"))] #[cfg(any(not(feature = "std"), target_os = "none"))]
pub use ::core::result::Result::{self, Err, Ok}; pub use ::core::result::Result::{self, Err, Ok};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use ::std::option::Option::{self, None, Some}; pub use ::std::option::Option::{self, None, Some};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use ::std::result::Result::{self, Err, Ok}; pub use ::std::result::Result::{self, Err, Ok};
pub use self::core::{f32, f64}; pub use self::core::{f32, f64};
@@ -51,93 +58,95 @@ macro_rules! crate_root {
pub use self::core::result; pub use self::core::result;
pub use self::core::time::Duration; pub use self::core::time::Duration;
#[cfg(all(feature = "alloc", not(feature = "std")))] // For alloc types: use alloc when std is not available OR on target_os = "none"
#[cfg(all(feature = "alloc", any(not(feature = "std"), target_os = "none")))]
pub use alloc::borrow::{Cow, ToOwned}; pub use alloc::borrow::{Cow, ToOwned};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::borrow::{Cow, ToOwned}; pub use std::borrow::{Cow, ToOwned};
#[cfg(all(feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "alloc", any(not(feature = "std"), target_os = "none")))]
pub use alloc::string::{String, ToString}; pub use alloc::string::{String, ToString};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::string::{String, ToString}; pub use std::string::{String, ToString};
#[cfg(all(feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "alloc", any(not(feature = "std"), target_os = "none")))]
pub use alloc::vec::Vec; pub use alloc::vec::Vec;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::vec::Vec; pub use std::vec::Vec;
#[cfg(all(feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "alloc", any(not(feature = "std"), target_os = "none")))]
pub use alloc::boxed::Box; pub use alloc::boxed::Box;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::boxed::Box; pub use std::boxed::Box;
#[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "rc", feature = "alloc", any(not(feature = "std"), target_os = "none")))]
pub use alloc::rc::{Rc, Weak as RcWeak}; pub use alloc::rc::{Rc, Weak as RcWeak};
#[cfg(all(feature = "rc", feature = "std"))] #[cfg(all(feature = "rc", feature = "std", not(target_os = "none")))]
pub use std::rc::{Rc, Weak as RcWeak}; pub use std::rc::{Rc, Weak as RcWeak};
#[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "rc", feature = "alloc", any(not(feature = "std"), target_os = "none")))]
pub use alloc::sync::{Arc, Weak as ArcWeak}; pub use alloc::sync::{Arc, Weak as ArcWeak};
#[cfg(all(feature = "rc", feature = "std"))] #[cfg(all(feature = "rc", feature = "std", not(target_os = "none")))]
pub use std::sync::{Arc, Weak as ArcWeak}; pub use std::sync::{Arc, Weak as ArcWeak};
#[cfg(all(feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "alloc", any(not(feature = "std"), target_os = "none")))]
pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque}; pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque}; pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
#[cfg(all(not(no_core_cstr), not(feature = "std")))] #[cfg(all(not(no_core_cstr), any(not(feature = "std"), target_os = "none")))]
pub use self::core::ffi::CStr; pub use self::core::ffi::CStr;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::ffi::CStr; pub use std::ffi::CStr;
#[cfg(all(not(no_core_cstr), feature = "alloc", not(feature = "std")))] #[cfg(all(not(no_core_cstr), feature = "alloc", any(not(feature = "std"), target_os = "none")))]
pub use alloc::ffi::CString; pub use alloc::ffi::CString;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::ffi::CString; pub use std::ffi::CString;
#[cfg(all(not(no_core_net), not(feature = "std")))] #[cfg(all(not(no_core_net), any(not(feature = "std"), target_os = "none")))]
pub use self::core::net; pub use self::core::net;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::net; pub use std::net;
#[cfg(feature = "std")] // std-only types - not available on target_os = "none"
#[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::error; pub use std::error;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::collections::{HashMap, HashSet}; pub use std::collections::{HashMap, HashSet};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::ffi::{OsStr, OsString}; pub use std::ffi::{OsStr, OsString};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::hash::{BuildHasher, Hash}; pub use std::hash::{BuildHasher, Hash};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::io::Write; pub use std::io::Write;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::path::{Path, PathBuf}; pub use std::path::{Path, PathBuf};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::sync::{Mutex, RwLock}; pub use std::sync::{Mutex, RwLock};
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
pub use std::time::{SystemTime, UNIX_EPOCH}; pub use std::time::{SystemTime, UNIX_EPOCH};
#[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic)))] #[cfg(all(feature = "std", not(target_os = "none"), no_target_has_atomic, not(no_std_atomic)))]
pub use std::sync::atomic::{ pub use std::sync::atomic::{
AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32,
AtomicU8, AtomicUsize, Ordering, AtomicU8, AtomicUsize, Ordering,
}; };
#[cfg(all(feature = "std", no_target_has_atomic, not(no_std_atomic64)))] #[cfg(all(feature = "std", not(target_os = "none"), no_target_has_atomic, not(no_std_atomic64)))]
pub use std::sync::atomic::{AtomicI64, AtomicU64}; pub use std::sync::atomic::{AtomicI64, AtomicU64};
#[cfg(all(feature = "std", not(no_target_has_atomic)))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_target_has_atomic)))]
pub use std::sync::atomic::Ordering; pub use std::sync::atomic::Ordering;
#[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "8"))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_target_has_atomic), target_has_atomic = "8"))]
pub use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU8}; pub use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};
#[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "16"))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_target_has_atomic), target_has_atomic = "16"))]
pub use std::sync::atomic::{AtomicI16, AtomicU16}; pub use std::sync::atomic::{AtomicI16, AtomicU16};
#[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "32"))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_target_has_atomic), target_has_atomic = "32"))]
pub use std::sync::atomic::{AtomicI32, AtomicU32}; pub use std::sync::atomic::{AtomicI32, AtomicU32};
#[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "64"))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_target_has_atomic), target_has_atomic = "64"))]
pub use std::sync::atomic::{AtomicI64, AtomicU64}; pub use std::sync::atomic::{AtomicI64, AtomicU64};
#[cfg(all(feature = "std", not(no_target_has_atomic), target_has_atomic = "ptr"))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_target_has_atomic), target_has_atomic = "ptr"))]
pub use std::sync::atomic::{AtomicIsize, AtomicUsize}; pub use std::sync::atomic::{AtomicIsize, AtomicUsize};
#[cfg(not(no_core_num_saturating))] #[cfg(not(no_core_num_saturating))]
@@ -189,7 +198,7 @@ macro_rules! crate_root {
include!(concat!(env!("OUT_DIR"), "/private.rs")); include!(concat!(env!("OUT_DIR"), "/private.rs"));
#[cfg(all(not(feature = "std"), no_core_error))] #[cfg(all(any(not(feature = "std"), target_os = "none"), no_core_error))]
#[cfg_attr(all(docsrs, if_docsrs_then_no_serde_core), path = "core/std_error.rs")] #[cfg_attr(all(docsrs, if_docsrs_then_no_serde_core), path = "core/std_error.rs")]
mod std_error; mod std_error;
}; };
serde_core/src/de/impls.rs
+24 -24
View File
@@ -1,9 +1,9 @@
use crate::lib::*; use crate::lib::*;
// Explicit prelude import for wasm32v1-none target compatibility // Explicit prelude import for wasm32v1-none and other no_std targets
// These may appear unused but are required for ?Sized bounds on wasm32v1-none // Even when "std" feature is enabled (due to Cargo feature unification),
// the prelude may not be injected on wasm32v1-none target
#[allow(unused_imports)] #[allow(unused_imports)]
#[cfg(not(feature = "std"))]
use ::core::prelude::rust_2021::*; use ::core::prelude::rust_2021::*;
use crate::de::{ use crate::de::{
@@ -237,7 +237,7 @@ macro_rules! num_as_copysign_self {
Ok(v as Self::Value) Ok(v as Self::Value)
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
{ {
// Preserve sign of NaN. The `as` produces a nondeterministic sign. // Preserve sign of NaN. The `as` produces a nondeterministic sign.
let sign = if v.is_sign_positive() { 1.0 } else { -1.0 }; let sign = if v.is_sign_positive() { 1.0 } else { -1.0 };
@@ -1113,7 +1113,7 @@ seq_impl!(
); );
seq_impl!( seq_impl!(
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
HashSet<T: Eq + Hash, S: BuildHasher + Default>, HashSet<T: Eq + Hash, S: BuildHasher + Default>,
seq, seq,
@@ -1569,7 +1569,7 @@ map_impl! {
} }
map_impl! { map_impl! {
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
HashMap<K: Eq + Hash, V, S: BuildHasher + Default>, HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
map, map,
@@ -1787,10 +1787,10 @@ parse_socket_impl! {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
struct PathVisitor; struct PathVisitor;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
impl<'a> Visitor<'a> for PathVisitor { impl<'a> Visitor<'a> for PathVisitor {
type Value = &'a Path; type Value = &'a Path;
@@ -1815,7 +1815,7 @@ impl<'a> Visitor<'a> for PathVisitor {
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<'de: 'a, 'a> Deserialize<'de> for &'a Path { impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -1826,10 +1826,10 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
struct PathBufVisitor; struct PathBufVisitor;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
impl<'de> Visitor<'de> for PathBufVisitor { impl<'de> Visitor<'de> for PathBufVisitor {
type Value = PathBuf; type Value = PathBuf;
@@ -1870,7 +1870,7 @@ impl<'de> Visitor<'de> for PathBufVisitor {
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<'de> Deserialize<'de> for PathBuf { impl<'de> Deserialize<'de> for PathBuf {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -1882,7 +1882,7 @@ impl<'de> Deserialize<'de> for PathBuf {
} }
forwarded_impl! { forwarded_impl! {
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
(), Box<Path>, PathBuf::into_boxed_path (), Box<Path>, PathBuf::into_boxed_path
} }
@@ -1893,17 +1893,17 @@ forwarded_impl! {
// //
// #[derive(Deserialize)] // #[derive(Deserialize)]
// #[serde(variant_identifier)] // #[serde(variant_identifier)]
#[cfg(all(feature = "std", any(unix, windows)))] #[cfg(all(feature = "std", not(target_os = "none"), any(unix, windows)))]
variant_identifier! { variant_identifier! {
OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1) OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1)
"`Unix` or `Windows`", "`Unix` or `Windows`",
OSSTR_VARIANTS OSSTR_VARIANTS
} }
#[cfg(all(feature = "std", any(unix, windows)))] #[cfg(all(feature = "std", not(target_os = "none"), any(unix, windows)))]
struct OsStringVisitor; struct OsStringVisitor;
#[cfg(all(feature = "std", any(unix, windows)))] #[cfg(all(feature = "std", not(target_os = "none"), any(unix, windows)))]
impl<'de> Visitor<'de> for OsStringVisitor { impl<'de> Visitor<'de> for OsStringVisitor {
type Value = OsString; type Value = OsString;
@@ -1944,7 +1944,7 @@ impl<'de> Visitor<'de> for OsStringVisitor {
} }
} }
#[cfg(all(feature = "std", any(unix, windows)))] #[cfg(all(feature = "std", not(target_os = "none"), any(unix, windows)))]
#[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))] #[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))]
impl<'de> Deserialize<'de> for OsString { impl<'de> Deserialize<'de> for OsString {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -1976,7 +1976,7 @@ forwarded_impl! {
} }
forwarded_impl! { forwarded_impl! {
#[cfg(all(feature = "std", any(unix, windows)))] #[cfg(all(feature = "std", not(target_os = "none"), any(unix, windows)))]
#[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))] #[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))]
(), Box<OsStr>, OsString::into_boxed_os_str (), Box<OsStr>, OsString::into_boxed_os_str
} }
@@ -2111,13 +2111,13 @@ forwarded_impl! {
} }
forwarded_impl! { forwarded_impl! {
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
(T), Mutex<T>, Mutex::new (T), Mutex<T>, Mutex::new
} }
forwarded_impl! { forwarded_impl! {
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
(T), RwLock<T>, RwLock::new (T), RwLock<T>, RwLock::new
} }
@@ -2272,7 +2272,7 @@ impl<'de> Deserialize<'de> for Duration {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<'de> Deserialize<'de> for SystemTime { impl<'de> Deserialize<'de> for SystemTime {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -3105,7 +3105,7 @@ where
} }
} }
#[cfg(all(feature = "std", not(no_std_atomic)))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_std_atomic)))]
macro_rules! atomic_impl { macro_rules! atomic_impl {
($($ty:ident $size:expr)*) => { ($($ty:ident $size:expr)*) => {
$( $(
@@ -3123,7 +3123,7 @@ macro_rules! atomic_impl {
}; };
} }
#[cfg(all(feature = "std", not(no_std_atomic)))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_std_atomic)))]
atomic_impl! { atomic_impl! {
AtomicBool "8" AtomicBool "8"
AtomicI8 "8" AtomicI8 "8"
@@ -3136,7 +3136,7 @@ atomic_impl! {
AtomicUsize "ptr" AtomicUsize "ptr"
} }
#[cfg(all(feature = "std", not(no_std_atomic64)))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_std_atomic64)))]
atomic_impl! { atomic_impl! {
AtomicI64 "64" AtomicI64 "64"
AtomicU64 "64" AtomicU64 "64"
serde_core/src/de/mod.rs
+6 -7
View File
@@ -114,9 +114,8 @@
use crate::lib::*; use crate::lib::*;
// Explicit prelude import for wasm32v1-none target compatibility // Explicit prelude import for wasm32v1-none and other no_std targets
#[allow(unused_imports)] #[allow(unused_imports)]
#[cfg(not(feature = "std"))]
use ::core::prelude::rust_2021::*; use ::core::prelude::rust_2021::*;
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@@ -127,13 +126,13 @@ mod ignored_any;
mod impls; mod impls;
pub use self::ignored_any::IgnoredAny; pub use self::ignored_any::IgnoredAny;
#[cfg(all(not(feature = "std"), no_core_error))] #[cfg(all(any(not(feature = "std"), target_os = "none"), no_core_error))]
#[doc(no_inline)] #[doc(no_inline)]
pub use crate::std_error::Error as StdError; pub use crate::std_error::Error as StdError;
#[cfg(not(any(feature = "std", no_core_error)))] #[cfg(all(any(not(feature = "std"), target_os = "none"), not(no_core_error)))]
#[doc(no_inline)] #[doc(no_inline)]
pub use core::error::Error as StdError; pub use core::error::Error as StdError;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[doc(no_inline)] #[doc(no_inline)]
pub use std::error::Error as StdError; pub use std::error::Error as StdError;
@@ -305,10 +304,10 @@ macro_rules! declare_error_trait {
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
declare_error_trait!(Error: Sized + StdError); declare_error_trait!(Error: Sized + StdError);
#[cfg(not(feature = "std"))] #[cfg(any(not(feature = "std"), target_os = "none"))]
declare_error_trait!(Error: Sized + Debug + Display); declare_error_trait!(Error: Sized + Debug + Display);
/// `Unexpected` represents an unexpected invocation of any one of the `Visitor` /// `Unexpected` represents an unexpected invocation of any one of the `Visitor`
serde_core/src/de/value.rs
+3 -3
View File
@@ -112,7 +112,7 @@ impl Debug for Error {
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl error::Error for Error { impl error::Error for Error {
fn description(&self) -> &str { fn description(&self) -> &str {
@@ -1160,7 +1160,7 @@ where
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S> impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>
where where
@@ -1588,7 +1588,7 @@ where
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S> impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
where where
serde_core/src/lib.rs
+3 -1
View File
@@ -37,7 +37,9 @@
// Serde types in rustdoc of other crates get linked to here. // Serde types in rustdoc of other crates get linked to here.
#![doc(html_root_url = "https://docs.rs/serde_core/1.0.228")] #![doc(html_root_url = "https://docs.rs/serde_core/1.0.228")]
// Support using Serde without the standard library! // Support using Serde without the standard library!
#![cfg_attr(not(feature = "std"), no_std)] // Also force no_std on target_os = "none" (wasm32v1-none) even if std feature is enabled
// This handles Cargo feature unification where std gets enabled for no_std targets
#![cfg_attr(any(not(feature = "std"), target_os = "none"), no_std)]
// Show which crate feature enables conditionally compiled APIs in documentation. // Show which crate feature enables conditionally compiled APIs in documentation.
#![cfg_attr(docsrs, feature(doc_cfg, rustdoc_internals))] #![cfg_attr(docsrs, feature(doc_cfg, rustdoc_internals))]
#![cfg_attr(docsrs, allow(internal_features))] #![cfg_attr(docsrs, allow(internal_features))]
serde_core/src/private/doc.rs
+2 -3
View File
@@ -2,9 +2,8 @@
use crate::lib::*; use crate::lib::*;
// Explicit prelude import for wasm32v1-none target compatibility // Explicit prelude import for wasm32v1-none and other no_std targets
#[allow(unused_imports)] #[allow(unused_imports)]
#[cfg(not(feature = "std"))]
use ::core::prelude::rust_2021::*; use ::core::prelude::rust_2021::*;
use crate::ser; use crate::ser;
@@ -23,7 +22,7 @@ impl ser::Error for Error {
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(not(no_diagnostic_namespace), diagnostic::do_not_recommend)] #[cfg_attr(not(no_diagnostic_namespace), diagnostic::do_not_recommend)]
impl error::Error for Error { impl error::Error for Error {
fn description(&self) -> &str { fn description(&self) -> &str {
serde_core/src/ser/fmt.rs
+1 -2
View File
@@ -1,8 +1,7 @@
use crate::lib::*; use crate::lib::*;
// Explicit prelude import for wasm32v1-none target compatibility // Explicit prelude import for wasm32v1-none and other no_std targets
#[allow(unused_imports)] #[allow(unused_imports)]
#[cfg(not(feature = "std"))]
use ::core::prelude::rust_2021::*; use ::core::prelude::rust_2021::*;
use crate::ser::{Error, Impossible, Serialize, Serializer}; use crate::ser::{Error, Impossible, Serialize, Serializer};
serde_core/src/ser/impls.rs
+15 -15
View File
@@ -1,9 +1,9 @@
use crate::lib::*; use crate::lib::*;
// Explicit prelude import for wasm32v1-none target compatibility // Explicit prelude import for wasm32v1-none and other no_std targets
// These may appear unused but are required for ?Sized bounds on wasm32v1-none // Even when "std" feature is enabled (due to Cargo feature unification),
// the prelude may not be injected on wasm32v1-none target
#[allow(unused_imports)] #[allow(unused_imports)]
#[cfg(not(feature = "std"))]
use ::core::prelude::rust_2021::*; use ::core::prelude::rust_2021::*;
use crate::ser::{Error, Serialize, SerializeTuple, Serializer}; use crate::ser::{Error, Serialize, SerializeTuple, Serializer};
@@ -225,7 +225,7 @@ seq_impl! {
} }
seq_impl! { seq_impl! {
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
HashSet<T, H: BuildHasher> HashSet<T, H: BuildHasher>
} }
@@ -456,7 +456,7 @@ map_impl! {
} }
map_impl! { map_impl! {
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
HashMap<K: Eq + Hash, V, H: BuildHasher> HashMap<K: Eq + Hash, V, H: BuildHasher>
} }
@@ -630,7 +630,7 @@ where
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<T> Serialize for Mutex<T> impl<T> Serialize for Mutex<T>
where where
@@ -647,7 +647,7 @@ where
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl<T> Serialize for RwLock<T> impl<T> Serialize for RwLock<T>
where where
@@ -703,7 +703,7 @@ impl Serialize for Duration {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl Serialize for SystemTime { impl Serialize for SystemTime {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -909,7 +909,7 @@ impl Serialize for net::SocketAddrV6 {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl Serialize for Path { impl Serialize for Path {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -923,7 +923,7 @@ impl Serialize for Path {
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[cfg_attr(docsrs, doc(cfg(feature = "std")))] #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
impl Serialize for PathBuf { impl Serialize for PathBuf {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -934,7 +934,7 @@ impl Serialize for PathBuf {
} }
} }
#[cfg(all(feature = "std", any(unix, windows)))] #[cfg(all(feature = "std", not(target_os = "none"), any(unix, windows)))]
#[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))] #[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))]
impl Serialize for OsStr { impl Serialize for OsStr {
#[cfg(unix)] #[cfg(unix)]
@@ -957,7 +957,7 @@ impl Serialize for OsStr {
} }
} }
#[cfg(all(feature = "std", any(unix, windows)))] #[cfg(all(feature = "std", not(target_os = "none"), any(unix, windows)))]
#[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))] #[cfg_attr(docsrs, doc(cfg(all(feature = "std", any(unix, windows)))))]
impl Serialize for OsString { impl Serialize for OsString {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -1012,7 +1012,7 @@ where
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
#[cfg(all(feature = "std", not(no_std_atomic)))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_std_atomic)))]
macro_rules! atomic_impl { macro_rules! atomic_impl {
($($ty:ident $size:expr)*) => { ($($ty:ident $size:expr)*) => {
$( $(
@@ -1031,7 +1031,7 @@ macro_rules! atomic_impl {
} }
} }
#[cfg(all(feature = "std", not(no_std_atomic)))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_std_atomic)))]
atomic_impl! { atomic_impl! {
AtomicBool "8" AtomicBool "8"
AtomicI8 "8" AtomicI8 "8"
@@ -1044,7 +1044,7 @@ atomic_impl! {
AtomicUsize "ptr" AtomicUsize "ptr"
} }
#[cfg(all(feature = "std", not(no_std_atomic64)))] #[cfg(all(feature = "std", not(target_os = "none"), not(no_std_atomic64)))]
atomic_impl! { atomic_impl! {
AtomicI64 "64" AtomicI64 "64"
AtomicU64 "64" AtomicU64 "64"
serde_core/src/ser/impossible.rs
+1 -2
View File
@@ -2,9 +2,8 @@
use crate::lib::*; use crate::lib::*;
// Explicit prelude import for wasm32v1-none target compatibility // Explicit prelude import for wasm32v1-none and other no_std targets
#[allow(unused_imports)] #[allow(unused_imports)]
#[cfg(not(feature = "std"))]
use ::core::prelude::rust_2021::*; use ::core::prelude::rust_2021::*;
use crate::ser::{ use crate::ser::{
serde_core/src/ser/mod.rs
+6 -7
View File
@@ -109,9 +109,8 @@
use crate::lib::*; use crate::lib::*;
// Explicit prelude import for wasm32v1-none target compatibility // Explicit prelude import for wasm32v1-none and other no_std targets
#[allow(unused_imports)] #[allow(unused_imports)]
#[cfg(not(feature = "std"))]
use ::core::prelude::rust_2021::*; use ::core::prelude::rust_2021::*;
mod fmt; mod fmt;
@@ -120,13 +119,13 @@ mod impossible;
pub use self::impossible::Impossible; pub use self::impossible::Impossible;
#[cfg(all(not(feature = "std"), no_core_error))] #[cfg(all(any(not(feature = "std"), target_os = "none"), no_core_error))]
#[doc(no_inline)] #[doc(no_inline)]
pub use crate::std_error::Error as StdError; pub use crate::std_error::Error as StdError;
#[cfg(not(any(feature = "std", no_core_error)))] #[cfg(all(any(not(feature = "std"), target_os = "none"), not(no_core_error)))]
#[doc(no_inline)] #[doc(no_inline)]
pub use core::error::Error as StdError; pub use core::error::Error as StdError;
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
#[doc(no_inline)] #[doc(no_inline)]
pub use std::error::Error as StdError; pub use std::error::Error as StdError;
@@ -193,10 +192,10 @@ macro_rules! declare_error_trait {
} }
} }
#[cfg(feature = "std")] #[cfg(all(feature = "std", not(target_os = "none")))]
declare_error_trait!(Error: Sized + StdError); declare_error_trait!(Error: Sized + StdError);
#[cfg(not(feature = "std"))] #[cfg(any(not(feature = "std"), target_os = "none"))]
declare_error_trait!(Error: Sized + Debug + Display); declare_error_trait!(Error: Sized + Debug + Display);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////