fix: fully qualify #cratename::BorshSchema in derive-generated code…

… to void function name collisions leading to compilation errors (#244)
near · Oct 12, 2023 · 4ef9d00 · 4ef9d00
1 parent 49df318
commit 4ef9d00
Show file tree

Hide file tree

Showing 42 changed files with 378 additions and 144 deletions.
diff --git a/borsh-derive/src/internals/attributes/field/mod.rs b/borsh-derive/src/internals/attributes/field/mod.rs
@@ -178,7 +178,7 @@ impl Attributes {
     }
     pub(crate) fn collect_bounds(&self, ty: BoundType) -> Vec<WherePredicate> {
         let predicates = self.get_bounds(ty);
-        predicates.unwrap_or(vec![])
+        predicates.unwrap_or_default()
     }
 }
 

diff --git a/borsh-derive/src/internals/schema/enums/mod.rs b/borsh-derive/src/internals/schema/enums/mod.rs
@@ -72,7 +72,7 @@ pub fn process(input: &ItemEnum, cratename: Path) -> syn::Result<TokenStream2> {
                 tag_width: 1,
                 variants: #cratename::__private::maybestd::vec![#(#variants_defs),*],
             };
-            #cratename::schema::add_definition(Self::declaration(), definition, definitions);
+            #cratename::schema::add_definition(<Self as #cratename::BorshSchema>::declaration(), definition, definitions);
         }
     };
 
@@ -147,7 +147,7 @@ fn process_variant(
         process_discriminant(&variant.ident, discriminant_info)?;
 
     let variant_entry = quote! {
-        (#discriminant_variable as i64, #variant_name.to_string(), <#full_variant_ident #inner_struct_ty_generics>::declaration())
+        (#discriminant_variable as i64, #variant_name.to_string(), <#full_variant_ident #inner_struct_ty_generics as #cratename::BorshSchema>::declaration())
     };
     Ok(VariantOutput {
         inner_struct,

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
@@ -51,15 +51,21 @@ impl borsh::BorshSchema for X {
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "A".to_string(), < XA > ::declaration()),
-                (discriminant_1 as i64, "B".to_string(), < XB > ::declaration()),
-                (discriminant_2 as i64, "C".to_string(), < XC > ::declaration()),
-                (discriminant_3 as i64, "D".to_string(), < XD > ::declaration()),
-                (discriminant_4 as i64, "E".to_string(), < XE > ::declaration()),
-                (discriminant_5 as i64, "F".to_string(), < XF > ::declaration())
+                (discriminant_0 as i64, "A".to_string(), < XA as borsh::BorshSchema >
+                ::declaration()), (discriminant_1 as i64, "B".to_string(), < XB as
+                borsh::BorshSchema > ::declaration()), (discriminant_2 as i64, "C"
+                .to_string(), < XC as borsh::BorshSchema > ::declaration()),
+                (discriminant_3 as i64, "D".to_string(), < XD as borsh::BorshSchema >
+                ::declaration()), (discriminant_4 as i64, "E".to_string(), < XE as
+                borsh::BorshSchema > ::declaration()), (discriminant_5 as i64, "F"
+                .to_string(), < XF as borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
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
@@ -51,15 +51,21 @@ impl borsh::BorshSchema for X {
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "A".to_string(), < XA > ::declaration()),
-                (discriminant_1 as i64, "B".to_string(), < XB > ::declaration()),
-                (discriminant_2 as i64, "C".to_string(), < XC > ::declaration()),
-                (discriminant_3 as i64, "D".to_string(), < XD > ::declaration()),
-                (discriminant_4 as i64, "E".to_string(), < XE > ::declaration()),
-                (discriminant_5 as i64, "F".to_string(), < XF > ::declaration())
+                (discriminant_0 as i64, "A".to_string(), < XA as borsh::BorshSchema >
+                ::declaration()), (discriminant_1 as i64, "B".to_string(), < XB as
+                borsh::BorshSchema > ::declaration()), (discriminant_2 as i64, "C"
+                .to_string(), < XC as borsh::BorshSchema > ::declaration()),
+                (discriminant_3 as i64, "D".to_string(), < XD as borsh::BorshSchema >
+                ::declaration()), (discriminant_4 as i64, "E".to_string(), < XE as
+                borsh::BorshSchema > ::declaration()), (discriminant_5 as i64, "F"
+                .to_string(), < XF as borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
diff --git a/borsh-derive/src/internals/schema/enums/snapshots/complex_enum.snap b/borsh-derive/src/internals/schema/enums/snapshots/complex_enum.snap
@@ -42,14 +42,19 @@ impl borsh::BorshSchema for A {
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "Bacon".to_string(), < ABacon > ::declaration()),
-                (discriminant_1 as i64, "Eggs".to_string(), < AEggs > ::declaration()),
-                (discriminant_2 as i64, "Salad".to_string(), < ASalad > ::declaration()),
-                (discriminant_3 as i64, "Sausage".to_string(), < ASausage >
-                ::declaration())
+                (discriminant_0 as i64, "Bacon".to_string(), < ABacon as
+                borsh::BorshSchema > ::declaration()), (discriminant_1 as i64, "Eggs"
+                .to_string(), < AEggs as borsh::BorshSchema > ::declaration()),
+                (discriminant_2 as i64, "Salad".to_string(), < ASalad as
+                borsh::BorshSchema > ::declaration()), (discriminant_3 as i64, "Sausage"
+                .to_string(), < ASausage as borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
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
@@ -9,7 +9,8 @@ where
 {
     fn declaration() -> borsh::schema::Declaration {
         let params = borsh::__private::maybestd::vec![
-            < C > ::declaration(), < W > ::declaration()
+            < C as borsh::BorshSchema > ::declaration(), < W as borsh::BorshSchema >
+            ::declaration()
         ];
         format!(r#"{}<{}>"#, "A", params.join(", "))
     }
@@ -49,14 +50,19 @@ where
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "Bacon".to_string(), < ABacon > ::declaration()),
-                (discriminant_1 as i64, "Eggs".to_string(), < AEggs > ::declaration()),
-                (discriminant_2 as i64, "Salad".to_string(), < ASalad < C > >
-                ::declaration()), (discriminant_3 as i64, "Sausage".to_string(), <
-                ASausage < W > > ::declaration())
+                (discriminant_0 as i64, "Bacon".to_string(), < ABacon as
+                borsh::BorshSchema > ::declaration()), (discriminant_1 as i64, "Eggs"
+                .to_string(), < AEggs as borsh::BorshSchema > ::declaration()),
+                (discriminant_2 as i64, "Salad".to_string(), < ASalad < C > as
+                borsh::BorshSchema > ::declaration()), (discriminant_3 as i64, "Sausage"
+                .to_string(), < ASausage < W > as borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
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
@@ -9,7 +9,8 @@ where
 {
     fn declaration() -> borsh::schema::Declaration {
         let params = borsh::__private::maybestd::vec![
-            < U > ::declaration(), < C > ::declaration()
+            < U as borsh::BorshSchema > ::declaration(), < C as borsh::BorshSchema >
+            ::declaration()
         ];
         format!(r#"{}<{}>"#, "A", params.join(", "))
     }
@@ -51,14 +52,20 @@ where
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "Bacon".to_string(), < ABacon > ::declaration()),
-                (discriminant_1 as i64, "Eggs".to_string(), < AEggs > ::declaration()),
-                (discriminant_2 as i64, "Salad".to_string(), < ASalad < C > >
-                ::declaration()), (discriminant_3 as i64, "Sausage".to_string(), <
-                ASausage < W, U > > ::declaration())
+                (discriminant_0 as i64, "Bacon".to_string(), < ABacon as
+                borsh::BorshSchema > ::declaration()), (discriminant_1 as i64, "Eggs"
+                .to_string(), < AEggs as borsh::BorshSchema > ::declaration()),
+                (discriminant_2 as i64, "Salad".to_string(), < ASalad < C > as
+                borsh::BorshSchema > ::declaration()), (discriminant_3 as i64, "Sausage"
+                .to_string(), < ASausage < W, U > as borsh::BorshSchema >
+                ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
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
@@ -8,7 +8,9 @@ where
     W: borsh::BorshSchema,
 {
     fn declaration() -> borsh::schema::Declaration {
-        let params = borsh::__private::maybestd::vec![< W > ::declaration()];
+        let params = borsh::__private::maybestd::vec![
+            < W as borsh::BorshSchema > ::declaration()
+        ];
         format!(r#"{}<{}>"#, "A", params.join(", "))
     }
     fn add_definitions_recursively(
@@ -50,14 +52,19 @@ where
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "Bacon".to_string(), < ABacon > ::declaration()),
-                (discriminant_1 as i64, "Eggs".to_string(), < AEggs > ::declaration()),
-                (discriminant_2 as i64, "Salad".to_string(), < ASalad < C > >
-                ::declaration()), (discriminant_3 as i64, "Sausage".to_string(), <
-                ASausage < W > > ::declaration())
+                (discriminant_0 as i64, "Bacon".to_string(), < ABacon as
+                borsh::BorshSchema > ::declaration()), (discriminant_1 as i64, "Eggs"
+                .to_string(), < AEggs as borsh::BorshSchema > ::declaration()),
+                (discriminant_2 as i64, "Salad".to_string(), < ASalad < C > as
+                borsh::BorshSchema > ::declaration()), (discriminant_3 as i64, "Sausage"
+                .to_string(), < ASausage < W > as borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
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
@@ -34,12 +34,16 @@ impl borsh::BorshSchema for A {
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "B".to_string(), < AB > ::declaration()),
-                (discriminant_1 as i64, "Negative".to_string(), < ANegative >
-                ::declaration())
+                (discriminant_0 as i64, "B".to_string(), < AB as borsh::BorshSchema >
+                ::declaration()), (discriminant_1 as i64, "Negative".to_string(), <
+                ANegative as borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
diff --git a/borsh-derive/src/internals/schema/enums/snapshots/generic_associated_type.snap b/borsh-derive/src/internals/schema/enums/snapshots/generic_associated_type.snap
@@ -15,8 +15,9 @@ where
 {
     fn declaration() -> borsh::schema::Declaration {
         let params = borsh::__private::maybestd::vec![
-            < T > ::declaration(), < K > ::declaration(), < K::Associated >
-            ::declaration(), < V > ::declaration()
+            < T as borsh::BorshSchema > ::declaration(), < K as borsh::BorshSchema >
+            ::declaration(), < K::Associated as borsh::BorshSchema > ::declaration(), < V
+            as borsh::BorshSchema > ::declaration()
         ];
         format!(r#"{}<{}>"#, "EnumParametrized", params.join(", "))
     }
@@ -60,12 +61,17 @@ where
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "B".to_string(), < EnumParametrizedB < K, V > >
-                ::declaration()), (discriminant_1 as i64, "C".to_string(), <
-                EnumParametrizedC < T > > ::declaration())
+                (discriminant_0 as i64, "B".to_string(), < EnumParametrizedB < K, V > as
+                borsh::BorshSchema > ::declaration()), (discriminant_1 as i64, "C"
+                .to_string(), < EnumParametrizedC < T > as borsh::BorshSchema >
+                ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
diff --git a/...h-derive/src/internals/schema/enums/snapshots/generic_associated_type_param_override.snap b/...h-derive/src/internals/schema/enums/snapshots/generic_associated_type_param_override.snap
@@ -15,8 +15,9 @@ where
 {
     fn declaration() -> borsh::schema::Declaration {
         let params = borsh::__private::maybestd::vec![
-            < T > ::declaration(), < K > ::declaration(), < < K as TraitName >
-            ::Associated > ::declaration(), < V > ::declaration()
+            < T as borsh::BorshSchema > ::declaration(), < K as borsh::BorshSchema >
+            ::declaration(), < < K as TraitName > ::Associated as borsh::BorshSchema >
+            ::declaration(), < V as borsh::BorshSchema > ::declaration()
         ];
         format!(r#"{}<{}>"#, "EnumParametrized", params.join(", "))
     }
@@ -61,12 +62,17 @@ where
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "B".to_string(), < EnumParametrizedB < K, V > >
-                ::declaration()), (discriminant_1 as i64, "C".to_string(), <
-                EnumParametrizedC < T > > ::declaration())
+                (discriminant_0 as i64, "B".to_string(), < EnumParametrizedB < K, V > as
+                borsh::BorshSchema > ::declaration()), (discriminant_1 as i64, "C"
+                .to_string(), < EnumParametrizedC < T > as borsh::BorshSchema >
+                ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
diff --git a/borsh-derive/src/internals/schema/enums/snapshots/recursive_enum.snap b/borsh-derive/src/internals/schema/enums/snapshots/recursive_enum.snap
@@ -10,7 +10,8 @@ where
 {
     fn declaration() -> borsh::schema::Declaration {
         let params = borsh::__private::maybestd::vec![
-            < K > ::declaration(), < V > ::declaration()
+            < K as borsh::BorshSchema > ::declaration(), < V as borsh::BorshSchema >
+            ::declaration()
         ];
         format!(r#"{}<{}>"#, "A", params.join(", "))
     }
@@ -41,12 +42,16 @@ where
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "B".to_string(), < AB < K, V > >
-                ::declaration()), (discriminant_1 as i64, "C".to_string(), < AC < K > >
-                ::declaration())
+                (discriminant_0 as i64, "B".to_string(), < AB < K, V > as
+                borsh::BorshSchema > ::declaration()), (discriminant_1 as i64, "C"
+                .to_string(), < AC < K > as borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
diff --git a/borsh-derive/src/internals/schema/enums/snapshots/simple_enum.snap b/borsh-derive/src/internals/schema/enums/snapshots/simple_enum.snap
@@ -27,11 +27,16 @@ impl borsh::BorshSchema for A {
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "Bacon".to_string(), < ABacon > ::declaration()),
-                (discriminant_1 as i64, "Eggs".to_string(), < AEggs > ::declaration())
+                (discriminant_0 as i64, "Bacon".to_string(), < ABacon as
+                borsh::BorshSchema > ::declaration()), (discriminant_1 as i64, "Eggs"
+                .to_string(), < AEggs as borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }
 
diff --git a/borsh-derive/src/internals/schema/enums/snapshots/simple_enum_with_custom_crate.snap b/borsh-derive/src/internals/schema/enums/snapshots/simple_enum_with_custom_crate.snap
@@ -31,12 +31,14 @@ impl reexporter::borsh::BorshSchema for A {
         let definition = reexporter::borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: reexporter::borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "Bacon".to_string(), < ABacon > ::declaration()),
-                (discriminant_1 as i64, "Eggs".to_string(), < AEggs > ::declaration())
+                (discriminant_0 as i64, "Bacon".to_string(), < ABacon as
+                reexporter::borsh::BorshSchema > ::declaration()), (discriminant_1 as
+                i64, "Eggs".to_string(), < AEggs as reexporter::borsh::BorshSchema >
+                ::declaration())
             ],
         };
         reexporter::borsh::schema::add_definition(
-            Self::declaration(),
+            <Self as reexporter::borsh::BorshSchema>::declaration(),
             definition,
             definitions,
         );

diff --git a/borsh-derive/src/internals/schema/enums/snapshots/single_field_enum.snap b/borsh-derive/src/internals/schema/enums/snapshots/single_field_enum.snap
@@ -21,10 +21,15 @@ impl borsh::BorshSchema for A {
         let definition = borsh::schema::Definition::Enum {
             tag_width: 1,
             variants: borsh::__private::maybestd::vec![
-                (discriminant_0 as i64, "Bacon".to_string(), < ABacon > ::declaration())
+                (discriminant_0 as i64, "Bacon".to_string(), < ABacon as
+                borsh::BorshSchema > ::declaration())
             ],
         };
-        borsh::schema::add_definition(Self::declaration(), definition, definitions);
+        borsh::schema::add_definition(
+            <Self as borsh::BorshSchema>::declaration(),
+            definition,
+            definitions,
+        );
     }
 }