From 15e99ae0ff4fab42b34f6a9dd59fc71373293684 Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Thu, 4 Jan 2024 14:41:47 +0100 Subject: [PATCH 1/5] util: remove alternative display for Variant Strict encoding should know nothing about strict code syntax --- rust/src/util.rs | 4 ---- 1 file changed, 4 deletions(-) diff --git a/rust/src/util.rs b/rust/src/util.rs index 8373937..af2b62d 100644 --- a/rust/src/util.rs +++ b/rust/src/util.rs @@ -123,10 +123,6 @@ impl Ord for Variant { impl Display for Variant { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { write!(f, "{}", self.name)?; - if f.alternate() { - f.write_str(":")?; - Display::fmt(&self.tag, f)?; - } Ok(()) } } From 75b52688fcaddc92a57492fb1dc59597c352ecf6 Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Thu, 4 Jan 2024 14:43:27 +0100 Subject: [PATCH 2/5] stl: remove u*_ prefixes from U* variants --- rust/src/stl.rs | 48 ------------------------------------------------ 1 file changed, 48 deletions(-) diff --git a/rust/src/stl.rs b/rust/src/stl.rs index e6e695d..5252406 100644 --- a/rust/src/stl.rs +++ b/rust/src/stl.rs @@ -140,37 +140,21 @@ impl StrictDecode for bool { #[repr(u8)] pub enum U4 { #[default] - #[strict_type(rename = "u4_0")] _0 = 0, - #[strict_type(rename = "u4_1")] _1, - #[strict_type(rename = "u4_2")] _2, - #[strict_type(rename = "u4_3")] _3, - #[strict_type(rename = "u4_4")] _4, - #[strict_type(rename = "u4_5")] _5, - #[strict_type(rename = "u4_6")] _6, - #[strict_type(rename = "u4_7")] _7, - #[strict_type(rename = "u4_8")] _8, - #[strict_type(rename = "u4_9")] _9, - #[strict_type(rename = "u4_10")] _10, - #[strict_type(rename = "u4_11")] _11, - #[strict_type(rename = "u4_12")] _12, - #[strict_type(rename = "u4_13")] _13, - #[strict_type(rename = "u4_14")] _14, - #[strict_type(rename = "u4_15")] _15, } @@ -196,69 +180,37 @@ impl StrictDecode for u4 { #[repr(u8)] pub enum U5 { #[default] - #[strict_type(rename = "u5_0")] _0 = 0, - #[strict_type(rename = "u5_1")] _1, - #[strict_type(rename = "u5_2")] _2, - #[strict_type(rename = "u5_3")] _3, - #[strict_type(rename = "u5_4")] _4, - #[strict_type(rename = "u5_5")] _5, - #[strict_type(rename = "u5_6")] _6, - #[strict_type(rename = "u5_7")] _7, - #[strict_type(rename = "u5_8")] _8, - #[strict_type(rename = "u5_9")] _9, - #[strict_type(rename = "u5_10")] _10, - #[strict_type(rename = "u5_11")] _11, - #[strict_type(rename = "u5_12")] _12, - #[strict_type(rename = "u5_13")] _13, - #[strict_type(rename = "u5_14")] _14, - #[strict_type(rename = "u5_15")] _15, - #[strict_type(rename = "u5_16")] _16, - #[strict_type(rename = "u5_17")] _17, - #[strict_type(rename = "u5_18")] _18, - #[strict_type(rename = "u5_19")] _19, - #[strict_type(rename = "u5_20")] _20, - #[strict_type(rename = "u5_21")] _21, - #[strict_type(rename = "u5_22")] _22, - #[strict_type(rename = "u5_23")] _23, - #[strict_type(rename = "u5_24")] _24, - #[strict_type(rename = "u5_25")] _25, - #[strict_type(rename = "u5_26")] _26, - #[strict_type(rename = "u5_27")] _27, - #[strict_type(rename = "u5_28")] _28, - #[strict_type(rename = "u5_29")] _29, - #[strict_type(rename = "u5_30")] _30, - #[strict_type(rename = "u5_31")] _31, } From bb23cfd5e0daecce4c63e5c3ff69b359b1cf28eb Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Thu, 4 Jan 2024 15:00:28 +0100 Subject: [PATCH 3/5] stl: add all U* types --- rust/src/stl.rs | 148 ++++++++++++++++++------------------------------ 1 file changed, 55 insertions(+), 93 deletions(-) diff --git a/rust/src/stl.rs b/rust/src/stl.rs index 5252406..a6eee14 100644 --- a/rust/src/stl.rs +++ b/rust/src/stl.rs @@ -19,14 +19,14 @@ // See the License for the specific language governing permissions and // limitations under the License. -#![allow(non_camel_case_types)] +#![allow(non_camel_case_types, unused_imports)] use std::io; use std::marker::PhantomData; use amplify::ascii::AsciiChar; use amplify::confinement::Confined; -use amplify::num::{u4, u5}; +use amplify::num::{u2, u3, u4, u5, u6, u7}; use crate::{ DecodeError, StrictDecode, StrictDumb, StrictEncode, StrictEnum, StrictSum, StrictType, @@ -134,101 +134,63 @@ impl StrictDecode for bool { } } -#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Default)] -#[derive(StrictType, StrictEncode, StrictDecode)] -#[strict_type(lib = LIB_NAME_STD, tags = repr, into_u8, try_from_u8, crate = crate)] -#[repr(u8)] -pub enum U4 { - #[default] - _0 = 0, - _1, - _2, - _3, - _4, - _5, - _6, - _7, - _8, - _9, - _10, - _11, - _12, - _13, - _14, - _15, -} +macro_rules! impl_u { + ($ty:ident, $inner:ty, $( $no:ident )+) => { + #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Default)] + #[derive(StrictType, StrictEncode, StrictDecode)] + #[strict_type(lib = LIB_NAME_STD, tags = repr, into_u8, try_from_u8, crate = crate)] + #[repr(u8)] + pub enum $ty { + #[default] + $( $no ),+ + } -impl StrictType for u4 { - const STRICT_LIB_NAME: &'static str = LIB_NAME_STD; - fn strict_name() -> Option { Some(tn!("U4")) } -} -impl StrictEncode for u4 { - fn strict_encode(&self, writer: W) -> io::Result { - writer.write_enum::(U4::try_from(self.to_u8()).expect("broken u4 types guarantees")) - } -} -impl StrictDecode for u4 { - fn strict_decode(reader: &mut impl TypedRead) -> Result { - let v: U4 = reader.read_enum()?; - Ok(u4::with(v as u8)) + impl StrictType for $inner { + const STRICT_LIB_NAME: &'static str = LIB_NAME_STD; + fn strict_name() -> Option { Some(tn!(stringify!($ty))) } + } + impl StrictEncode for $inner { + fn strict_encode(&self, writer: W) -> io::Result { + writer.write_enum::<$ty>($ty::try_from(self.to_u8()) + .expect(concat!("broken", stringify!($inner), "type guarantees"))) + } + } + impl StrictDecode for $inner { + fn strict_decode(reader: &mut impl TypedRead) -> Result { + let v: $ty = reader.read_enum()?; + Ok(<$inner>::with(v as u8)) + } + } } } -#[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, Debug, Default)] -#[derive(StrictType, StrictEncode, StrictDecode)] -#[strict_type(lib = LIB_NAME_STD, tags = repr, into_u8, try_from_u8, crate = crate)] -#[repr(u8)] -pub enum U5 { - #[default] - _0 = 0, - _1, - _2, - _3, - _4, - _5, - _6, - _7, - _8, - _9, - _10, - _11, - _12, - _13, - _14, - _15, - _16, - _17, - _18, - _19, - _20, - _21, - _22, - _23, - _24, - _25, - _26, - _27, - _28, - _29, - _30, - _31, -} - -impl StrictType for u5 { - const STRICT_LIB_NAME: &'static str = LIB_NAME_STD; - fn strict_name() -> Option { Some(tn!("U5")) } -} -impl StrictEncode for u5 { - fn strict_encode(&self, writer: W) -> io::Result { - writer.write_enum::(U5::try_from(self.to_u8()).expect("broken u5 types guarantees")) - } -} -impl StrictDecode for u5 { - fn strict_decode(reader: &mut impl TypedRead) -> Result { - let v: U5 = reader.read_enum()?; - Ok(u5::with(v as u8)) - } -} +impl_u!(U2, u2, _0 _1 _2 _3); +impl_u!(U3, u3, _0 _1 _2 _3 _4 _5 _6 _7); +impl_u!(U4, u4, _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _10 _11 _12 _13 _14 _15); +impl_u!(U5, u5, _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 + _10 _11 _12 _13 _14 _15 _16 _17 _18 _19 + _20 _21 _22 _23 _24 _25 _26 _27 _28 _29 + _30 _31); +impl_u!(U6, u6, _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 + _10 _11 _12 _13 _14 _15 _16 _17 _18 _19 + _20 _21 _22 _23 _24 _25 _26 _27 _28 _29 + _30 _31 _32 _33 _34 _35 _36 _37 _38 _39 + _40 _41 _42 _43 _44 _45 _46 _47 _48 _49 + _50 _51 _52 _53 _54 _55 _56 _57 _58 _59 + _60 _61 _62 _63); +impl_u!(U7, u7, _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 + _10 _11 _12 _13 _14 _15 _16 _17 _18 _19 + _20 _21 _22 _23 _24 _25 _26 _27 _28 _29 + _30 _31 _32 _33 _34 _35 _36 _37 _38 _39 + _40 _41 _42 _43 _44 _45 _46 _47 _48 _49 + _50 _51 _52 _53 _54 _55 _56 _57 _58 _59 + _60 _61 _62 _63 _64 _65 _66 _67 _68 _69 + _70 _71 _72 _73 _74 _75 _76 _77 _78 _79 + _80 _81 _82 _83 _84 _85 _86 _87 _88 _89 + _90 _91 _92 _93 _94 _95 _96 _97 _98 _99 + _100 _101 _102 _103 _104 _105 _106 _107 _108 _109 + _110 _111 _112 _113 _114 _115 _116 _117 _118 _119 + _120 _121 _122 _123 _124 _125 _126 _127); #[derive(Wrapper, WrapperMut, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, From)] #[wrapper(Deref, Display, Debug)] From 3ac7190454a824f2cd900ce55fd71a3076c8b5e8 Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Thu, 4 Jan 2024 15:40:48 +0100 Subject: [PATCH 4/5] derive: prefix variants starting with non-alphabetic char with _ --- rust/derive/src/params.rs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/rust/derive/src/params.rs b/rust/derive/src/params.rs index 575d80b..79487d3 100644 --- a/rust/derive/src/params.rs +++ b/rust/derive/src/params.rs @@ -232,7 +232,15 @@ impl TryFrom for VariantAttr { impl VariantAttr { pub fn variant_name(&self, name: &Ident) -> LitStr { match self.rename { - None => LitStr::new(&name.to_string().to_lower_camel_case(), name.span()), + None => { + let mut camel_case = name.to_string().to_lower_camel_case(); + if let Some(first) = camel_case.chars().next() { + if !first.is_alphabetic() { + camel_case = "_".to_owned() + &camel_case; + } + } + LitStr::new(&camel_case, name.span()) + } Some(ref name) => name.clone(), } } From e91dff375f407ce4233ad51a65c65a8e526c53d4 Mon Sep 17 00:00:00 2001 From: Dr Maxim Orlovsky Date: Fri, 5 Jan 2024 20:36:09 +0100 Subject: [PATCH 5/5] fix removal of reference mark from autogenerated type names --- rust/src/types.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/src/types.rs b/rust/src/types.rs index b75be18..d0f6cd8 100644 --- a/rust/src/types.rs +++ b/rust/src/types.rs @@ -54,7 +54,7 @@ pub trait StrictType: Sized { .unwrap_or(path) } - let name = any::type_name::(); + let name = any::type_name::().replace('&', ""); let mut ident = vec![]; for mut arg in name.split([',', '<', '>', '(', ')']) { arg = arg.trim();