Make library no_std and introduce std and unstable features

Remove all references to std from the library and introduce std and
unstable features which enable corresponding serde features.

In default build, std is enabled and nothing changes.  However, if std
is disabled, the library becomes no_std.  Downside of lack of std is
that Error enum no longer implements std::error;:Error.  To remedy that,
unstable feature uses core::error::Error but requires a nightly compiler.

For the most part, this commit is mostly just replacing references to
std crate with core and alloc crates.  On exception is std::error::Error
which is replaced by serde’s StdError such that Error enums implement
whatever trait serde uses.  With std or unstable feature enabled it’s
just an alias to {std,core}::error::Error.

Issue: CosmWasm/cosmwasm#1484
Issue: #40

Author: mina86

CHANGELOG.md

@@ -9,10 +9,17 @@ project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
 
+- Introduce `std` (enabled by default) and `unstable` features ([#58]).  They
+  enable corresponding serde’s features and if either is enabled, `Error`
+  implements `std::error::Error` trait.  By itself, `serde-json-wasm` is now
+  `no_std`; it’s up to serde’s features whether the entire build is.  **Please
+  not:** this potentially breaks `default-features = false` builds.
+
 - Serialize / deserialize `u128`/`i128` types as numbers instead of strings
   ([#59]).<br/> **Please note:** this breaks deserialization of `u128`/`i128`
   serialized with older versions of `serde-json-wasm`.
 
+[#58]: https://github.com/CosmWasm/serde-json-wasm/pull/58
 [#59]: https://github.com/CosmWasm/serde-json-wasm/pull/59
 
 ## [0.5.1] - 2023-04-11

Cargo.lock

@@ -27,9 +27,14 @@ ryu = "1.0.5"
 
 [dependencies.serde]
 default-features = false
-features = ["alloc", "derive"]
+features = ["alloc"]
 version = "1.0.100"
 
 [dev-dependencies]
-serde_derive = "1.0.100"
+serde = { version = "1.0.100", default-features = false, features = ["derive"] }
 serde_json = "1.0.120"
+
+[features]
+default = ["std"]
+std = ["serde/std"]
+unstable = ["serde/unstable"]

Cargo.toml

@@ -1,11 +1,18 @@
-use serde::{de, Serialize};
-use std::{error, fmt};
+use alloc::string::{String, ToString};
+
+use serde::de;
 
 /// Deserialization result
 pub type Result<T> = core::result::Result<T, Error>;
 
-/// This type represents all possible errors that can occur when deserializing JSON data
-#[derive(Debug, PartialEq, Eq, Clone, Serialize)]
+/// This type represents all possible errors that can occur when deserializing
+/// JSON data
+///
+/// It implements [`std::error::Error`] trait so long as either `std` or
+/// `unstable` features are enabled.  `std` is enabled by default and disabling
+/// it makes the crate `no_std`.  `unstable` makes sit necessary to build code
+/// with nightly compiler.
+#[derive(Debug, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum Error {
     /// Control character (U+0000 to U+001F) found in string. Those must always be escaped.
@@ -75,27 +82,16 @@ pub enum Error {
     Custom(String),
 }
 
-impl error::Error for Error {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        None
-    }
-
-    fn description(&self) -> &str {
-        "(use display)"
-    }
-}
+impl de::StdError for Error {}
 
 impl de::Error for Error {
-    fn custom<T>(msg: T) -> Self
-    where
-        T: fmt::Display,
-    {
+    fn custom<T: core::fmt::Display>(msg: T) -> Self {
         Error::Custom(msg.to_string())
     }
 }
 
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(
             f,
             "{}",

src/de/errors.rs

@@ -6,16 +6,17 @@ mod map;
 mod seq;
 mod unescape;
 
+use alloc::string::String;
+
 pub use errors::{Error, Result};
 
-use std::str::{self, FromStr};
+use core::str::{self, FromStr};
 
 use serde::de::{self, Visitor};
 
 use self::enum_::{UnitVariantAccess, VariantAccess};
 use self::map::MapAccess;
 use self::seq::SeqAccess;
-use std::str::from_utf8;
 
 /// Deserializer will parse serde-json-wasm flavored JSON into a
 /// serde-annotated struct
@@ -131,7 +132,7 @@ impl<'a> Deserializer<'a> {
                             )?))
                         } else {
                             Ok(StringLike::Borrowed(
-                                from_utf8(&self.slice[start..end])
+                                core::str::from_utf8(&self.slice[start..end])
                                     .map_err(|_| Error::InvalidUnicodeCodePoint)?,
                             ))
                         };
@@ -697,7 +698,12 @@ where
 #[cfg(test)]
 mod tests {
     use super::from_str;
-    use serde_derive::{Deserialize, Serialize};
+
+    use alloc::string::{String, ToString};
+    use alloc::vec;
+    use alloc::vec::Vec;
+
+    use serde::{Deserialize, Serialize};
 
     #[derive(Debug, Deserialize, PartialEq)]
     enum Type {
@@ -895,7 +901,7 @@ mod tests {
     fn integer() {
         assert_eq!(from_str("5"), Ok(5));
         assert_eq!(from_str("101"), Ok(101));
-        assert!(dbg!(from_str::<u16>("1e5")).is_err());
+        assert!(from_str::<u16>("1e5").is_err());
         assert!(from_str::<u8>("256").is_err());
         assert!(from_str::<f32>(",").is_err());
     }
@@ -1331,7 +1337,7 @@ mod tests {
 
     #[test]
     fn numbered_key_maps() {
-        use std::collections::BTreeMap;
+        use alloc::collections::BTreeMap;
 
         // u8
         let mut ranking: BTreeMap<u8, String> = BTreeMap::new();
@@ -1432,7 +1438,7 @@ mod tests {
             pub messages: Vec<Msg>,
         }
 
-        #[derive(Debug, Deserialize, PartialEq, Eq, serde_derive::Serialize)]
+        #[derive(Debug, Deserialize, PartialEq, Eq, serde::Serialize)]
         pub struct Msg {
             pub name: String,
         }

src/de/mod.rs

@@ -1,4 +1,6 @@
-use std::convert::TryFrom;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::convert::TryFrom;
 
 use super::errors::{Error, Result};
 

src/de/unescape.rs

@@ -56,7 +56,15 @@
 #![deny(missing_docs)]
 #![deny(rust_2018_compatibility)]
 #![deny(rust_2018_idioms)]
-#![cfg_attr(not(feature = "std"), no_std)]
+// Note: Even though we declare the crate as `no_std`, by default `std` feature
+// is enabled which enables serde’s `std` feature which makes our dependency
+// non-`no_std`.  This `no_std` declaration only makes sure that our code
+// doesn’t depend on `std` directly (except for tests).
+#![no_std]
+
+extern crate alloc;
+#[cfg(test)]
+extern crate std;
 
 pub mod de;
 pub mod ser;
@@ -67,10 +75,14 @@ pub use self::ser::{to_string, to_vec};
 
 #[cfg(test)]
 mod test {
-    use std::collections::BTreeMap;
+    use alloc::borrow::ToOwned;
+    use alloc::collections::BTreeMap;
+    use alloc::string::{String, ToString};
+    use alloc::vec;
+    use alloc::vec::Vec;
 
     use super::*;
-    use serde_derive::{Deserialize, Serialize};
+    use serde::{Deserialize, Serialize};
 
     #[derive(Debug, Deserialize, Serialize, PartialEq)]
     struct Address(String);
@@ -106,7 +118,7 @@ mod test {
     fn can_serde() {
         let min = Item {
             model: Model::Comment,
-            title: "".to_string(),
+            title: String::new(),
             content: None,
             list: vec![],
             published: false,

src/lib.rs

@@ -1,5 +1,3 @@
-use std::fmt;
-
 use serde::{ser, Serialize};
 
 use crate::ser::{Error, Result, Serializer};
@@ -58,7 +56,7 @@ struct MapKeySerializer<'a> {
 }
 
 pub(crate) fn key_must_be_a_string() -> Error {
-    Error::Custom("JSON object key is required to be a string type.".to_string())
+    Error::Custom("JSON object key is required to be a string type.".into())
 }
 
 macro_rules! serialize_unsigned_key {
@@ -255,7 +253,7 @@ impl<'a> ser::Serializer for MapKeySerializer<'a> {
 
     fn collect_str<T>(self, _value: &T) -> Result<()>
     where
-        T: ?Sized + fmt::Display,
+        T: ?Sized + core::fmt::Display,
     {
         unreachable!()
     }

src/ser/map.rs

@@ -1,12 +1,11 @@
 //! Serialize a Rust data structure into JSON data
 
-use std::{error, fmt, str};
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use core::{fmt, str};
 
 use serde::ser;
 use serde::ser::SerializeStruct as _;
-use serde::Serialize;
-
-use std::vec::Vec;
 
 use self::map::SerializeMap;
 use self::seq::SerializeSeq;
@@ -20,7 +19,12 @@ mod struct_;
 pub type Result<T> = ::core::result::Result<T, Error>;
 
 /// This type represents all possible errors that can occur when serializing JSON data
-#[derive(Debug, PartialEq, Eq, Clone, Serialize)]
+///
+/// It implements [`std::error::Error`] trait so long as either `std` or
+/// `unstable` features are enabled.  `std` is enabled by default and disabling
+/// it makes the crate `no_std`.  `unstable` makes sit necessary to build code
+/// with nightly compiler.
+#[derive(Debug)]
 #[non_exhaustive]
 pub enum Error {
     /// Buffer is full
@@ -42,18 +46,10 @@ impl From<u8> for Error {
     }
 }
 
-impl error::Error for Error {
-    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        None
-    }
+impl ser::StdError for Error {}
 
-    fn description(&self) -> &str {
-        "(use display)"
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Error::BufferFull => write!(f, "Buffer is full"),
             Error::Custom(msg) => write!(f, "{}", &msg),
@@ -479,18 +475,21 @@ where
 }
 
 impl ser::Error for Error {
-    fn custom<T>(msg: T) -> Self
-    where
-        T: fmt::Display,
-    {
+    fn custom<T: core::fmt::Display>(msg: T) -> Self {
         Error::Custom(msg.to_string())
     }
 }
 
 #[cfg(test)]
 mod tests {
-
     use super::to_string;
+
+    use alloc::collections::BTreeMap;
+    use alloc::string::{String, ToString};
+    use alloc::vec;
+    use alloc::vec::Vec;
+    use std::collections::HashMap;
+
     use serde::{Deserialize, Serialize, Serializer};
 
     #[macro_export]
@@ -1085,7 +1084,7 @@ mod tests {
         }
 
         let users = Users {
-            users: vec!["joe".to_string(), "alice".to_string()],
+            users: vec!["joe".into(), "alice".into()],
             pagination: Pagination {
                 offset: 100,
                 limit: 20,
@@ -1102,8 +1101,6 @@ mod tests {
 
     #[test]
     fn btree_map() {
-        use std::collections::BTreeMap;
-
         // empty map
         let empty = BTreeMap::<(), ()>::new();
         assert_eq!(to_string(&empty).unwrap(), r#"{}"#);
@@ -1225,8 +1222,6 @@ mod tests {
 
     #[test]
     fn number_key() {
-        use std::collections::HashMap;
-
         // i8 key
         let mut map = HashMap::new();
         map.insert(10i8, "my_age");
@@ -1289,7 +1284,6 @@ mod tests {
     #[test]
     fn invalid_json_key() {
         use crate::ser::map::key_must_be_a_string;
-        use std::collections::HashMap;
 
         #[derive(Debug, Serialize, PartialEq, Eq, Hash)]
         #[serde(rename_all = "lowercase")]
@@ -1345,7 +1339,7 @@ mod tests {
 
     #[test]
     fn serialize_embedded_enum() {
-        use serde_derive::Deserialize;
+        use serde::Deserialize;
 
         #[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
         #[serde(rename_all = "lowercase")]