refactor(generator): transform to pure incremental source generator with DTO-based pipeline

Complete architectural transformation of Nino.Generator from hybrid incremental generator
to pure incremental source generator using only value-based DTOs. This eliminates all
ITypeSymbol dependencies in the code generation phase and implements proper multi-stage
incremental caching following Roslyn best practices.

Key Changes:

Architecture:
- Implemented 7-stage incremental pipeline with optimal caching at each stage
- Created single symbol bridge pattern in SymbolDataExtractor.cs
- Converted all metadata types to readonly record structs for value-based equality
- Replaced ITypeSymbol comparisons with TypeId-based lookups

New Infrastructure (Pipeline):
- Pipeline/SymbolDataExtractor.cs - Centralized ITypeSymbol extraction (THE ONLY symbol bridge)
- Pipeline/NinoGraphBuilder.cs - Pure DTO-based graph construction
- Metadata/CircularTypeDetector.cs - Circular reference detection using graph traversal

New Metadata DTOs:
- Metadata/TypeInfoDto.cs - Complete type information DTO
- Metadata/TypeInfoDtoExtensions.cs - Type analysis extension methods
- Metadata/TypeInfoDtoEnums.cs - Enum mappings (TypeKindDto, SpecialTypeDto, etc.)
- Metadata/ConstructorInfoDto.cs - Constructor metadata for deserialization
- Metadata/EquatableArray.cs - Value-based array wrapper for caching
- Metadata/CompilationMetadata.cs - Compilation-level metadata

Utilities:
- NinoConstants.cs - Constants (WeakVersionToleranceSymbol)
- Common/StringExtensions.cs - String utilities for code generation
- Common/CodeGeneratorExtensions.cs - Code generation helper methods

Converted to readonly record struct:
- Metadata/NinoMember.cs - Member metadata
- Metadata/NinoType.cs - Type metadata with members and constructors
- Metadata/NinoGraph.cs - Type hierarchy graph

Updated Generators (25 files):
- GlobalGenerator.cs - Completely rewritten with 7-stage pipeline
- All 5 common generators (Serializer, Deserializer, TypeConst, UnsafeAccessor, PartialClass)
- All 15 built-in type generators (Array, List, Dictionary, HashSet, Queue, Stack, etc.)
- All 3 base generator classes (NinoGenerator, NinoCommonGenerator, NinoBuiltInTypeGenerator)

Removed:
- Parser/CSharpParser.cs - Replaced by SymbolDataExtractor
- Parser/NinoTypeParser.cs - Replaced by NinoGraphBuilder
- DTOs/CompilationMetadataDto.cs - Renamed to CompilationMetadata.cs
- DTOs/TypeTransformations.cs - Logic moved to SymbolDataExtractor

Enhanced Features:
- Full constructor reflection support in DTO pipeline
- Intelligent constructor selection (NinoConstructor attribute, primary constructor, etc.)
- Pre-computed display names and instance variable names
- Support for custom serializers from external assemblies

Build Status: 0 errors, 0 warnings

Impact:
- Optimal incremental caching (only changed types trigger regeneration)
- Zero ITypeSymbol retention after extraction phase
- Value-based equality for all metadata types
- Type-safe DTO-based code generation
- Proper separation between symbol extraction and code generation

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

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

Author: JasonXuDeveloper

src/Nino.Generator/BuiltInType/ArrayGenerator.cs

@@ -32,38 +32,39 @@
 namespace Nino.Generator.BuiltInType;
 
 public class ArrayGenerator(
+    Dictionary<int, TypeInfoDto> typeInfoCache,
+    string assemblyNamespace,
     NinoGraph ninoGraph,
-    HashSet<ITypeSymbol> potentialTypes,
-    HashSet<ITypeSymbol> selectedTypes,
-    Compilation compilation) : NinoBuiltInTypeGenerator(ninoGraph, potentialTypes, selectedTypes, compilation)
+    HashSet<int> potentialTypeIds,
+    HashSet<int> selectedTypeIds,
+    bool isUnityAssembly = false) : NinoBuiltInTypeGenerator(typeInfoCache, assemblyNamespace, ninoGraph, potentialTypeIds, selectedTypeIds, isUnityAssembly)
 {
     protected override string OutputFileName => "NinoArrayTypeGenerator";
 
-    public override bool Filter(ITypeSymbol typeSymbol)
+    public override bool Filter(TypeInfoDto typeInfo)
     {
-        if (typeSymbol is not IArrayTypeSymbol arraySymbol) return false;
-        var elementType = arraySymbol.ElementType;
-        return elementType.GetKind(NinoGraph, GeneratedTypes) != NinoTypeHelper.NinoTypeKind.Invalid;
+        if (typeInfo.ArrayRank == 0) return false;
+        if (!typeInfo.ArrayElementType.HasValue) return false;
+        var elementType = typeInfo.ArrayElementType.Value;
+        return TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) != NinoTypeKind.Invalid;
     }
 
-    protected override void GenerateSerializer(ITypeSymbol typeSymbol, Writer writer)
+    protected override void GenerateSerializer(TypeInfoDto typeInfo, Writer writer)
     {
-        var arraySymbol = (IArrayTypeSymbol)typeSymbol;
-        var elementType = arraySymbol.ElementType;
-        elementType.GetDisplayString();
-        var rank = arraySymbol.Rank;
-        var typeName = typeSymbol.GetDisplayString();
+        var elementType = typeInfo.ArrayElementType!.Value;
+        var rank = typeInfo.ArrayRank;
+        var typeName = typeInfo.DisplayName;
 
         // Check if we can use the fast unmanaged write path
         // Element must be unmanaged AND cannot be polymorphic
         // Fast path only works for 1D arrays
-        bool canUseFastPath = rank == 1 && elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.Unmanaged;
+        bool canUseFastPath = rank == 1 && TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.Unmanaged;
 
         // Check if we can use monomorphic fast path (sealed/struct NinoType)
         // This allows us to cache the serializer delegate once instead of lookup per element
         bool canUseMonomorphicPath = rank == 1 &&
-                                      elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.NinoType &&
-                                      elementType.IsSealedOrStruct();
+                                      TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.NinoType &&
+                                      TypeInfoDtoExtensions.IsSealedOrStruct(elementType);
 
         WriteAggressiveInlining(writer);
         writer.Append("public static void Serialize(this ");
@@ -105,20 +106,20 @@ protected override void GenerateSerializer(ITypeSymbol typeSymbol, Writer writer
             writer.AppendLine();
             writer.AppendLine("    do");
             writer.AppendLine("    {");
-            IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+            IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                 w => { w.AppendLine("        var pos = writer.Advance(4);"); });
 
             if (canUseMonomorphicPath)
             {
                 // Monomorphic fast path: direct call to avoid delegate allocation
-                writer.AppendLine($"        CachedSerializer<{elementType.GetDisplayString()}>.SerializePolymorphic(cur, ref writer);");
+                writer.AppendLine($"        CachedSerializer<{elementType.DisplayName}>.SerializePolymorphic(cur, ref writer);");
             }
             else
             {
                 writer.Append("        ");
                 writer.AppendLine(GetSerializeString(elementType, "cur"));
             }
-            IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+            IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                 w => { w.AppendLine("        writer.PutLength(pos);"); });
             writer.AppendLine("        cur = ref System.Runtime.CompilerServices.Unsafe.Add(ref cur, 1);");
             writer.AppendLine("    }");
@@ -174,11 +175,11 @@ protected override void GenerateSerializer(ITypeSymbol typeSymbol, Writer writer
             var indices = string.Join(", ", Enumerable.Range(0, rank).Select(i => $"i{i}"));
 
             // Only use WEAK_VERSION_TOLERANCE for non-unmanaged types
-            bool isUnmanaged = elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.Unmanaged;
+            bool isUnmanaged = TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.Unmanaged;
 
             if (!isUnmanaged)
             {
-                IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w => { w.AppendLine($"{innerIndent}var pos = writer.Advance(4);"); });
             }
 
@@ -187,7 +188,7 @@ protected override void GenerateSerializer(ITypeSymbol typeSymbol, Writer writer
 
             if (!isUnmanaged)
             {
-                IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w => { w.AppendLine($"{innerIndent}writer.PutLength(pos);"); });
             }
 
@@ -201,24 +202,23 @@ protected override void GenerateSerializer(ITypeSymbol typeSymbol, Writer writer
         writer.AppendLine("}");
     }
 
-    protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writer)
+    protected override void GenerateDeserializer(TypeInfoDto typeInfo, Writer writer)
     {
-        var arraySymbol = (IArrayTypeSymbol)typeSymbol;
-        var elementType = arraySymbol.ElementType;
-        var elemType = elementType.GetDisplayString();
-        var rank = arraySymbol.Rank;
-        var typeName = typeSymbol.GetDisplayString();
+        var elementType = typeInfo.ArrayElementType!.Value;
+        var elemType = elementType.DisplayName;
+        var rank = typeInfo.ArrayRank;
+        var typeName = typeInfo.DisplayName;
 
         // Check if we can use the fast unmanaged read path
         // Element must be unmanaged AND cannot be polymorphic
         // Fast path only works for 1D arrays
-        bool canUseFastPath = rank == 1 && elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.Unmanaged;
+        bool canUseFastPath = rank == 1 && TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.Unmanaged;
 
         // Check if we can use monomorphic fast path (sealed/struct NinoType)
         // This allows us to cache the deserializer delegate once instead of lookup per element
         bool canUseMonomorphicPath = rank == 1 &&
-                                      elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.NinoType &&
-                                      elementType.IsSealedOrStruct();
+                                      TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.NinoType &&
+                                      TypeInfoDtoExtensions.IsSealedOrStruct(elementType);
 
         // Out overload
         WriteAggressiveInlining(writer);
@@ -242,7 +242,7 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
             writer.AppendLine("    }");
             writer.AppendLine();
             // Optimized array deserialization - reduce reader slicing overhead
-            IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+            IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                 w => { w.AppendLine("    Reader eleReader;"); });
             writer.AppendLine();
             writer.Append("    value = new ");
@@ -256,20 +256,20 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
             if (canUseMonomorphicPath)
             {
                 // Monomorphic fast path: direct call to avoid delegate allocation
-                IfElseDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfElseDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w =>
                     {
                         w.AppendLine("        eleReader = reader.Slice();");
-                        w.AppendLine($"        CachedDeserializer<{elementType.GetDisplayString()}>.Deserialize(out span[i], ref eleReader);");
+                        w.AppendLine($"        CachedDeserializer<{elementType.DisplayName}>.Deserialize(out span[i], ref eleReader);");
                     },
                     w =>
                     {
-                        w.AppendLine($"        CachedDeserializer<{elementType.GetDisplayString()}>.Deserialize(out span[i], ref reader);");
+                        w.AppendLine($"        CachedDeserializer<{elementType.DisplayName}>.Deserialize(out span[i], ref reader);");
                     });
             }
             else
             {
-                IfElseDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfElseDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w =>
                     {
                         w.AppendLine("        eleReader = reader.Slice();");
@@ -314,11 +314,11 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
             writer.AppendLine();
 
             // Only use WEAK_VERSION_TOLERANCE reader for non-unmanaged types
-            bool isUnmanaged = elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.Unmanaged;
+            bool isUnmanaged = TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.Unmanaged;
 
             if (!isUnmanaged)
             {
-                IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w => { w.AppendLine("    Reader eleReader;"); });
             }
             writer.AppendLine();
@@ -344,7 +344,7 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
 
             if (!isUnmanaged)
             {
-                IfElseDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfElseDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w =>
                     {
                         w.AppendLine($"{innerIndent}eleReader = reader.Slice();");
@@ -397,7 +397,7 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
             writer.AppendLine("    }");
             writer.AppendLine();
 
-            IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+            IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                 w => { w.AppendLine("    Reader eleReader;"); });
             writer.AppendLine();
 
@@ -421,20 +421,20 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
             if (canUseMonomorphicPath)
             {
                 // Monomorphic fast path: direct call to avoid delegate allocation
-                IfElseDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfElseDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w =>
                     {
                         w.AppendLine("        eleReader = reader.Slice();");
-                        w.AppendLine($"        CachedDeserializer<{elementType.GetDisplayString()}>.DeserializeRef(ref span[i], ref eleReader);");
+                        w.AppendLine($"        CachedDeserializer<{elementType.DisplayName}>.DeserializeRef(ref span[i], ref eleReader);");
                     },
                     w =>
                     {
-                        w.AppendLine($"        CachedDeserializer<{elementType.GetDisplayString()}>.DeserializeRef(ref span[i], ref reader);");
+                        w.AppendLine($"        CachedDeserializer<{elementType.DisplayName}>.DeserializeRef(ref span[i], ref reader);");
                     });
             }
             else
             {
-                IfElseDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfElseDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w =>
                     {
                         w.AppendLine("        eleReader = reader.Slice();");
@@ -478,11 +478,11 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
             writer.AppendLine();
 
             // Only use WEAK_VERSION_TOLERANCE reader for non-unmanaged types
-            bool isUnmanagedRef = elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.Unmanaged;
+            bool isUnmanagedRef = TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.Unmanaged;
 
             if (!isUnmanagedRef)
             {
-                IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w => { w.AppendLine("    Reader eleReader;"); });
             }
             writer.AppendLine();
@@ -519,7 +519,7 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
 
             if (!isUnmanagedRef)
             {
-                IfElseDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+                IfElseDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                     w =>
                     {
                         w.AppendLine($"{innerIndent}eleReader = reader.Slice();");

src/Nino.Generator/BuiltInType/ArraySegmentGenerator.cs

@@ -31,40 +31,42 @@
 namespace Nino.Generator.BuiltInType;
 
 public class ArraySegmentGenerator(
+    Dictionary<int, TypeInfoDto> typeInfoCache,
+    string assemblyNamespace,
     NinoGraph ninoGraph,
-    HashSet<ITypeSymbol> potentialTypes,
-    HashSet<ITypeSymbol> selectedTypes,
-    Compilation compilation) : NinoBuiltInTypeGenerator(ninoGraph, potentialTypes, selectedTypes, compilation)
+    HashSet<int> potentialTypeIds,
+    HashSet<int> selectedTypeIds,
+    bool isUnityAssembly = false) : NinoBuiltInTypeGenerator(typeInfoCache, assemblyNamespace, ninoGraph, potentialTypeIds, selectedTypeIds, isUnityAssembly)
 {
     protected override string OutputFileName => "NinoArraySegmentTypeGenerator";
 
-    public override bool Filter(ITypeSymbol typeSymbol)
+    public override bool Filter(TypeInfoDto typeInfo)
     {
-        if (typeSymbol is not INamedTypeSymbol namedType) return false;
+        if (!typeInfo.IsGenericType) return false;
+        if (typeInfo.TypeArguments.Length != 1) return false;
 
         // Only accept ArraySegment<T>
-        var originalDef = namedType.OriginalDefinition.ToDisplayString();
+        var originalDef = typeInfo.GenericOriginalDefinition;
         if (originalDef != "System.ArraySegment<T>")
             return false;
 
-        var elementType = namedType.TypeArguments[0];
+        var elementType = typeInfo.TypeArguments[0];
 
         // Element type must be valid
-        if (elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.Invalid)
+        if (TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.Invalid)
             return false;
 
         return true;
     }
 
-    protected override void GenerateSerializer(ITypeSymbol typeSymbol, Writer writer)
+    protected override void GenerateSerializer(TypeInfoDto typeInfo, Writer writer)
     {
-        var namedType = (INamedTypeSymbol)typeSymbol;
-        var elementType = namedType.TypeArguments[0];
+        var elementType = typeInfo.TypeArguments[0];
 
-        var typeName = typeSymbol.GetDisplayString();
+        var typeName = typeInfo.DisplayName;
 
         // Check if element type is unmanaged for fast path
-        bool canUseFastPath = elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.Unmanaged;
+        bool canUseFastPath = TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.Unmanaged;
 
         WriteAggressiveInlining(writer);
         writer.Append("public static void Serialize(this ");
@@ -96,28 +98,27 @@ protected override void GenerateSerializer(ITypeSymbol typeSymbol, Writer writer
             // For managed element types, serialize element by element
             writer.AppendLine("    for (int i = 0; i < cnt; i++)");
             writer.AppendLine("    {");
-            IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+            IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                 w => { w.AppendLine("        var pos = writer.Advance(4);"); });
 
             writer.Append("        ");
             writer.AppendLine(GetSerializeString(elementType, "value[i]"));
-            IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+            IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                 w => { w.AppendLine("        writer.PutLength(pos);"); });
             writer.AppendLine("    }");
         }
 
         writer.AppendLine("}");
     }
 
-    protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writer)
+    protected override void GenerateDeserializer(TypeInfoDto typeInfo, Writer writer)
     {
-        var namedType = (INamedTypeSymbol)typeSymbol;
-        var elementType = namedType.TypeArguments[0];
-        var elemType = elementType.GetDisplayString();
-        var typeName = typeSymbol.GetDisplayString();
+        var elementType = typeInfo.TypeArguments[0];
+        var elemType = elementType.DisplayName;
+        var typeName = typeInfo.DisplayName;
 
         // Check if element type is unmanaged for fast path
-        bool canUseFastPath = elementType.GetKind(NinoGraph, GeneratedTypes) == NinoTypeHelper.NinoTypeKind.Unmanaged;
+        bool canUseFastPath = TypeInfoDtoExtensions.GetKind(elementType, NinoGraph, GeneratedTypeIds) == NinoTypeKind.Unmanaged;
 
         // Out overload
         WriteAggressiveInlining(writer);
@@ -148,7 +149,7 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
             writer.AppendLine();
 
             // For managed element types, deserialize element by element
-            IfDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+            IfDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                 w => { w.AppendLine("    Reader eleReader;"); });
             writer.AppendLine();
 
@@ -158,7 +159,7 @@ protected override void GenerateDeserializer(ITypeSymbol typeSymbol, Writer writ
             writer.AppendLine("    for (int i = 0; i < length; i++)");
             writer.AppendLine("    {");
 
-            IfElseDirective(NinoTypeHelper.WeakVersionToleranceSymbol, writer,
+            IfElseDirective(NinoConstants.WeakVersionToleranceSymbol, writer,
                 w =>
                 {
                     w.AppendLine("        eleReader = reader.Slice();");