fix(generator): gracefully handle unbound generic types

The generator would previously crash when encountering an unbound generic type due to an `InvalidOperationException` in `GetTypeHierarchyLevel` when calling `.Max()` on an empty collection of type arguments.

Additionally, the generator would produce invalid code if an unbound generic type was not filtered out correctly.

This commit addresses the issue by:
1.  Making `GetTypeHierarchyLevel` robust against empty type argument lists.
2.  Adding an explicit check for unbound generic types in `CheckGenericValidity` to ensure they are filtered out early in the type collection process.

Adds a new test case to verify that the generator no longer crashes and produces valid code when an unbound generic type is referenced.

Co-authored-by: Gemini <gemini@google.com>

Author: JasonXuDeveloper

src/Nino.Generator/NinoTypeHelper.cs

@@ -192,7 +192,7 @@ public static (bool isValid, Compilation newCompilation) IsValidCompilation(this
                 .Any(u =>
                 {
                     var name = u.Name.ToString();
-                    return name == "Nino.Core" || name == "global::Nino.Core" || name?.StartsWith("Nino.Core.") == true;
+                    return name.Contains("Nino.Core");
                 }));
 
         if (!hasNinoCoreUsage)
@@ -344,6 +344,9 @@ public static bool CheckGenericValidity(this ITypeSymbol containingType)
                 case IArrayTypeSymbol arrayTypeSymbol:
                     toValidate.Push(arrayTypeSymbol.ElementType);
                     break;
+                
+                case INamedTypeSymbol { IsUnboundGenericType: true }:
+                    return false;
 
                 case INamedTypeSymbol { IsGenericType: true } namedTypeSymbol:
                     // Validate generic type
@@ -842,7 +845,9 @@ public static int GetTypeHierarchyLevel(this ITypeSymbol type)
 
             // Generics: 1 + max level of type arguments
             INamedTypeSymbol { IsGenericType: true } namedType =>
-                1 + namedType.TypeArguments.Max(GetTypeHierarchyLevel),
+                namedType.TypeArguments.Length > 0
+                    ? 1 + namedType.TypeArguments.Max(GetTypeHierarchyLevel)
+                    : 1,
 
             // Base types (including non-generic named types)
             _ => 1

src/Nino.UnitTests/GenericTypeTests.cs

@@ -231,4 +231,16 @@ public void TestListObject()
 
         Assert.IsNull(result[3]); // null
     }
+
+    [TestMethod]
+    public void TestUnboundGeneric()
+    {
+        var obj = new ClassWithUnboundGenericType()
+        {
+            OtherData = 42
+        };
+        var serialized = NinoSerializer.Serialize(obj);
+        var deserialized = NinoDeserializer.Deserialize<ClassWithUnboundGenericType>(serialized);
+        Assert.AreEqual(obj.OtherData, deserialized.OtherData);
+    }
 }

src/Nino.UnitTests/TestClass.cs

@@ -623,11 +623,26 @@ public sealed class SimpleClassWithConstructor
 
         // [NinoConstructor(nameof(Id), nameof(Name), nameof(CreateTime))] - we try not to use this and test if it still works
         // should automatically use this constructor since this is the only public constructor
+
         public SimpleClassWithConstructor(int id, string name, DateTime createTime)
         {
             Id = id;
             Name = name;
             CreateTime = createTime;
         }
     }
+
+    [NinoType]
+    public class UnboundGenericTest<T>
+    {
+        public T Data;
+    }
+
+    [NinoType]
+    public class ClassWithUnboundGenericType
+    {
+        [NinoIgnore]
+        public Type UnboundType = typeof(UnboundGenericTest<>);
+        public int OtherData = 1;
+    }
 }