Harden VSTHRD002 caller conversion

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: AArnott

src/Microsoft.VisualStudio.Threading.Analyzers.CodeFixes/VSTHRD002UseJtfRunCodeFixWithAwait.cs

@@ -192,8 +192,9 @@ private static bool HasAsyncNameCollision(IMethodSymbol method)
         return method.ContainingType.GetMembers(asyncName)
             .OfType<IMethodSymbol>()
             .Any(candidate => candidate.Arity == method.Arity
-                && candidate.Parameters.Length == method.Parameters.Length
-                && candidate.Parameters.Zip(method.Parameters, ParametersHaveEquivalentSignatures).All(match => match));
+                && candidate.Parameters.Length >= method.Parameters.Length
+                && candidate.Parameters.Take(method.Parameters.Length).Zip(method.Parameters, ParametersHaveEquivalentSignatures).All(match => match)
+                && candidate.Parameters.Skip(method.Parameters.Length).All(parameter => parameter.IsOptional));
     }
 
     private static bool ParametersHaveEquivalentSignatures(IParameterSymbol left, IParameterSymbol right)
@@ -275,10 +276,7 @@ or LocalFunctionStatementSyntax
                     && callerReturnType.IsAsyncCompatibleReturnType()
                     && ((invocation.FirstAncestorOrSelf<ReturnStatementSyntax>() is { Expression: { } returnExpression }
                             && returnExpression.FullSpan.Contains(invocation.Span))
-                        || (callingMethod.ExpressionBody?.Expression.FullSpan.Contains(invocation.Span) is true))
-                    && (callerReturnType.Arity == 0
-                        || !Utils.IsTask(callerReturnType)
-                        || !semanticModel.Compilation.ClassifyConversion(method.ReturnType, callerReturnType.TypeArguments[0]).IsImplicit))
+                        || (callingMethod.ExpressionBody?.Expression.FullSpan.Contains(invocation.Span) is true)))
                 {
                     return false;
                 }

test/Microsoft.VisualStudio.Threading.Analyzers.Tests/VSTHRD002UseJtfRunAnalyzerTests.cs

@@ -1926,6 +1926,55 @@ static DerivedTask<int> GetValue(Task<int> task)
         await CSVerify.VerifyCodeFixAsync(test, test);
     }
 
+    [Fact]
+    public async Task CodeFixIsNotOfferedForDirectReturnFromAsyncCompatibleCaller()
+    {
+        string test = """
+            using System;
+            using System.Runtime.CompilerServices;
+            using System.Threading.Tasks;
+
+            [AsyncMethodBuilder(typeof(CustomTaskMethodBuilder<>))]
+            class CustomTask<T>
+            {
+                public TaskAwaiter<T> GetAwaiter() => Task.FromResult(default(T)).GetAwaiter();
+                public static implicit operator CustomTask<T>(T value) => new();
+            }
+
+            struct CustomTaskMethodBuilder<T>
+            {
+                public static CustomTaskMethodBuilder<T> Create() => default;
+                public CustomTask<T> Task => new();
+                public void SetResult(T result) { }
+                public void SetException(Exception exception) { }
+                public void SetStateMachine(IAsyncStateMachine stateMachine) { }
+                public void Start<TStateMachine>(ref TStateMachine stateMachine)
+                    where TStateMachine : IAsyncStateMachine => stateMachine.MoveNext();
+                public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+                    where TAwaiter : INotifyCompletion
+                    where TStateMachine : IAsyncStateMachine { }
+                public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
+                    where TAwaiter : ICriticalNotifyCompletion
+                    where TStateMachine : IAsyncStateMachine { }
+            }
+
+            class Test
+            {
+                static int GetValue(Task<int> task)
+                {
+                    return task.[|Result|];
+                }
+
+                static CustomTask<int> Caller(Task<int> task)
+                {
+                    return GetValue(task);
+                }
+            }
+            """;
+
+        await CSVerify.VerifyCodeFixAsync(test, test);
+    }
+
     [Fact]
     public async Task CodeFixIsNotOfferedWhenCallerUsesConditionalAccess()
     {
@@ -1973,6 +2022,29 @@ Task<int> GetValueAsync(Task<int> task)
         await CSVerify.VerifyCodeFixAsync(test, test);
     }
 
+    [Fact]
+    public async Task CodeFixIsNotOfferedWhenAsyncNameHasApplicableOptionalOverload()
+    {
+        string test = """
+            using System.Threading.Tasks;
+
+            class Test
+            {
+                int GetValue(Task<int> task)
+                {
+                    return task.[|Result|];
+                }
+
+                Task<int> GetValueAsync(Task<int> task, bool optional = false)
+                {
+                    return task;
+                }
+            }
+            """;
+
+        await CSVerify.VerifyCodeFixAsync(test, test);
+    }
+
     [Fact]
     public async Task CodeFixIsNotOfferedWhenChangingMethodContract()
     {