fix(generator): resolve CS8628 error for nullable reference types in collections

Fixed compilation error CS8628 "Cannot use a nullable reference type in object creation"
that occurred when generating code for nullable collection types like Dictionary<K,V>?,
List<T>?, Queue<T>?, etc.

The issue was caused by typeSymbol.GetDisplayString() returning type names with the
trailing '?' nullable annotation, which is invalid in 'new' expressions. Centralized
the fix in NinoTypeHelper.GetDisplayString() by calling GetPureType() to strip the
nullable annotation before converting to string.

This ensures all BuiltInTypeGenerators (Dictionary, List, HashSet, Queue, Stack, etc.)
automatically generate correct code without the nullable annotation in object creation,
while still maintaining type safety.

Added comprehensive unit tests for nullable collection types including:
- Dictionary<string, byte[]?>?
- List<string?>?
- HashSet<byte[]?>?
- Queue<int?>?

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: JasonXuDeveloper

src/Nino.Generator/NinoTypeHelper.cs

@@ -230,7 +230,11 @@ public static string GetDisplayString(this ITypeSymbol typeSymbol)
             return ret;
         }
 
-        ret = typeSymbol.ToDisplayString();
+        // Remove nullable annotation and normalize tuple types before converting to string
+        // This ensures that types used in 'new' expressions don't have the trailing '?'
+        // which would cause CS8628: Cannot use a nullable reference type in object creation
+        var pureType = typeSymbol.GetPureType().GetNormalizedTypeSymbol();
+        ret = pureType.ToDisplayString();
 
         // Sanitize multi-dimensional array syntax: [*,*] -> [,], [*,*,*] -> [,,], etc.
         // This handles all cases including user-defined types and nested arrays

src/Nino.UnitTests/GenericTypeTests.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading.Tasks;
@@ -243,4 +242,91 @@ public void TestUnboundGeneric()
         var deserialized = NinoDeserializer.Deserialize<ClassWithUnboundGenericType>(serialized);
         Assert.AreEqual(obj.OtherData, deserialized.OtherData);
     }
+    
+    #nullable enable
+
+    [TestMethod]
+    public void TestNullableCollectionTypes()
+    {
+        // Test nullable collection types to ensure no CS8628 error occurs during code generation
+        var obj = new NullableCollectionTestClass
+        {
+            NullableDict = new Dictionary<string, byte[]?>
+            {
+                { "key1", new byte[] { 1, 2, 3 } },
+                { "key2", null },
+                { "key3", new byte[] { 4, 5 } }
+            },
+            NullableList = new List<string?>
+            {
+                "item1",
+                null,
+                "item3"
+            },
+            NullableHashSet = new HashSet<byte[]?>
+            {
+                new byte[] { 1, 2 },
+                null,
+                new byte[] { 3, 4 }
+            },
+            NullableQueue = new Queue<int?>()
+        };
+        obj.NullableQueue.Enqueue(1);
+        obj.NullableQueue.Enqueue(null);
+        obj.NullableQueue.Enqueue(3);
+
+        // Serialize
+        byte[] bytes = NinoSerializer.Serialize(obj);
+        Assert.IsNotNull(bytes);
+        Console.WriteLine($"Serialized nullable collections: {bytes.Length} bytes");
+
+        // Deserialize
+        var result = NinoDeserializer.Deserialize<NullableCollectionTestClass>(bytes);
+
+        // Verify Dictionary
+        Assert.IsNotNull(result.NullableDict);
+        Assert.AreEqual(3, result.NullableDict.Count);
+        Assert.IsTrue(result.NullableDict.ContainsKey("key1"));
+        Assert.IsTrue(result.NullableDict.ContainsKey("key2"));
+        Assert.IsTrue(result.NullableDict.ContainsKey("key3"));
+        Assert.IsNotNull(result.NullableDict["key1"]);
+        Assert.IsNull(result.NullableDict["key2"]);
+
+        // Verify List
+        Assert.IsNotNull(result.NullableList);
+        Assert.AreEqual(3, result.NullableList.Count);
+        Assert.AreEqual("item1", result.NullableList[0]);
+        Assert.IsNull(result.NullableList[1]);
+        Assert.AreEqual("item3", result.NullableList[2]);
+
+        // Verify HashSet
+        Assert.IsNotNull(result.NullableHashSet);
+        Assert.AreEqual(3, result.NullableHashSet.Count);
+
+        // Verify Queue
+        Assert.IsNotNull(result.NullableQueue);
+        Assert.AreEqual(3, result.NullableQueue.Count);
+        var q1 = result.NullableQueue.Dequeue();
+        var q2 = result.NullableQueue.Dequeue();
+        var q3 = result.NullableQueue.Dequeue();
+        Assert.AreEqual(1, q1);
+        Assert.IsNull(q2);
+        Assert.AreEqual(3, q3);
+
+        // Test with null collections
+        var obj2 = new NullableCollectionTestClass
+        {
+            NullableDict = null,
+            NullableList = null,
+            NullableHashSet = null,
+            NullableQueue = null
+        };
+
+        bytes = NinoSerializer.Serialize(obj2);
+        var result2 = NinoDeserializer.Deserialize<NullableCollectionTestClass>(bytes);
+        Assert.IsNull(result2.NullableDict);
+        Assert.IsNull(result2.NullableList);
+        Assert.IsNull(result2.NullableHashSet);
+        Assert.IsNull(result2.NullableQueue);
+    }
 }

src/Nino.UnitTests/TestClass.cs

@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Nino.Core;
 
 #nullable disable
@@ -469,10 +470,25 @@ public sealed class TestClass3 : TestClass2
     }
 
     [NinoType]
-    public struct TestStruct
+    public struct TestStruct : IEquatable<TestStruct>
     {
         public int A;
         public string B;
+
+        public bool Equals(TestStruct other)
+        {
+            return A == other.A && B == other.B;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is TestStruct other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(A, B);
+        }
     }
 
     [NinoType]
@@ -646,3 +662,23 @@ public class ClassWithUnboundGenericType
         public int OtherData = 1;
     }
 }
+
+#nullable enable
+namespace Nino.UnitTests
+{
+    /// <summary>
+    /// Test class with nullable collection types to verify CS8628 fix
+    /// </summary>
+    [NinoType]
+    public class NullableCollectionTestClass
+    {
+        public Dictionary<string, byte[]?>? NullableDict;
+        public List<string?>? NullableList;
+        public HashSet<byte[]?>? NullableHashSet;
+        public Queue<int?>? NullableQueue;
+        public Task<Dictionary<string, byte[]?>?>? NullableTask;
+        public Task<Dictionary<string, byte[]?>?> NullableTask2 = null!;
+        public Task<Dictionary<string, byte[]?>>? NullableTask3;
+    }
+}
+#nullable disable