Address PR review feedback for INTL0304 code fix

- Add Simplifier annotations so code-fix output simplifies Task symbols
- Build replacement expressions with syntax nodes instead of raw strings
- Skip code-fix rewrites when Task.Delay overload includes timeProvider
- Add regression tests for TimeProvider overload no-fix behavior
- Update fixed-code expectations for simplified output

Author: BenjaminMichaelis

IntelliTect.Analyzer/IntelliTect.Analyzer.CodeFixes/TaskDelayZero.cs

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Operations;
+using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
 
 namespace IntelliTect.Analyzer.CodeFixes
@@ -86,11 +87,18 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 return null;
             }
 
+            // Task.Delay overloads that include a TimeProvider cannot be safely rewritten to
+            // Task.CompletedTask/Task.FromCanceled without changing observable behavior.
+            if (invocation.Arguments.Any(a => a.Parameter?.Name == "timeProvider"))
+            {
+                return null;
+            }
+
             IArgumentOperation? cancellationTokenArgument = invocation.Arguments
                 .FirstOrDefault(a => a.Parameter?.Name == "cancellationToken");
             if (cancellationTokenArgument is null)
             {
-                return SyntaxFactory.ParseExpression("global::System.Threading.Tasks.Task.CompletedTask");
+                return CreateTaskCompletedTaskExpression();
             }
 
             if (cancellationTokenArgument.Value.Syntax is not ExpressionSyntax cancellationTokenExpression)
@@ -104,13 +112,40 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             }
 
             string tokenExpressionText = NormalizeCancellationTokenExpression(cancellationTokenExpression);
+            ExpressionSyntax normalizedTokenExpression = SyntaxFactory.ParseExpression(tokenExpressionText)
+                .WithAdditionalAnnotations(Simplifier.Annotation);
 
             // Runtime behavior reference:
             // https://github.com/dotnet/runtime/blob/1acc89c305165239a5a824567a3176b6b3342790/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs#L5907-L5911
             // Task.Delay(0, token) maps to:
             // token.IsCancellationRequested ? Task.FromCanceled(token) : Task.CompletedTask
-            return SyntaxFactory.ParseExpression(
-                $"({tokenExpressionText}.IsCancellationRequested ? global::System.Threading.Tasks.Task.FromCanceled({tokenExpressionText}) : global::System.Threading.Tasks.Task.CompletedTask)");
+            return SyntaxFactory.ConditionalExpression(
+                SyntaxFactory.MemberAccessExpression(
+                    SyntaxKind.SimpleMemberAccessExpression,
+                    normalizedTokenExpression,
+                    SyntaxFactory.IdentifierName("IsCancellationRequested")),
+                CreateTaskFromCanceledExpression(normalizedTokenExpression),
+                CreateTaskCompletedTaskExpression());
+        }
+
+        private static ExpressionSyntax CreateTaskCompletedTaskExpression()
+        {
+            return SyntaxFactory.MemberAccessExpression(
+                SyntaxKind.SimpleMemberAccessExpression,
+                SyntaxFactory.ParseName("global::System.Threading.Tasks.Task").WithAdditionalAnnotations(Simplifier.Annotation),
+                SyntaxFactory.IdentifierName("CompletedTask"));
+        }
+
+        private static InvocationExpressionSyntax CreateTaskFromCanceledExpression(ExpressionSyntax cancellationTokenExpression)
+        {
+            return SyntaxFactory.InvocationExpression(
+                SyntaxFactory.MemberAccessExpression(
+                    SyntaxKind.SimpleMemberAccessExpression,
+                    SyntaxFactory.ParseName("global::System.Threading.Tasks.Task").WithAdditionalAnnotations(Simplifier.Annotation),
+                    SyntaxFactory.IdentifierName("FromCanceled")),
+                SyntaxFactory.ArgumentList(
+                    SyntaxFactory.SingletonSeparatedList(
+                        SyntaxFactory.Argument(cancellationTokenExpression))));
         }
 
         private static string NormalizeCancellationTokenExpression(ExpressionSyntax cancellationTokenExpression)
@@ -154,7 +189,7 @@ private static async Task<Document> ReplaceInvocationAsync(
 
             ExpressionSyntax replacementExpression = replacement
                 .WithTriviaFrom(invocation)
-                .WithAdditionalAnnotations(Formatter.Annotation);
+                .WithAdditionalAnnotations(Formatter.Annotation, Simplifier.Annotation);
 
             SyntaxNode newRoot = oldRoot.ReplaceNode(invocation, replacementExpression);
             return document.WithSyntaxRoot(newRoot);

IntelliTect.Analyzer/IntelliTect.Analyzer.Test/TaskDelayZeroTests.cs

@@ -109,7 +109,7 @@ class C
                 {
                     Task M()
                     {
-                        return global::System.Threading.Tasks.Task.CompletedTask;
+                        return Task.CompletedTask;
                     }
                 }
                 """;
@@ -141,7 +141,7 @@ class C
                 {
                     Task M(CancellationToken token)
                     {
-                        return (token.IsCancellationRequested ? global::System.Threading.Tasks.Task.FromCanceled(token) : global::System.Threading.Tasks.Task.CompletedTask);
+                        return token.IsCancellationRequested ? Task.FromCanceled(token) : Task.CompletedTask;
                     }
                 }
                 """;
@@ -171,7 +171,7 @@ class C
                 {
                     Task M()
                     {
-                        return (default(global::System.Threading.CancellationToken).IsCancellationRequested ? global::System.Threading.Tasks.Task.FromCanceled(default(global::System.Threading.CancellationToken)) : global::System.Threading.Tasks.Task.CompletedTask);
+                        return default(global::System.Threading.CancellationToken).IsCancellationRequested ? Task.FromCanceled(default) : Task.CompletedTask;
                     }
                 }
                 """;
@@ -245,14 +245,53 @@ class C
                 {
                     Task M()
                     {
-                        return (CancellationToken.None.IsCancellationRequested ? global::System.Threading.Tasks.Task.FromCanceled(CancellationToken.None) : global::System.Threading.Tasks.Task.CompletedTask);
+                        return CancellationToken.None.IsCancellationRequested ? Task.FromCanceled(CancellationToken.None) : Task.CompletedTask;
                     }
                 }
                 """;
 
             await VerifyCSharpFix(source, fixedSource);
         }
 
+        [TestMethod]
+        public async Task TaskDelayZeroWithTimeProvider_NoCodeFix()
+        {
+            string source = """
+                using System;
+                using System.Threading.Tasks;
+
+                class C
+                {
+                    Task M()
+                    {
+                        return Task.Delay(0, TimeProvider.System);
+                    }
+                }
+                """;
+
+            await VerifyCSharpFix(source, source);
+        }
+
+        [TestMethod]
+        public async Task TaskDelayZeroWithTimeProviderAndToken_NoCodeFix()
+        {
+            string source = """
+                using System;
+                using System.Threading;
+                using System.Threading.Tasks;
+
+                class C
+                {
+                    Task M(CancellationToken token)
+                    {
+                        return Task.Delay(0, TimeProvider.System, token);
+                    }
+                }
+                """;
+
+            await VerifyCSharpFix(source, source);
+        }
+
         [TestMethod]
         public async Task AwaitTaskDelayZero_CodeFix_UsesCompletedTask()
         {
@@ -275,7 +314,7 @@ class C
                 {
                     async Task M()
                     {
-                        await global::System.Threading.Tasks.Task.CompletedTask;
+                        await Task.CompletedTask;
                     }
                 }
                 """;