stash

Author: dzmitry-lahoda

borsh-derive/src/internals/attributes/item/mod.rs

@@ -3,7 +3,7 @@ use proc_macro2::Span;
 use quote::ToTokens;
 use syn::{spanned::Spanned, Attribute, DeriveInput, Error, Expr, ItemEnum, Path, TypePath};
 
-use super::{get_one_attribute, parsing, TAG_WIDTH};
+use super::{get_one_attribute, parsing, RUST_REPR, TAG_WIDTH};
 
 pub fn check_attributes(derive_input: &DeriveInput) -> Result<(), Error> {
     let borsh = get_one_attribute(&derive_input.attrs)?;
@@ -75,6 +75,16 @@ pub(crate) fn contains_use_discriminant(input: &ItemEnum) -> Result<bool, syn::E
     Ok(use_discriminant.unwrap_or(false))
 }
 
+pub(crate) fn get_may_be_repr(inpute: &ItemEnum) -> Result<Option<(TypePath, Span)>, syn::Error> {
+    inpute
+        .attrs
+        .iter()
+        .find(|attr| attr.path() == RUST_REPR)
+        .map(|attr| attr.parse_args::<TypePath>().map(|value| (attr, value)))
+        .transpose()
+        .map(|(attr, value)| value.map(|value| (value, attr.unwrap().span())))
+}
+
 pub(crate) fn get_maybe_borsh_tag_width(
     input: &ItemEnum,
 ) -> Result<Option<(u8, Span)>, syn::Error> {

borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_invalid_on_whole_item.snap.new

@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/attributes/item/mod.rs
-assertion_line: 243
+assertion_line: 247
 expression: actual.unwrap_err()
 ---
 Error(

borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_skip_on_whole_item.snap.new

@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/attributes/item/mod.rs
-assertion_line: 229
+assertion_line: 233
 expression: actual.unwrap_err()
 ---
 Error(

borsh-derive/src/internals/attributes/item/snapshots/check_attrs_init_function_wrong_format.snap.new

@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/attributes/item/mod.rs
-assertion_line: 328
+assertion_line: 332
 expression: actual.unwrap_err()
 ---
 Error(

borsh-derive/src/internals/attributes/mod.rs

@@ -33,6 +33,8 @@ pub const CRATE: Symbol = Symbol("crate", "crate = ...");
 /// tag_width - sub-borsh nested meta, item-level only attribute in `BorshSerialize`, `BorshDeserialize`, `BorshSchema` contexts
 pub const TAG_WIDTH: Symbol = Symbol("tag_width", "tag_width = ...");
 
+pub const RUST_REPR: Symbol = Symbol("repr", "repr(...)");
+
 #[cfg(feature = "schema")]
 pub mod schema_keys {
     use super::Symbol;

borsh-derive/src/internals/enum_discriminant.rs

@@ -1,3 +1,8 @@
+//! 
+//! Algorithm of finding out tag width:
+//! 1. Rust `repr(...)` and `borsh(tag_width = ...) attributes are read
+//! 2. If repr is signed, transparent or variable with *size, borsh errors with unsupported
+//! 2.1. NOTE: signed to be supported
 use core::convert::TryInto;
 use std::collections::HashMap;
 use std::convert::TryFrom;
@@ -17,26 +22,11 @@ impl Discriminants {
         let mut map = HashMap::new();
         let mut next_discriminant_if_not_specified = quote! {0};
 
-        fn bytes_needed(value: usize) -> usize {
-            let bits_needed = std::mem::size_of::<usize>() * 8 - value.leading_zeros() as usize;
-            (bits_needed + 7) / 8
-        }
-
         let min_tag_width: u8 = bytes_needed(variants.len())
             .try_into()
             .expect("variants cannot be bigger u64");
 
-        let mut min = 0;
-        let mut max = 0;
-
         for variant in variants {
-            if let Some(discriminant) = &variant.discriminant {
-                let value = discriminant.1.to_token_stream().to_string();
-                let value = value.parse::<i128>().unwrap();
-                min = value.min(min);
-                max = value.max(max);
-            }
-
             let this_discriminant = variant.discriminant.clone().map_or_else(
                 || quote! { #next_discriminant_if_not_specified },
                 |(_, e)| quote! { #e },
@@ -46,15 +36,6 @@ impl Discriminants {
             map.insert(variant.ident.clone(), this_discriminant);
         }
 
-        let min: u64 = min.abs().try_into().expect("variants cannot be bigger u64");
-        let max: u64 = max.try_into().expect("variants cannot be bigger u64");
-        if min > 0 {
-            return Err(syn::Error::new(
-                variants.span(),
-                "negative variants are not supported, please write manual impl",
-            ));
-        }
-        let max_bytes: u8 = bytes_needed(max as usize).try_into().expect("");
         if let Some((borsh_tag_width, span)) = maybe_borsh_tag_width {
             if borsh_tag_width < min_tag_width {
                 return Err(syn::Error::new(
@@ -68,17 +49,17 @@ impl Discriminants {
             }
         }
 
-        let tag_with = maybe_borsh_tag_width
+        let tag_width = maybe_borsh_tag_width
             .map(|(tag_width, _)| tag_width)
-            .unwrap_or_else(|| (max_bytes).max(min_tag_width));
+            .unwrap_or_else(|| (1).max(min_tag_width));
 
-        let tag_width_type = if tag_with <= 1 {
+        let tag_width_type = if tag_width <= 1 {
             "u8"
-        } else if tag_with <= 2 {
+        } else if tag_width <= 2 {
             "u16"
-        } else if tag_with <= 4 {
+        } else if tag_width <= 4 {
             "u32"
-        } else if tag_with <= 8 {
+        } else if tag_width <= 8 {
             "u64"
         } else {
             unreachable!("we eliminated such error earlier")

borsh/tests/roundtrip/requires_derive_category/test_enum_discriminants.rs

@@ -54,6 +54,7 @@ pub fn u16_discriminant() {
     data.serialize(&mut buf).unwrap();
     assert_eq!(buf[0], 154);
     assert_eq!(buf[1], 2);
+    assert!(buf.len(), 2);
     let deserialized = U16Discriminant::deserialize(&mut buf.as_slice()).unwrap();
     assert_eq!(deserialized, data);
 }
@@ -63,16 +64,17 @@ pub fn u32_discriminant() {
     use borsh::{BorshDeserialize, BorshSerialize};
     #[derive(BorshSerialize, BorshDeserialize, Debug, Eq, PartialEq)]
     #[borsh(use_discriminant = true)]
+    #[repr(u32)]
     enum U32Discriminant {
-        U8 { a: u16 } = 42,
+        U8 { a: u16 } = 42u32,
         U32 { b: u32 } = u32::MAX,
     }
     let mut buf = vec![];
-    let data = U16Discriminant::U16 { b: 1234567 };
+    let data = U32Discriminant::U32 { b: 1234567 };
     data.serialize(&mut buf).unwrap();
     assert_eq!(buf[0], 154);
     assert_eq!(buf[1], 2);
-    let deserialized = U16Discriminant::deserialize(&mut buf.as_slice()).unwrap();
+    let deserialized = U32Discriminant::deserialize(&mut buf.as_slice()).unwrap();
     assert_eq!(deserialized, data);
 }