release v3.2.5

- [feat] support deserialize to collection virtual interfaces (IList, IDictionary, Dictionary<int, IDictionary<X,Y>[]>, etc.)

Author: JasonXuDeveloper

src/Nino.Generator/Collection/CollectionDeserializerGenerator.cs

@@ -20,9 +20,6 @@ protected override void Generate(SourceProductionContext spc)
         HashSet<string> addedElemType = new HashSet<string>();
         foreach (var type in typeSymbols)
         {
-            //obviously we cannot deserialize to an interface, we want an actual type
-            if (type.TypeKind == TypeKind.Interface) continue;
-
             var typeFullName = type.ToDisplayString();
             if (!addedType.Add(typeFullName)) continue;
 
@@ -56,21 +53,37 @@ protected override void Generate(SourceProductionContext spc)
             //if type implements IDictionary only
             var idict = type.AllInterfaces.FirstOrDefault(namedTypeSymbol =>
                 namedTypeSymbol.Name == "IDictionary" && namedTypeSymbol.TypeArguments.Length == 2);
+            if (idict == null)
+            {
+                //if type is indeed IDictionary
+                idict = type.TypeKind == TypeKind.Interface && type.Name == "IDictionary"
+                    ? (INamedTypeSymbol)type
+                    : null;
+            }
+
             if (idict != null)
             {
                 if (idict is { TypeArguments.Length: 2 } namedTypeSymbol)
                 {
                     var type1 = namedTypeSymbol.TypeArguments[0].ToDisplayString();
                     var type2 = namedTypeSymbol.TypeArguments[1].ToDisplayString();
-                    sb.AppendLine(GenerateDictionarySerialization(type1, type2, typeFullName, "        "));
+                    sb.AppendLine(GenerateDictionarySerialization(type1, type2,
+                        namedTypeSymbol.TypeArguments[0], namedTypeSymbol.TypeArguments[1],
+                        typeFullName,
+                        type.TypeKind == TypeKind.Interface
+                            ? "System.Collections.Generic.Dictionary<" + type1 + ", " + type2 + ">"
+                            : typeFullName, "        "));
                     sb.GenerateClassDeserializeMethods(typeFullName);
+
                     continue;
                 }
             }
 
             //if type is array
             if (type is IArrayTypeSymbol)
             {
+                if (((IArrayTypeSymbol)type).ElementType.IsUnmanagedType)
+                    continue;
                 var elemType = ((IArrayTypeSymbol)type).ElementType.ToDisplayString();
                 if (addedElemType.Add(elemType))
                     sb.AppendLine(GenerateArraySerialization(
@@ -81,7 +94,8 @@ protected override void Generate(SourceProductionContext spc)
             }
 
             //ICollection<T>
-            if (type is INamedTypeSymbol { TypeArguments.Length: 1 } s)
+            if (type is INamedTypeSymbol { TypeArguments.Length: 1 } s &&
+                s.AllInterfaces.Any(namedTypeSymbol => namedTypeSymbol.Name == "ICollection"))
             {
                 var elemType = s.TypeArguments[0].ToDisplayString();
                 if (addedElemType.Add(elemType) && !s.TypeArguments[0].IsUnmanagedType)
@@ -183,12 +197,20 @@ public static void Deserialize(out {{elemType}}[] value, ref Reader reader)
         return $"{indent}{ret}";
     }
 
-    private static string GenerateDictionarySerialization(string type1, string type2, string typeFullName,
+    private static string GenerateDictionarySerialization(string type1, string type2, ITypeSymbol keyType,
+        ITypeSymbol valType,
+        string sigTypeFullName,
+        string typeFullName,
         string indent = "")
     {
+        bool isUnmanaged = keyType.IsUnmanagedType && valType.IsUnmanagedType;
+        var reader = isUnmanaged ? "reader" : "eleReader";
+        var slice = isUnmanaged ? "" : "eleReader = reader.Slice();";
+        var eleReaderDecl = isUnmanaged ? "" : "Reader eleReader;";
+
         var ret = $$"""
                     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                    public static void Deserialize(out {{typeFullName}} value, ref Reader reader)
+                    public static void Deserialize(out {{sigTypeFullName}} value, ref Reader reader)
                     {
                     #if {{NinoTypeHelper.WeakVersionToleranceSymbol}}
                          if (reader.Eof)
@@ -204,13 +226,13 @@ public static void Deserialize(out {{typeFullName}} value, ref Reader reader)
                             return;
                         }
                     
-                        Reader eleReader;
+                        {{eleReaderDecl}}
                         
                         value = new {{typeFullName}}({{(typeFullName.StartsWith("System.Collections.Generic.Dictionary") ? "length" : "")}});
                         for (int i = 0; i < length; i++)
                         {
-                            eleReader = reader.Slice();
-                            Deserialize(out KeyValuePair<{{type1}}, {{type2}}> kvp, ref eleReader);
+                            {{slice}}
+                            Deserialize(out KeyValuePair<{{type1}}, {{type2}}> kvp, ref {{reader}});
                             value[kvp.Key] = kvp.Value;
                         }
                     }
@@ -221,7 +243,8 @@ public static void Deserialize(out {{typeFullName}} value, ref Reader reader)
         return $"{indent}{ret}";
     }
 
-    private static string GenerateCollectionSerialization(string prefix, string elemType, string sigTypeFullname,
+    private static string GenerateCollectionSerialization(string prefix, string elemType,
+        string sigTypeFullname,
         string typeFullname,
         string indent)
     {
@@ -253,7 +276,8 @@ public static void Deserialize(out {{sigTypeFullname}} value, ref Reader reader)
         return $"{indent}{ret}";
     }
 
-    private static string GenerateListSerialization(string prefix, string elemType, string sigTypeFullname,
+    private static string GenerateListSerialization(string prefix, string elemType,
+        string sigTypeFullname,
         string typeFullname,
         string indent,
         bool isInterface = false)

src/Nino.Generator/NinoTypeHelper.cs

@@ -92,16 +92,6 @@ bool IsAccessibleType(ITypeSymbol typeSymbol)
                     return true;
                 }
 
-                //we dont want IList/ICollection of unmanaged
-                var i = ts.AllInterfaces.FirstOrDefault(namedTypeSymbol =>
-                    namedTypeSymbol.Name == (forDeserialization ? "IList" : "ICollection") &&
-                    namedTypeSymbol.TypeArguments.Length == 1);
-                if (i != null)
-                {
-                    if (i.TypeArguments[0].IsUnmanagedType) return false;
-                    if (!IsAccessibleType(i.TypeArguments[0])) return false;
-                }
-
                 //we dont want Dictionary that has no getter/setter in its indexer
                 var iDict = ts.AllInterfaces.FirstOrDefault(namedTypeSymbol =>
                     namedTypeSymbol.Name == "IDictionary" && namedTypeSymbol.TypeArguments.Length == 2);
@@ -110,9 +100,22 @@ bool IsAccessibleType(ITypeSymbol typeSymbol)
                     var kType = iDict.TypeArguments[0];
                     var vType = iDict.TypeArguments[1];
 
-                    if (kType.IsUnmanagedType && vType.IsUnmanagedType) return false;
+                    bool isJustTrivial = ts.OriginalDefinition.ToDisplayString() ==
+                                         "System.Collections.Generic.Dictionary<TKey, TValue>" ||
+                                         ts.OriginalDefinition.ToDisplayString() ==
+                                         "System.Collections.Generic.IDictionary<TKey, TValue>" ||
+                                         ts.TypeKind == TypeKind.Interface;
+
+                    if (kType.IsUnmanagedType && vType.IsUnmanagedType)
+                    {
+                        if (forDeserialization && !isJustTrivial) return true;
+                        return false;
+                    }
+
                     if (!IsAccessibleType(kType) || !IsAccessibleType(vType)) return false;
 
+                    if (ts.TypeKind == TypeKind.Interface && forDeserialization) return true;
+
                     //use indexer to set/get value, TODO alternatively, use attributes to specify relevant methods
                     var indexers = ts
                         .GetMembers()
@@ -135,7 +138,7 @@ bool IsAccessibleType(ITypeSymbol typeSymbol)
                     if (!hasValidIndexer)
                         return false;
                 }
-
+                
                 //we dont want array of unmanaged
                 if (ts is IArrayTypeSymbol arrayTypeSymbol)
                 {
@@ -144,6 +147,27 @@ bool IsAccessibleType(ITypeSymbol typeSymbol)
                     if (!IsAccessibleType(arrayTypeSymbol.ElementType)) return false;
                 }
 
+                //we dont want IList/ICollection of unmanaged
+                var i = ts.AllInterfaces.FirstOrDefault(namedTypeSymbol =>
+                    namedTypeSymbol.Name == (forDeserialization ? "IList" : "ICollection") &&
+                    namedTypeSymbol.TypeArguments.Length == 1);
+                if (i != null)
+                {
+                    bool isJustTrivial = ts.OriginalDefinition.ToDisplayString() ==
+                                         "System.Collections.Generic.List<T>" ||
+                                         ts.OriginalDefinition.ToDisplayString() ==
+                                         "System.Collections.Generic.IList<T>" ||
+                                         ts.TypeKind == TypeKind.Interface;
+                    if (i.TypeArguments[0].IsUnmanagedType)
+                    {
+                        if (forDeserialization && !isJustTrivial) return true;
+                        return false;
+                    }
+
+                    if (!IsAccessibleType(i.TypeArguments[0])) return false;
+                }
+
+
                 //we dont want nullable of unmanaged
                 if (ts.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T)
                 {

src/Nino.UnitTests/SimpleTests.cs

@@ -10,6 +10,66 @@ namespace Nino.UnitTests
     [TestClass]
     public class SimpleTests
     {
+        [TestMethod]
+        public void TestCollections()
+        {
+            ConcurrentDictionary<int,int>[] dict = new ConcurrentDictionary<int, int>[10];
+            for (int i = 0; i < dict.Length; i++)
+            {
+                dict[i] = new ConcurrentDictionary<int, int>();
+                dict[i].TryAdd(i, i);
+            }
+            var bytes = dict.Serialize();
+            Assert.IsNotNull(bytes);
+            
+            Deserializer.Deserialize(bytes, out ConcurrentDictionary<int, int>[] result);
+            Assert.AreEqual(dict.Length, result.Length);
+            for (int i = 0; i < dict.Length; i++)
+            {
+                Assert.AreEqual(dict[i].Count, result[i].Count);
+                Assert.AreEqual(dict[i][i], result[i][i]);
+            }
+            
+            ConcurrentDictionary<int,string>[] dict2 = new ConcurrentDictionary<int, string>[10];
+            for (int i = 0; i < dict2.Length; i++)
+            {
+                dict2[i] = new ConcurrentDictionary<int, string>();
+                dict2[i].TryAdd(i, i.ToString());
+            }
+            bytes = dict2.Serialize();
+            Assert.IsNotNull(bytes);
+            
+            Deserializer.Deserialize(bytes, out IDictionary<int, string>[] result2);
+            Assert.AreEqual(dict2.Length, result2.Length);
+            for (int i = 0; i < dict2.Length; i++)
+            {
+                Assert.AreEqual(dict2[i].Count, result2[i].Count);
+                Assert.AreEqual(dict2[i][i], result2[i][i]);
+            }
+            
+            IDictionary<int, IDictionary<int, int[]>> dict3 = new Dictionary<int, IDictionary<int, int[]>>();
+            for (int i = 0; i < 10; i++)
+            {
+                dict3[i] = new ConcurrentDictionary<int, int[]>();
+                dict3[i].TryAdd(i, new int[]{i, i});
+            }
+            dict2.Serialize();
+            bytes = dict3.Serialize();
+            Assert.IsNotNull(bytes);
+            
+            Deserializer.Deserialize(bytes, out IDictionary<int, IDictionary<int, int[]>> result3);
+            Assert.AreEqual(dict3.Count, result3.Count);
+            for (int i = 0; i < dict3.Count; i++)
+            {
+                Assert.AreEqual(dict3[i].Count, result3[i].Count);
+                Assert.AreEqual(dict3[i][i].Length, result3[i][i].Length);
+                for (int j = 0; j < dict3[i][i].Length; j++)
+                {
+                    Assert.AreEqual(dict3[i][i][j], result3[i][i][j]);
+                }
+            }
+        }
+        
         [TestMethod]
         public void TestModifyListMemberDataStructure()
         {