Make the library no_std

Eliminate all uses of std crate from non-test code.  For the most part
it is a matter of using core or alloc namespaces instead.

The only exception is std::error::Error trait.  However, it is
re-exported by serde as serde::{de,ser}::StdError so implement that
instead.

Tests use HashMap which requires std crate.  Since test code doesn’t
matter for no_std support, enable std crate when building tests.

no_std support was tested by building for thumbv6m-none-eabi target.

Issue: CosmWasm/cosmwasm#1484
Issue: CosmWasm#40

Author: mina86

src/de/errors.rs

@@ -1,5 +1,6 @@
+use alloc::string::{String, ToString};
+
 use serde::de;
-use std::{error, fmt};
 
 /// Deserialization result
 pub type Result<T> = core::result::Result<T, Error>;
@@ -72,27 +73,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 serde::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/mod.rs

@@ -6,14 +6,15 @@ mod map;
 mod seq;
 mod unescape;
 
+use alloc::string::String;
+
 pub use errors::{Error, Result};
 
 use serde::de::{self, Visitor};
 
 use self::enum_::{StructVariantAccess, UnitVariantAccess};
 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
@@ -126,7 +127,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)?,
                             ))
                         };
@@ -687,6 +688,11 @@ where
 #[cfg(test)]
 mod tests {
     use super::from_str;
+
+    use alloc::string::{String, ToString};
+    use alloc::vec;
+    use alloc::vec::Vec;
+
     use serde_derive::{Deserialize, Serialize};
 
     #[derive(Debug, Deserialize, PartialEq)]
@@ -947,7 +953,7 @@ mod tests {
         assert_eq!(
             from_str(r#"{ "description": "An ambient temperature sensor" }"#),
             Ok(Property {
-                description: Some("An ambient temperature sensor".to_string()),
+                description: Some("An ambient temperature sensor".into()),
             })
         );
 
@@ -1036,7 +1042,7 @@ mod tests {
         }
 
         let expected = Users {
-            users: vec!["joe".to_string(), "alice".to_string()],
+            users: vec!["joe".into(), "alice".into()],
             pagination: Pagination {
                 offset: 100,
                 limit: 20,
@@ -1116,7 +1122,7 @@ mod tests {
         }
 
         let element: Address = from_str(r#""johnny""#).unwrap();
-        assert_eq!(element, Address("johnny".to_string()));
+        assert_eq!(element, Address("johnny".into()));
 
         let element: CommentId = from_str(r#"5464813"#).unwrap();
         assert_eq!(element, CommentId(5464813));
@@ -1125,101 +1131,101 @@ mod tests {
         assert_eq!(
             element,
             NewtypeDemo {
-                address: Address("johnny".to_string()),
+                address: Address("johnny".into()),
                 comment: CommentId(9897),
             }
         );
     }
 
     #[test]
     fn numbered_key_maps() {
-        use std::collections::BTreeMap;
+        use alloc::collections::BTreeMap;
 
         // u8
         let mut ranking: BTreeMap<u8, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<u8, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // u16
         let mut ranking: BTreeMap<u16, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<u16, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // u32
         let mut ranking: BTreeMap<u32, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<u32, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // u64
         let mut ranking: BTreeMap<u64, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<u64, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // u128
         let mut ranking: BTreeMap<u128, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<u128, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // i8
         let mut ranking: BTreeMap<i8, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<i8, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // i16
         let mut ranking: BTreeMap<i16, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<i16, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // i32
         let mut ranking: BTreeMap<i32, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<i32, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // i64
         let mut ranking: BTreeMap<i64, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<i64, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
         );
 
         // i128
         let mut ranking: BTreeMap<i128, String> = BTreeMap::new();
-        ranking.insert(1, "Elon".to_string());
-        ranking.insert(2, "Bazos".to_string());
+        ranking.insert(1, "Elon".into());
+        ranking.insert(2, "Bazos".into());
         assert_eq!(
             from_str::<BTreeMap<i128, String>>(r#"{"1": "Elon", "2": "Bazos"}"#).unwrap(),
             ranking
@@ -1250,12 +1256,7 @@ mod tests {
         }"#,
         )
         .expect("simple");
-        assert_eq!(
-            m,
-            Msg {
-                name: "one".to_string()
-            }
-        );
+        assert_eq!(m, Msg { name: "one".into() });
 
         let o: OptIn = from_str(
             r#"{
@@ -1266,7 +1267,7 @@ mod tests {
         assert_eq!(
             o,
             OptIn {
-                name: Some("two".to_string())
+                name: Some("two".into())
             }
         );
 
@@ -1280,10 +1281,8 @@ mod tests {
         assert_eq!(
             res,
             Response {
-                log: Some("my log".to_string()),
-                messages: vec![Msg {
-                    name: "one".to_string()
-                }],
+                log: Some("my log".into()),
+                messages: vec![Msg { name: "one".into() }],
             }
         );
 
@@ -1333,10 +1332,10 @@ mod tests {
         assert_eq!(
             res,
             MyResult::Ok(Response {
-                log: Some("hello".to_string()),
+                log: Some("hello".into()),
                 messages: vec![Msg {
-                    name: "fred".to_string(),
-                    amount: Some("15".to_string())
+                    name: "fred".into(),
+                    amount: Some("15".into())
                 }]
             })
         );
@@ -1353,7 +1352,7 @@ mod tests {
         assert_eq!(
             res,
             MyResult::Ok(Response {
-                log: Some("hello".to_string()),
+                log: Some("hello".into()),
                 messages: Vec::new()
             })
         );
@@ -1433,21 +1432,21 @@ mod tests {
                 properties: Properties {
                     temperature: Property {
                         ty: Type::Number,
-                        unit: Some("celsius".to_string()),
-                        description: Some("An ambient temperature sensor".to_string()),
-                        href: "/properties/temperature".to_string(),
+                        unit: Some("celsius".into()),
+                        description: Some("An ambient temperature sensor".into()),
+                        href: "/properties/temperature".into(),
                     },
                     humidity: Property {
                         ty: Type::Number,
-                        unit: Some("percent".to_string()),
+                        unit: Some("percent".into()),
                         description: None,
-                        href: "/properties/humidity".to_string(),
+                        href: "/properties/humidity".into(),
                     },
                     led: Property {
                         ty: Type::Boolean,
                         unit: None,
-                        description: Some("A red LED".to_string()),
-                        href: "/properties/led".to_string(),
+                        description: Some("A red LED".into()),
+                        href: "/properties/led".into(),
                     },
                 },
                 ty: Type::Thing,