check array rank (#29)

* check array rank

* disable unit test of array rank

* update versions

Author: quabug

Assets/Samples/ReadOnlyArrayValues.cs

@@ -7,12 +7,15 @@ public class ReadOnlyArrayValues : MonoBehaviour
     {
         [AnySerialize] public int[] IntArray { get; }
         [AnySerialize] public int[][] IntArray2 { get; }
+        // [AnySerialize] public int[,,] IntArrayRank3 { get; }
         [AnySerialize] public List<long>[] LongListArray { get; }
         [AnySerialize] public Dictionary<string, int>[] DictionaryArray { get; }
+        // [AnySerialize] public string[,] StringArrayRank2 { get; }
         [AnySerialize] public string[][][] StringArray3 { get; }
         [AnySerialize] public IReadOnlyList<string> StringReadOnlyList { get; }
         [AnySerialize] public PlainClass[][] PlainClasses2 { get; }
 
+        [ContextMenu("log")]
         private void Awake()
         {
             this.JsonLog();

Assets/Samples/ReadOnlyArrayValues.prefab

@@ -97,6 +97,8 @@ MonoBehaviour:
     _value:
     - _value:
       - _value:
-          Int: 0
-          Float: 0
-          DoubleArray: []
+          Int: 321
+          Float: 432
+          DoubleArray:
+          - 33
+          - 44

Assets/Tests/AnySerialize/TestDefaultTypeSearcher.cs

@@ -87,6 +87,12 @@ public void should_find_replace_type_for_3D_array_type()
             AssertTypeEqual<ReadOnlyAnyArray<int[][], ReadOnlyAnyArray<int[], AnyArray_Int32>>>(SearchReadOnly<int[][][]>());
         }
 
+        [Test, Ignore("not support yet")]
+        public void should_find_replace_type_for_array_type_with_rank()
+        {
+            SearchReadOnly<int[,]>();
+        }
+        
         [Test]
         public void should_find_replace_type_for_dictionary_type()
         {

Packages/com.quabug.any-processor/CodeGen/Extension/ReflectionExtension.cs

@@ -42,7 +42,8 @@ public static Type ToReflectionType(this TypeReference cecilType)
                         .ToArray()
                 ),
                 GenericParameter _ => throw new NotSupportedException(),
-                ArrayType arrayType => arrayType.ElementType.ToReflectionType().MakeArrayType(/*arrayType.Rank*/), // array with rank become [*] which is not the same as array type in reflection.
+                ArrayType { Rank: > 1 } arrayType => arrayType.ElementType.ToReflectionType().MakeArrayType(arrayType.Rank),
+                ArrayType arrayType => arrayType.ElementType.ToReflectionType().MakeArrayType(), // array with rank become [*] which is not the same as array type in reflection.
                 ByReferenceType byReferenceType => byReferenceType.ElementType.ToReflectionType().MakeByRefType(),
                 PointerType pointerType => pointerType.ElementType.ToReflectionType().MakePointerType(),
                 TypeSpecification _ => throw new NotSupportedException(),

Packages/com.quabug.any-processor/CodeGen/Extension/TypeEqualsExtension.cs

@@ -68,6 +68,14 @@ public static bool TypeEquals(this GenericParameterConstraint? lhs, GenericParam
             return TypeEquals(lhs.ConstraintType, rhs.ConstraintType);
         }
 
+        [Pure]
+        public static bool TypeEquals(this ArrayType? lhs, ArrayType? rhs)
+        {
+            if (lhs == null) throw new ArgumentNullException(nameof(lhs));
+            if (rhs == null) throw new ArgumentNullException(nameof(rhs));
+            return lhs.Rank == rhs.Rank && TypeEquals(lhs.ElementType, rhs.ElementType);
+        }
+        
         [Pure]
         public static bool TypeEquals(this TypeSpecification? lhs, TypeSpecification? rhs)
         {

Packages/com.quabug.any-processor/CodeGen/Extension/TypeGenericExtension.cs

@@ -115,7 +115,7 @@ public static bool IsDerivedFrom(this TypeReference derived, TypeReference @base
             if (derived.Resolve() == null) throw new ArgumentException("cannot resolve type", nameof(derived));
             if (@base.Resolve() == null) throw new ArgumentException("cannot resolve type", nameof(@base));
             if (derived is ArrayType derivedArray && @base is ArrayType baseArray)
-                return derivedArray.ElementType.IsDerivedFrom(baseArray.ElementType);
+                return derivedArray.Rank == baseArray.Rank && derivedArray.ElementType.IsDerivedFrom(baseArray.ElementType);
             if (derived.IsArray || @base.IsArray) return false;
             if (!derived.Resolve()!.IsDerivedFrom(@base.Resolve()!)) return false;
             if (derived.GetGenericParametersOrArgumentsCount() != @base.GetGenericParametersOrArgumentsCount()) return false;
@@ -156,7 +156,7 @@ static bool IsMatch(TypeReference selfArgument, TypeReference genericArgument)
             {
                 if (selfArgument.IsGenericParameter || genericArgument.IsGenericParameter) return true;
                 if (selfArgument is ArrayType selfArray && genericArgument is ArrayType genericArray)
-                    return IsMatch(selfArray.ElementType!, genericArray.ElementType!);
+                    return selfArray.Rank == genericArray.Rank && IsMatch(selfArray.ElementType!, genericArray.ElementType!);
                 if (selfArgument.IsArray || genericArgument.IsArray) return false;
                 if (!selfArgument.IsGenericType() && !genericArgument.IsGenericType()) return selfArgument.TypeEquals(genericArgument);
                 if (!(selfArgument.IsGenericType() && genericArgument.IsGenericType())) return false;

Packages/com.quabug.any-processor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.quabug.any-processor",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "unity": "2021.3",
   "displayName": "AnyProcessor",
   "type": "library",

Packages/com.quabug.any-serialize/CodeGen/FieldTypeSearcher.cs

@@ -36,7 +36,6 @@ public FieldTypeSearcher(
             ).ToArray();
             if (searcherFieldCount != fields.Length || fieldIndex < 0) return;
 
-
             var field = fields[fieldIndex];
             var property = field.GetBackingFieldProperty();
             var fieldType = property == null ? field.FieldType! : property.PropertyType!;

Packages/com.quabug.any-serialize/CodeGen/SerializeTypeSearcher.cs

@@ -40,6 +40,9 @@ public SerializeTypeSearcher(
                 throw new ArgumentException($"{nameof(_targetType)} must be a concrete generic instance with one and only one arguments.", nameof(_targetType));
 
             var propertyType = _targetType.GetGenericParametersOrArguments().First();
+            if (propertyType is ArrayType propertyArrayType && propertyArrayType.Rank > 1)
+                throw new ArgumentException($"Invalid property type ({propertyType}): array type with rank is not supported yet.", nameof(_targetType));
+            
             var isAnySerializable = propertyType.Resolve().GetAttributesOf<AnySerializableAttribute>().Any();
             var anyClassInterface = _module.ImportReference(typeof(IReadOnlyAnyClass<>)).Resolve();
 
@@ -74,7 +77,7 @@ bool IsCloserImplementation(TypeReference? previous, TypeReference? current, Typ
                 if (current == null || current.IsGenericParameter) return false;
                 if (previous.TypeEquals(current)) return true;
                 if (previous is ArrayType previousArray && current is ArrayType currentArray && target is ArrayType targetArray)
-                    return IsCloserImplementation(previousArray.ElementType, currentArray.ElementType, targetArray.ElementType!);
+                    return currentArray.Rank == targetArray.Rank && IsCloserImplementation(previousArray.ElementType, currentArray.ElementType, targetArray.ElementType!);
                 if (current.IsArray && target.IsArray) return true;
 
                 var previousDefinition = previous.Resolve()!;

Packages/com.quabug.any-serialize/Runtime/AnyNullableClass.cs

@@ -3,7 +3,7 @@
 
 namespace AnySerialize
 {
-    [Serializable, AnySerializePriority(AnySerializePriorityAttribute.AnyValuePriority + 10000)]
+    [Serializable, AnySerializePriority(AnySerializePriorityAttribute.AnyCustomOnly)]
     public class AnyNullableClass<T> : IReadOnlyAny<T?>, IAny<T?> where T : class
     {
         [field: SerializeReference] public T? Value { get; set; } = null;