Fix fallback path to preserve action lambda for unrecognized constraints

Co-authored-by: thomhurst <30480171+thomhurst@users.noreply.github.com>

Author: Copilot

TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs

@@ -667,7 +667,12 @@ private ExpressionSyntax ConvertNUnitThrows(InvocationExpressionSyntax invocatio
         }
 
         // Fallback for unsupported Throws patterns
-        return CreateTUnitAssertion("Throws", invocation.ArgumentList.Arguments[0].Expression);
+        // If we have 2+ arguments, it's a constraint-based form where arg[1] is the action
+        // Otherwise, it's a single-argument form where arg[0] is the action
+        var fallbackArg = invocation.ArgumentList.Arguments.Count >= 2
+            ? invocation.ArgumentList.Arguments[1].Expression
+            : invocation.ArgumentList.Arguments[0].Expression;
+        return CreateTUnitAssertion("Throws", fallbackArg);
     }
 
     /// <summary>

TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs

@@ -1822,6 +1822,61 @@ public async Task TestMethod()
         );
     }
 
+    [Test]
+    public async Task NUnit_ThrowsAsync_WithUnrecognizedConstraint_PreservesAction()
+    {
+        // Test that unrecognized constraint patterns still preserve the action lambda
+        // This tests the fallback path in ConvertNUnitThrows
+        await CodeFixer.VerifyCodeFixAsync(
+            """
+                using NUnit.Framework;
+                using System;
+
+                {|#0:public class MyClass|}
+                {
+                    [Test]
+                    public void TestMethod()
+                    {
+                        // Using Is.InstanceOf which is not recognized by TryExtractTypeFromConstraint
+                        Assert.ThrowsAsync(Is.InstanceOf<ArgumentException>(), async () => await SomeMethod());
+                    }
+                    
+                    private async System.Threading.Tasks.Task SomeMethod()
+                    {
+                        await System.Threading.Tasks.Task.Delay(1);
+                        throw new ArgumentException();
+                    }
+                }
+                """,
+            Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
+            """
+                using System;
+                using System.Threading.Tasks;
+                using TUnit.Core;
+                using TUnit.Assertions;
+                using static TUnit.Assertions.Assert;
+                using TUnit.Assertions.Extensions;
+
+                public class MyClass
+                {
+                    [Test]
+                    public async Task TestMethod()
+                    {
+                        // Using Is.InstanceOf which is not recognized by TryExtractTypeFromConstraint
+                        await Assert.That(async () => await SomeMethod()).Throws();
+                    }
+                    
+                    private async System.Threading.Tasks.Task SomeMethod()
+                    {
+                        await System.Threading.Tasks.Task.Delay(1);
+                        throw new ArgumentException();
+                    }
+                }
+                """,
+            ConfigureNUnitTest
+        );
+    }
+
     private static void ConfigureNUnitTest(Verifier.Test test)
     {
         test.TestState.AdditionalReferences.Add(typeof(NUnit.Framework.TestAttribute).Assembly);