dotnet · CyrusNajmabadi · Dec 17, 2025 · Dec 17, 2025 · Dec 17, 2025 · Dec 17, 2025
@@ -77,7 +77,7 @@ protected override PropertyDeclarationSyntax RewriteFieldReferencesInProperty(
         return (PropertyDeclarationSyntax)rewriter.Visit(property);
     }
 
-    protected override Task<SyntaxNode> UpdatePropertyAsync(
+    protected override async Task<SyntaxNode> UpdatePropertyAsync(
         Document propertyDocument,
         Compilation compilation,
         IFieldSymbol fieldSymbol,
@@ -105,7 +105,7 @@ protected override Task<SyntaxNode> UpdatePropertyAsync(
             // Nothing to actually do.  We're not changing the accessors to `get;set;` accessors, and we didn't have to
             // add an setter.  We also had no field initializer to move over.  This can happen when we're converting to
             // using `field` and that rewrite already happened.
-            return Task.FromResult<SyntaxNode>(propertyDeclaration);
+            return propertyDeclaration;
         }
 
         // 1. If we have a trivial getters/setter then we want to convert to an accessor list to have `get;set;`
@@ -140,7 +140,7 @@ protected override Task<SyntaxNode> UpdatePropertyAsync(
         var finalProperty = updatedProperty
             .WithTrailingTrivia(propertyDeclaration.GetTrailingTrivia())
             .WithAdditionalAnnotations(SpecializedFormattingAnnotation);
-        return Task.FromResult<SyntaxNode>(finalProperty);
+        return finalProperty;
 
         static PropertyDeclarationSyntax MoveAttributes(
             PropertyDeclarationSyntax property,

@@ -93,11 +93,11 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
                 actions.Add(CodeAction.Create(
                     title,
-                    cancellationToken =>
+                    async cancellationToken =>
                     {
                         var (finalTarget, replacement) = ApplyFix(document, semanticModel, targetNode, conversionType, cancellationToken);
 
-                        return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(finalTarget, replacement)));
+                        return document.WithSyntaxRoot(root.ReplaceNode(finalTarget, replacement));
                     },
                     title));
 

@@ -56,11 +56,11 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
             actions.Add(CodeAction.Create(
                 title,
-                cancellationToken =>
+                async cancellationToken =>
                 {
                     var aliasDirective = syntaxGenerator.AliasImportDeclaration(typeName, symbol);
                     var newRoot = addImportService.AddImport(semanticModel, root, diagnosticNode, aliasDirective, syntaxGenerator, placementOption, cancellationToken);
-                    return Task.FromResult(document.WithSyntaxRoot(newRoot));
+                    return document.WithSyntaxRoot(newRoot);
                 },
                 title));
         }

@@ -73,7 +73,7 @@ public bool SupportsFormattingOnTypedCharacter(Document document, char ch)
         return s_supportedChars.IndexOf(ch) >= 0;
     }
 
-    public Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
+    public async Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
         Document document,
         ITextBuffer textBuffer,
         TextSpan? textSpan,
@@ -85,31 +85,31 @@ public Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(
         var span = textSpan ?? new TextSpan(0, parsedDocument.Root.FullSpan.Length);
         var formattingSpan = CommonFormattingHelpers.GetFormattingSpan(parsedDocument.Root, span);
 
-        return Task.FromResult(Formatter.GetFormattedTextChanges(parsedDocument.Root, [formattingSpan], document.Project.Solution.Services, options, cancellationToken).ToImmutableArray());
+        return [.. Formatter.GetFormattedTextChanges(parsedDocument.Root, [formattingSpan], document.Project.Solution.Services, options, cancellationToken)];
     }
 
-    public Task<ImmutableArray<TextChange>> GetFormattingChangesOnPasteAsync(Document document, ITextBuffer textBuffer, TextSpan textSpan, CancellationToken cancellationToken)
+    public async Task<ImmutableArray<TextChange>> GetFormattingChangesOnPasteAsync(Document document, ITextBuffer textBuffer, TextSpan textSpan, CancellationToken cancellationToken)
     {
         var parsedDocument = ParsedDocument.CreateSynchronously(document, cancellationToken);
         var options = textBuffer.GetSyntaxFormattingOptions(_editorOptionsService, document.Project.GetFallbackAnalyzerOptions(), parsedDocument.LanguageServices, explicitFormat: true);
         var service = parsedDocument.LanguageServices.GetRequiredService<ISyntaxFormattingService>();
-        return Task.FromResult(service.GetFormattingChangesOnPaste(parsedDocument, textSpan, options, cancellationToken));
+        return service.GetFormattingChangesOnPaste(parsedDocument, textSpan, options, cancellationToken);
     }
 
-    public Task<ImmutableArray<TextChange>> GetFormattingChangesOnReturnAsync(Document document, int caretPosition, CancellationToken cancellationToken)
-        => SpecializedTasks.EmptyImmutableArray<TextChange>();
+    public async Task<ImmutableArray<TextChange>> GetFormattingChangesOnReturnAsync(Document document, int caretPosition, CancellationToken cancellationToken)
+        => [];
 
-    public Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(Document document, ITextBuffer textBuffer, char typedChar, int position, CancellationToken cancellationToken)
+    public async Task<ImmutableArray<TextChange>> GetFormattingChangesAsync(Document document, ITextBuffer textBuffer, char typedChar, int position, CancellationToken cancellationToken)
     {
         var parsedDocument = ParsedDocument.CreateSynchronously(document, cancellationToken);
         var service = parsedDocument.LanguageServices.GetRequiredService<ISyntaxFormattingService>();
 
         if (service.ShouldFormatOnTypedCharacter(parsedDocument, typedChar, position, cancellationToken))
         {
             var indentationOptions = textBuffer.GetIndentationOptions(_editorOptionsService, document.Project.GetFallbackAnalyzerOptions(), parsedDocument.LanguageServices, explicitFormat: false);
-            return Task.FromResult(service.GetFormattingChangesOnTypedCharacter(parsedDocument, position, indentationOptions, cancellationToken));
+            return service.GetFormattingChangesOnTypedCharacter(parsedDocument, position, indentationOptions, cancellationToken);
         }
 
-        return SpecializedTasks.EmptyImmutableArray<TextChange>();
+        return [];
     }
 }
@@ -67,7 +67,7 @@ protected async Task NavigateToPositionAsync(Workspace workspace, DocumentId doc
         }
     }
 
-    internal virtual Task<(DocumentId documentId, int position, int virtualSpace)> GetNavigationLocationAsync(
+    internal virtual async ValueTask<(DocumentId documentId, int position, int virtualSpace)> GetNavigationLocationAsync(
         Document document,
         NavigationBarItem item,
         SymbolItem symbolItem,
@@ -79,15 +79,15 @@ protected async Task NavigateToPositionAsync(Workspace workspace, DocumentId doc
             // If the item points to a location in this document, then just determine the where that span currently
             // is (in case recent edits have moved it) and navigate there.
             var navigationSpan = item.GetCurrentItemSpan(textVersion, symbolItem.Location.InDocumentInfo.Value.navigationSpan);
-            return Task.FromResult((document.Id, navigationSpan.Start, 0));
+            return (document.Id, navigationSpan.Start, 0);
         }
         else
         {
             // Otherwise, the item pointed to a location in another document.  Just return the position we
             // computed and stored for it.
             Contract.ThrowIfNull(symbolItem.Location.OtherDocumentInfo);
             var (documentId, span) = symbolItem.Location.OtherDocumentInfo.Value;
-            return Task.FromResult((documentId, span.Start, 0));
+            return (documentId, span.Start, 0);
         }
     }
 

@@ -36,10 +36,8 @@ public bool IsEnabled
         }
     }
 
-    public Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken)
-    {
-        return Task.FromResult(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty);
-    }
+    public async Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken)
+        => ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty);
 
     public async Task<IInlineRenameInfo> GetRenameInfoAsync(Document document, int position, CancellationToken cancellationToken)
     {

@@ -32,10 +32,8 @@ public async Task<IInlineRenameInfo> GetRenameInfoAsync(Document document, int p
             _refactorNotifyServices, symbolicInfo, cancellationToken);
     }
 
-    public virtual Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken)
-    {
-        return Task.FromResult(ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty);
-    }
+    public virtual async Task<ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>> GetRenameContextAsync(IInlineRenameInfo inlineRenameInfo, IInlineRenameLocationSet inlineRenameLocationSet, CancellationToken cancellationToken)
+        => ImmutableDictionary<string, ImmutableArray<(string filePath, string content)>>.Empty;
 
     /// <summary>
     /// Returns the <see cref="TextSpan"/> of the nearest encompassing <see cref="SyntaxNode"/> of type

@@ -50,7 +50,7 @@ public Task<ImmutableArray<VSCompletionItem>> SortCompletionListAsync(
         throw new NotImplementedException();
     }
 
-    public Task<CompletionList<VSCompletionItem>> SortCompletionItemListAsync(
+    public async ValueTask<CompletionList<VSCompletionItem>> SortCompletionItemListAsync(
         IAsyncCompletionSession session,
         AsyncCompletionSessionInitialDataSnapshot data,
         CancellationToken cancellationToken)
@@ -73,7 +73,7 @@ public Task<CompletionList<VSCompletionItem>> SortCompletionItemListAsync(
         }
 
         AsyncCompletionLogger.LogItemManagerSortTicksDataPoint(stopwatch.Elapsed);
-        return Task.FromResult(itemList);
+        return itemList;
     }
 
     private static void SortCompletionItems(List<VSCompletionItem> list, AsyncCompletionSessionInitialDataSnapshot data, CancellationToken cancellationToken)

@@ -265,12 +265,12 @@ public virtual AbstractLanguageServer<RequestContext> Create(
 
     public abstract ServerCapabilities GetCapabilities(ClientCapabilities clientCapabilities);
 
-    public Task<InitializationFailureContext?> OnServerInitializeFailedAsync(ILanguageClientInitializationInfo initializationState)
+    public async Task<InitializationFailureContext?> OnServerInitializeFailedAsync(ILanguageClientInitializationInfo initializationState)
     {
         var initializationFailureContext = new InitializationFailureContext();
         initializationFailureContext.FailureMessage = string.Format(EditorFeaturesResources.Language_client_initialization_failed,
             Name, initializationState.StatusMessage, initializationState.InitializationException?.ToString());
-        return Task.FromResult<InitializationFailureContext?>(initializationFailureContext);
+        return initializationFailureContext;
     }
 
     /// <summary>

@@ -55,15 +55,15 @@ public RenameTrackingCodeAction(
         protected sealed override CodeActionPriority ComputePriority()
             => CodeActionPriority.High;
 
-        protected override Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(
+        protected override async Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(
             IProgress<CodeAnalysisProgress> progress, CancellationToken cancellationToken)
         {
             // Invoked directly without previewing.
             if (_renameTrackingCommitter == null && !TryInitializeRenameTrackingCommitter())
-                return SpecializedTasks.EmptyImmutableArray<CodeActionOperation>();
+                return [];
 
             var committerOperation = new RenameTrackingCommitterOperation(_renameTrackingCommitter, _threadingContext);
-            return Task.FromResult(ImmutableArray.Create<CodeActionOperation>(committerOperation));
+            return [committerOperation];
         }
 
         protected override async Task<IEnumerable<CodeActionOperation>> ComputePreviewOperationsAsync(CancellationToken cancellationToken)

@@ -29,10 +29,10 @@ private sealed class RefineUsingCopilotCodeAction(
     {
         public override string Title => EditorFeaturesResources.Refine_using_Copilot;
 
-        protected override Task<IEnumerable<CodeActionOperation>> ComputePreviewOperationsAsync(CancellationToken cancellationToken)
+        protected override async Task<IEnumerable<CodeActionOperation>> ComputePreviewOperationsAsync(CancellationToken cancellationToken)
         {
             // Make sure we don't trigger the refinement session for preview operation
-            return Task.FromResult(SpecializedCollections.EmptyEnumerable<CodeActionOperation>());
+            return [];
         }
 
         protected override async Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(IProgress<CodeAnalysisProgress> progress, CancellationToken cancellationToken)

@@ -22,11 +22,10 @@
 
         public override string Title => FeaturesResources.Install_with_package_manager;
 
-        protected override Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(
+        protected override async Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(
             IProgress<CodeAnalysisProgress> progress, CancellationToken cancellationToken)
         {
-            return Task.FromResult(ImmutableArray.Create<CodeActionOperation>(
-                new InstallWithPackageManagerCodeActionOperation(_installerService, _packageName)));
+            return [new InstallWithPackageManagerCodeActionOperation(_installerService, _packageName))];
         }
 
         private sealed class InstallWithPackageManagerCodeActionOperation(

@@ -24,14 +24,14 @@ public MetadataSymbolReferenceCodeAction(Document originalDocument, AddImportFix
             Contract.ThrowIfFalse(fixData.Kind == AddImportFixKind.MetadataSymbol);
         }
 
-        protected override Task<CodeActionOperation?> UpdateProjectAsync(Project project, bool isPreview, CancellationToken cancellationToken)
+        protected override async Task<CodeActionOperation?> UpdateProjectAsync(Project project, bool isPreview, CancellationToken cancellationToken)
         {
             var projectWithReference = project.Solution.GetRequiredProject(FixData.PortableExecutableReferenceProjectId);
             var reference = projectWithReference.MetadataReferences
                                                 .OfType<PortableExecutableReference>()
                                                 .First(pe => pe.FilePath == FixData.PortableExecutableReferenceFilePathToAdd);
 
-            return Task.FromResult<CodeActionOperation?>(new ApplyChangesOperation(project.AddMetadataReference(reference).Solution));
+            return new ApplyChangesOperation(project.AddMetadataReference(reference).Solution);
         }
     }
 }
@@ -37,19 +37,19 @@ public ProjectSymbolReferenceCodeAction(
         private static bool ShouldAddProjectReference(Document originalDocument, AddImportFixData fixData)
             => fixData.ProjectReferenceToAdd != null && fixData.ProjectReferenceToAdd != originalDocument.Project.Id;
 
-        protected override Task<CodeActionOperation?> UpdateProjectAsync(Project project, bool isPreview, CancellationToken cancellationToken)
+        protected override async Task<CodeActionOperation?> UpdateProjectAsync(Project project, bool isPreview, CancellationToken cancellationToken)
         {
             if (!ShouldAddProjectReference(this.OriginalDocument, this.FixData))
-                return SpecializedTasks.Null<CodeActionOperation>();
+                return null;
 
             var projectWithAddedReference = project.AddProjectReference(new ProjectReference(FixData.ProjectReferenceToAdd));
             var applyOperation = new ApplyChangesOperation(projectWithAddedReference.Solution);
             if (isPreview)
             {
-                return Task.FromResult<CodeActionOperation?>(applyOperation);
+                return applyOperation;
             }
 
-            return Task.FromResult<CodeActionOperation?>(new AddProjectReferenceCodeActionOperation(OriginalDocument.Project.Id, FixData.ProjectReferenceToAdd, applyOperation));
+            return new AddProjectReferenceCodeActionOperation(OriginalDocument.Project.Id, FixData.ProjectReferenceToAdd, applyOperation);
         }
 
         private sealed class AddProjectReferenceCodeActionOperation(ProjectId referencingProject, ProjectId referencedProject, ApplyChangesOperation applyOperation) : CodeActionOperation

@@ -70,22 +70,21 @@ public static async Task<CodeAction> CreateAsync(Project project, AssemblyIdenti
         return new AddMissingReferenceCodeAction(project, description, null, missingAssemblyIdentity);
     }
 
-    protected override Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(
+    protected override async Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(
         IProgress<CodeAnalysisProgress> progress, CancellationToken cancellationToken)
     {
         // If we have a project reference to add, then add it
         if (_projectReferenceToAdd != null)
         {
             // note: no need to post process since we are just adding a project reference and not making any code changes.
-            return Task.FromResult(ImmutableArray.Create<CodeActionOperation>(
-                new ApplyChangesOperation(_project.AddProjectReference(_projectReferenceToAdd).Solution)));
+            return [new ApplyChangesOperation(_project.AddProjectReference(_projectReferenceToAdd).Solution)];
         }
         else
         {
             // We didn't have any project, so we need to try adding a metadata reference
             var factoryService = _project.Solution.Services.GetRequiredService<IAddMetadataReferenceCodeActionOperationFactoryWorkspaceService>();
             var operation = factoryService.CreateAddMetadataReferenceOperation(_project.Id, _missingAssemblyIdentity);
-            return Task.FromResult(ImmutableArray.Create(operation));
+            return [operation];
         }
     }
 }
@@ -19,11 +19,10 @@ internal sealed class InstallWithPackageManagerCodeAction(
 
     public override string Title => FeaturesResources.Install_with_package_manager;
 
-    protected override Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(
+    protected override async Task<ImmutableArray<CodeActionOperation>> ComputeOperationsAsync(
         IProgress<CodeAnalysisProgress> progress, CancellationToken cancellationToken)
     {
-        return Task.FromResult(ImmutableArray.Create<CodeActionOperation>(
-            new InstallWithPackageManagerCodeActionOperation(this)));
+        return [new InstallWithPackageManagerCodeActionOperation(this)];
     }
 
     private sealed class InstallWithPackageManagerCodeActionOperation(