fix: resolve IndexOutOfRangeException when using MethodDataSource<T> …

…on a class with tuples (#5118)

Two bugs caused class-level MethodDataSource<T> with tuple data to fail:

1. Source generator didn't extract T from generic attribute type arguments,
   so it couldn't find the data source method and skipped Factory generation.

2. Runtime reflection path used test method parameters instead of constructor
   parameters for tuple unwrapping, causing truncation of tuple elements.

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);
+    }
+}