perf(engine): avoid string round-trip when building nested type names (#6049)

TUnit.Engine/Helpers/TypeNameHelper.cs

@@ -0,0 +1,43 @@
+using TUnit.Core.Helpers;
+
+namespace TUnit.Engine.Helpers;
+
+internal static class TypeNameHelper
+{
+    /// <summary>
+    /// Appends a type's display name to the builder, expanding generic arguments by their
+    /// full name to ensure uniqueness (e.g. <c>List&lt;System.Int32&gt;</c>).
+    /// </summary>
+    internal static void AppendTypeNameWithGenericArgs(ref ValueStringBuilder vsb, Type type)
+    {
+        if (!type.IsGenericType)
+        {
+            vsb.Append(type.Name);
+            return;
+        }
+
+        var name = type.Name;
+        var backtickIndex = name.IndexOf('`');
+        if (backtickIndex > 0)
+        {
+            vsb.Append(name.AsSpan(0, backtickIndex));
+        }
+        else
+        {
+            vsb.Append(name);
+        }
+
+        // Use the full name for generic arguments to ensure uniqueness.
+        var genericArgs = type.GetGenericArguments();
+        vsb.Append('<');
+        for (var i = 0; i < genericArgs.Length; i++)
+        {
+            if (i > 0)
+            {
+                vsb.Append(", ");
+            }
+            vsb.Append(genericArgs[i].FullName ?? genericArgs[i].Name);
+        }
+        vsb.Append('>');
+    }
+}

TUnit.Engine/Services/MetadataFilterMatcher.cs

@@ -8,6 +8,7 @@
 using Microsoft.Testing.Platform.Requests;
 using TUnit.Core;
 using TUnit.Core.Helpers;
+using TUnit.Engine.Helpers;
 
 namespace TUnit.Engine.Services;
 
@@ -309,77 +310,34 @@ private static string BuildClassNameForMatching(Type type)
             return type.Name;
         }
 
-        // Build the full nested type hierarchy with '+' separators
-        // This matches TestIdentifierService.WriteTypeNameWithGenerics
-        var typeHierarchy = new ValueListBuilder<string>([null, null, null, null]);
-        var typeVsb = new ValueStringBuilder(stackalloc char[128]);
+        // Collect the nested-type chain (inner -> outer) without allocating per-segment strings,
+        // then emit it directly into the result builder. Matches TestIdentifierService.WriteTypeNameWithGenerics.
+        var typeHierarchy = new ValueListBuilder<Type>([null!, null!, null!, null!]);
+        var resultVsb = new ValueStringBuilder(stackalloc char[256]);
         try
         {
             var currentType = type;
-
             while (currentType != null)
             {
-                if (currentType.IsGenericType)
-                {
-                    var name = currentType.Name;
-
-                    var backtickIndex = name.IndexOf('`');
-                    if (backtickIndex > 0)
-                    {
-                        typeVsb.Append(name.AsSpan(0, backtickIndex));
-                    }
-                    else
-                    {
-                        typeVsb.Append(name);
-                    }
-
-                    // Add the generic type arguments (same format as TestIdentifierService)
-                    var genericArgs = currentType.GetGenericArguments();
-                    typeVsb.Append('<');
-                    for (var i = 0; i < genericArgs.Length; i++)
-                    {
-                        if (i > 0)
-                        {
-                            typeVsb.Append(", ");
-                        }
-                        typeVsb.Append(genericArgs[i].FullName ?? genericArgs[i].Name);
-                    }
-                    typeVsb.Append('>');
-
-                    typeHierarchy.Append(typeVsb.AsSpan().ToString());
-                    typeVsb.Length = 0;
-                }
-                else
-                {
-                    typeHierarchy.Append(currentType.Name);
-                }
-
+                typeHierarchy.Append(currentType);
                 currentType = currentType.DeclaringType;
             }
 
-            // Build result: reverse to get outer-to-inner order and join with '+'
-            var resultVsb = new ValueStringBuilder(stackalloc char[256]);
-            try
+            // Reverse to get outer-to-inner order and join with '+'.
+            for (var i = typeHierarchy.Length - 1; i >= 0; i--)
             {
-                for (var i = typeHierarchy.Length - 1; i >= 0; i--)
+                if (i < typeHierarchy.Length - 1)
                 {
-                    if (i < typeHierarchy.Length - 1)
-                    {
-                        resultVsb.Append('+');
-                    }
-                    resultVsb.Append(typeHierarchy[i]);
+                    resultVsb.Append('+');
                 }
-                return resultVsb.ToString();
-            }
-            finally
-            {
-                resultVsb.Dispose();
+                TypeNameHelper.AppendTypeNameWithGenericArgs(ref resultVsb, typeHierarchy[i]);
             }
+            return resultVsb.ToString();
         }
         finally
         {
+            resultVsb.Dispose();
             typeHierarchy.Dispose();
-            typeVsb.Dispose();
         }
     }
 

TUnit.Engine/Services/TestIdentifierService.cs

@@ -1,6 +1,7 @@
 using TUnit.Core;
 using TUnit.Core.Helpers;
 using TUnit.Engine.Building;
+using TUnit.Engine.Helpers;
 
 namespace TUnit.Engine.Services;
 
@@ -117,69 +118,30 @@ public static string GenerateFailedTestId(TestMetadata metadata, TestDataCombina
 
     private static void WriteTypeNameWithGenerics(ref ValueStringBuilder vsb, Type type)
     {
-        // Build the full type hierarchy including all containing types
-        var typeHierarchy = new ValueListBuilder<string>([null, null, null, null]);
-        var typeVsb = new ValueStringBuilder(stackalloc char[128]);
+        // Collect the nested-type chain (inner -> outer) without allocating per-segment strings.
+        var typeHierarchy = new ValueListBuilder<Type>([null!, null!, null!, null!]);
         try
         {
             var currentType = type;
-
             while (currentType != null)
             {
-                if (currentType.IsGenericType)
-                {
-                    var name = currentType.Name;
-
-                    var backtickIndex = name.IndexOf('`');
-                    if (backtickIndex > 0)
-                    {
-                        typeVsb.Append(name.AsSpan(0, backtickIndex));
-                    }
-                    else
-                    {
-                        typeVsb.Append(name);
-                    }
-
-                    // Add the generic type arguments
-                    var genericArgs = currentType.GetGenericArguments();
-                    typeVsb.Append('<');
-                    for (var i = 0; i < genericArgs.Length; i++)
-                    {
-                        if (i > 0)
-                        {
-                            typeVsb.Append(", ");
-                        }
-                        // Use the full name for generic arguments to ensure uniqueness
-                        typeVsb.Append(genericArgs[i].FullName ?? genericArgs[i].Name);
-                    }
-                    typeVsb.Append('>');
-
-                    typeHierarchy.Append(typeVsb.AsSpan().ToString());
-                    typeVsb.Length = 0;
-                }
-                else
-                {
-                    typeHierarchy.Append(currentType.Name);
-                }
-
+                typeHierarchy.Append(currentType);
                 currentType = currentType.DeclaringType;
             }
 
-            // Reverse to get outer-to-inner order
-            // Append all types with + separator (matching .NET Type.FullName convention for nested types)
+            // Reverse to get outer-to-inner order (matches .NET Type.FullName convention for nested types).
             for (var i = typeHierarchy.Length - 1; i >= 0; i--)
             {
                 if (i < typeHierarchy.Length - 1)
                 {
                     vsb.Append('+');
                 }
-                vsb.Append(typeHierarchy[i]);
+                TypeNameHelper.AppendTypeNameWithGenericArgs(ref vsb, typeHierarchy[i]);
             }
         }
         finally
         {
             typeHierarchy.Dispose();
-            typeVsb.Dispose();
         }
     }