feat: Add no_std support (#108)

near · Dec 4, 2020 · 949f0da · 949f0da
1 parent 4c2f1a0
commit 949f0da
Show file tree

Hide file tree

Showing 28 changed files with 1,109 additions and 325 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -2,7 +2,7 @@ language: rust
 rust:
   - stable
   - beta
-  - nightly-2019-05-22
+  - nightly-2020-05-15
   - nightly
 
 matrix:
@@ -20,6 +20,7 @@ install:
 script:
   - cargo build --verbose --manifest-path=borsh-rs/Cargo.toml
   - cargo test --verbose --manifest-path=borsh-rs/Cargo.toml
+  - cd borsh-rs/borsh && cargo test --verbose --no-default-features
 
 addons:
   apt:

diff --git a/borsh-rs/CHANGELOG.md b/borsh-rs/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Changelog
 
+## 0.8.0
+- Add no_std support.
+
 ## 0.7.2
 - Implement `BorshSerialize` for reference fields (`&T`)
 

diff --git a/borsh-rs/benchmarks/Cargo.toml b/borsh-rs/benchmarks/Cargo.toml
@@ -11,7 +11,7 @@ bench = false
 [dependencies]
 rand_xorshift = "0.2.0"
 rand = "0.7.0"
-borsh = { path = "../borsh" }
+borsh = { path = "../borsh", default-features = false }
 serde = { version = "1.0", features = ["derive"] }
 speedy-derive = "0.5"
 speedy = "0.5"
@@ -25,3 +25,6 @@ serde_cbor = "0.10"
 [[bench]]
 name = "bench"
 harness = false
+
+[features]
+default = ["borsh/std"]
diff --git a/borsh-rs/borsh-derive-internal/Cargo.toml b/borsh-rs/borsh-derive-internal/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "borsh-derive-internal"
-version = "0.7.2"
+version = "0.8.0"
 authors = ["Near Inc <hello@nearprotocol.com>"]
 edition = "2018"
 license = "Apache-2.0"

diff --git a/borsh-rs/borsh-derive-internal/src/enum_de.rs b/borsh-rs/borsh-derive-internal/src/enum_de.rs
@@ -1,12 +1,12 @@
-use std::convert::TryFrom;
+use core::convert::TryFrom;
 
 use quote::quote;
 use syn::export::TokenStream2;
-use syn::{Fields, ItemEnum, WhereClause};
+use syn::{Fields, Ident, ItemEnum, WhereClause};
 
 use crate::attribute_helpers::{contains_initialize_with, contains_skip};
 
-pub fn enum_de(input: &ItemEnum) -> syn::Result<TokenStream2> {
+pub fn enum_de(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream2> {
     let name = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let mut where_clause = where_clause.map_or_else(
@@ -33,11 +33,11 @@ pub fn enum_de(input: &ItemEnum) -> syn::Result<TokenStream2> {
                     } else {
                         let field_type = &field.ty;
                         where_clause.predicates.push(syn::parse2(quote! {
-                            #field_type: borsh::BorshDeserialize
+                            #field_type: #cratename::BorshDeserialize
                         }).unwrap());
 
                         variant_header.extend(quote! {
-                            #field_name: borsh::BorshDeserialize::deserialize(buf)?,
+                            #field_name: #cratename::BorshDeserialize::deserialize(buf)?,
                         });
                     }
                 }
@@ -50,11 +50,11 @@ pub fn enum_de(input: &ItemEnum) -> syn::Result<TokenStream2> {
                     } else {
                         let field_type = &field.ty;
                         where_clause.predicates.push(syn::parse2(quote! {
-                            #field_type: borsh::BorshDeserialize
+                            #field_type: #cratename::BorshDeserialize
                         }).unwrap());
 
                         variant_header
-                            .extend(quote! { borsh::BorshDeserialize::deserialize(buf)?, });
+                            .extend(quote! { #cratename::BorshDeserialize::deserialize(buf)?, });
                     }
                 }
                 variant_header = quote! { ( #variant_header )};
@@ -66,20 +66,23 @@ pub fn enum_de(input: &ItemEnum) -> syn::Result<TokenStream2> {
         });
     }
     let variant_idx = quote! {
-        let variant_idx: u8 = borsh::BorshDeserialize::deserialize(buf)?;
+        let variant_idx: u8 = #cratename::BorshDeserialize::deserialize(buf)?;
     };
     if let Some(method_ident) = init_method {
         Ok(quote! {
-            impl #impl_generics borsh::de::BorshDeserialize for #name #ty_generics #where_clause {
-                fn deserialize(buf: &mut &[u8]) -> std::result::Result<Self, std::io::Error> {
+            impl #impl_generics #cratename::de::BorshDeserialize for #name #ty_generics #where_clause {
+                fn deserialize(buf: &mut &[u8]) -> core::result::Result<Self, #cratename::maybestd::io::Error> {
                     #variant_idx
                     let mut return_value = match variant_idx {
                         #variant_arms
-                        _ =>
-                        return Err(std::io::Error::new(
-                                   std::io::ErrorKind::InvalidInput,
-                                   format!("Unexpected variant index: {:?}", variant_idx),
-                                  )),
+                        _ => {
+                            let msg = #cratename::maybestd::format!("Unexpected variant index: {:?}", variant_idx);
+
+                            return Err(#cratename::maybestd::io::Error::new(
+                                #cratename::maybestd::io::ErrorKind::InvalidInput,
+                                msg,
+                            ));
+                        }
                     };
                     return_value.#method_ident();
                     Ok(return_value)
@@ -88,16 +91,19 @@ pub fn enum_de(input: &ItemEnum) -> syn::Result<TokenStream2> {
         })
     } else {
         Ok(quote! {
-            impl #impl_generics borsh::de::BorshDeserialize for #name #ty_generics #where_clause {
-                fn deserialize(buf: &mut &[u8]) -> std::result::Result<Self, std::io::Error> {
+            impl #impl_generics #cratename::de::BorshDeserialize for #name #ty_generics #where_clause {
+                fn deserialize(buf: &mut &[u8]) -> core::result::Result<Self, #cratename::maybestd::io::Error> {
                     #variant_idx
                     let return_value = match variant_idx {
                         #variant_arms
-                        _ =>
-                        return Err(std::io::Error::new(
-                                   std::io::ErrorKind::InvalidInput,
-                                   format!("Unexpected variant index: {:?}", variant_idx),
-                                  )),
+                        _ => {
+                            let msg = #cratename::maybestd::format!("Unexpected variant index: {:?}", variant_idx);
+
+                            return Err(#cratename::maybestd::io::Error::new(
+                                #cratename::maybestd::io::ErrorKind::InvalidInput,
+                                msg,
+                            ));
+                        }
                     };
                     Ok(return_value)
                 }

diff --git a/borsh-rs/borsh-derive-internal/src/enum_ser.rs b/borsh-rs/borsh-derive-internal/src/enum_ser.rs
@@ -1,12 +1,12 @@
-use std::convert::TryFrom;
+use core::convert::TryFrom;
 
 use quote::quote;
 use syn::export::{Span, TokenStream2};
 use syn::{Fields, Ident, ItemEnum, WhereClause};
 
 use crate::attribute_helpers::contains_skip;
 
-pub fn enum_ser(input: &ItemEnum) -> syn::Result<TokenStream2> {
+pub fn enum_ser(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream2> {
     let name = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let mut where_clause = where_clause.map_or_else(
@@ -32,12 +32,12 @@ pub fn enum_ser(input: &ItemEnum) -> syn::Result<TokenStream2> {
                     } else {
                         let field_type = &field.ty;
                         where_clause.predicates.push(syn::parse2(quote! {
-                            #field_type: borsh::ser::BorshSerialize
+                            #field_type: #cratename::ser::BorshSerialize
                         }).unwrap());
                         variant_header.extend(quote! { #field_name, });
                     }
                     variant_body.extend(quote! {
-                         borsh::BorshSerialize::serialize(#field_name, writer)?;
+                         #cratename::BorshSerialize::serialize(#field_name, writer)?;
                     })
                 }
                 variant_header = quote! { { #variant_header }};
@@ -54,14 +54,14 @@ pub fn enum_ser(input: &ItemEnum) -> syn::Result<TokenStream2> {
                     } else {
                         let field_type = &field.ty;
                         where_clause.predicates.push(syn::parse2(quote! {
-                            #field_type: borsh::ser::BorshSerialize
+                            #field_type: #cratename::ser::BorshSerialize
                         }).unwrap());
 
                         let field_ident =
                             Ident::new(format!("id{}", field_idx).as_str(), Span::call_site());
                         variant_header.extend(quote! { #field_ident, });
                         variant_body.extend(quote! {
-                            borsh::BorshSerialize::serialize(#field_ident, writer)?;
+                            #cratename::BorshSerialize::serialize(#field_ident, writer)?;
                         })
                     }
                 }
@@ -78,8 +78,8 @@ pub fn enum_ser(input: &ItemEnum) -> syn::Result<TokenStream2> {
         ))
     }
     Ok(quote! {
-        impl #impl_generics borsh::ser::BorshSerialize for #name #ty_generics #where_clause {
-            fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::result::Result<(), std::io::Error> {
+        impl #impl_generics #cratename::ser::BorshSerialize for #name #ty_generics #where_clause {
+            fn serialize<W: #cratename::maybestd::io::Write>(&self, writer: &mut W) -> core::result::Result<(), #cratename::maybestd::io::Error> {
                 match self {
                     #body
                 }

diff --git a/borsh-rs/borsh-derive-internal/src/struct_de.rs b/borsh-rs/borsh-derive-internal/src/struct_de.rs
@@ -1,9 +1,9 @@
 use crate::attribute_helpers::{contains_initialize_with, contains_skip};
 use quote::quote;
 use syn::export::TokenStream2;
-use syn::{Fields, ItemStruct, WhereClause};
+use syn::{Fields, Ident, ItemStruct, WhereClause};
 
-pub fn struct_de(input: &ItemStruct) -> syn::Result<TokenStream2> {
+pub fn struct_de(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStream2> {
     let name = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let mut where_clause = where_clause.map_or_else(
@@ -26,11 +26,11 @@ pub fn struct_de(input: &ItemStruct) -> syn::Result<TokenStream2> {
                 } else {
                     let field_type = &field.ty;
                     where_clause.predicates.push(syn::parse2(quote! {
-                        #field_type: borsh::BorshDeserialize
+                        #field_type: #cratename::BorshDeserialize
                     }).unwrap());
 
                     quote! {
-                        #field_name: borsh::BorshDeserialize::deserialize(buf)?,
+                        #field_name: #cratename::BorshDeserialize::deserialize(buf)?,
                     }
                 };
                 body.extend(delta);
@@ -43,7 +43,7 @@ pub fn struct_de(input: &ItemStruct) -> syn::Result<TokenStream2> {
             let mut body = TokenStream2::new();
             for _ in 0..fields.unnamed.len() {
                 let delta = quote! {
-                    borsh::BorshDeserialize::deserialize(buf)?,
+                    #cratename::BorshDeserialize::deserialize(buf)?,
                 };
                 body.extend(delta);
             }
@@ -59,8 +59,8 @@ pub fn struct_de(input: &ItemStruct) -> syn::Result<TokenStream2> {
     };
     if let Some(method_ident) = init_method {
         Ok(quote! {
-            impl #impl_generics borsh::de::BorshDeserialize for #name #ty_generics #where_clause {
-                fn deserialize(buf: &mut &[u8]) ->  std::result::Result<Self, std::io::Error> {
+            impl #impl_generics #cratename::de::BorshDeserialize for #name #ty_generics #where_clause {
+                fn deserialize(buf: &mut &[u8]) ->  core::result::Result<Self, #cratename::maybestd::io::Error> {
                     let mut return_value = #return_value;
                     return_value.#method_ident();
                     Ok(return_value)
@@ -69,8 +69,8 @@ pub fn struct_de(input: &ItemStruct) -> syn::Result<TokenStream2> {
         })
     } else {
         Ok(quote! {
-            impl #impl_generics borsh::de::BorshDeserialize for #name #ty_generics #where_clause {
-                fn deserialize(buf: &mut &[u8]) -> std::result::Result<Self, std::io::Error> {
+            impl #impl_generics #cratename::de::BorshDeserialize for #name #ty_generics #where_clause {
+                fn deserialize(buf: &mut &[u8]) -> core::result::Result<Self, #cratename::maybestd::io::Error> {
                     Ok(#return_value)
                 }
             }

diff --git a/borsh-rs/borsh-derive-internal/src/struct_ser.rs b/borsh-rs/borsh-derive-internal/src/struct_ser.rs
@@ -1,12 +1,12 @@
-use std::convert::TryFrom;
+use core::convert::TryFrom;
 
 use quote::quote;
 use syn::export::{Span, TokenStream2};
-use syn::{Fields, Index, ItemStruct, WhereClause};
+use syn::{Fields, Ident, Index, ItemStruct, WhereClause};
 
 use crate::attribute_helpers::contains_skip;
 
-pub fn struct_ser(input: &ItemStruct) -> syn::Result<TokenStream2> {
+pub fn struct_ser(input: &ItemStruct, cratename: Ident) -> syn::Result<TokenStream2> {
     let name = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let mut where_clause = where_clause.map_or_else(
@@ -25,13 +25,13 @@ pub fn struct_ser(input: &ItemStruct) -> syn::Result<TokenStream2> {
                 }
                 let field_name = field.ident.as_ref().unwrap();
                 let delta = quote! {
-                    borsh::BorshSerialize::serialize(&self.#field_name, writer)?;
+                    #cratename::BorshSerialize::serialize(&self.#field_name, writer)?;
                 };
                 body.extend(delta);
 
                 let field_type = &field.ty;
                 where_clause.predicates.push(syn::parse2(quote! {
-                    #field_type: borsh::ser::BorshSerialize
+                    #field_type: #cratename::ser::BorshSerialize
                 }).unwrap());
             }
         }
@@ -42,16 +42,16 @@ pub fn struct_ser(input: &ItemStruct) -> syn::Result<TokenStream2> {
                     span: Span::call_site(),
                 };
                 let delta = quote! {
-                    borsh::BorshSerialize::serialize(&self.#field_idx, writer)?;
+                    #cratename::BorshSerialize::serialize(&self.#field_idx, writer)?;
                 };
                 body.extend(delta);
             }
         }
         Fields::Unit => {}
     }
     Ok(quote! {
-        impl #impl_generics borsh::ser::BorshSerialize for #name #ty_generics #where_clause {
-            fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::result::Result<(), std::io::Error> {
+        impl #impl_generics #cratename::ser::BorshSerialize for #name #ty_generics #where_clause {
+            fn serialize<W: #cratename::maybestd::io::Write>(&self, writer: &mut W) -> core::result::Result<(), #cratename::maybestd::io::Error> {
                 #body
                 Ok(())
             }
@@ -78,14 +78,14 @@ mod tests {
             }
         }).unwrap();
 
-        let actual = struct_ser(&item_struct).unwrap();
+        let actual = struct_ser(&item_struct, Ident::new("borsh", Span::call_site())).unwrap();
         let expected = quote!{
             impl borsh::ser::BorshSerialize for A
             where
                 u64: borsh::ser::BorshSerialize,
                 String: borsh::ser::BorshSerialize
             {
-                fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::result::Result<(), std::io::Error> {
+                fn serialize<W: borsh::maybestd::io::Write>(&self, writer: &mut W) -> core::result::Result<(), borsh::maybestd::io::Error> {
                     borsh::BorshSerialize::serialize(&self.x, writer)?;
                     borsh::BorshSerialize::serialize(&self.y, writer)?;
                     Ok(())
@@ -104,14 +104,14 @@ mod tests {
             }
         }).unwrap();
 
-        let actual = struct_ser(&item_struct).unwrap();
+        let actual = struct_ser(&item_struct, Ident::new("borsh", Span::call_site())).unwrap();
         let expected = quote!{
             impl<K, V> borsh::ser::BorshSerialize for A<K, V>
             where
                 HashMap<K, V>: borsh::ser::BorshSerialize,
                 String: borsh::ser::BorshSerialize
             {
-                fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::result::Result<(), std::io::Error> {
+                fn serialize<W: borsh::maybestd::io::Write>(&self, writer: &mut W) -> core::result::Result<(), borsh::maybestd::io::Error> {
                     borsh::BorshSerialize::serialize(&self.x, writer)?;
                     borsh::BorshSerialize::serialize(&self.y, writer)?;
                     Ok(())
@@ -130,15 +130,15 @@ mod tests {
             }
         }).unwrap();
 
-        let actual = struct_ser(&item_struct).unwrap();
+        let actual = struct_ser(&item_struct, Ident::new("borsh", Span::call_site())).unwrap();
         let expected = quote!{
             impl<K: Key, V> borsh::ser::BorshSerialize for A<K, V>
             where
                 V: Value,
                 HashMap<K, V>: borsh::ser::BorshSerialize,
                 String: borsh::ser::BorshSerialize
             {
-                fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::result::Result<(), std::io::Error> {
+                fn serialize<W: borsh::maybestd::io::Write>(&self, writer: &mut W) -> core::result::Result<(), borsh::maybestd::io::Error> {
                     borsh::BorshSerialize::serialize(&self.x, writer)?;
                     borsh::BorshSerialize::serialize(&self.y, writer)?;
                     Ok(())

diff --git a/borsh-rs/borsh-derive-internal/src/union_de.rs b/borsh-rs/borsh-derive-internal/src/union_de.rs
@@ -1,6 +1,6 @@
 use syn::export::TokenStream2;
-use syn::ItemUnion;
+use syn::{Ident, ItemUnion};
 
-pub fn union_de(_input: &ItemUnion) -> syn::Result<TokenStream2> {
+pub fn union_de(_input: &ItemUnion, _cratename: Ident) -> syn::Result<TokenStream2> {
     unimplemented!()
 }
diff --git a/borsh-rs/borsh-derive-internal/src/union_ser.rs b/borsh-rs/borsh-derive-internal/src/union_ser.rs
@@ -1,6 +1,6 @@
 use syn::export::TokenStream2;
-use syn::ItemUnion;
+use syn::{Ident, ItemUnion};
 
-pub fn union_ser(_input: &ItemUnion) -> syn::Result<TokenStream2> {
+pub fn union_ser(_input: &ItemUnion, _cratename: Ident) -> syn::Result<TokenStream2> {
     unimplemented!()
 }