Handle switching from params to non-params overload in xUnit1051

If the analyzer has fired on a `params` method, it means that the new
overload is actually array + `CancellationToken`, since C# forbids
placing any argument after a params argument. To avoid generating
invalid code, we need to replace the params expression with an array
creation expression.

Does not currently handle the expanded range of allowed `params` types
implemented in C# 13. Considering you can use _any_ type that implements
`IEnumerable<T>`, I think it would be quite difficult to handle all the
different cases there.
Being a new feature, it's also less likely to be used, though this will
of course change over time...

Closes [#3068](xunit/xunit#3068)

src/xunit.analyzers.fixes/X1000/UseCancellationTokenFixer.cs

@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
+using Microsoft.CodeAnalysis.Operations;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 
 namespace Xunit.Analyzers.Fixes;
@@ -51,6 +52,9 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
 		if (root.FindNode(diagnostic.Location.SourceSpan) is not InvocationExpressionSyntax invocation)
 			return;
 
+		if (semanticModel.GetOperation(invocation, context.CancellationToken) is not IInvocationOperation invocationOperation)
+			return;
+
 		var arguments = invocation.ArgumentList.Arguments;
 
 		for (var argumentIndex = 0; argumentIndex < arguments.Count; argumentIndex++)
@@ -78,6 +82,16 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
 					var args = new List<ArgumentSyntax>(arguments);
 
+					if (
+						invocationOperation.Arguments.FirstOrDefault(arg =>
+							arg.ArgumentKind == ArgumentKind.ParamArray
+						) is
+						{ } paramsArgument
+					)
+					{
+						TransformParamsArgument(args, paramsArgument, editor.Generator);
+					}
+
 					if (parameterIndex < args.Count)
 					{
 						args[parameterIndex] = args[parameterIndex].WithExpression(testContextCancellationTokenExpression);
@@ -106,4 +120,38 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
 			context.Diagnostics
 		);
 	}
+
+	private static void TransformParamsArgument(
+		List<ArgumentSyntax> arguments,
+		IArgumentOperation paramsOperation,
+		SyntaxGenerator generator
+	)
+	{
+
+		if (paramsOperation is not
+			{
+				Value: IArrayCreationOperation
+				{
+					Type: IArrayTypeSymbol arrayTypeSymbol,
+					Initializer: { } initializer
+				}
+			})
+		{
+			return;
+		}
+
+		// We know that the params arguments occupy the end of the list because the language
+		// does not allow regular arguments after params.
+		int paramsCount = initializer.ElementValues.Length;
+		int paramsStart = arguments.Count - paramsCount;
+
+		arguments.RemoveRange(paramsStart, paramsCount);
+
+		ExpressionSyntax arrayCreation = (ExpressionSyntax)generator.ArrayCreationExpression(
+			generator.TypeExpression(arrayTypeSymbol.ElementType),
+			initializer.ElementValues.Select(x => x.Syntax)
+		);
+
+		arguments.Add(Argument(arrayCreation));
+	}
 }

src/xunit.analyzers.tests/Fixes/X1000/UseCancellationTokenFixerTests.cs

@@ -90,7 +90,130 @@ public void TestMethod()
 			        Function(MyContext.Current.CancellationToken);
 			    }
 			
-			    void Function(CancellationToken token = default(CancellationToken)) { }
+				void Function(CancellationToken token = default(CancellationToken)) { }
+			}
+			""";
+
+		await Verify.VerifyCodeFixV3(before, after, UseCancellationTokenFixer.Key_UseCancellationTokenArgument);
+	}
+
+	[Fact]
+	public async Task UseCancellationTokenArgument_ParamsArgument()
+	{
+		var before = /* lang=c#-test */ """
+			using System.Threading;
+			using System.Threading.Tasks;
+			using MyContext = Xunit.TestContext;
+
+			public class TestClass {
+				[Xunit.Fact]
+				public void TestMethod()
+				{
+					[|Function(1, 2, 3)|];
+				}
+
+				void Function(params int[] integers) { }
+
+				void Function(int[] integers, CancellationToken token = default(CancellationToken)) { }
+			}
+			""";
+		var after = /* lang=c#-test */ """
+			using System.Threading;
+			using System.Threading.Tasks;
+			using MyContext = Xunit.TestContext;
+
+			public class TestClass {
+				[Xunit.Fact]
+				public void TestMethod()
+				{
+					Function(new int[] { 1, 2, 3 }, MyContext.Current.CancellationToken);
+				}
+			
+				void Function(params int[] integers) { }
+
+				void Function(int[] integers, CancellationToken token = default(CancellationToken)) { }
+			}
+			""";
+
+		await Verify.VerifyCodeFixV3(before, after, UseCancellationTokenFixer.Key_UseCancellationTokenArgument);
+	}
+
+	[Fact]
+	public async Task UseCancellationTokenArgument_ParamsArgumentAfterRegularArguments()
+	{
+		var before = /* lang=c#-test */ """
+			using System.Threading;
+			using System.Threading.Tasks;
+			using MyContext = Xunit.TestContext;
+
+			public class TestClass {
+				[Xunit.Fact]
+				public void TestMethod()
+				{
+					[|Function("hello", System.Guid.NewGuid(), System.Guid.NewGuid())|];
+				}
+			
+				void Function(string str, params System.Guid[] guids) { }
+			
+				void Function(string str, System.Guid[] guids, CancellationToken token = default(CancellationToken)) { }
+			}
+			""";
+		var after = /* lang=c#-test */ """
+			using System.Threading;
+			using System.Threading.Tasks;
+			using MyContext = Xunit.TestContext;
+
+			public class TestClass {
+				[Xunit.Fact]
+				public void TestMethod()
+				{
+					Function("hello", new System.Guid[] { System.Guid.NewGuid(), System.Guid.NewGuid() }, MyContext.Current.CancellationToken);
+				}
+			
+				void Function(string str, params System.Guid[] guids) { }
+			
+				void Function(string str, System.Guid[] guids, CancellationToken token = default(CancellationToken)) { }
+			}
+			""";
+
+		await Verify.VerifyCodeFixV3(before, after, UseCancellationTokenFixer.Key_UseCancellationTokenArgument);
+	}
+
+	[Fact]
+	public async Task UseCancellationTokenArgument_ParamsArgumentWithNoValues()
+	{
+		var before = /* lang=c#-test */ """
+			using System.Threading;
+			using System.Threading.Tasks;
+			using MyContext = Xunit.TestContext;
+
+			public class TestClass {
+				[Xunit.Fact]
+				public void TestMethod()
+				{
+					[|Function()|];
+				}
+
+				void Function(params int[] integers) { }
+
+				void Function(int[] integers, CancellationToken token = default(CancellationToken)) { }
+			}
+			""";
+		var after = /* lang=c#-test */ """
+			using System.Threading;
+			using System.Threading.Tasks;
+			using MyContext = Xunit.TestContext;
+
+			public class TestClass {
+				[Xunit.Fact]
+				public void TestMethod()
+				{
+					Function(new int[] { }, MyContext.Current.CancellationToken);
+				}
+			
+				void Function(params int[] integers) { }
+
+				void Function(int[] integers, CancellationToken token = default(CancellationToken)) { }
 			}
 			""";