feat!: prepend ___ to names of helper structs, generated in derives…

… of `BorshSchema` for enums
near · Jun 5, 2024 · 57c2107 · 57c2107
1 parent ffa45e0
commit 57c2107
Show file tree

Hide file tree

Showing 16 changed files with 147 additions and 142 deletions.
diff --git a/borsh-derive/src/internals/schema/enums/mod.rs b/borsh-derive/src/internals/schema/enums/mod.rs
@@ -117,7 +117,7 @@ fn process_variant(
     generics_output: &mut schema::GenericsOutput,
 ) -> syn::Result<VariantOutput> {
     let variant_name = variant.ident.to_token_stream().to_string();
-    let full_variant_name = format!("{}{}", enum_name, variant_name);
+    let full_variant_name = format!("___{}{}", enum_name, variant_name);
     let full_variant_ident = Ident::new(&full_variant_name, Span::call_site());
 
     schema::visit_struct_fields(&variant.fields, &mut generics_output.params_visitor)?;

diff --git a/borsh-derive/src/internals/schema/enums/snapshots/borsh_discriminant_false.snap b/borsh-derive/src/internals/schema/enums/snapshots/borsh_discriminant_false.snap
@@ -15,44 +15,44 @@ impl borsh::BorshSchema for X {
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XA;
+        struct ___XA;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XB;
+        struct ___XB;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XC;
+        struct ___XC;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XD;
+        struct ___XD;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XE;
+        struct ___XE;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XF;
-        <XA as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XB as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XC as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XD as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XE as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XF as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        struct ___XF;
+        <___XA as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XB as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XC as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XD as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XE as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XF as borsh::BorshSchema>::add_definitions_recursively(definitions);
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (u8::from(0u8) as i64, "A".into(), < XA as borsh::BorshSchema >
-                ::declaration()), (u8::from(1u8) as i64, "B".into(), < XB as
+                (u8::from(0u8) as i64, "A".into(), < ___XA as borsh::BorshSchema >
+                ::declaration()), (u8::from(1u8) as i64, "B".into(), < ___XB as
                 borsh::BorshSchema > ::declaration()), (u8::from(2u8) as i64, "C".into(),
-                < XC as borsh::BorshSchema > ::declaration()), (u8::from(3u8) as i64, "D"
-                .into(), < XD as borsh::BorshSchema > ::declaration()), (u8::from(4u8) as
-                i64, "E".into(), < XE as borsh::BorshSchema > ::declaration()),
-                (u8::from(5u8) as i64, "F".into(), < XF as borsh::BorshSchema >
-                ::declaration())
+                < ___XC as borsh::BorshSchema > ::declaration()), (u8::from(3u8) as i64,
+                "D".into(), < ___XD as borsh::BorshSchema > ::declaration()),
+                (u8::from(4u8) as i64, "E".into(), < ___XE as borsh::BorshSchema >
+                ::declaration()), (u8::from(5u8) as i64, "F".into(), < ___XF as
+                borsh::BorshSchema > ::declaration())
             ],
         };
         borsh::schema::add_definition(

diff --git a/borsh-derive/src/internals/schema/enums/snapshots/borsh_discriminant_true.snap b/borsh-derive/src/internals/schema/enums/snapshots/borsh_discriminant_true.snap
@@ -15,44 +15,44 @@ impl borsh::BorshSchema for X {
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XA;
+        struct ___XA;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XB;
+        struct ___XB;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XC;
+        struct ___XC;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XD;
+        struct ___XD;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XE;
+        struct ___XE;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct XF;
-        <XA as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XB as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XC as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XD as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XE as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <XF as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        struct ___XF;
+        <___XA as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XB as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XC as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XD as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XE as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___XF as borsh::BorshSchema>::add_definitions_recursively(definitions);
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (u8::from(0) as i64, "A".into(), < XA as borsh::BorshSchema >
-                ::declaration()), (u8::from(20) as i64, "B".into(), < XB as
+                (u8::from(0) as i64, "A".into(), < ___XA as borsh::BorshSchema >
+                ::declaration()), (u8::from(20) as i64, "B".into(), < ___XB as
                 borsh::BorshSchema > ::declaration()), (u8::from(20 + 1) as i64, "C"
-                .into(), < XC as borsh::BorshSchema > ::declaration()), (u8::from(20 + 1
-                + 1) as i64, "D".into(), < XD as borsh::BorshSchema > ::declaration()),
-                (u8::from(10) as i64, "E".into(), < XE as borsh::BorshSchema >
-                ::declaration()), (u8::from(10 + 1) as i64, "F".into(), < XF as
-                borsh::BorshSchema > ::declaration())
+                .into(), < ___XC as borsh::BorshSchema > ::declaration()), (u8::from(20 +
+                1 + 1) as i64, "D".into(), < ___XD as borsh::BorshSchema >
+                ::declaration()), (u8::from(10) as i64, "E".into(), < ___XE as
+                borsh::BorshSchema > ::declaration()), (u8::from(10 + 1) as i64, "F"
+                .into(), < ___XF as borsh::BorshSchema > ::declaration())
             ],
         };
         borsh::schema::add_definition(

diff --git a/borsh-derive/src/internals/schema/enums/snapshots/complex_enum.snap b/borsh-derive/src/internals/schema/enums/snapshots/complex_enum.snap
@@ -15,35 +15,35 @@ impl borsh::BorshSchema for A {
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ABacon;
+        struct ___ABacon;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct AEggs;
+        struct ___AEggs;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ASalad(Tomatoes, Cucumber, Oil);
+        struct ___ASalad(Tomatoes, Cucumber, Oil);
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ASausage {
+        struct ___ASausage {
             wrapper: Wrapper,
             filling: Filling,
         }
-        <ABacon as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <AEggs as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ASalad as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ASausage as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ABacon as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___AEggs as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ASalad as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ASausage as borsh::BorshSchema>::add_definitions_recursively(definitions);
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (u8::from(0u8) as i64, "Bacon".into(), < ABacon as borsh::BorshSchema >
-                ::declaration()), (u8::from(1u8) as i64, "Eggs".into(), < AEggs as
+                (u8::from(0u8) as i64, "Bacon".into(), < ___ABacon as borsh::BorshSchema
+                > ::declaration()), (u8::from(1u8) as i64, "Eggs".into(), < ___AEggs as
                 borsh::BorshSchema > ::declaration()), (u8::from(2u8) as i64, "Salad"
-                .into(), < ASalad as borsh::BorshSchema > ::declaration()),
-                (u8::from(3u8) as i64, "Sausage".into(), < ASausage as borsh::BorshSchema
-                > ::declaration())
+                .into(), < ___ASalad as borsh::BorshSchema > ::declaration()),
+                (u8::from(3u8) as i64, "Sausage".into(), < ___ASausage as
+                borsh::BorshSchema > ::declaration())
             ],
         };
         borsh::schema::add_definition(

diff --git a/borsh-derive/src/internals/schema/enums/snapshots/complex_enum_generics.snap b/borsh-derive/src/internals/schema/enums/snapshots/complex_enum_generics.snap
@@ -23,34 +23,34 @@ where
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ABacon;
+        struct ___ABacon;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct AEggs;
+        struct ___AEggs;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ASalad<C>(Tomatoes, C, Oil);
+        struct ___ASalad<C>(Tomatoes, C, Oil);
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ASausage<W> {
+        struct ___ASausage<W> {
             wrapper: W,
             filling: Filling,
         }
-        <ABacon as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <AEggs as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ASalad<C> as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ASausage<W> as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ABacon as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___AEggs as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ASalad<C> as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ASausage<W> as borsh::BorshSchema>::add_definitions_recursively(definitions);
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (u8::from(0u8) as i64, "Bacon".into(), < ABacon as borsh::BorshSchema >
-                ::declaration()), (u8::from(1u8) as i64, "Eggs".into(), < AEggs as
+                (u8::from(0u8) as i64, "Bacon".into(), < ___ABacon as borsh::BorshSchema
+                > ::declaration()), (u8::from(1u8) as i64, "Eggs".into(), < ___AEggs as
                 borsh::BorshSchema > ::declaration()), (u8::from(2u8) as i64, "Salad"
-                .into(), < ASalad < C > as borsh::BorshSchema > ::declaration()),
-                (u8::from(3u8) as i64, "Sausage".into(), < ASausage < W > as
+                .into(), < ___ASalad < C > as borsh::BorshSchema > ::declaration()),
+                (u8::from(3u8) as i64, "Sausage".into(), < ___ASausage < W > as
                 borsh::BorshSchema > ::declaration())
             ],
         };

diff --git a/...ve/src/internals/schema/enums/snapshots/complex_enum_generics_borsh_skip_named_field.snap b/...ve/src/internals/schema/enums/snapshots/complex_enum_generics_borsh_skip_named_field.snap
@@ -23,36 +23,39 @@ where
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ABacon;
+        struct ___ABacon;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct AEggs;
+        struct ___AEggs;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ASalad<C>(Tomatoes, C, Oil);
+        struct ___ASalad<C>(Tomatoes, C, Oil);
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ASausage<W, U> {
+        struct ___ASausage<W, U> {
             #[borsh(skip)]
             wrapper: W,
             filling: Filling,
             unexpected: U,
         }
-        <ABacon as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <AEggs as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ASalad<C> as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ASausage<W, U> as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ABacon as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___AEggs as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ASalad<C> as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ASausage<
+            W,
+            U,
+        > as borsh::BorshSchema>::add_definitions_recursively(definitions);
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (u8::from(0u8) as i64, "Bacon".into(), < ABacon as borsh::BorshSchema >
-                ::declaration()), (u8::from(1u8) as i64, "Eggs".into(), < AEggs as
+                (u8::from(0u8) as i64, "Bacon".into(), < ___ABacon as borsh::BorshSchema
+                > ::declaration()), (u8::from(1u8) as i64, "Eggs".into(), < ___AEggs as
                 borsh::BorshSchema > ::declaration()), (u8::from(2u8) as i64, "Salad"
-                .into(), < ASalad < C > as borsh::BorshSchema > ::declaration()),
-                (u8::from(3u8) as i64, "Sausage".into(), < ASausage < W, U > as
+                .into(), < ___ASalad < C > as borsh::BorshSchema > ::declaration()),
+                (u8::from(3u8) as i64, "Sausage".into(), < ___ASausage < W, U > as
                 borsh::BorshSchema > ::declaration())
             ],
         };

diff --git a/...ve/src/internals/schema/enums/snapshots/complex_enum_generics_borsh_skip_tuple_field.snap b/...ve/src/internals/schema/enums/snapshots/complex_enum_generics_borsh_skip_tuple_field.snap
@@ -22,37 +22,37 @@ where
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ABacon;
+        struct ___ABacon;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct AEggs;
+        struct ___AEggs;
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ASalad<C: Eq>(Tomatoes, #[borsh(skip)] C, Oil);
+        struct ___ASalad<C: Eq>(Tomatoes, #[borsh(skip)] C, Oil);
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ASausage<W>
+        struct ___ASausage<W>
         where
             W: Hash,
         {
             wrapper: W,
             filling: Filling,
         }
-        <ABacon as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <AEggs as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ASalad<C> as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ASausage<W> as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ABacon as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___AEggs as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ASalad<C> as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ASausage<W> as borsh::BorshSchema>::add_definitions_recursively(definitions);
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (u8::from(0u8) as i64, "Bacon".into(), < ABacon as borsh::BorshSchema >
-                ::declaration()), (u8::from(1u8) as i64, "Eggs".into(), < AEggs as
+                (u8::from(0u8) as i64, "Bacon".into(), < ___ABacon as borsh::BorshSchema
+                > ::declaration()), (u8::from(1u8) as i64, "Eggs".into(), < ___AEggs as
                 borsh::BorshSchema > ::declaration()), (u8::from(2u8) as i64, "Salad"
-                .into(), < ASalad < C > as borsh::BorshSchema > ::declaration()),
-                (u8::from(3u8) as i64, "Sausage".into(), < ASausage < W > as
+                .into(), < ___ASalad < C > as borsh::BorshSchema > ::declaration()),
+                (u8::from(3u8) as i64, "Sausage".into(), < ___ASausage < W > as
                 borsh::BorshSchema > ::declaration())
             ],
         };

diff --git a/borsh-derive/src/internals/schema/enums/snapshots/filter_foreign_attrs.snap b/borsh-derive/src/internals/schema/enums/snapshots/filter_foreign_attrs.snap
@@ -15,7 +15,7 @@ impl borsh::BorshSchema for A {
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct AB {
+        struct ___AB {
             c: i32,
             #[borsh(skip)]
             d: u32,
@@ -24,17 +24,17 @@ impl borsh::BorshSchema for A {
         #[allow(dead_code)]
         #[derive(borsh::BorshSchema)]
         #[borsh(crate = "borsh")]
-        struct ANegative {
+        struct ___ANegative {
             beta: String,
         }
-        <AB as borsh::BorshSchema>::add_definitions_recursively(definitions);
-        <ANegative as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___AB as borsh::BorshSchema>::add_definitions_recursively(definitions);
+        <___ANegative as borsh::BorshSchema>::add_definitions_recursively(definitions);
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (u8::from(0u8) as i64, "B".into(), < AB as borsh::BorshSchema >
-                ::declaration()), (u8::from(1u8) as i64, "Negative".into(), < ANegative
-                as borsh::BorshSchema > ::declaration())
+                (u8::from(0u8) as i64, "B".into(), < ___AB as borsh::BorshSchema >
+                ::declaration()), (u8::from(1u8) as i64, "Negative".into(), <
+                ___ANegative as borsh::BorshSchema > ::declaration())
             ],
         };
         borsh::schema::add_definition(