fix: resolve IndexOutOfRangeException with MethodDataSource<T> on class (#5118)

TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs

@@ -842,7 +842,16 @@ private static void GenerateMethodDataSourceAttribute(CodeWriter writer, Attribu
         {
             // MethodDataSource(string) overload
             methodName = attr.ConstructorArguments[0].Value?.ToString();
-            targetType = typeSymbol;
+
+            // Check for MethodDataSource<T> generic variant - extract T from type arguments
+            if (attr.AttributeClass is { IsGenericType: true, TypeArguments.Length: > 0 })
+            {
+                targetType = attr.AttributeClass.TypeArguments[0];
+            }
+            else
+            {
+                targetType = typeSymbol;
+            }
         }
 
         if (string.IsNullOrEmpty(methodName))

TUnit.Core/Attributes/TestData/MethodDataSourceAttribute.cs

@@ -228,7 +228,9 @@ public MethodDataSourceAttribute(
         }
 
         // Compute paramTypes once to avoid repeated LINQ allocations
-        var paramTypes = GetParameterTypes(dataGeneratorMetadata.TestInformation?.Parameters);
+        // Use MembersToGenerate which contains the correct parameters for this data generator type
+        // (constructor params for class-level, method params for method-level)
+        var paramTypes = GetMemberTypes(dataGeneratorMetadata.MembersToGenerate);
 
         // If it's IAsyncEnumerable, handle it specially
         if (IsAsyncEnumerable(methodResult.GetType()))
@@ -325,6 +327,26 @@ public MethodDataSourceAttribute(
         return types;
     }
 
+    private static Type[]? GetMemberTypes(IMemberMetadata[]? members)
+    {
+        if (members == null || members.Length == 0)
+        {
+            return null;
+        }
+
+        var types = new Type[members.Length];
+        for (var i = 0; i < members.Length; i++)
+        {
+            types[i] = members[i] switch
+            {
+                ParameterMetadata param => param.Type,
+                PropertyMetadata prop => prop.Type,
+                _ => typeof(object)
+            };
+        }
+        return types;
+    }
+
     private static bool IsAsyncEnumerable([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.Interfaces)] Type type)
     {
         return type.GetInterfaces()

TUnit.TestProject/Bugs/5118/AsyncClassMethodDataSourceTests.cs

@@ -0,0 +1,29 @@
+using TUnit.TestProject.Attributes;
+
+namespace TUnit.TestProject.Bugs._5118;
+
+public class AsyncTestDataSources
+{
+    public static async IAsyncEnumerable<(int Id, string Name, DateTime CreatedAt)> GetAsyncTestData()
+    {
+        for (var i = 1; i <= 3; i++)
+        {
+            await Task.Delay(10).ConfigureAwait(false);
+
+            yield return (Id: i, Name: $"Item_{i}", CreatedAt: DateTime.UtcNow.AddDays(-i));
+        }
+    }
+}
+
+[EngineTest(ExpectedResult.Pass)]
+[MethodDataSource<AsyncTestDataSources>(nameof(AsyncTestDataSources.GetAsyncTestData))]
+public class AsyncClassMethodDataSourceTests(int Id, string Name, DateTime CreatedAt)
+{
+    [Test, Timeout(5000)]
+    public async Task TestWithAsyncComplexData(CancellationToken token)
+    {
+        await Assert.That(Id).IsGreaterThan(0);
+        await Assert.That(Name).StartsWith("Item_");
+        await Assert.That(CreatedAt).IsLessThan(DateTime.UtcNow);
+    }
+}