fix DojoStore for generic structs/enums

Author: remybar

crates/dojo/core-cairo-test/src/tests/meta/introspect.cairo

@@ -189,7 +189,6 @@ fn test_generic_struct_introspect() {
     );
 }
 
-
 #[test]
 fn test_generic_enum_introspect() {
     let size = Introspect::<GenericEnum<u32>>::size();

crates/dojo/core-cairo-test/src/tests/storage/dojo_store.cairo

@@ -28,6 +28,30 @@ enum EComplex {
     B,
 }
 
+
+#[derive(Drop, Introspect, Serde, Debug, PartialEq)]
+struct GenericStruct<T> {
+    value: T,
+}
+
+#[derive(Drop, Introspect, Serde, Default, Debug, PartialEq)]
+enum GenericEnum<T> {
+    #[default]
+    A: T,
+}
+
+#[derive(Drop, Introspect, Serde, Debug, PartialEq)]
+struct UseGenericStruct {
+    x: GenericStruct<u16>,
+    y: u8,
+}
+
+#[derive(Drop, Introspect, Serde, Debug, PartialEq)]
+struct UseGenericEnum {
+    x: GenericEnum<u16>,
+    y: u8,
+}
+
 #[test]
 fn test_dojo_store_primitives() {
     // felt252
@@ -292,6 +316,75 @@ fn test_dojo_store_tuples() {
     );
 }
 
+#[test]
+fn test_dojo_store_generic_struct() {
+    let s = GenericStruct::<u32> { value: 1234567 };
+
+    let mut serialized = array![];
+    DojoStore::serialize(@s, ref serialized);
+    assert_eq!(serialized, array![1234567], "DojoStore<GenericStruct<u32>> serialization failed");
+
+    let mut values = [1234567].span();
+    let res = DojoStore::<GenericStruct<u32>>::deserialize(ref values);
+    assert_eq!(
+        res,
+        Option::Some(GenericStruct::<u32> { value: 1234567 }),
+        "DojoStore<GenericStruct<u32>> deserialization failed",
+    );
+}
+
+#[test]
+fn test_dojo_store_generic_enum() {
+    let e = GenericEnum::<u32>::A(1234567);
+
+    let mut serialized = array![];
+    DojoStore::serialize(@e, ref serialized);
+    assert_eq!(serialized, array![1, 1234567], "DojoStore<GenericEnum<u32>> serialization failed");
+
+    let mut values = [1, 1234567].span();
+    let res = DojoStore::<GenericEnum<u32>>::deserialize(ref values);
+    assert_eq!(
+        res,
+        Option::Some(GenericEnum::<u32>::A(1234567)),
+        "DojoStore<GenericEnum<u32>> deserialization failed",
+    );
+}
+
+
+#[test]
+fn test_dojo_store_use_generic_struct() {
+    let s = UseGenericStruct { x: GenericStruct { value: 12345 }, y: 42 };
+
+    let mut serialized = array![];
+    DojoStore::serialize(@s, ref serialized);
+    assert_eq!(serialized, array![12345, 42], "DojoStore<UseGenericStruct> serialization failed");
+
+    let mut values = [12345, 42].span();
+    let res = DojoStore::<UseGenericStruct>::deserialize(ref values);
+    assert_eq!(
+        res,
+        Option::Some(UseGenericStruct { x: GenericStruct { value: 12345 }, y: 42 }),
+        "DojoStore<UseGenericStruct> deserialization failed",
+    );
+}
+
+#[test]
+fn test_dojo_store_use_generic_enum() {
+    let e = UseGenericEnum { x: GenericEnum::A(12345), y: 42 };
+
+    let mut serialized = array![];
+    DojoStore::serialize(@e, ref serialized);
+    assert_eq!(serialized, array![1, 12345, 42], "DojoStore<UseGenericEnum> serialization failed");
+
+    let mut values = [1, 12345, 42].span();
+    let res = DojoStore::<UseGenericEnum>::deserialize(ref values);
+    assert_eq!(
+        res,
+        Option::Some(UseGenericEnum { x: GenericEnum::A(12345), y: 42 }),
+        "DojoStore<UseGenericEnum> deserialization failed",
+    );
+}
+
 #[test]
 fn test_mix() {
     let e = EComplex::A(

crates/dojo/core/src/storage/dojo_store.cairo

@@ -1,44 +1,48 @@
+// Might not be necessary from Cairo 2.11
 pub impl ContractAddressDefault of Default<core::starknet::ContractAddress> {
     fn default() -> core::starknet::ContractAddress {
         core::starknet::contract_address_const::<0>()
     }
 }
 
-/// Handle data (de)serialization to be stored into
-/// the world storage.
-///
-/// The default implementation of this trait uses Serde.
-pub trait DojoStore<T, +Serde<T>> {
-    fn serialize(
-        self: @T, ref serialized: Array<felt252>,
-    ) {
-        Serde::<T>::serialize(self, ref serialized);
-    }
-    fn deserialize(ref values: Span<felt252>) -> Option<T> {
-        Serde::<T>::deserialize(ref values)
+/// Handle data (de)serialization to be stored into the world storage.
+pub trait DojoStore<T> {
+    fn serialize(self: @T, ref serialized: Array<felt252>);
+    fn deserialize(ref values: Span<felt252>) -> Option<T>;
+}
+
+/// The default implementation of DojoStore uses Serde.
+mod default_impl {
+    pub impl SerdeBasedDojoStore<T, +Serde<T>> of super::DojoStore<T> {
+        fn serialize(self: @T, ref serialized: Array<felt252>) {
+            Serde::serialize(self, ref serialized);
+        }
+        fn deserialize(ref values: Span<felt252>) -> Option<T> {
+            Serde::<T>::deserialize(ref values)
+        }
     }
 }
 
-impl DojoStore_felt252 of DojoStore<felt252>;
-impl DojoStore_bool of DojoStore<bool>;
-impl DojoStore_u8 of DojoStore<u8>;
-impl DojoStore_u16 of DojoStore<u16>;
-impl DojoStore_u32 of DojoStore<u32>;
-impl DojoStore_u64 of DojoStore<u64>;
-impl DojoStore_u128 of DojoStore<u128>;
-impl DojoStore_u256 of DojoStore<u256>;
-impl DojoStore_i8 of DojoStore<i8>;
-impl DojoStore_i16 of DojoStore<i16>;
-impl DojoStore_i32 of DojoStore<i32>;
-impl DojoStore_i64 of DojoStore<i64>;
-impl DojoStore_i128 of DojoStore<i128>;
-impl DojoStore_ContractAddress of DojoStore<starknet::ContractAddress>;
-impl DojoStore_ClassHash of DojoStore<starknet::ClassHash>;
-impl DojoStore_EthAddress of DojoStore<starknet::EthAddress>;
-impl DojoStore_ByteArray of DojoStore<ByteArray>;
+pub impl DojoStore_felt252 = default_impl::SerdeBasedDojoStore<felt252>;
+pub impl DojoStore_bool = default_impl::SerdeBasedDojoStore<bool>;
+pub impl DojoStore_u8 = default_impl::SerdeBasedDojoStore<u8>;
+pub impl DojoStore_u16 = default_impl::SerdeBasedDojoStore<u16>;
+pub impl DojoStore_u32 = default_impl::SerdeBasedDojoStore<u32>;
+pub impl DojoStore_u64 = default_impl::SerdeBasedDojoStore<u64>;
+pub impl DojoStore_u128 = default_impl::SerdeBasedDojoStore<u128>;
+pub impl DojoStore_u256 = default_impl::SerdeBasedDojoStore<u256>;
+pub impl DojoStore_i8 = default_impl::SerdeBasedDojoStore<i8>;
+pub impl DojoStore_i16 = default_impl::SerdeBasedDojoStore<i16>;
+pub impl DojoStore_i32 = default_impl::SerdeBasedDojoStore<i32>;
+pub impl DojoStore_i64 = default_impl::SerdeBasedDojoStore<i64>;
+pub impl DojoStore_i128 = default_impl::SerdeBasedDojoStore<i128>;
+pub impl DojoStore_ContractAddress = default_impl::SerdeBasedDojoStore<starknet::ContractAddress>;
+pub impl DojoStore_ClassHash = default_impl::SerdeBasedDojoStore<starknet::ClassHash>;
+pub impl DojoStore_EthAddress = default_impl::SerdeBasedDojoStore<starknet::EthAddress>;
+pub impl DojoStore_ByteArray = default_impl::SerdeBasedDojoStore<ByteArray>;
 
 /// Specific implementation of DojoStore for Option<T>.
-impl DojoStore_option<T, +Serde<T>, +DojoStore<T>, +Serde<Option<T>>> of DojoStore<Option<T>> {
+impl DojoStore_option<T, +DojoStore<T>> of DojoStore<Option<T>> {
     fn serialize(self: @Option<T>, ref serialized: Array<felt252>) {
         match self {
             Option::Some(x) => {
@@ -63,7 +67,7 @@ impl DojoStore_option<T, +Serde<T>, +DojoStore<T>, +Serde<Option<T>>> of DojoSto
     }
 }
 
-fn serialize_array_helper<T, +Serde<T>, +DojoStore<T>, +Drop<T>>(
+fn serialize_array_helper<T, +DojoStore<T>, +Drop<T>>(
     mut input: Span<T>, ref output: Array<felt252>,
 ) {
     match input.pop_front() {
@@ -75,7 +79,7 @@ fn serialize_array_helper<T, +Serde<T>, +DojoStore<T>, +Drop<T>>(
     }
 }
 
-fn deserialize_array_helper<T, +Serde<T>, +DojoStore<T>, +Drop<T>>(
+fn deserialize_array_helper<T, +DojoStore<T>, +Drop<T>>(
     ref serialized: Span<felt252>, mut curr_output: Array<T>, remaining: felt252,
 ) -> Option<Array<T>> {
     if remaining == 0 {
@@ -85,10 +89,9 @@ fn deserialize_array_helper<T, +Serde<T>, +DojoStore<T>, +Drop<T>>(
     deserialize_array_helper(ref serialized, curr_output, remaining - 1)
 }
 
-
 /// Specific implementation of DojoStore for Array<T>,
 /// to call DojoStore for array items instead of Serde directly.
-impl DojoStore_array<T, +Drop<T>, +Serde<T>, +DojoStore<T>> of DojoStore<Array<T>> {
+impl DojoStore_array<T, +Drop<T>, +DojoStore<T>> of DojoStore<Array<T>> {
     fn serialize(self: @Array<T>, ref serialized: Array<felt252>) {
         DojoStore::serialize(@self.len(), ref serialized);
         serialize_array_helper(self.span(), ref serialized);
@@ -100,4 +103,3 @@ impl DojoStore_array<T, +Drop<T>, +Serde<T>, +DojoStore<T>> of DojoStore<Array<T
         deserialize_array_helper(ref values, arr, length)
     }
 }
-

crates/dojo/lang/src/derive_macros/introspect/mod.rs

@@ -33,11 +33,8 @@ pub fn handle_introspect_struct(
 
     let inspect_gen_impls =
         build_generic_impls(&gen_types, &["+dojo::meta::introspect::Introspect".to_string()], &[]);
-    let dojo_store_gen_impls = build_generic_impls(
-        &gen_types,
-        &["+dojo::storage::DojoStore".to_string(), "+core::serde::Serde".to_string()],
-        &[format!("+core::serde::Serde<{struct_name_with_generics}>")],
-    );
+    let dojo_store_gen_impls =
+        build_generic_impls(&gen_types, &["+dojo::storage::DojoStore".to_string()], &[]);
 
     let struct_size = size::compute_struct_layout_size(db, &struct_ast, packed);
     let ty = ty::build_struct_ty(db, &struct_name_with_generics, &struct_ast);
@@ -95,10 +92,7 @@ pub fn handle_introspect_enum(
     let dojo_store_gen_impls = build_generic_impls(
         &gen_types,
         &["+dojo::storage::DojoStore".to_string(), "+core::serde::Serde".to_string()],
-        &[
-            format!("+core::serde::Serde<{enum_name_with_generics}>"),
-            format!("+core::traits::Default<{enum_name_with_generics}>"),
-        ],
+        &[format!("+core::traits::Default<{enum_name_with_generics}>")],
     );
 
     let variant_sizes = size::compute_enum_variant_sizes(db, &enum_ast);