fix(sourcegen): infer generic method types from any MethodDataSource row shape

src/TUnit.Analyzers/TestDataAnalyzer.cs

@@ -434,14 +434,19 @@ private void CheckMethodDataSource(SymbolAnalysisContext context,
 
             // An overload that takes exactly the Arguments wins over one that also takes an injected trailing
             // CancellationToken, as it does at runtime, whatever order the overloads are declared in.
+            // A generic data method is skipped while a non-generic one exists: neither mode can call it without
+            // type arguments, so IEnumerable<int> Rows() is used over IEnumerable<T> Rows<T>().
             var dataSourceMethod = methodSymbols
                                                .FirstOrDefault(methodSymbol =>
                                                    methodSymbol.Name == methodName &&
+                                                   !methodSymbol.IsGenericMethod &&
                                                    ArgumentsMatchParameterTypes(context, argumentsForMethodCall, methodSymbol.Parameters.Select(p => p.Type)))
                                            ?? methodSymbols
                                                .FirstOrDefault(methodSymbol =>
                                                    methodSymbol.Name == methodName &&
+                                                   !methodSymbol.IsGenericMethod &&
                                                    ArgumentsMatchParameterTypes(context, argumentsForMethodCall, methodSymbol.Parameters.WithoutCancellationTokenParameter().Select(p => p.Type)))
+                                           ?? methodSymbols.FirstOrDefault(x => x.Name == methodName && !x.IsGenericMethod)
                                            ?? methodSymbols.FirstOrDefault(x => x.Name == methodName);
 
             // If no method found, check for properties or fields

src/TUnit.Core.SourceGenerator/CodeGenerators/StaticPropertyInitializationGenerator.cs

@@ -396,7 +396,7 @@ private static void GenerateIndividualPropertyInitializer(CodeWriter writer, Pro
         writer.AppendLine($"Type = typeof({propertyData.Property.GloballyQualifiedType}),");
         writer.AppendLine($"IsStatic = true,");
         writer.AppendLine($"ReflectionInfo = typeof({typeName}).GetProperty(\"{propertyName}\", global::System.Reflection.BindingFlags.Public | global::System.Reflection.BindingFlags.Static),");
-        writer.AppendLine($"Getter = _ => {typeName}.{propertyName},");
+        writer.AppendLine($"Getter = _ => {typeName}.{IdentifierHelper.Escape(propertyName)},");
         writer.AppendLine("ClassMetadata = containingTypeMetadata,");
         writer.AppendLine("ContainingTypeMetadata = containingTypeMetadata");
         writer.Unindent();
@@ -439,7 +439,7 @@ private static void GenerateIndividualPropertyInitializer(CodeWriter writer, Pro
         writer.AppendLine("if (value != null)");
         writer.AppendLine("{");
         writer.Indent();
-        writer.AppendLine($"{typeName}.{propertyName} = ({propertyData.Property.GloballyQualifiedType})value;");
+        writer.AppendLine($"{typeName}.{IdentifierHelper.Escape(propertyName)} = ({propertyData.Property.GloballyQualifiedType})value;");
         writer.Unindent();
         writer.AppendLine("}");
         writer.AppendLine();

src/TUnit.Core.SourceGenerator/Helpers/IdentifierHelper.cs

@@ -0,0 +1,13 @@
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace TUnit.Core.SourceGenerator.Helpers;
+
+internal static class IdentifierHelper
+{
+    /// <summary>
+    /// A symbol's Name drops the @ of an escaped identifier, so a member named after a keyword, such as
+    /// <c>@event</c>, needs it back before generated code can access the member.
+    /// </summary>
+    public static string Escape(string name)
+        => SyntaxFacts.GetKeywordKind(name) != SyntaxKind.None ? "@" + name : name;
+}

src/TUnit.Core.SourceGenerator/Models/TestMethodMetadata.cs

@@ -6,7 +6,29 @@
 
 namespace TUnit.Core.SourceGenerator.Models;
 
-public record CompilationContext(CSharpCompilation Compilation, AttributeWriter AttributeWriter, WellKnownTypes WellKnownTypes);
+public record CompilationContext(CSharpCompilation Compilation, AttributeWriter AttributeWriter, WellKnownTypes WellKnownTypes)
+{
+    private MethodDataSourceRowTypes? _methodDataSourceRowTypes;
+
+    /// <summary>
+    /// The generic definitions used to unwrap [MethodDataSource] row types, looked up once per compilation
+    /// on first use. A race only repeats the lookups: both instances hold the same symbols.
+    /// </summary>
+    public MethodDataSourceRowTypes MethodDataSourceRowTypes => _methodDataSourceRowTypes ??= new MethodDataSourceRowTypes(Compilation);
+}
+
+/// <summary>
+/// The generic type definitions that wrap a [MethodDataSource] row. It holds symbols from one compilation, so,
+/// like <see cref="CompilationContext"/>, it must never flow through the incremental pipeline.
+/// </summary>
+public sealed class MethodDataSourceRowTypes(Compilation compilation)
+{
+    public INamedTypeSymbol? TaskType { get; } = compilation.GetTypeByMetadataName("System.Threading.Tasks.Task`1");
+    public INamedTypeSymbol? ValueTaskType { get; } = compilation.GetTypeByMetadataName("System.Threading.Tasks.ValueTask`1");
+    public INamedTypeSymbol? FuncType { get; } = compilation.GetTypeByMetadataName("System.Func`1");
+    public INamedTypeSymbol? AsyncEnumerableType { get; } = compilation.GetTypeByMetadataName("System.Collections.Generic.IAsyncEnumerable`1");
+    public INamedTypeSymbol? TestDataRowType { get; } = compilation.GetTypeByMetadataName("TUnit.Core.TestDataRow`1");
+}
 
 /// <summary>
 /// Contains all the metadata about a test method discovered by the source generator.

src/TUnit.Core.SourceGenerator/Utilities/MetadataGenerationHelper.cs

@@ -2,6 +2,7 @@
 using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
 using TUnit.Core.SourceGenerator.Extensions;
+using TUnit.Core.SourceGenerator.Helpers;
 
 namespace TUnit.Core.SourceGenerator.Utilities;
 
@@ -331,13 +332,13 @@ private static string GetPropertyAccessor(INamedTypeSymbol namedTypeSymbol, IPro
                 // Use reflection to get the value at runtime
                 ? $"_ => typeof({namedTypeSymbol.GloballyQualified()}).GetProperty(\"{property.Name}\")?.GetValue(null)"
                 // Use dynamic to avoid invalid cast to open generic type
-                : $"o => ((dynamic)o).{property.Name}";
+                : $"o => ((dynamic)o).{IdentifierHelper.Escape(property.Name)}";
         }
 
         var safeTypeName = namedTypeSymbol.GloballyQualified();
         return property.IsStatic
-            ? $"_ => {safeTypeName}.{property.Name}"
-            : $"o => (({safeTypeName})o).{property.Name}";
+            ? $"_ => {safeTypeName}.{IdentifierHelper.Escape(property.Name)}"
+            : $"o => (({safeTypeName})o).{IdentifierHelper.Escape(property.Name)}";
     }
 
     /// <summary>