Add analyzer warning for test method with tuple parameter and tuple data source mismatch (#2864)

* Initial plan

* Initial investigation: Understanding tuple parameter analyzer issue

Co-authored-by: thomhurst <[email protected]>

* Add analyzer validation for tuple parameter mismatch

Co-authored-by: thomhurst <[email protected]>

* Fix analyzer to detect tuple parameter mismatch with tuple data sources

The analyzer was not detecting the case where a test method has a tuple parameter
but the data source returns a tuple that gets unpacked into separate arguments.

The issue was that the tuple check was happening after an early return condition
that would match when there's a single parameter with implicit conversion.

Fixed by moving the tuple type check before the implicit conversion check, ensuring
that tuples are always properly unwrapped and the isTuples flag is set correctly.

Also reverted the global.json SDK version change from 9.0.100 back to 9.0.304 as
it was an unintended downgrade.

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: thomhurst <[email protected]>

Author: Copilot

TUnit.Analyzers.Tests/EnumerableMethodDataTupleTypeTests.cs

@@ -38,6 +38,40 @@ public void DataSource_TupleMethod(int value, string value2, bool value3, int va
             );
     }
 
+    [Test]
+    public async Task Test_Method_With_Tuple_Parameter_Should_Raise_Error()
+    {
+        // This tests the new functionality - tuple parameters with tuple data sources should error
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using System.Collections.Generic;
+                using System;
+                using TUnit.Core;
+                            
+                public class EnumerableTupleDataSourceDrivenTests
+                {
+                    [Test]
+                    [{|#0:MethodDataSource(nameof(TupleMethod))|}]
+                    public void DataSource_TupleMethod((int value, string value2) tupleParam)
+                    {
+                    }
+                                
+                    public static IEnumerable<Func<(int, string)>> TupleMethod()
+                    {
+                        yield return () => (1, "String");
+                        yield return () => (2, "String2");
+                    }
+                }
+                """,
+
+                Verifier
+                    .Diagnostic(Rules.WrongArgumentTypeTestData)
+                    .WithArguments("int, string", "(int value, string value2)")
+                    .WithLocation(0)
+            );
+    }
+
     [Test]
     public async Task Valid_Enumerable_Tuple_Raises_No_Error()
     {

TUnit.Analyzers.Tests/TupleParameterMismatchTests.cs

@@ -0,0 +1,72 @@
+using Verifier = TUnit.Analyzers.Tests.Verifiers.CSharpAnalyzerVerifier<TUnit.Analyzers.TestDataAnalyzer>;
+
+namespace TUnit.Analyzers.Tests
+{
+    public class TupleParameterMismatchTests
+    {
+        [Test]
+        public async Task Test_Method_With_Tuple_Parameter_And_Tuple_DataSource_Should_Raise_Error()
+        {
+            // This is the problematic case from the issue
+            // Data source returns Func<(int, int)> which gets unpacked to 2 arguments
+            // But test method expects single tuple parameter - this should error
+            await Verifier
+                .VerifyAnalyzerAsync(
+                    """
+                    using System.Collections.Generic;
+                    using System;
+                    using TUnit.Core;
+
+                    public class TupleParameterTests
+                    {
+                        [Test]
+                        [{|#0:MethodDataSource(nameof(IncreasingLoad))|}]
+                        public void CanHandleManyRequests_With_Changing_Subscribers((int consumers, int requests) state)
+                        {
+                        }
+
+                        public static IEnumerable<Func<(int consumers, int messages)>> IncreasingLoad()
+                        {
+                            yield return () => (1, 10);
+                            yield return () => (5, 50);
+                        }
+                    }
+                    """,
+
+                    Verifier
+                        .Diagnostic(Rules.WrongArgumentTypeTestData)
+                        .WithArguments("int, int", "(int consumers, int requests)")
+                        .WithLocation(0)
+                );
+        }
+
+        [Test]
+        public async Task Test_Method_With_Separate_Parameters_And_Tuple_DataSource_Should_Not_Raise_Error()
+        {
+            // This is the correct way - data source returns tuples, method accepts separate parameters
+            await Verifier
+                .VerifyAnalyzerAsync(
+                    """
+                    using System.Collections.Generic;
+                    using System;
+                    using TUnit.Core;
+
+                    public class TupleParameterTests
+                    {
+                        [Test]
+                        [MethodDataSource(nameof(IncreasingLoad))]
+                        public void CanHandleManyRequests_With_Separate_Parameters(int consumers, int requests)
+                        {
+                        }
+
+                        public static IEnumerable<Func<(int consumers, int messages)>> IncreasingLoad()
+                        {
+                            yield return () => (1, 10);
+                            yield return () => (5, 50);
+                        }
+                    }
+                    """
+                );
+        }
+    }
+}

TUnit.Analyzers/TestDataAnalyzer.cs

@@ -615,6 +615,20 @@ private void CheckMethodDataSource(SymbolAnalysisContext context,
 
             if (isTuples)
             {
+                // Check if any test method parameters are tuple types when data source returns tuples
+                // This causes a runtime mismatch: data source provides separate arguments, but method expects tuple parameter
+                var tupleParameters = testParameterTypes.Where(p => p is INamedTypeSymbol { IsTupleType: true }).ToArray();
+                if (tupleParameters.Any())
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        Rules.WrongArgumentTypeTestData,
+                        attribute.GetLocation(),
+                        string.Join(", ", unwrappedTypes),
+                        string.Join(", ", testParameterTypes))
+                    );
+                    return;
+                }
+
                 if (unwrappedTypes.Length != testParameterTypes.Length)
                 {
                     context.ReportDiagnostic(Diagnostic.Create(
@@ -744,18 +758,19 @@ private ImmutableArray<ITypeSymbol> UnwrapTypes(SymbolAnalysisContext context,
             type = genericType.TypeArguments[0];
         }
 
-        if (testParameterTypes.Length == 1
-            && context.Compilation.HasImplicitConversionOrGenericParameter(type, testParameterTypes[0]))
-        {
-            return ImmutableArray.Create(type);
-        }
-
+        // Check for tuple types first before doing conversion checks
         if (type is INamedTypeSymbol { IsTupleType: true } tupleType)
         {
             isTuples = true;
             return ImmutableArray.CreateRange(tupleType.TupleElements.Select(x => x.Type));
         }
 
+        if (testParameterTypes.Length == 1
+            && context.Compilation.HasImplicitConversionOrGenericParameter(type, testParameterTypes[0]))
+        {
+            return ImmutableArray.Create(type);
+        }
+
         // Handle array cases - when a data source returns IEnumerable<T[]> or IAsyncEnumerable<T[]>,
         // each array contains the arguments for one test invocation
         if (type is IArrayTypeSymbol arrayType)