diff --git a/src/Workspaces/Core/Portable/CodeActions/CodeAction.cs b/src/Workspaces/Core/Portable/CodeActions/CodeAction.cs index d0bed3f4f5309..343bd759a0530 100644 --- a/src/Workspaces/Core/Portable/CodeActions/CodeAction.cs +++ b/src/Workspaces/Core/Portable/CodeActions/CodeAction.cs @@ -752,8 +752,8 @@ public static NoChangeAction Create( CodeActionPriority priority = CodeActionPriority.Default) => new(title, equivalenceKey, priority, createdFromFactoryMethod: true); - protected sealed override Task GetChangedSolutionAsync(IProgress progress, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + protected sealed override async Task GetChangedSolutionAsync(IProgress progress, CancellationToken cancellationToken) + => null; } #endregion diff --git a/src/Workspaces/Core/Portable/CodeActions/CodeActionWithOptions.cs b/src/Workspaces/Core/Portable/CodeActions/CodeActionWithOptions.cs index 0f8c3b5471b5c..a482e4ee9c882 100644 --- a/src/Workspaces/Core/Portable/CodeActions/CodeActionWithOptions.cs +++ b/src/Workspaces/Core/Portable/CodeActions/CodeActionWithOptions.cs @@ -63,8 +63,8 @@ private protected sealed override async Task /// /// An object instance returned from a call to . /// A cancellation token. - protected virtual Task> ComputeOperationsAsync(object options, CancellationToken cancellationToken) - => SpecializedTasks.EmptyEnumerable(); + protected virtual async Task> ComputeOperationsAsync(object options, CancellationToken cancellationToken) + => []; /// /// Override this method to compute the operations that implement this . Prefer @@ -74,6 +74,6 @@ protected virtual Task> ComputeOperationsAsync( protected virtual Task> ComputeOperationsAsync(object options, IProgress progress, CancellationToken cancellationToken) => ComputeOperationsAsync(options, cancellationToken); - protected override Task> ComputeOperationsAsync(CancellationToken cancellationToken) - => SpecializedTasks.EmptyEnumerable(); + protected override async Task> ComputeOperationsAsync(CancellationToken cancellationToken) + => []; } diff --git a/src/Workspaces/Core/Portable/CodeActions/Operations/ApplyChangesOperation.cs b/src/Workspaces/Core/Portable/CodeActions/Operations/ApplyChangesOperation.cs index 472c72ec61d23..59473aa8c9e9c 100644 --- a/src/Workspaces/Core/Portable/CodeActions/Operations/ApplyChangesOperation.cs +++ b/src/Workspaces/Core/Portable/CodeActions/Operations/ApplyChangesOperation.cs @@ -40,8 +40,8 @@ public sealed class ApplyChangesOperation(Solution changedSolution) : CodeAction public override void Apply(Workspace workspace, CancellationToken cancellationToken) => workspace.TryApplyChanges(ChangedSolution, CodeAnalysisProgress.None); - internal sealed override Task TryApplyAsync(Workspace workspace, Solution originalSolution, IProgress progressTracker, CancellationToken cancellationToken) - => Task.FromResult(ApplyOrMergeChanges(workspace, originalSolution, ChangedSolution, progressTracker, cancellationToken)); + internal sealed override async Task TryApplyAsync(Workspace workspace, Solution originalSolution, IProgress progressTracker, CancellationToken cancellationToken) + => ApplyOrMergeChanges(workspace, originalSolution, ChangedSolution, progressTracker, cancellationToken); internal static bool ApplyOrMergeChanges( Workspace workspace, diff --git a/src/Workspaces/Core/Portable/CodeActions/Operations/CodeActionOperation.cs b/src/Workspaces/Core/Portable/CodeActions/Operations/CodeActionOperation.cs index 1b42c22b424e9..cd751e5107a06 100644 --- a/src/Workspaces/Core/Portable/CodeActions/Operations/CodeActionOperation.cs +++ b/src/Workspaces/Core/Portable/CodeActions/Operations/CodeActionOperation.cs @@ -31,12 +31,12 @@ public virtual void Apply(Workspace workspace, CancellationToken cancellationTok /// Called by the host environment to apply the effect of the operation. /// This method is guaranteed to be called on the UI thread. /// - internal virtual Task TryApplyAsync(Workspace workspace, Solution originalSolution, IProgress progressTracker, CancellationToken cancellationToken) + internal virtual async Task TryApplyAsync(Workspace workspace, Solution originalSolution, IProgress progressTracker, CancellationToken cancellationToken) { // It is a requirement that this method be called on the UI thread. So it's safe for us to call // into .Apply without any threading operations here. this.Apply(workspace, cancellationToken); - return SpecializedTasks.True; + return true; } /// diff --git a/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimplificationCodeCleanupProvider.cs b/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimplificationCodeCleanupProvider.cs index ea4943c2ef085..b2b376f1839ff 100644 --- a/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimplificationCodeCleanupProvider.cs +++ b/src/Workspaces/Core/Portable/CodeCleanup/Providers/SimplificationCodeCleanupProvider.cs @@ -19,9 +19,9 @@ internal sealed class SimplificationCodeCleanupProvider : ICodeCleanupProvider public Task CleanupAsync(Document document, ImmutableArray spans, CodeCleanupOptions options, CancellationToken cancellationToken) => Simplifier.ReduceAsync(document, spans, options.SimplifierOptions, cancellationToken); - public Task CleanupAsync(SyntaxNode root, ImmutableArray spans, SyntaxFormattingOptions options, SolutionServices services, CancellationToken cancellationToken) + public async Task CleanupAsync(SyntaxNode root, ImmutableArray spans, SyntaxFormattingOptions options, SolutionServices services, CancellationToken cancellationToken) { // Simplifier doesn't work without semantic information - return Task.FromResult(root); + return root; } } diff --git a/src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/FixAllState.FixMultipleDiagnosticProvider.cs b/src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/FixAllState.FixMultipleDiagnosticProvider.cs index d300d1999f1eb..af06f65d38d4f 100644 --- a/src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/FixAllState.FixMultipleDiagnosticProvider.cs +++ b/src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/FixAllState.FixMultipleDiagnosticProvider.cs @@ -33,7 +33,7 @@ public FixMultipleDiagnosticProvider(ImmutableDictionary>.Empty; } - public override Task> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) + public override async Task> GetAllDiagnosticsAsync(Project project, CancellationToken cancellationToken) { var allDiagnosticsBuilder = ArrayBuilder.GetInstance(); ImmutableArray diagnostics; @@ -53,27 +53,27 @@ public override Task> GetAllDiagnosticsAsync(Project pro allDiagnosticsBuilder.AddRange(diagnostics); } - return Task.FromResult>(allDiagnosticsBuilder.ToImmutableAndFree()); + return allDiagnosticsBuilder.ToImmutableAndFree(); } - public override Task> GetDocumentDiagnosticsAsync(Document document, CancellationToken cancellationToken) + public override async Task> GetDocumentDiagnosticsAsync(Document document, CancellationToken cancellationToken) { if (DocumentDiagnosticsMap.TryGetValue(document, out var diagnostics)) { - return Task.FromResult>(diagnostics); + return diagnostics; } - return SpecializedTasks.EmptyEnumerable(); + return []; } - public override Task> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken) + public override async Task> GetProjectDiagnosticsAsync(Project project, CancellationToken cancellationToken) { if (ProjectDiagnosticsMap.TryGetValue(project, out var diagnostics)) { - return Task.FromResult>(diagnostics); + return diagnostics; } - return SpecializedTasks.EmptyEnumerable(); + return []; } } } diff --git a/src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/NoOpFixAllProvider.cs b/src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/NoOpFixAllProvider.cs index 34003ef3452e4..48536883db552 100644 --- a/src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/NoOpFixAllProvider.cs +++ b/src/Workspaces/Core/Portable/CodeFixes/FixAllOccurrences/NoOpFixAllProvider.cs @@ -22,6 +22,6 @@ private NoOpFixAllProvider() { } - public override Task GetFixAsync(FixAllContext fixAllContext) - => Task.FromResult(null); + public override async Task GetFixAsync(FixAllContext fixAllContext) + => null; } diff --git a/src/Workspaces/Core/Portable/CodeFixesAndRefactorings/DefaultFixAllProviderHelpers.cs b/src/Workspaces/Core/Portable/CodeFixesAndRefactorings/DefaultFixAllProviderHelpers.cs index bd3b899996941..e7ce2878139e0 100644 --- a/src/Workspaces/Core/Portable/CodeFixesAndRefactorings/DefaultFixAllProviderHelpers.cs +++ b/src/Workspaces/Core/Portable/CodeFixesAndRefactorings/DefaultFixAllProviderHelpers.cs @@ -44,7 +44,7 @@ FixAllScope.Document or FixAllScope.ContainingMember or FixAllScope.ContainingTy return null; return CodeAction.Create( - title, (_, _) => Task.FromResult(solution), equivalenceKey: null, CodeActionPriority.Default, fixAllContext.State.FixAllProvider.Cleanup); + title, async (_, _) => solution, equivalenceKey: null, CodeActionPriority.Default, fixAllContext.State.FixAllProvider.Cleanup); } private static Task GetDocumentFixesAsync( diff --git a/src/Workspaces/Core/Portable/Diagnostics/DocumentDiagnosticAnalyzer.cs b/src/Workspaces/Core/Portable/Diagnostics/DocumentDiagnosticAnalyzer.cs index 9cb666d29f30f..72d29750941b4 100644 --- a/src/Workspaces/Core/Portable/Diagnostics/DocumentDiagnosticAnalyzer.cs +++ b/src/Workspaces/Core/Portable/Diagnostics/DocumentDiagnosticAnalyzer.cs @@ -16,11 +16,11 @@ internal abstract class DocumentDiagnosticAnalyzer : DiagnosticAnalyzer { public const int DefaultPriority = 50; - public virtual Task> AnalyzeSyntaxAsync(TextDocument textDocument, SyntaxTree? tree, CancellationToken cancellationToken) - => SpecializedTasks.EmptyImmutableArray(); + public virtual async Task> AnalyzeSyntaxAsync(TextDocument textDocument, SyntaxTree? tree, CancellationToken cancellationToken) + => []; - public virtual Task> AnalyzeSemanticsAsync(TextDocument textDocument, SyntaxTree? tree, CancellationToken cancellationToken) - => SpecializedTasks.EmptyImmutableArray(); + public virtual async Task> AnalyzeSemanticsAsync(TextDocument textDocument, SyntaxTree? tree, CancellationToken cancellationToken) + => []; /// /// it is not allowed one to implement both DocumentDiagnosticAnalyzer and DiagnosticAnalyzer diff --git a/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs b/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs index cbd469cb79047..d5297107104b9 100644 --- a/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs +++ b/src/Workspaces/Core/Portable/Diagnostics/Extensions.cs @@ -349,10 +349,10 @@ public static ImmutableArray Filter( /// This checksum is also affected by the for this project. /// As such, it is not usable across different sessions of a particular host. /// - public static Task GetDiagnosticChecksumAsync(this Project? project, CancellationToken cancellationToken) + public static async Task GetDiagnosticChecksumAsync(this Project? project, CancellationToken cancellationToken) { if (project is null) - return SpecializedTasks.Default(); + return default(Checksum); var lazyChecksum = s_projectToDiagnosticChecksum.GetValue( project, @@ -360,7 +360,7 @@ public static Task GetDiagnosticChecksumAsync(this Project? project, C static (project, cancellationToken) => ComputeDiagnosticChecksumAsync(project, cancellationToken), project)); - return lazyChecksum.GetValueAsync(cancellationToken); + return await lazyChecksum.GetValueAsync(cancellationToken).ConfigureAwait(false); static async Task ComputeDiagnosticChecksumAsync(Project project, CancellationToken cancellationToken) { diff --git a/src/Workspaces/Core/Portable/Editing/SymbolEditor.cs b/src/Workspaces/Core/Portable/Editing/SymbolEditor.cs index 3fc98f00b8f0b..9ca9c86b72177 100644 --- a/src/Workspaces/Core/Portable/Editing/SymbolEditor.cs +++ b/src/Workspaces/Core/Portable/Editing/SymbolEditor.cs @@ -260,10 +260,9 @@ public Task EditOneDeclarationAsync( { return this.EditOneDeclarationAsync( symbol, - (e, d, c) => + async (e, d, c) => { editAction(e, d); - return Task.CompletedTask; }, cancellationToken); } @@ -351,10 +350,9 @@ public Task EditOneDeclarationAsync( return this.EditOneDeclarationAsync( symbol, location, - (e, d, c) => + async (e, d, c) => { editAction(e, d); - return Task.CompletedTask; }, cancellationToken); } @@ -434,10 +432,9 @@ public Task EditOneDeclarationAsync( return this.EditOneDeclarationAsync( symbol, member, - (e, d, c) => + async (e, d, c) => { editAction(e, d); - return Task.CompletedTask; }, cancellationToken); } @@ -515,10 +512,9 @@ public Task EditAllDeclarationsAsync( { return this.EditAllDeclarationsAsync( symbol, - (e, d, c) => + async (e, d, c) => { editAction(e, d); - return Task.CompletedTask; }, cancellationToken); } diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder_DerivedClasses.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder_DerivedClasses.cs index 0d14dd1197a7d..1c6e4e1d355b1 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder_DerivedClasses.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder_DerivedClasses.cs @@ -12,7 +12,7 @@ namespace Microsoft.CodeAnalysis.FindSymbols; internal static partial class DependentTypeFinder { - private static Task> FindDerivedClassesInCurrentProcessAsync( + private static async Task> FindDerivedClassesInCurrentProcessAsync( INamedTypeSymbol type, Solution solution, IImmutableSet? projects, @@ -24,13 +24,13 @@ private static Task> FindDerivedClassesInCurren static bool TypeMatches(INamedTypeSymbol type, HashSet set) => TypeHasBaseTypeInSet(type, set); - return DescendInheritanceTreeAsync(type, solution, projects, + return await DescendInheritanceTreeAsync(type, solution, projects, typeMatches: TypeMatches, shouldContinueSearching: s_isNonSealedClass, transitive: transitive, - cancellationToken: cancellationToken); + cancellationToken: cancellationToken).ConfigureAwait(false); } - return SpecializedTasks.EmptyImmutableArray(); + return []; } } diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder_DerivedInterfaces.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder_DerivedInterfaces.cs index 40e155a7d09b2..eb62c6c38c171 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder_DerivedInterfaces.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/DependentTypeFinder_DerivedInterfaces.cs @@ -12,7 +12,7 @@ namespace Microsoft.CodeAnalysis.FindSymbols; internal static partial class DependentTypeFinder { - private static Task> FindDerivedInterfacesInCurrentProcessAsync( + private static async Task> FindDerivedInterfacesInCurrentProcessAsync( INamedTypeSymbol type, Solution solution, IImmutableSet? projects, @@ -25,13 +25,13 @@ private static Task> FindDerivedInterfacesInCur static bool TypeMatches(INamedTypeSymbol type, HashSet set) => s_isInterface(type) && TypeHasInterfaceInSet(type, set); - return DescendInheritanceTreeAsync(type, solution, projects, + return await DescendInheritanceTreeAsync(type, solution, projects, typeMatches: TypeMatches, shouldContinueSearching: s_isInterface, transitive: transitive, - cancellationToken: cancellationToken); + cancellationToken: cancellationToken).ConfigureAwait(false); } - return SpecializedTasks.EmptyImmutableArray(); + return []; } } diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.NonCascadingSymbolSet.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.NonCascadingSymbolSet.cs index 90189a63e9875..051f3e148c990 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.NonCascadingSymbolSet.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.NonCascadingSymbolSet.cs @@ -21,11 +21,10 @@ private sealed class NonCascadingSymbolSet(FindReferencesSearchEngine engine, Me public override ImmutableArray GetAllSymbols() => _symbols; - public override Task InheritanceCascadeAsync(Project project, CancellationToken cancellationToken) + public override async Task InheritanceCascadeAsync(Project project, CancellationToken cancellationToken) { // Nothing to do here. We're in a non-cascading scenario, so even as we encounter a new project we // don't have to figure out what new symbols may be found. - return Task.CompletedTask; } } } diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.cs index 9fda34d3981d9..2c02f5b714830 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine.cs @@ -301,7 +301,7 @@ private async ValueTask ProcessDocumentAsync( await Parallel.ForEachAsync( symbolsToSearchFor, GetParallelOptions(cancellationToken), - (kvp, cancellationToken) => + async (kvp, cancellationToken) => { var (symbolToSearchFor, symbolGroup) = kvp; @@ -311,7 +311,6 @@ await Parallel.ForEachAsync( cache, TryGet(symbolToGlobalAliases, symbolToSearchFor)); ProcessDocument(symbolToSearchFor, symbolGroup, state, onReferenceFound); - return ValueTask.CompletedTask; }).ConfigureAwait(false); return; diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_FindReferencesInDocuments.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_FindReferencesInDocuments.cs index 28bdfeecea888..12a3dd0c7f171 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_FindReferencesInDocuments.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/FindReferencesSearchEngine_FindReferencesInDocuments.cs @@ -134,7 +134,7 @@ async ValueTask DirectSymbolSearchAsync(ISymbol symbol, SymbolGroup group, FindR { await ProducerConsumer.RunAsync( ProducerConsumerOptions.SingleReaderWriterOptions, - static (callback, args, cancellationToken) => + static async (callback, args, cancellationToken) => { var (@this, symbol, group, state) = args; @@ -148,8 +148,6 @@ await ProducerConsumer.RunAsync( static (finderLocation, callback) => callback(finderLocation), callback, @this._options, cancellationToken); } - - return Task.CompletedTask; }, consumeItems: static async (values, args, cancellationToken) => { diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractMemberScopedReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractMemberScopedReferenceFinder.cs index 1c194904c1ca4..cdddde2c58f9e 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractMemberScopedReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractMemberScopedReferenceFinder.cs @@ -24,7 +24,7 @@ protected abstract bool TokensMatch( protected sealed override bool CanFind(TSymbol symbol) => true; - protected sealed override Task DetermineDocumentsToSearchAsync( + protected sealed override async Task DetermineDocumentsToSearchAsync( TSymbol symbol, HashSet? globalAliases, Project project, @@ -36,17 +36,16 @@ protected sealed override Task DetermineDocumentsToSearchAsync( { var location = symbol.Locations.FirstOrDefault(); if (location == null || !location.IsInSource) - return Task.CompletedTask; + return; var document = project.GetDocument(location.SourceTree); if (document == null) - return Task.CompletedTask; + return; if (documents != null && !documents.Contains(document)) - return Task.CompletedTask; + return; processResult(document, processResultData); - return Task.CompletedTask; } protected sealed override void FindReferencesInDocument( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs index fcc624121fa30..87619f7d9a253 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AbstractReferenceFinder.cs @@ -144,7 +144,7 @@ protected static Task FindDocumentsWithGlobalSuppressMessageAttributeAsync index.ContainsGlobalSuppressMessageAttribute, processResult, processResultData, cancellationToken); } - protected static Task FindDocumentsAsync( + protected static async Task FindDocumentsAsync( Project project, IImmutableSet? documents, PredefinedType predefinedType, @@ -153,10 +153,10 @@ protected static Task FindDocumentsAsync( CancellationToken cancellationToken) { if (predefinedType == PredefinedType.None) - return Task.CompletedTask; + return; - return FindDocumentsWithPredicateAsync( - project, documents, static (index, predefinedType) => index.ContainsPredefinedType(predefinedType), predefinedType, processResult, processResultData, cancellationToken); + await FindDocumentsWithPredicateAsync( + project, documents, static (index, predefinedType) => index.ContainsPredefinedType(predefinedType), predefinedType, processResult, processResultData, cancellationToken).ConfigureAwait(false); } protected static bool IdentifiersMatch(ISyntaxFactsService syntaxFacts, string name, SyntaxToken token) @@ -666,10 +666,10 @@ protected abstract void FindReferencesInDocument( Action processResult, TData processResultData, FindReferencesSearchOptions options, CancellationToken cancellationToken); - protected virtual Task> DetermineGlobalAliasesAsync( + protected virtual async Task> DetermineGlobalAliasesAsync( TSymbol symbol, Project project, CancellationToken cancellationToken) { - return SpecializedTasks.EmptyImmutableArray(); + return []; } public sealed override Task> DetermineGlobalAliasesAsync( @@ -680,15 +680,13 @@ public sealed override Task> DetermineGlobalAliasesAsync( : SpecializedTasks.EmptyImmutableArray(); } - public sealed override Task DetermineDocumentsToSearchAsync( + public sealed override async Task DetermineDocumentsToSearchAsync( ISymbol symbol, HashSet? globalAliases, Project project, IImmutableSet? documents, Action processResult, TData processResultData, FindReferencesSearchOptions options, CancellationToken cancellationToken) { if (symbol is TSymbol typedSymbol && CanFind(typedSymbol)) - return DetermineDocumentsToSearchAsync(typedSymbol, globalAliases, project, documents, processResult, processResultData, options, cancellationToken); - - return Task.CompletedTask; + await DetermineDocumentsToSearchAsync(typedSymbol, globalAliases, project, documents, processResult, processResultData, options, cancellationToken).ConfigureAwait(false); } public sealed override void FindReferencesInDocument( @@ -698,23 +696,23 @@ public sealed override void FindReferencesInDocument( FindReferencesInDocument(typedSymbol, state, processResult, processResultData, options, cancellationToken); } - public sealed override ValueTask> DetermineCascadedSymbolsAsync( + public sealed override async ValueTask> DetermineCascadedSymbolsAsync( ISymbol symbol, Solution solution, FindReferencesSearchOptions options, CancellationToken cancellationToken) { if (options.Cascade && symbol is TSymbol typedSymbol && CanFind(typedSymbol)) { - return DetermineCascadedSymbolsAsync(typedSymbol, solution, options, cancellationToken); + return await DetermineCascadedSymbolsAsync(typedSymbol, solution, options, cancellationToken).ConfigureAwait(false); } - return new([]); + return []; } - protected virtual ValueTask> DetermineCascadedSymbolsAsync( + protected virtual async ValueTask> DetermineCascadedSymbolsAsync( TSymbol symbol, Solution solution, FindReferencesSearchOptions options, CancellationToken cancellationToken) { - return new([]); + return []; } protected static void FindReferencesInDocumentUsingSymbolName( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AliasSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AliasSymbolReferenceFinder.cs index 5acaa790afd3d..201318e2717e8 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AliasSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/AliasSymbolReferenceFinder.cs @@ -21,7 +21,7 @@ private AliasSymbolReferenceFinder() protected override bool CanFind(IAliasSymbol symbol) => true; - protected override Task DetermineDocumentsToSearchAsync( + protected override async Task DetermineDocumentsToSearchAsync( IAliasSymbol symbol, HashSet? globalAliases, Project project, @@ -37,8 +37,6 @@ protected override Task DetermineDocumentsToSearchAsync( if (document?.Project == project) processResult(document, processResultData); } - - return Task.CompletedTask; } protected override void FindReferencesInDocument( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ConstructorSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ConstructorSymbolReferenceFinder.cs index 574fdca8ab760..349e83213f182 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ConstructorSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ConstructorSymbolReferenceFinder.cs @@ -25,12 +25,12 @@ private ConstructorSymbolReferenceFinder() protected override bool CanFind(IMethodSymbol symbol) => symbol.MethodKind is MethodKind.Constructor or MethodKind.StaticConstructor; - protected override ValueTask> DetermineCascadedSymbolsAsync(IMethodSymbol symbol, Solution solution, FindReferencesSearchOptions options, CancellationToken cancellationToken) + protected override async ValueTask> DetermineCascadedSymbolsAsync(IMethodSymbol symbol, Solution solution, FindReferencesSearchOptions options, CancellationToken cancellationToken) { if (symbol.MethodKind is MethodKind.Constructor) - return new(GetOtherPartsOfPartial(symbol)); + return GetOtherPartsOfPartial(symbol); - return new([]); + return []; } private static ImmutableArray GetOtherPartsOfPartial(IMethodSymbol symbol) diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/CrefTypeParameterSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/CrefTypeParameterSymbolReferenceFinder.cs index da5c9354a7339..56e2b563e08b9 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/CrefTypeParameterSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/CrefTypeParameterSymbolReferenceFinder.cs @@ -24,7 +24,7 @@ private CrefTypeParameterSymbolReferenceFinder() protected override bool CanFind(ITypeParameterSymbol symbol) => symbol.TypeParameterKind == TypeParameterKind.Cref; - protected override Task DetermineDocumentsToSearchAsync( + protected override async Task DetermineDocumentsToSearchAsync( ITypeParameterSymbol symbol, HashSet? globalAliases, Project project, @@ -40,8 +40,6 @@ protected override Task DetermineDocumentsToSearchAsync( if (document != null) processResult(document, processResultData); } - - return Task.CompletedTask; } protected override void FindReferencesInDocument( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/DestructorSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/DestructorSymbolReferenceFinder.cs index 35741d81ce547..953b3ac880336 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/DestructorSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/DestructorSymbolReferenceFinder.cs @@ -15,7 +15,7 @@ internal sealed class DestructorSymbolReferenceFinder : AbstractReferenceFinder< protected override bool CanFind(IMethodSymbol symbol) => symbol.MethodKind == MethodKind.Destructor; - protected override Task DetermineDocumentsToSearchAsync( + protected override async Task DetermineDocumentsToSearchAsync( IMethodSymbol symbol, HashSet? globalAliases, Project project, @@ -25,7 +25,6 @@ protected override Task DetermineDocumentsToSearchAsync( FindReferencesSearchOptions options, CancellationToken cancellationToken) { - return Task.CompletedTask; } protected override void FindReferencesInDocument( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/EventSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/EventSymbolReferenceFinder.cs index 611c8a6476e0b..2c511322fe574 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/EventSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/EventSymbolReferenceFinder.cs @@ -17,7 +17,7 @@ internal sealed class EventSymbolReferenceFinder : AbstractMethodOrPropertyOrEve protected override bool CanFind(IEventSymbol symbol) => true; - protected sealed override ValueTask> DetermineCascadedSymbolsAsync( + protected sealed override async ValueTask> DetermineCascadedSymbolsAsync( IEventSymbol symbol, Solution solution, FindReferencesSearchOptions options, @@ -32,7 +32,7 @@ protected sealed override ValueTask> DetermineCascadedSy .WhereAsArray(n => symbol.Equals(n.AssociatedSymbol)) .CastArray(); - return new([.. GetOtherPartsOfPartial(symbol), .. backingFields, .. associatedNamedTypes]); + return [.. GetOtherPartsOfPartial(symbol), .. backingFields, .. associatedNamedTypes]; } private static ImmutableArray GetOtherPartsOfPartial(IEventSymbol symbol) diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ExplicitInterfaceMethodReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ExplicitInterfaceMethodReferenceFinder.cs index 888729ebfd1a7..d8e14c0435b7f 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ExplicitInterfaceMethodReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/ExplicitInterfaceMethodReferenceFinder.cs @@ -15,7 +15,7 @@ internal sealed class ExplicitInterfaceMethodReferenceFinder : AbstractReference protected override bool CanFind(IMethodSymbol symbol) => symbol.MethodKind == MethodKind.ExplicitInterfaceImplementation; - protected sealed override Task DetermineDocumentsToSearchAsync( + protected sealed override async Task DetermineDocumentsToSearchAsync( IMethodSymbol symbol, HashSet? globalAliases, Project project, @@ -26,7 +26,6 @@ protected sealed override Task DetermineDocumentsToSearchAsync( CancellationToken cancellationToken) { // An explicit method can't be referenced anywhere. - return Task.CompletedTask; } protected sealed override void FindReferencesInDocument( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs index f929bc1c580d6..eb22c3ce7316c 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/MethodTypeParameterSymbolReferenceFinder.cs @@ -23,7 +23,7 @@ private MethodTypeParameterSymbolReferenceFinder() protected override bool CanFind(ITypeParameterSymbol symbol) => symbol.TypeParameterKind == TypeParameterKind.Method; - protected override ValueTask> DetermineCascadedSymbolsAsync( + protected override async ValueTask> DetermineCascadedSymbolsAsync( ITypeParameterSymbol symbol, Solution solution, FindReferencesSearchOptions options, @@ -35,13 +35,13 @@ protected override ValueTask> DetermineCascadedSymbolsAs if (ordinal >= 0) { if (method.PartialDefinitionPart != null && ordinal < method.PartialDefinitionPart.TypeParameters.Length) - return new([method.PartialDefinitionPart.TypeParameters[ordinal]]); + return [method.PartialDefinitionPart.TypeParameters[ordinal]]; if (method.PartialImplementationPart != null && ordinal < method.PartialImplementationPart.TypeParameters.Length) - return new([method.PartialImplementationPart.TypeParameters[ordinal]]); + return [method.PartialImplementationPart.TypeParameters[ordinal]]; } - return new([]); + return []; } protected sealed override Task DetermineDocumentsToSearchAsync( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamedTypeSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamedTypeSymbolReferenceFinder.cs index e94f628cce45d..b68b2fd47e894 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamedTypeSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/NamedTypeSymbolReferenceFinder.cs @@ -25,7 +25,7 @@ protected override Task> DetermineGlobalAliasesAsync(INam return GetAllMatchingGlobalAliasNamesAsync(project, symbol.Name, symbol.Arity, cancellationToken); } - protected override ValueTask> DetermineCascadedSymbolsAsync( + protected override async ValueTask> DetermineCascadedSymbolsAsync( INamedTypeSymbol symbol, Solution solution, FindReferencesSearchOptions options, @@ -42,7 +42,7 @@ protected override ValueTask> DetermineCascadedSymbolsAs // cascade to destructor Add(result, symbol.GetMembers(WellKnownMemberNames.DestructorName)); - return new(result.ToImmutable()); + return result.ToImmutable(); } private static void Add(ArrayBuilder result, ImmutableArray enumerable) where TSymbol : ISymbol diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OperatorSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OperatorSymbolReferenceFinder.cs index a7ec78f9f8280..41c8a1721779c 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OperatorSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OperatorSymbolReferenceFinder.cs @@ -33,7 +33,7 @@ protected sealed override async Task DetermineDocumentsToSearchAsync( await FindDocumentsWithGlobalSuppressMessageAttributeAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); } - private static Task FindDocumentsAsync( + private static async Task FindDocumentsAsync( Project project, IImmutableSet? documents, PredefinedOperator op, @@ -42,10 +42,10 @@ private static Task FindDocumentsAsync( CancellationToken cancellationToken) { if (op == PredefinedOperator.None) - return Task.CompletedTask; + return; - return FindDocumentsWithPredicateAsync( - project, documents, static (index, op) => index.ContainsPredefinedOperator(op), op, processResult, processResultData, cancellationToken); + await FindDocumentsWithPredicateAsync( + project, documents, static (index, op) => index.ContainsPredefinedOperator(op), op, processResult, processResultData, cancellationToken).ConfigureAwait(false); } protected sealed override void FindReferencesInDocument( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OrdinaryMethodReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OrdinaryMethodReferenceFinder.cs index 6c65d0a37a15d..088312654b994 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OrdinaryMethodReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/OrdinaryMethodReferenceFinder.cs @@ -21,7 +21,7 @@ MethodKind.DeclareMethod or MethodKind.ReducedExtension or MethodKind.LocalFunction; - protected override ValueTask> DetermineCascadedSymbolsAsync( + protected override async ValueTask> DetermineCascadedSymbolsAsync( IMethodSymbol symbol, Solution solution, FindReferencesSearchOptions options, @@ -30,7 +30,7 @@ protected override ValueTask> DetermineCascadedSymbolsAs // If it's a delegate method, then cascade to the type as well. These guys are // practically equivalent for users. if (symbol.ContainingType.TypeKind == TypeKind.Delegate) - return new([symbol.ContainingType]); + return [symbol.ContainingType]; using var _ = ArrayBuilder.GetInstance(out var result); @@ -43,7 +43,7 @@ protected override ValueTask> DetermineCascadedSymbolsAs if (symbol.TryGetCorrespondingExtensionBlockMethod() is IMethodSymbol method) result.Add(method); - return new(result.ToImmutableAndClear()); + return result.ToImmutableAndClear(); } private static ImmutableArray GetOtherPartsOfPartial(IMethodSymbol symbol) diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertyAccessorSymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertyAccessorSymbolReferenceFinder.cs index 3799f7231bfaa..7bcc55d8e1cef 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertyAccessorSymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertyAccessorSymbolReferenceFinder.cs @@ -17,7 +17,7 @@ internal sealed class PropertyAccessorSymbolReferenceFinder : AbstractMethodOrPr protected override bool CanFind(IMethodSymbol symbol) => symbol.MethodKind.IsPropertyAccessor(); - protected override ValueTask> DetermineCascadedSymbolsAsync( + protected override async ValueTask> DetermineCascadedSymbolsAsync( IMethodSymbol symbol, Solution solution, FindReferencesSearchOptions options, @@ -33,7 +33,7 @@ protected override ValueTask> DetermineCascadedSymbolsAs // If the given symbol is an extension accessor, cascade to its implementation method result.AddIfNotNull(symbol.AssociatedExtensionImplementation); - return new(result.ToImmutableAndClear()); + return result.ToImmutableAndClear(); } protected override async Task DetermineDocumentsToSearchAsync( diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertySymbolReferenceFinder.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertySymbolReferenceFinder.cs index 1132babf80056..a453c554d724b 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertySymbolReferenceFinder.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/Finders/PropertySymbolReferenceFinder.cs @@ -27,7 +27,7 @@ private PropertySymbolReferenceFinder() protected override bool CanFind(IPropertySymbol symbol) => true; - protected override ValueTask> DetermineCascadedSymbolsAsync( + protected override async ValueTask> DetermineCascadedSymbolsAsync( IPropertySymbol symbol, Solution solution, FindReferencesSearchOptions options, @@ -40,7 +40,7 @@ protected override ValueTask> DetermineCascadedSymbolsAs CascadeToAccessors(symbol, result); CascadeToPrimaryConstructorParameters(symbol, result, cancellationToken); - return new(result.ToImmutable()); + return result.ToImmutable(); } private static void CascadeToOtherPartOfPartial(IPropertySymbol symbol, ArrayBuilder result) diff --git a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/StreamingFindReferencesProgress.cs b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/StreamingFindReferencesProgress.cs index 6e9c6f8336976..fc5e3c0528103 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/FindReferences/StreamingFindReferencesProgress.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/FindReferences/StreamingFindReferencesProgress.cs @@ -25,27 +25,23 @@ internal sealed class StreamingFindReferencesProgressAdapter : IStreamingFindRef public StreamingFindReferencesProgressAdapter(IFindReferencesProgress progress) { _progress = progress; - ProgressTracker = new StreamingProgressTracker((current, max, ct) => + ProgressTracker = new StreamingProgressTracker(async (current, max, ct) => { _progress.ReportProgress(current, max); - return default; }); } - public ValueTask OnCompletedAsync(CancellationToken cancellationToken) + public async ValueTask OnCompletedAsync(CancellationToken cancellationToken) { _progress.OnCompleted(); - return default; } - public ValueTask OnDefinitionFoundAsync(SymbolGroup group, CancellationToken cancellationToken) + public async ValueTask OnDefinitionFoundAsync(SymbolGroup group, CancellationToken cancellationToken) { try { foreach (var symbol in group.Symbols) _progress.OnDefinitionFound(symbol); - - return default; } catch (Exception ex) when (FatalError.ReportAndPropagateUnlessCanceled(ex, cancellationToken)) { @@ -53,17 +49,14 @@ public ValueTask OnDefinitionFoundAsync(SymbolGroup group, CancellationToken can } } - public ValueTask OnReferencesFoundAsync(ImmutableArray<(SymbolGroup group, ISymbol symbol, ReferenceLocation location)> references, CancellationToken cancellationToken) + public async ValueTask OnReferencesFoundAsync(ImmutableArray<(SymbolGroup group, ISymbol symbol, ReferenceLocation location)> references, CancellationToken cancellationToken) { foreach (var (_, symbol, location) in references) _progress.OnReferenceFound(symbol, location); - - return ValueTask.CompletedTask; } - public ValueTask OnStartedAsync(CancellationToken cancellationToken) + public async ValueTask OnStartedAsync(CancellationToken cancellationToken) { _progress.OnStarted(); - return default; } } diff --git a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs index 408f0f9923ce7..5b1af0e92999b 100644 --- a/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs +++ b/src/Workspaces/Core/Portable/FindSymbols/SymbolTree/SymbolTreeInfo_Metadata.cs @@ -183,7 +183,7 @@ static async Task CreateMetadataSymbolTreeInfoAsync( arg.services, arg.solutionKey, arg.checksum, - createAsync: checksum => new ValueTask(new MetadataInfoCreator(checksum, GetMetadataNoThrow(arg.reference)).Create()), + createAsync: async checksum => new MetadataInfoCreator(checksum, GetMetadataNoThrow(arg.reference)).Create(), keySuffix: GetMetadataKeySuffix(arg.reference), cancellationToken), arg: (services, solutionKey, checksum, reference))); diff --git a/src/Workspaces/Core/Portable/Recommendations/Recommender.cs b/src/Workspaces/Core/Portable/Recommendations/Recommender.cs index fd8919d2a13d1..7a24a397850f5 100644 --- a/src/Workspaces/Core/Portable/Recommendations/Recommender.cs +++ b/src/Workspaces/Core/Portable/Recommendations/Recommender.cs @@ -32,14 +32,14 @@ public static IEnumerable GetRecommendedSymbolsAtPosition( } [Obsolete("Use GetRecommendedSymbolsAtPositionAsync(Document, ...)")] - public static Task> GetRecommendedSymbolsAtPositionAsync( + public static async Task> GetRecommendedSymbolsAtPositionAsync( SemanticModel semanticModel, int position, Workspace workspace, OptionSet? options = null, CancellationToken cancellationToken = default) { - return Task.FromResult(GetRecommendedSymbolsAtPosition(semanticModel, position, workspace, options, cancellationToken)); + return GetRecommendedSymbolsAtPosition(semanticModel, position, workspace, options, cancellationToken); } public static async Task> GetRecommendedSymbolsAtPositionAsync( diff --git a/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorageService.cs b/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorageService.cs index c17666916d22d..d4884dafbad74 100644 --- a/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorageService.cs +++ b/src/Workspaces/Core/Portable/Storage/SQLite/v2/SQLitePersistentStorageService.cs @@ -64,23 +64,23 @@ protected override string GetDatabaseFilePath(string workingFolderPath) return Path.Combine(workingFolderPath, StorageExtension, nameof(v2), PersistentStorageFileName); } - protected override ValueTask TryOpenDatabaseAsync( + protected override async ValueTask TryOpenDatabaseAsync( SolutionKey solutionKey, string workingFolderPath, string databaseFilePath, IPersistentStorageFaultInjector? faultInjector, CancellationToken cancellationToken) { if (!TryInitializeLibraries()) { // SQLite is not supported on the current platform - return new((IChecksummedPersistentStorage?)null); + return null; } if (solutionKey.FilePath == null) - return new(NoOpPersistentStorage.GetOrThrow(solutionKey, Configuration.ThrowOnFailure)); + return NoOpPersistentStorage.GetOrThrow(solutionKey, Configuration.ThrowOnFailure); - return new(SQLitePersistentStorage.TryCreate( + return SQLitePersistentStorage.TryCreate( solutionKey, workingFolderPath, databaseFilePath, asyncListener, - faultInjector)); + faultInjector); } } diff --git a/src/Workspaces/Core/Portable/SymbolSearch/ISymbolSearchService.cs b/src/Workspaces/Core/Portable/SymbolSearch/ISymbolSearchService.cs index 45337f28d766e..211d88014e0d9 100644 --- a/src/Workspaces/Core/Portable/SymbolSearch/ISymbolSearchService.cs +++ b/src/Workspaces/Core/Portable/SymbolSearch/ISymbolSearchService.cs @@ -155,12 +155,12 @@ internal sealed class ReferenceAssemblyResult( [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] internal sealed class DefaultSymbolSearchService() : ISymbolSearchService { - public ValueTask> FindPackagesAsync(string source, TypeQuery typeQuery, NamespaceQuery namespaceQuery, CancellationToken cancellationToken) - => ValueTask.FromResult(ImmutableArray.Empty); + public async ValueTask> FindPackagesAsync(string source, TypeQuery typeQuery, NamespaceQuery namespaceQuery, CancellationToken cancellationToken) + => ImmutableArray.Empty; - public ValueTask> FindPackagesWithAssemblyAsync(string source, string assemblyName, CancellationToken cancellationToken) - => ValueTask.FromResult(ImmutableArray.Empty); + public async ValueTask> FindPackagesWithAssemblyAsync(string source, string assemblyName, CancellationToken cancellationToken) + => ImmutableArray.Empty; - public ValueTask> FindReferenceAssembliesAsync(TypeQuery typeQuery, NamespaceQuery namespaceQuery, CancellationToken cancellationToken) - => ValueTask.FromResult(ImmutableArray.Empty); + public async ValueTask> FindReferenceAssembliesAsync(TypeQuery typeQuery, NamespaceQuery namespaceQuery, CancellationToken cancellationToken) + => ImmutableArray.Empty; } diff --git a/src/Workspaces/Core/Portable/TemporaryStorage/TrivialTemporaryStorageService.cs b/src/Workspaces/Core/Portable/TemporaryStorage/TrivialTemporaryStorageService.cs index cc0f48a32e732..7c4381c1e6d7d 100644 --- a/src/Workspaces/Core/Portable/TemporaryStorage/TrivialTemporaryStorageService.cs +++ b/src/Workspaces/Core/Portable/TemporaryStorage/TrivialTemporaryStorageService.cs @@ -32,9 +32,9 @@ public ITemporaryStorageTextHandle WriteToTemporaryStorage(SourceText text, Canc return new TextStorage(text); } - public Task WriteToTemporaryStorageAsync(SourceText text, CancellationToken cancellationToken) + public async Task WriteToTemporaryStorageAsync(SourceText text, CancellationToken cancellationToken) { - return Task.FromResult(new TextStorage(text)); + return new TextStorage(text); } private sealed class StreamStorage : ITemporaryStorageStreamHandle @@ -74,9 +74,9 @@ public SourceText ReadFromTemporaryStorage(CancellationToken cancellationToken) return _sourceText; } - public Task ReadFromTemporaryStorageAsync(CancellationToken cancellationToken) + public async Task ReadFromTemporaryStorageAsync(CancellationToken cancellationToken) { - return Task.FromResult(_sourceText); + return _sourceText; } } } diff --git a/src/Workspaces/Core/Portable/Workspace/Host/DocumentService/DocumentExcerptHelper.cs b/src/Workspaces/Core/Portable/Workspace/Host/DocumentService/DocumentExcerptHelper.cs index b409b22a479fc..8497e7a584f49 100644 --- a/src/Workspaces/Core/Portable/Workspace/Host/DocumentService/DocumentExcerptHelper.cs +++ b/src/Workspaces/Core/Portable/Workspace/Host/DocumentService/DocumentExcerptHelper.cs @@ -23,20 +23,20 @@ public static bool CanExcerpt(Document document) return document.DocumentServiceProvider.GetService() is not null; } - public static Task TryExcerptAsync(Document document, TextSpan span, ExcerptMode mode, ClassificationOptions classificationOptions, CancellationToken cancellationToken) + public static async Task TryExcerptAsync(Document document, TextSpan span, ExcerptMode mode, ClassificationOptions classificationOptions, CancellationToken cancellationToken) { if (document is SourceGeneratedDocument sourceGeneratedDocument && document.Project.Solution.Services.GetService() is { } sourceGeneratedExcerptService) { - return sourceGeneratedExcerptService.TryExcerptAsync(sourceGeneratedDocument, span, mode, classificationOptions, cancellationToken); + return await sourceGeneratedExcerptService.TryExcerptAsync(sourceGeneratedDocument, span, mode, classificationOptions, cancellationToken).ConfigureAwait(false); } var excerptService = document.DocumentServiceProvider.GetService(); if (excerptService == null) { - return SpecializedTasks.Default(); + return null; } - return excerptService.TryExcerptAsync(document, span, mode, classificationOptions, cancellationToken); + return await excerptService.TryExcerptAsync(document, span, mode, classificationOptions, cancellationToken).ConfigureAwait(false); } } diff --git a/src/Workspaces/Core/Portable/Workspace/Host/PersistentStorage/NoOpPersistentStorage.cs b/src/Workspaces/Core/Portable/Workspace/Host/PersistentStorage/NoOpPersistentStorage.cs index 0af8e93ab5b28..123d9bf2315f6 100644 --- a/src/Workspaces/Core/Portable/Workspace/Host/PersistentStorage/NoOpPersistentStorage.cs +++ b/src/Workspaces/Core/Portable/Workspace/Host/PersistentStorage/NoOpPersistentStorage.cs @@ -20,68 +20,68 @@ public static IChecksummedPersistentStorage GetOrThrow(SolutionKey solutionKey, ? throw new InvalidOperationException("Database was not supported") : new NoOpPersistentStorage(solutionKey); - public Task ChecksumMatchesAsync(string name, Checksum checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task ChecksumMatchesAsync(string name, Checksum checksum, CancellationToken cancellationToken) + => false; - public Task ChecksumMatchesAsync(Project project, string name, Checksum checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task ChecksumMatchesAsync(Project project, string name, Checksum checksum, CancellationToken cancellationToken) + => false; - public Task ChecksumMatchesAsync(Document document, string name, Checksum checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task ChecksumMatchesAsync(Document document, string name, Checksum checksum, CancellationToken cancellationToken) + => false; - public Task ChecksumMatchesAsync(ProjectKey project, string name, Checksum checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task ChecksumMatchesAsync(ProjectKey project, string name, Checksum checksum, CancellationToken cancellationToken) + => false; - public Task ChecksumMatchesAsync(DocumentKey document, string name, Checksum checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task ChecksumMatchesAsync(DocumentKey document, string name, Checksum checksum, CancellationToken cancellationToken) + => false; - public Task ReadStreamAsync(Document document, string name, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task ReadStreamAsync(Document document, string name, CancellationToken cancellationToken) + => null; - public Task ReadStreamAsync(Project project, string name, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task ReadStreamAsync(Project project, string name, CancellationToken cancellationToken) + => null; - public Task ReadStreamAsync(string name, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task ReadStreamAsync(string name, CancellationToken cancellationToken) + => null; - public Task ReadStreamAsync(string name, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task ReadStreamAsync(string name, Checksum? checksum, CancellationToken cancellationToken) + => null; - public Task ReadStreamAsync(Project project, string name, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task ReadStreamAsync(Project project, string name, Checksum? checksum, CancellationToken cancellationToken) + => null; - public Task ReadStreamAsync(Document document, string name, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task ReadStreamAsync(Document document, string name, Checksum? checksum, CancellationToken cancellationToken) + => null; - public Task ReadStreamAsync(ProjectKey project, string name, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task ReadStreamAsync(ProjectKey project, string name, Checksum? checksum, CancellationToken cancellationToken) + => null; - public Task ReadStreamAsync(DocumentKey document, string name, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task ReadStreamAsync(DocumentKey document, string name, Checksum? checksum, CancellationToken cancellationToken) + => null; - public Task WriteStreamAsync(Document document, string name, Stream stream, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task WriteStreamAsync(Document document, string name, Stream stream, CancellationToken cancellationToken) + => false; - public Task WriteStreamAsync(Project project, string name, Stream stream, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task WriteStreamAsync(Project project, string name, Stream stream, CancellationToken cancellationToken) + => false; - public Task WriteStreamAsync(string name, Stream stream, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task WriteStreamAsync(string name, Stream stream, CancellationToken cancellationToken) + => false; - public Task WriteStreamAsync(string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task WriteStreamAsync(string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) + => false; - public Task WriteStreamAsync(Project project, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task WriteStreamAsync(Project project, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) + => false; - public Task WriteStreamAsync(Document document, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task WriteStreamAsync(Document document, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) + => false; - public Task WriteStreamAsync(ProjectKey projectKey, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task WriteStreamAsync(ProjectKey projectKey, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) + => false; - public Task WriteStreamAsync(DocumentKey documentKey, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) - => SpecializedTasks.False; + public async Task WriteStreamAsync(DocumentKey documentKey, string name, Stream stream, Checksum? checksum, CancellationToken cancellationToken) + => false; public readonly struct TestAccessor { diff --git a/src/Workspaces/Core/Portable/Workspace/Host/PersistentStorage/NoOpPersistentStorageService.cs b/src/Workspaces/Core/Portable/Workspace/Host/PersistentStorage/NoOpPersistentStorageService.cs index 5f5bc076f5df3..1b14a15cf1c4f 100644 --- a/src/Workspaces/Core/Portable/Workspace/Host/PersistentStorage/NoOpPersistentStorageService.cs +++ b/src/Workspaces/Core/Portable/Workspace/Host/PersistentStorage/NoOpPersistentStorageService.cs @@ -22,6 +22,6 @@ public static IChecksummedPersistentStorageService GetOrThrow(IPersistentStorage ? throw new InvalidOperationException("Database was not supported") : Instance; - public ValueTask GetStorageAsync(SolutionKey solutionKey, CancellationToken cancellationToken) - => new(NoOpPersistentStorage.GetOrThrow(solutionKey, throwOnFailure: false)); + public async ValueTask GetStorageAsync(SolutionKey solutionKey, CancellationToken cancellationToken) + => NoOpPersistentStorage.GetOrThrow(solutionKey, throwOnFailure: false); } diff --git a/src/Workspaces/Core/Portable/Workspace/Host/TemporaryStorage/LegacyTemporaryStorageService.cs b/src/Workspaces/Core/Portable/Workspace/Host/TemporaryStorage/LegacyTemporaryStorageService.cs index a4e011da48238..9a3fc38b5f180 100644 --- a/src/Workspaces/Core/Portable/Workspace/Host/TemporaryStorage/LegacyTemporaryStorageService.cs +++ b/src/Workspaces/Core/Portable/Workspace/Host/TemporaryStorage/LegacyTemporaryStorageService.cs @@ -50,9 +50,9 @@ public Stream ReadStream(CancellationToken cancellationToken = default) return new MemoryStream(stream.GetBuffer(), 0, (int)stream.Length, writable: false); } - public Task ReadStreamAsync(CancellationToken cancellationToken = default) + public async Task ReadStreamAsync(CancellationToken cancellationToken = default) { - return Task.FromResult(ReadStream(cancellationToken)); + return ReadStream(cancellationToken); } public void WriteStream(Stream stream, CancellationToken cancellationToken = default) @@ -92,8 +92,8 @@ public void Dispose() public SourceText ReadText(CancellationToken cancellationToken = default) => _sourceText ?? throw new InvalidOperationException(); - public Task ReadTextAsync(CancellationToken cancellationToken = default) - => Task.FromResult(ReadText(cancellationToken)); + public async Task ReadTextAsync(CancellationToken cancellationToken = default) + => ReadText(cancellationToken); public void WriteText(SourceText text, CancellationToken cancellationToken = default) { @@ -107,10 +107,9 @@ public void WriteText(SourceText text, CancellationToken cancellationToken = def } } - public Task WriteTextAsync(SourceText text, CancellationToken cancellationToken = default) + public async Task WriteTextAsync(SourceText text, CancellationToken cancellationToken = default) { WriteText(text, cancellationToken); - return Task.CompletedTask; } } } diff --git a/src/Workspaces/Core/Portable/Workspace/IsolatedAnalyzerReferenceSet.Core.cs b/src/Workspaces/Core/Portable/Workspace/IsolatedAnalyzerReferenceSet.Core.cs index 2592d94422eb8..6b6c349c0d6d7 100644 --- a/src/Workspaces/Core/Portable/Workspace/IsolatedAnalyzerReferenceSet.Core.cs +++ b/src/Workspaces/Core/Portable/Workspace/IsolatedAnalyzerReferenceSet.Core.cs @@ -210,7 +210,7 @@ public static async partial ValueTask> CreateI useAsync, analyzerChecksums, solutionServices, - () => Task.FromResult(references), + async () => references, cancellationToken).ConfigureAwait(false); } diff --git a/src/Workspaces/Core/Portable/Workspace/IsolatedAnalyzerReferenceSet.Desktop.cs b/src/Workspaces/Core/Portable/Workspace/IsolatedAnalyzerReferenceSet.Desktop.cs index 362f448ae8262..b4638bdf3a54f 100644 --- a/src/Workspaces/Core/Portable/Workspace/IsolatedAnalyzerReferenceSet.Desktop.cs +++ b/src/Workspaces/Core/Portable/Workspace/IsolatedAnalyzerReferenceSet.Desktop.cs @@ -21,13 +21,13 @@ namespace Microsoft.CodeAnalysis; /// internal sealed partial class IsolatedAnalyzerReferenceSet { - public static partial ValueTask> CreateIsolatedAnalyzerReferencesAsync( + public static async partial ValueTask> CreateIsolatedAnalyzerReferencesAsync( bool useAsync, ImmutableArray references, SolutionServices solutionServices, CancellationToken cancellationToken) { - return ValueTask.FromResult(references); + return references; } public static async partial ValueTask> CreateIsolatedAnalyzerReferencesAsync( diff --git a/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.BatchingDocumentCollection.cs b/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.BatchingDocumentCollection.cs index ab75dacee1552..b41df54f26611 100644 --- a/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.BatchingDocumentCollection.cs +++ b/src/Workspaces/Core/Portable/Workspace/ProjectSystem/ProjectSystemProject.BatchingDocumentCollection.cs @@ -664,8 +664,8 @@ public SourceTextLoader(SourceTextContainer textContainer, string? filePath) _filePath = filePath; } - public override Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) - => Task.FromResult(TextAndVersion.Create(_textContainer.CurrentText, VersionStamp.Create(), _filePath)); + public override async Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) + => TextAndVersion.Create(_textContainer.CurrentText, VersionStamp.Create(), _filePath); } } } diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/ConstantTextAndVersionSource.cs b/src/Workspaces/Core/Portable/Workspace/Solution/ConstantTextAndVersionSource.cs index 19d32d984b671..d2c38a34cb8f1 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/ConstantTextAndVersionSource.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/ConstantTextAndVersionSource.cs @@ -27,8 +27,8 @@ public TextLoader? TextLoader public TextAndVersion GetValue(LoadTextOptions options, CancellationToken cancellationToken) => _value; - public Task GetValueAsync(LoadTextOptions options, CancellationToken cancellationToken) - => Task.FromResult(_value); + public async Task GetValueAsync(LoadTextOptions options, CancellationToken cancellationToken) + => _value; public bool TryGetValue(LoadTextOptions options, [MaybeNullWhen(false)] out TextAndVersion value) { @@ -42,6 +42,6 @@ public bool TryGetVersion(LoadTextOptions options, out VersionStamp version) return true; } - public ValueTask GetVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) - => new(_value.Version); + public async ValueTask GetVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) + => _value.Version; } diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs index 7b83ff5fb000d..ce4b54061fd2b 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/Document.cs @@ -165,18 +165,18 @@ public bool SupportsSemanticModel /// to or may end up causing computation /// to occur at that point. /// - public Task GetSyntaxTreeAsync(CancellationToken cancellationToken = default) + public async Task GetSyntaxTreeAsync(CancellationToken cancellationToken = default) { // If the language doesn't support getting syntax trees for a document, then bail out immediately. if (!this.SupportsSyntaxTree) { - return SpecializedTasks.Null(); + return null; } // if we have a cached result task use it if (_syntaxTreeResultTask != null) { - return _syntaxTreeResultTask.AsNullable(); + return await _syntaxTreeResultTask.ConfigureAwait(false); } // check to see if we already have the tree before actually going async @@ -185,13 +185,13 @@ public bool SupportsSemanticModel // stash a completed result task for this value for the next request (to reduce extraneous allocations of tasks) // don't use the actual async task because it depends on a specific cancellation token // its okay to cache the task and hold onto the SyntaxTree, because the DocumentState already keeps the SyntaxTree alive. - Interlocked.CompareExchange(ref _syntaxTreeResultTask, Task.FromResult(tree), null); + _ = Interlocked.CompareExchange(ref _syntaxTreeResultTask, Task.FromResult(tree), null); - return _syntaxTreeResultTask.AsNullable(); + return await _syntaxTreeResultTask.ConfigureAwait(false); } // do it async for real. - return DocumentState.GetSyntaxTreeAsync(cancellationToken).AsTask().AsNullable(); + return await DocumentState.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); } internal SyntaxTree? GetSyntaxTreeSynchronously(CancellationToken cancellationToken) diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState_TreeTextSource.cs b/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState_TreeTextSource.cs index 53f5d0dc024c4..02c21970b852e 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState_TreeTextSource.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/DocumentState_TreeTextSource.cs @@ -58,6 +58,6 @@ public bool TryGetVersion(LoadTextOptions options, out VersionStamp version) return version != default; } - public ValueTask GetVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) - => new(_version); + public async ValueTask GetVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) + => _version; } diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/Solution.cs b/src/Workspaces/Core/Portable/Workspace/Solution/Solution.cs index df6641633fe30..764d65bc75496 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/Solution.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/Solution.cs @@ -251,31 +251,31 @@ private static Project CreateProject(ProjectId projectId, Solution solution) /// /// Gets a document or a source generated document in this solution with the specified document ID. /// - internal ValueTask GetDocumentAsync(DocumentId? documentId, bool includeSourceGenerated = false, CancellationToken cancellationToken = default) + internal async ValueTask GetDocumentAsync(DocumentId? documentId, bool includeSourceGenerated = false, CancellationToken cancellationToken = default) { var project = GetProject(documentId?.ProjectId); if (project == null) { - return default; + return null; } Contract.ThrowIfNull(documentId); - return project.GetDocumentAsync(documentId, includeSourceGenerated, cancellationToken); + return await project.GetDocumentAsync(documentId, includeSourceGenerated, cancellationToken).ConfigureAwait(false); } /// /// Gets a document, additional document, analyzer config document or a source generated document in this solution with the specified document ID. /// - internal ValueTask GetTextDocumentAsync(DocumentId? documentId, CancellationToken cancellationToken = default) + internal async ValueTask GetTextDocumentAsync(DocumentId? documentId, CancellationToken cancellationToken = default) { var project = GetProject(documentId?.ProjectId); if (project == null) { - return default; + return null; } Contract.ThrowIfNull(documentId); - return project.GetTextDocumentAsync(documentId, cancellationToken); + return await project.GetTextDocumentAsync(documentId, cancellationToken).ConfigureAwait(false); } /// @@ -304,17 +304,17 @@ private static Project CreateProject(ProjectId projectId, Solution solution) return null; } - public ValueTask GetSourceGeneratedDocumentAsync(DocumentId documentId, CancellationToken cancellationToken) + public async ValueTask GetSourceGeneratedDocumentAsync(DocumentId documentId, CancellationToken cancellationToken) { var project = GetProject(documentId.ProjectId); if (project == null) { - return new(result: null); + return null; } else { - return project.GetSourceGeneratedDocumentAsync(documentId, cancellationToken); + return await project.GetSourceGeneratedDocumentAsync(documentId, cancellationToken).ConfigureAwait(false); } } diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.RegularCompilationTracker.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.RegularCompilationTracker.cs index 7754b7924a122..9f13228131041 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.RegularCompilationTracker.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.RegularCompilationTracker.cs @@ -213,22 +213,22 @@ public bool TryGetCompilation([NotNullWhen(true)] out Compilation? compilation) } } - public Task GetCompilationAsync(SolutionCompilationState compilationState, CancellationToken cancellationToken) + public async Task GetCompilationAsync(SolutionCompilationState compilationState, CancellationToken cancellationToken) { if (this.TryGetCompilation(out var compilation)) { - return Task.FromResult(compilation); + return compilation; } else if (cancellationToken.IsCancellationRequested) { // Handle early cancellation here to avoid throwing/catching cancellation exceptions in the async // state machines. This helps reduce the total number of First Chance Exceptions occurring in IDE // typing scenarios. - return Task.FromCanceled(cancellationToken); + return await Task.FromCanceled(cancellationToken).ConfigureAwait(false); } else { - return GetCompilationSlowAsync(compilationState, cancellationToken); + return await GetCompilationSlowAsync(compilationState, cancellationToken).ConfigureAwait(false); } } diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.SkeletonReferenceCache.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.SkeletonReferenceCache.cs index 129720b03bd5f..75081bcd871b0 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.SkeletonReferenceCache.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.SkeletonReferenceCache.cs @@ -208,8 +208,8 @@ public readonly SkeletonReferenceCache Clone() // concurrent requests asynchronously wait for that work to be done. var lazy = s_compilationToSkeletonSet.GetValue(compilation, - compilation => AsyncLazy.Create(static (arg, cancellationToken) => - Task.FromResult(CreateSkeletonSet(arg.services, arg.compilation, cancellationToken)), + compilation => AsyncLazy.Create(static async (arg, cancellationToken) => + CreateSkeletonSet(arg.services, arg.compilation, cancellationToken), arg: (services, compilation))); return await lazy.GetValueAsync(cancellationToken).ConfigureAwait(false); diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs index 85c092e64821a..a1b490c502b4a 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/SolutionCompilationState.TranslationAction_Actions.cs @@ -82,8 +82,8 @@ internal sealed class TouchAdditionalDocumentsAction( // compilation with stale trees around, answering true is still important. public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true; - public override Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) - => Task.FromResult(oldCompilation); + public override async Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) + => oldCompilation; public override TranslationAction? TryMergeWithPrior(TranslationAction priorAction) { @@ -117,10 +117,10 @@ internal sealed class TouchAnalyzerConfigDocumentsAction( /// /// Updating editorconfig document updates . /// - public override Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) + public override async Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) { RoslynDebug.AssertNotNull(this.NewProjectState.CompilationOptions); - return Task.FromResult(oldCompilation.WithOptions(this.NewProjectState.CompilationOptions)); + return oldCompilation.WithOptions(this.NewProjectState.CompilationOptions); } // Updating the analyzer config optons doesn't require us to reparse trees, so we can use this to update @@ -239,10 +239,10 @@ internal sealed class ProjectCompilationOptionsAction( ProjectState oldProjectState, ProjectState newProjectState) : TranslationAction(oldProjectState, newProjectState) { - public override Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) + public override async Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) { Contract.ThrowIfNull(this.NewProjectState.CompilationOptions); - return Task.FromResult(oldCompilation.WithOptions(this.NewProjectState.CompilationOptions)); + return oldCompilation.WithOptions(this.NewProjectState.CompilationOptions); } // Updating the options of a compilation doesn't require us to reparse trees, so we can use this to update @@ -262,8 +262,8 @@ internal sealed class ProjectAssemblyNameAction( ProjectState newProjectState) : TranslationAction(oldProjectState, newProjectState) { - public override Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) - => Task.FromResult(oldCompilation.WithAssemblyName(NewProjectState.AssemblyName)); + public override async Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) + => oldCompilation.WithAssemblyName(NewProjectState.AssemblyName); // Updating the options of a compilation doesn't require us to reparse trees, so we can use this to update // compilations with stale generated trees. @@ -285,8 +285,8 @@ internal sealed class AddOrRemoveAnalyzerReferencesAction( // compilation with stale trees around, answering true is still important. public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true; - public override Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) - => Task.FromResult(oldCompilation); + public override async Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) + => oldCompilation; public override GeneratorDriver TransformGeneratorDriver(GeneratorDriver generatorDriver) { @@ -316,8 +316,8 @@ internal sealed class AddAdditionalDocumentsAction( // compilation with stale trees around, answering true is still important. public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true; - public override Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) - => Task.FromResult(oldCompilation); + public override async Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) + => oldCompilation; public override GeneratorDriver TransformGeneratorDriver(GeneratorDriver generatorDriver) { @@ -336,8 +336,8 @@ internal sealed class RemoveAdditionalDocumentsAction( // compilation with stale trees around, answering true is still important. public override bool CanUpdateCompilationWithStaleGeneratedTreesIfGeneratorsGiveSameOutput => true; - public override Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) - => Task.FromResult(oldCompilation); + public override async Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) + => oldCompilation; public override GeneratorDriver TransformGeneratorDriver(GeneratorDriver generatorDriver) { @@ -355,8 +355,8 @@ internal sealed class ReplaceGeneratorDriverAction( // Replacing the generator doesn't change the non-generator compilation. So we can just return the old // compilation as is. - public override Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) - => Task.FromResult(oldCompilation); + public override async Task TransformCompilationAsync(Compilation oldCompilation, CancellationToken cancellationToken) + => oldCompilation; public override GeneratorDriver TransformGeneratorDriver(GeneratorDriver _) { diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState.cs b/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState.cs index ab9bfa465da47..375de862ad368 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/TextDocumentState.cs @@ -178,15 +178,15 @@ private static ITextAndVersionSource CreateTextFromLoader(SolutionServices solut return new RecoverableTextAndVersion(new LoadableTextAndVersionSource(loader, cacheResult: false), solutionServices); } - private ValueTask GetTextAndVersionAsync(CancellationToken cancellationToken) + private async ValueTask GetTextAndVersionAsync(CancellationToken cancellationToken) { if (this.TextAndVersionSource.TryGetValue(LoadTextOptions, out var textAndVersion)) { - return new ValueTask(textAndVersion); + return textAndVersion; } else { - return new ValueTask(TextAndVersionSource.GetValueAsync(LoadTextOptions, cancellationToken)); + return await TextAndVersionSource.GetValueAsync(LoadTextOptions, cancellationToken).ConfigureAwait(false); } } diff --git a/src/Workspaces/Core/Portable/Workspace/Solution/TextLoader.cs b/src/Workspaces/Core/Portable/Workspace/Solution/TextLoader.cs index ac00ed9a74486..9d3e1654a3ccf 100644 --- a/src/Workspaces/Core/Portable/Workspace/Solution/TextLoader.cs +++ b/src/Workspaces/Core/Portable/Workspace/Solution/TextLoader.cs @@ -200,8 +200,8 @@ private sealed class TextDocumentLoader : TextLoader internal TextDocumentLoader(TextAndVersion textAndVersion) => _textAndVersion = textAndVersion; - public override Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) - => Task.FromResult(_textAndVersion); + public override async Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) + => _textAndVersion; internal override TextAndVersion LoadTextAndVersionSynchronously(LoadTextOptions options, CancellationToken cancellationToken) => _textAndVersion; @@ -223,8 +223,8 @@ internal TextContainerLoader(SourceTextContainer container, VersionStamp version internal override string? FilePath => _filePath; - public override Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) - => Task.FromResult(LoadTextAndVersionSynchronously(options, cancellationToken)); + public override async Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) + => LoadTextAndVersionSynchronously(options, cancellationToken); internal override TextAndVersion LoadTextAndVersionSynchronously(LoadTextOptions options, CancellationToken cancellationToken) => TextAndVersion.Create(_container.CurrentText, _version, _filePath); diff --git a/src/Workspaces/CoreTest/BatchFixAllProviderTests.cs b/src/Workspaces/CoreTest/BatchFixAllProviderTests.cs index b43aa84cc4bb6..35c0f34534e2e 100644 --- a/src/Workspaces/CoreTest/BatchFixAllProviderTests.cs +++ b/src/Workspaces/CoreTest/BatchFixAllProviderTests.cs @@ -82,7 +82,7 @@ public ReplaceZeroFix(ImmutableArray replacements, bool nested) public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer; - public override Task RegisterCodeFixesAsync(CodeFixContext context) + public override async Task RegisterCodeFixesAsync(CodeFixContext context) { foreach (var diagnostic in context.Diagnostics) { @@ -105,8 +105,6 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context) context.RegisterCodeFix(fix, diagnostic); } } - - return Task.CompletedTask; } private static async Task CreateChangedDocument(Document document, TextSpan sourceSpan, int replacement, CancellationToken cancellationToken) diff --git a/src/Workspaces/CoreTest/CodeCleanup/CodeCleanupTests.cs b/src/Workspaces/CoreTest/CodeCleanup/CodeCleanupTests.cs index 0e562bd597b7d..507bbce3b9854 100644 --- a/src/Workspaces/CoreTest/CodeCleanup/CodeCleanupTests.cs +++ b/src/Workspaces/CoreTest/CodeCleanup/CodeCleanupTests.cs @@ -396,10 +396,10 @@ private static async Task VerifyRange(string code, ImmutableArray + CleanupDocumentAsyncImpl = async (provider, document, spans, options, cancellationToken) => { provider.ExpectedResult = spans; - return Task.FromResult(document); + return document; } }; diff --git a/src/Workspaces/CoreTest/CodeCleanup/MockCodeCleanupProvider.cs b/src/Workspaces/CoreTest/CodeCleanup/MockCodeCleanupProvider.cs index 0a992ecb57abb..26680babb2917 100644 --- a/src/Workspaces/CoreTest/CodeCleanup/MockCodeCleanupProvider.cs +++ b/src/Workspaces/CoreTest/CodeCleanup/MockCodeCleanupProvider.cs @@ -27,6 +27,6 @@ internal sealed class MockCodeCleanupProvider : ICodeCleanupProvider public Task CleanupAsync(Document document, ImmutableArray spans, CodeCleanupOptions options, CancellationToken cancellationToken) => (CleanupDocumentAsyncImpl ?? throw new NotImplementedException()).Invoke(this, document, spans, options.FormattingOptions, cancellationToken); - public Task CleanupAsync(SyntaxNode root, ImmutableArray spans, SyntaxFormattingOptions options, SolutionServices services, CancellationToken cancellationToken) - => Task.FromResult((CleanupNodeImpl ?? throw new NotImplementedException()).Invoke(root, spans, options, services)); + public async Task CleanupAsync(SyntaxNode root, ImmutableArray spans, SyntaxFormattingOptions options, SolutionServices services, CancellationToken cancellationToken) + => (CleanupNodeImpl ?? throw new NotImplementedException()).Invoke(root, spans, options, services); } diff --git a/src/Workspaces/CoreTest/Formatter/FormatterTests.cs b/src/Workspaces/CoreTest/Formatter/FormatterTests.cs index 040105af59734..7178230fe5960 100644 --- a/src/Workspaces/CoreTest/Formatter/FormatterTests.cs +++ b/src/Workspaces/CoreTest/Formatter/FormatterTests.cs @@ -38,8 +38,8 @@ public TestFormattingService() { } - public Task FormatAsync(Document document, IEnumerable? spans, LineFormattingOptions lineFormattingOptions, SyntaxFormattingOptions? syntaxFormattingOptions, CancellationToken cancellationToken) - => Task.FromResult(document.WithText(SourceText.From($"Formatted with options: {lineFormattingOptions.ToString().Replace("\r", "\\r").Replace("\n", "\\n")}"))); + public async Task FormatAsync(Document document, IEnumerable? spans, LineFormattingOptions lineFormattingOptions, SyntaxFormattingOptions? syntaxFormattingOptions, CancellationToken cancellationToken) + => document.WithText(SourceText.From($"Formatted with options: {lineFormattingOptions.ToString().Replace("\r", "\\r").Replace("\n", "\\n")}")); } [Fact] diff --git a/src/Workspaces/CoreTest/SyntaxNodeTests.cs b/src/Workspaces/CoreTest/SyntaxNodeTests.cs index 81a812676dd41..5eddfd2e26d20 100644 --- a/src/Workspaces/CoreTest/SyntaxNodeTests.cs +++ b/src/Workspaces/CoreTest/SyntaxNodeTests.cs @@ -28,10 +28,10 @@ public async Task TestReplaceOneNodeAsync() var root = tree.GetRoot(); var node = root.DescendantNodes().OfType().Single(); - var newRoot = await root.ReplaceNodesAsync([node], (o, n, c) => + var newRoot = await root.ReplaceNodesAsync([node], async (o, n, c) => { var decl = (VariableDeclaratorSyntax)n; - return Task.FromResult(decl.WithIdentifier(SyntaxFactory.Identifier("Y"))); + return decl.WithIdentifier(SyntaxFactory.Identifier("Y")); }, CancellationToken.None); var actual = newRoot.ToString(); @@ -48,22 +48,22 @@ public async Task TestReplaceNestedNodesAsync() var nodes = root.DescendantNodes().Where(n => n is VariableDeclaratorSyntax or ClassDeclarationSyntax).ToList(); var computations = 0; - var newRoot = await root.ReplaceNodesAsync(nodes, (o, n, c) => + var newRoot = await root.ReplaceNodesAsync(nodes, async (o, n, c) => { computations++; if (n is ClassDeclarationSyntax classDecl) { var id = classDecl.Identifier; - return Task.FromResult(classDecl.WithIdentifier(SyntaxFactory.Identifier(id.LeadingTrivia, id.ToString() + "1", id.TrailingTrivia))); + return classDecl.WithIdentifier(SyntaxFactory.Identifier(id.LeadingTrivia, id.ToString() + "1", id.TrailingTrivia)); } if (n is VariableDeclaratorSyntax varDecl) { var id = varDecl.Identifier; - return Task.FromResult(varDecl.WithIdentifier(SyntaxFactory.Identifier(id.LeadingTrivia, id.ToString() + "1", id.TrailingTrivia))); + return varDecl.WithIdentifier(SyntaxFactory.Identifier(id.LeadingTrivia, id.ToString() + "1", id.TrailingTrivia)); } - return Task.FromResult(n); + return n; }, CancellationToken.None); var actual = newRoot.ToString(); diff --git a/src/Workspaces/CoreTest/UtilityTest/AsyncLazyTests.cs b/src/Workspaces/CoreTest/UtilityTest/AsyncLazyTests.cs index 1ca298c74e810..89431b740e550 100644 --- a/src/Workspaces/CoreTest/UtilityTest/AsyncLazyTests.cs +++ b/src/Workspaces/CoreTest/UtilityTest/AsyncLazyTests.cs @@ -22,7 +22,7 @@ public void GetValueAsyncReturnsCompletedTaskIfAsyncComputationCompletesImmediat // Note, this test may pass even if GetValueAsync posted a task to the threadpool, since the // current thread may context switch out and allow the threadpool to complete the task before // we check the state. However, a failure here definitely indicates a bug in AsyncLazy. - var lazy = AsyncLazy.Create(static c => Task.FromResult(5)); + var lazy = AsyncLazy.Create(static async c => 5); var t = lazy.GetValueAsync(CancellationToken.None); Assert.Equal(TaskStatus.RanToCompletion, t.Status); Assert.Equal(5, t.Result); @@ -241,7 +241,7 @@ private static void CancellationDuringInlinedComputationFromGetValueOrGetValueAs }; var lazy = AsyncLazy.Create( - static (synchronousComputation, c) => Task.FromResult(synchronousComputation(c)), + static async (synchronousComputation, c) => synchronousComputation(c), includeSynchronousComputation ? static (synchronousComputation, c) => synchronousComputation(c) : null, arg: synchronousComputation); @@ -263,7 +263,7 @@ private static void CancellationDuringInlinedComputationFromGetValueOrGetValueAs [Fact] public void SynchronousRequestShouldCacheValueWithAsynchronousComputeFunction() { - var lazy = AsyncLazy.Create(static c => Task.FromResult(new object())); + var lazy = AsyncLazy.Create(static async c => new object()); var firstRequestResult = lazy.GetValue(CancellationToken.None); var secondRequestResult = lazy.GetValue(CancellationToken.None); @@ -339,7 +339,7 @@ public async Task CancelledAndReranAsynchronousComputationDoesNotBreakSynchronou Assert.Equal(TaskStatus.Canceled, asynchronousRequestToBeCancelled.Status); // Step 3: let's now let an async request run normally, producing a value - asynchronousComputation = _ => Task.FromResult("Returned from asynchronous computation: " + Guid.NewGuid()); + asynchronousComputation = async _ => "Returned from asynchronous computation: " + Guid.NewGuid(); var asynchronousRequest = lazy.GetValueAsync(CancellationToken.None); @@ -369,7 +369,7 @@ public async Task AsynchronousResultThatWasCancelledDoesNotBreakSynchronousReque var asynchronousRequestCancellationToken = new CancellationTokenSource(); var lazy = AsyncLazy.Create( - asynchronousComputeFunction: static (arg, ct) => + asynchronousComputeFunction: static async (arg, ct) => { arg.asynchronousRequestCancellationToken.Cancel(); @@ -381,7 +381,7 @@ public async Task AsynchronousResultThatWasCancelledDoesNotBreakSynchronousReque arg.asynchronousComputationReadyToComplete.Set(); arg.asynchronousComputationShouldCompleteEvent.WaitOne(); - return Task.FromResult("Returned from asynchronous computation: " + Guid.NewGuid()); + return "Returned from asynchronous computation: " + Guid.NewGuid(); }, synchronousComputeFunction: static (arg, _) => { diff --git a/src/Workspaces/CoreTestUtilities/Fakes/SimpleAssetSource.cs b/src/Workspaces/CoreTestUtilities/Fakes/SimpleAssetSource.cs index 271ab19c41819..dd2e4840fcc7a 100644 --- a/src/Workspaces/CoreTestUtilities/Fakes/SimpleAssetSource.cs +++ b/src/Workspaces/CoreTestUtilities/Fakes/SimpleAssetSource.cs @@ -17,7 +17,7 @@ namespace Microsoft.CodeAnalysis.Remote.Testing; /// internal sealed class SimpleAssetSource(ISerializerService serializerService, IReadOnlyDictionary map) : IAssetSource { - public ValueTask GetAssetsAsync( + public async ValueTask GetAssetsAsync( Checksum solutionChecksum, AssetPath assetPath, ReadOnlyMemory checksums, ISerializerService deserializerService, Action callback, TArg arg, CancellationToken cancellationToken) { foreach (var checksum in checksums.Span) @@ -37,7 +37,5 @@ public ValueTask GetAssetsAsync( Contract.ThrowIfNull(asset); callback(checksum, (T)asset, arg); } - - return ValueTask.CompletedTask; } } diff --git a/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs b/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs index 278245aeb2a8e..df9c1c71a7edd 100644 --- a/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs +++ b/src/Workspaces/CoreTestUtilities/Remote/InProcRemostHostClient.cs @@ -118,7 +118,7 @@ public event EventHandler? AvailabilityChanged public ValueTask GetPipeAsync(ServiceMoniker serviceMoniker, ServiceActivationOptions options, CancellationToken cancellationToken) => throw ExceptionUtilities.Unreachable(); - public ValueTask GetProxyAsync(ServiceRpcDescriptor descriptor, ServiceActivationOptions options, CancellationToken cancellationToken) where T : class + public async ValueTask GetProxyAsync(ServiceRpcDescriptor descriptor, ServiceActivationOptions options, CancellationToken cancellationToken) where T : class { var pipePair = FullDuplexStream.CreatePipePair(); @@ -145,7 +145,7 @@ public event EventHandler? AvailabilityChanged clientConnection.StartListening(); - return ValueTask.FromResult((T?)clientConnection.ConstructRpcClient()); + return (T?)clientConnection.ConstructRpcClient(); } } diff --git a/src/Workspaces/CoreTestUtilities/Remote/InProcRemoteHostClientProvider.cs b/src/Workspaces/CoreTestUtilities/Remote/InProcRemoteHostClientProvider.cs index cae4c5c4b814c..b893e6e3240c1 100644 --- a/src/Workspaces/CoreTestUtilities/Remote/InProcRemoteHostClientProvider.cs +++ b/src/Workspaces/CoreTestUtilities/Remote/InProcRemoteHostClientProvider.cs @@ -109,8 +109,8 @@ public void Dispose() } } - public Task TryGetRemoteHostClientAsync(CancellationToken cancellationToken) - => Task.FromResult(_lazyClient.Value); + public async Task TryGetRemoteHostClientAsync(CancellationToken cancellationToken) + => _lazyClient.Value; public Task WaitForClientCreationAsync(CancellationToken cancellationToken) => _clientCreationSource.Task.WithCancellation(cancellationToken); diff --git a/src/Workspaces/CoreTestUtilities/TestDynamicFileInfoProviderThatProducesFiles.cs b/src/Workspaces/CoreTestUtilities/TestDynamicFileInfoProviderThatProducesFiles.cs index 61a2882c96efa..c139e61f22a2b 100644 --- a/src/Workspaces/CoreTestUtilities/TestDynamicFileInfoProviderThatProducesFiles.cs +++ b/src/Workspaces/CoreTestUtilities/TestDynamicFileInfoProviderThatProducesFiles.cs @@ -27,14 +27,14 @@ public TestDynamicFileInfoProviderThatProducesFiles() event EventHandler IDynamicFileInfoProvider.Updated { add { } remove { } } - public Task GetDynamicFileInfoAsync(ProjectId projectId, string projectFilePath, string filePath, CancellationToken cancellationToken) + public async Task GetDynamicFileInfoAsync(ProjectId projectId, string projectFilePath, string filePath, CancellationToken cancellationToken) { - return Task.FromResult(new DynamicFileInfo( + return new DynamicFileInfo( filePath + ".fromdynamicfile", SourceCodeKind.Regular, new TestTextLoader(GetDynamicFileText(filePath)), designTimeOnly: false, - new TestDocumentServiceProvider())); + new TestDocumentServiceProvider()); } public static string GetDynamicFileText(string filePath) diff --git a/src/Workspaces/CoreTestUtilities/TestDynamicFileInfoProviderThatProducesNoFiles.cs b/src/Workspaces/CoreTestUtilities/TestDynamicFileInfoProviderThatProducesNoFiles.cs index 0c1f47e007511..bfe3732cf5f09 100644 --- a/src/Workspaces/CoreTestUtilities/TestDynamicFileInfoProviderThatProducesNoFiles.cs +++ b/src/Workspaces/CoreTestUtilities/TestDynamicFileInfoProviderThatProducesNoFiles.cs @@ -27,8 +27,8 @@ public TestDynamicFileInfoProviderThatProducesNoFiles() event EventHandler IDynamicFileInfoProvider.Updated { add { } remove { } } - public Task GetDynamicFileInfoAsync(ProjectId projectId, string projectFilePath, string filePath, CancellationToken cancellationToken) - => SpecializedTasks.Null(); + public async Task GetDynamicFileInfoAsync(ProjectId projectId, string projectFilePath, string filePath, CancellationToken cancellationToken) + => null; public Task RemoveDynamicFileInfoAsync(ProjectId projectId, string projectFilePath, string filePath, CancellationToken cancellationToken) => Task.CompletedTask; diff --git a/src/Workspaces/CoreTestUtilities/TestTextLoader.cs b/src/Workspaces/CoreTestUtilities/TestTextLoader.cs index bab25b699b7fe..90f522f286406 100644 --- a/src/Workspaces/CoreTestUtilities/TestTextLoader.cs +++ b/src/Workspaces/CoreTestUtilities/TestTextLoader.cs @@ -18,6 +18,6 @@ public TestTextLoader(string text = "test", SourceHashAlgorithm checksumAlgorith _textAndVersion = TextAndVersion.Create(SourceText.From(text, encoding: null, checksumAlgorithm), VersionStamp.Create()); } - public override Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) - => Task.FromResult(_textAndVersion); + public override async Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) + => _textAndVersion; } diff --git a/src/Workspaces/CoreTestUtilities/Workspaces/TestHostDocument.cs b/src/Workspaces/CoreTestUtilities/Workspaces/TestHostDocument.cs index 4eee565e43341..632f8eef0814c 100644 --- a/src/Workspaces/CoreTestUtilities/Workspaces/TestHostDocument.cs +++ b/src/Workspaces/CoreTestUtilities/Workspaces/TestHostDocument.cs @@ -186,8 +186,8 @@ internal TestDocumentLoader(TestHostDocument hostDocument, string text) internal override string? FilePath => _hostDocument.FilePath; - public override Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) - => Task.FromResult(TextAndVersion.Create(SourceText.From(_text, encoding: Encoding.UTF8, options.ChecksumAlgorithm), VersionStamp.Create(), _hostDocument.FilePath)); + public override async Task LoadTextAndVersionAsync(LoadTextOptions options, CancellationToken cancellationToken) + => TextAndVersion.Create(SourceText.From(_text, encoding: Encoding.UTF8, options.ChecksumAlgorithm), VersionStamp.Create(), _hostDocument.FilePath); } public TextLoader Loader => _loader; diff --git a/src/Workspaces/CoreTestUtilities/Workspaces/TestWorkspace`1.cs b/src/Workspaces/CoreTestUtilities/Workspaces/TestWorkspace`1.cs index 308073548de5d..6b52acce18858 100644 --- a/src/Workspaces/CoreTestUtilities/Workspaces/TestWorkspace`1.cs +++ b/src/Workspaces/CoreTestUtilities/Workspaces/TestWorkspace`1.cs @@ -468,14 +468,13 @@ internal override void SetDocumentContext(DocumentId documentId) /// Overriding base impl so that when we close a document it goes back to the initial state when the test /// workspace was loaded, throwing away any changes made to the open version. /// - internal override ValueTask TryOnDocumentClosedAsync(DocumentId documentId, CancellationToken cancellationToken) + internal override async ValueTask TryOnDocumentClosedAsync(DocumentId documentId, CancellationToken cancellationToken) { var testDocument = this.GetTestDocument(documentId); Contract.ThrowIfNull(testDocument); Contract.ThrowIfTrue(testDocument.IsSourceGenerated); this.OnDocumentClosedEx(documentId, testDocument.Loader, requireDocumentPresentAndOpen: false); - return ValueTask.CompletedTask; } public override void CloseDocument(DocumentId documentId) diff --git a/src/Workspaces/MSBuild/BuildHost/BuildHost.cs b/src/Workspaces/MSBuild/BuildHost/BuildHost.cs index d0ea6e76d4962..9a08ed2537a5a 100644 --- a/src/Workspaces/MSBuild/BuildHost/BuildHost.cs +++ b/src/Workspaces/MSBuild/BuildHost/BuildHost.cs @@ -249,12 +249,10 @@ private int AddProjectFileTarget(Build.Evaluation.Project? project, string langu return _buildManager.TryGetOutputFilePathAsync(projectFilePath, cancellationToken); } - public Task ShutdownAsync() + public async Task ShutdownAsync() { _buildManager?.EndBatchBuild(); _server.Shutdown(); - - return Task.CompletedTask; } } diff --git a/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.Worker.cs b/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.Worker.cs index f858f5f41f28c..4157ab80caa8e 100644 --- a/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.Worker.cs +++ b/src/Workspaces/MSBuild/Core/MSBuild/MSBuildProjectLoader.Worker.cs @@ -185,7 +185,7 @@ private async Task> LoadProjectInfosFromPathAsync( return results; } - private Task CreateProjectInfoAsync(ProjectFileInfo projectFileInfo, ProjectId projectId, bool addDiscriminator, CancellationToken cancellationToken) + private async Task CreateProjectInfoAsync(ProjectFileInfo projectFileInfo, ProjectId projectId, bool addDiscriminator, CancellationToken cancellationToken) { var language = projectFileInfo.Language; var projectPath = projectFileInfo.FilePath; @@ -208,8 +208,7 @@ private Task CreateProjectInfoAsync(ProjectFileInfo projectFileInfo var compilationOptions = GetLanguageService(language) ?.GetDefaultCompilationOptions(); - return Task.FromResult( - ProjectInfo.Create( + return ProjectInfo.Create( new ProjectInfo.ProjectAttributes( projectId, version, @@ -222,10 +221,10 @@ private Task CreateProjectInfoAsync(ProjectFileInfo projectFileInfo outputRefFilePath: projectFileInfo.OutputRefFilePath, filePath: projectPath), compilationOptions: compilationOptions, - parseOptions: parseOptions)); + parseOptions: parseOptions); } - return _progress.DoOperationAndReportProgressAsync(ProjectLoadOperation.Resolve, projectPath, projectFileInfo.TargetFramework, async () => + return await _progress.DoOperationAndReportProgressAsync(ProjectLoadOperation.Resolve, projectPath, projectFileInfo.TargetFramework, async () => { var projectDirectory = Path.GetDirectoryName(projectPath); @@ -302,7 +301,7 @@ private Task CreateProjectInfoAsync(ProjectFileInfo projectFileInfo hostObjectType: null) .WithDefaultNamespace(projectFileInfo.DefaultNamespace) .WithAnalyzerConfigDocuments(analyzerConfigDocuments); - }); + }).ConfigureAwait(false); } private static string GetAssemblyNameFromProjectPath(string? projectFilePath) diff --git a/src/Workspaces/MSBuild/Test/RpcTests.cs b/src/Workspaces/MSBuild/Test/RpcTests.cs index a42b14094941b..04ef68a8171ab 100644 --- a/src/Workspaces/MSBuild/Test/RpcTests.cs +++ b/src/Workspaces/MSBuild/Test/RpcTests.cs @@ -235,12 +235,12 @@ public async Task RequestThatClosesServerDoesNotThrow() private sealed class ObjectWithVoidMethod { public string? Message; public void SetMessage(string message) { Message = message; } } private sealed class ObjectWithAsyncHelloMethods { - public Task HelloAsync(string name) { return Task.FromResult("Hello " + name); } - public Task HelloWithCancellationAsync(string name, CancellationToken cancellationToken) + public async Task HelloAsync(string name) { return "Hello " + name; } + public async Task HelloWithCancellationAsync(string name, CancellationToken cancellationToken) { // We never expect to be given a cancellable cancellation token over RPC Assert.False(cancellationToken.CanBeCanceled); - return Task.FromResult("Hello " + name); + return "Hello " + name; } } diff --git a/src/Workspaces/Remote/Core/EditAndContinue/ManagedHotReloadLanguageService.cs b/src/Workspaces/Remote/Core/EditAndContinue/ManagedHotReloadLanguageService.cs index 8897519edc0b0..df628047d59d6 100644 --- a/src/Workspaces/Remote/Core/EditAndContinue/ManagedHotReloadLanguageService.cs +++ b/src/Workspaces/Remote/Core/EditAndContinue/ManagedHotReloadLanguageService.cs @@ -35,12 +35,12 @@ private sealed class PdbMatchingSourceTextProvider : IPdbMatchingSourceTextProvi public static readonly PdbMatchingSourceTextProvider Instance = new(); // Returning null will check the file on disk: - public ValueTask TryGetMatchingSourceTextAsync(string filePath, ImmutableArray requiredChecksum, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken) - => ValueTask.FromResult(null); + public async ValueTask TryGetMatchingSourceTextAsync(string filePath, ImmutableArray requiredChecksum, SourceHashAlgorithm checksumAlgorithm, CancellationToken cancellationToken) + => null; } private static readonly ActiveStatementSpanProvider s_emptyActiveStatementProvider = - (_, _, _) => ValueTask.FromResult(ImmutableArray.Empty); + async (_, _, _) => ImmutableArray.Empty; private readonly ManagedHotReloadServiceProxy _debuggerService = new(serviceBrokerProvider.ServiceBroker); private readonly SolutionSnapshotProviderProxy _solutionSnapshotProvider = new(serviceBrokerProvider.ServiceBroker); @@ -99,11 +99,11 @@ public async ValueTask StartSessionAsync(CancellationToken cancellationToken) } } - private ValueTask BreakStateOrCapabilitiesChangedAsync(bool? inBreakState, CancellationToken cancellationToken) + private async ValueTask BreakStateOrCapabilitiesChangedAsync(bool? inBreakState, CancellationToken cancellationToken) { if (_disabled) { - return ValueTask.CompletedTask; + return; } try @@ -115,8 +115,6 @@ private ValueTask BreakStateOrCapabilitiesChangedAsync(bool? inBreakState, Cance { Disable(); } - - return ValueTask.CompletedTask; } public ValueTask EnterBreakStateAsync(CancellationToken cancellationToken) @@ -128,11 +126,11 @@ public ValueTask ExitBreakStateAsync(CancellationToken cancellationToken) public ValueTask OnCapabilitiesChangedAsync(CancellationToken cancellationToken) => BreakStateOrCapabilitiesChangedAsync(inBreakState: null, cancellationToken); - public ValueTask CommitUpdatesAsync(CancellationToken cancellationToken) + public async ValueTask CommitUpdatesAsync(CancellationToken cancellationToken) { if (_disabled) { - return ValueTask.CompletedTask; + return; } try @@ -149,19 +147,17 @@ public ValueTask CommitUpdatesAsync(CancellationToken cancellationToken) { Disable(); } - - return ValueTask.CompletedTask; } [Obsolete] public ValueTask UpdateBaselinesAsync(ImmutableArray projectPaths, CancellationToken cancellationToken) => throw new NotImplementedException(); - public ValueTask DiscardUpdatesAsync(CancellationToken cancellationToken) + public async ValueTask DiscardUpdatesAsync(CancellationToken cancellationToken) { if (_disabled) { - return ValueTask.CompletedTask; + return; } try @@ -175,15 +171,13 @@ public ValueTask DiscardUpdatesAsync(CancellationToken cancellationToken) { Disable(); } - - return ValueTask.CompletedTask; } - public ValueTask EndSessionAsync(CancellationToken cancellationToken) + public async ValueTask EndSessionAsync(CancellationToken cancellationToken) { if (_disabled) { - return ValueTask.CompletedTask; + return; } try @@ -200,8 +194,6 @@ public ValueTask EndSessionAsync(CancellationToken cancellationToken) { Disable(); } - - return ValueTask.CompletedTask; } /// diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteDocumentDifferenceService.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteDocumentDifferenceService.cs index 934c7a12b76fb..aaef097cfe118 100644 --- a/src/Workspaces/Remote/ServiceHub/Host/RemoteDocumentDifferenceService.cs +++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteDocumentDifferenceService.cs @@ -33,8 +33,8 @@ internal sealed class CSharpDocumentDifferenceService() : RemoteDocumentDifferen [method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)] internal sealed class VisualBasicDocumentDifferenceService() : RemoteDocumentDifferenceService; - public Task GetChangedMemberAsync(Document oldDocument, Document newDocument, CancellationToken cancellationToken) + public async Task GetChangedMemberAsync(Document oldDocument, Document newDocument, CancellationToken cancellationToken) { - return SpecializedTasks.Null(); + return null; } } diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs index f6603fc983db9..2fd6afe32773e 100644 --- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs +++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspace.cs @@ -58,7 +58,7 @@ await RunWithSolutionAsync( assetProvider, solutionChecksum, updatePrimaryBranch: true, - implementation: static _ => ValueTask.FromResult(false), + implementation: static async _ => false, cancellationToken).ConfigureAwait(false); } @@ -340,7 +340,7 @@ public async ValueTask GetSolutionAsync( CancellationToken cancellationToken) { var (solution, _) = await _remoteWorkspace.RunWithSolutionAsync( - assetProvider, solutionChecksum, updatePrimaryBranch, _ => ValueTask.FromResult(false), cancellationToken).ConfigureAwait(false); + assetProvider, solutionChecksum, updatePrimaryBranch, async _ => false, cancellationToken).ConfigureAwait(false); return solution; } } diff --git a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspaceManager.cs b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspaceManager.cs index 48bcac81ede3e..2625afbdbd48c 100644 --- a/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspaceManager.cs +++ b/src/Workspaces/Remote/ServiceHub/Host/RemoteWorkspaceManager.cs @@ -94,7 +94,7 @@ public async ValueTask GetSolutionAsync(ServiceBrokerClient client, Ch var (solution, _) = await workspace.RunWithSolutionAsync( assetProvider, solutionChecksum, - static _ => ValueTask.FromResult(false), + static async _ => false, cancellationToken).ConfigureAwait(false); return solution; diff --git a/src/Workspaces/Remote/ServiceHub/Services/AssetSynchronization/RemoteAssetSynchronizationService.cs b/src/Workspaces/Remote/ServiceHub/Services/AssetSynchronization/RemoteAssetSynchronizationService.cs index d96419e82b0d3..26bf388a88ef1 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/AssetSynchronization/RemoteAssetSynchronizationService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/AssetSynchronization/RemoteAssetSynchronizationService.cs @@ -46,11 +46,10 @@ public ValueTask SynchronizePrimaryWorkspaceAsync(Checksum solutionChecksum, Can }, cancellationToken); } - public ValueTask SynchronizeActiveDocumentAsync(DocumentId? documentId, CancellationToken cancellationToken) + public async ValueTask SynchronizeActiveDocumentAsync(DocumentId? documentId, CancellationToken cancellationToken) { var documentTrackingService = GetWorkspace().Services.GetRequiredService() as RemoteDocumentTrackingService; documentTrackingService?.SetActiveDocument(documentId); - return ValueTask.CompletedTask; } public ValueTask SynchronizeTextChangesAsync( diff --git a/src/Workspaces/Remote/ServiceHub/Services/AsynchronousOperationListener/RemoteAsynchronousOperationListenerService.cs b/src/Workspaces/Remote/ServiceHub/Services/AsynchronousOperationListener/RemoteAsynchronousOperationListenerService.cs index e58ac47a6bb35..c292ddb17447e 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/AsynchronousOperationListener/RemoteAsynchronousOperationListenerService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/AsynchronousOperationListener/RemoteAsynchronousOperationListenerService.cs @@ -25,22 +25,21 @@ public RemoteAsynchronousOperationListenerService(in ServiceConstructionArgument public ValueTask EnableAsync(bool enable, bool diagnostics, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { AsynchronousOperationListenerProvider.Enable(enable, diagnostics); - return default; }, cancellationToken); } public ValueTask IsCompletedAsync(ImmutableArray featureNames, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { var workspace = GetWorkspace(); var exportProvider = workspace.Services.SolutionServices.ExportProvider; var listenerProvider = exportProvider.GetExports().Single().Value; - return new ValueTask(!listenerProvider.HasPendingWaiter([.. featureNames])); + return !listenerProvider.HasPendingWaiter([.. featureNames]); }, cancellationToken); } diff --git a/src/Workspaces/Remote/ServiceHub/Services/BrokeredServiceBase.FactoryBase.cs b/src/Workspaces/Remote/ServiceHub/Services/BrokeredServiceBase.FactoryBase.cs index a79cd330b7dd1..2f810a4115815 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/BrokeredServiceBase.FactoryBase.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/BrokeredServiceBase.FactoryBase.cs @@ -44,7 +44,7 @@ protected virtual TService CreateService( object? clientRpcTarget) => CreateService(arguments); - public Task CreateAsync( + public async Task CreateAsync( Stream stream, IServiceProvider hostProvidedServices, ServiceActivationOptions serviceActivationOptions, @@ -67,11 +67,11 @@ public Task CreateAsync( CultureInfo.DefaultThreadCurrentCulture = serviceActivationOptions.ClientCulture; } - return Task.FromResult((object)Create( + return (object)Create( stream.UsePipe(), hostProvidedServices, serviceActivationOptions, - serviceBroker)); + serviceBroker); } catch (Exception e) when (FatalError.ReportAndPropagateUnlessCanceled(e)) { diff --git a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs index f7a9c14a22483..c36ad6e040758 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/DiagnosticAnalyzer/RemoteDiagnosticAnalyzerService.cs @@ -121,7 +121,7 @@ public ValueTask> GetSourceGeneratorDiagnosticsAs public ValueTask ReportAnalyzerPerformanceAsync(ImmutableArray snapshot, int unitCount, bool forSpanAnalysis, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { using (RoslynLogger.LogBlock(FunctionId.CodeAnalysisService_ReportAnalyzerPerformance, cancellationToken)) { @@ -130,13 +130,11 @@ public ValueTask ReportAnalyzerPerformanceAsync(ImmutableArray(); if (service == null) { - return default; + return; } service.AddSnapshot(snapshot, unitCount, forSpanAnalysis); } - - return default; }, cancellationToken); } diff --git a/src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/RemoteEditAndContinueService.cs b/src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/RemoteEditAndContinueService.cs index a76ae37045002..0900f79dc119d 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/RemoteEditAndContinueService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/EditAndContinue/RemoteEditAndContinueService.cs @@ -82,13 +82,13 @@ private ActiveStatementSpanProvider CreateActiveStatementSpanProvider(RemoteServ /// public ValueTask StartDebuggingSessionAsync(Checksum solutionChecksum, RemoteServiceCallbackId callbackId, bool reportDiagnostics, CancellationToken cancellationToken) { - return RunServiceAsync(solutionChecksum, solution => + return RunServiceAsync(solutionChecksum, async solution => { var debuggerService = new ManagedEditAndContinueDebuggerService(_callback, callbackId); var sourceTextProvider = new SourceTextProvider(_callback, callbackId); var sessionId = GetService().StartDebuggingSession(solution, debuggerService, sourceTextProvider, reportDiagnostics); - return ValueTask.FromResult(sessionId); + return sessionId; }, cancellationToken); } @@ -97,10 +97,9 @@ public ValueTask StartDebuggingSessionAsync(Checksum solutio /// public ValueTask BreakStateOrCapabilitiesChangedAsync(DebuggingSessionId sessionId, bool? inBreakState, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { GetService().BreakStateOrCapabilitiesChanged(sessionId, inBreakState); - return ValueTask.CompletedTask; }, cancellationToken); } @@ -109,10 +108,9 @@ public ValueTask BreakStateOrCapabilitiesChangedAsync(DebuggingSessionId session /// public ValueTask EndDebuggingSessionAsync(DebuggingSessionId sessionId, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { GetService().EndDebuggingSession(sessionId); - return ValueTask.CompletedTask; }, cancellationToken); } @@ -163,10 +161,9 @@ public ValueTask> GetDocumentDiagnosticsAsync(Che /// public ValueTask CommitSolutionUpdateAsync(DebuggingSessionId sessionId, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { GetService().CommitSolutionUpdate(sessionId); - return ValueTask.CompletedTask; }, cancellationToken); } @@ -175,10 +172,9 @@ public ValueTask CommitSolutionUpdateAsync(DebuggingSessionId sessionId, Cancell /// public ValueTask DiscardSolutionUpdateAsync(DebuggingSessionId sessionId, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { GetService().DiscardSolutionUpdate(sessionId); - return default; }, cancellationToken); } @@ -210,10 +206,9 @@ public ValueTask> GetAdjustedActiveStatement /// public ValueTask SetFileLoggingDirectoryAsync(string? logDirectory, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { GetService().SetFileLoggingDirectory(logDirectory); - return default; }, cancellationToken); } } diff --git a/src/Workspaces/Remote/ServiceHub/Services/ExtensionMethodImportCompletion/RemoteExtensionMethodImportCompletionService.cs b/src/Workspaces/Remote/ServiceHub/Services/ExtensionMethodImportCompletion/RemoteExtensionMethodImportCompletionService.cs index 679501bc4974c..8e0bf1dd7cafd 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/ExtensionMethodImportCompletion/RemoteExtensionMethodImportCompletionService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/ExtensionMethodImportCompletion/RemoteExtensionMethodImportCompletionService.cs @@ -61,11 +61,10 @@ public ValueTask> GetUnimported public ValueTask WarmUpCacheAsync(Checksum solutionChecksum, ProjectId projectId, CancellationToken cancellationToken) { - return RunServiceAsync(solutionChecksum, solution => + return RunServiceAsync(solutionChecksum, async solution => { var project = solution.GetRequiredProject(projectId); ExtensionMemberImportCompletionHelper.WarmUpCacheInCurrentProcess(project); - return ValueTask.CompletedTask; }, cancellationToken); } } diff --git a/src/Workspaces/Remote/ServiceHub/Services/Initialization/RemoteInitializationService.cs b/src/Workspaces/Remote/ServiceHub/Services/Initialization/RemoteInitializationService.cs index f1be8f34cafab..07e859ba90e8e 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/Initialization/RemoteInitializationService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/Initialization/RemoteInitializationService.cs @@ -28,12 +28,12 @@ protected override IRemoteInitializationService CreateService(in ServiceConstruc try { - var processId = await RunServiceAsync(cancellationToken => + var processId = await RunServiceAsync(async cancellationToken => { var service = (RemoteWorkspaceConfigurationService)GetWorkspaceServices().GetRequiredService(); service.InitializeOptions(options); - return ValueTask.FromResult(Process.GetCurrentProcess().Id); + return Process.GetCurrentProcess().Id; }, cancellationToken).ConfigureAwait(false); return (processId, errorMessage); diff --git a/src/Workspaces/Remote/ServiceHub/Services/LegacySolutionEvents/RemoteLegacySolutionEventsAggregationService.cs b/src/Workspaces/Remote/ServiceHub/Services/LegacySolutionEvents/RemoteLegacySolutionEventsAggregationService.cs index 320060bf361a2..7d4739b255a24 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/LegacySolutionEvents/RemoteLegacySolutionEventsAggregationService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/LegacySolutionEvents/RemoteLegacySolutionEventsAggregationService.cs @@ -24,11 +24,11 @@ public RemoteLegacySolutionEventsAggregationService(in ServiceConstructionArgume public ValueTask ShouldReportChangesAsync(CancellationToken cancellationToken) { return RunServiceImplAsync( - cancellationToken => + async cancellationToken => { var services = this.GetWorkspaceServices(); var aggregationService = services.GetRequiredService(); - return new ValueTask(aggregationService.ShouldReportChanges(services)); + return aggregationService.ShouldReportChanges(services); }, cancellationToken); } diff --git a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.PerformanceReporter.cs b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.PerformanceReporter.cs index 3f4230e85e358..0d5a5c15b9248 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.PerformanceReporter.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.PerformanceReporter.cs @@ -43,10 +43,10 @@ public PerformanceReporter( _diagnosticAnalyzerPerformanceTracker.SnapshotAdded += (_, _) => _workQueue.AddWork(); } - private ValueTask ProcessWorkAsync(CancellationToken cancellationToken) + private async ValueTask ProcessWorkAsync(CancellationToken cancellationToken) { if (!_telemetrySession.IsOptedIn) - return ValueTask.CompletedTask; + return; using (RoslynLogger.LogBlock(FunctionId.Diagnostics_GeneratePerformaceReport, cancellationToken)) { @@ -70,8 +70,6 @@ private ValueTask ProcessWorkAsync(CancellationToken cancellationToken) } } } - - return ValueTask.CompletedTask; } } } diff --git a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs index bb9112646ca6e..ab9572daa9c4c 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs @@ -39,7 +39,7 @@ protected override IRemoteProcessTelemetryService CreateService(in ServiceConstr /// public ValueTask InitializeTelemetrySessionAsync(int hostProcessId, string serializedSession, bool logDelta, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { var services = GetWorkspace().Services; @@ -65,8 +65,6 @@ public ValueTask InitializeTelemetrySessionAsync(int hostProcessId, string seria // We know in the remote layer that this type must exist. _performanceReporter = new PerformanceReporter(telemetrySession, diagnosticAnalyzerPerformanceTracker, _shutdownCancellationSource.Token); } - - return ValueTask.CompletedTask; }, cancellationToken); } @@ -75,7 +73,7 @@ public ValueTask InitializeTelemetrySessionAsync(int hostProcessId, string seria /// public ValueTask EnableLoggingAsync(ImmutableArray loggerTypeNames, ImmutableArray functionIds, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { var functionIdsSet = new HashSet(functionIds); bool logChecker(FunctionId id) => functionIdsSet.Contains(id); @@ -83,8 +81,6 @@ public ValueTask EnableLoggingAsync(ImmutableArray loggerTypeNames, Immu // we only support 2 types of loggers SetRoslynLogger(loggerTypeNames, () => new EtwLogger(logChecker)); SetRoslynLogger(loggerTypeNames, () => new TraceLogger(logChecker)); - - return ValueTask.CompletedTask; }, cancellationToken); } diff --git a/src/Workspaces/Remote/ServiceHub/Services/SemanticSearch/RemoteSemanticSearchService.cs b/src/Workspaces/Remote/ServiceHub/Services/SemanticSearch/RemoteSemanticSearchService.cs index 84ea91adddd5d..96506aa72e8a1 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/SemanticSearch/RemoteSemanticSearchService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/SemanticSearch/RemoteSemanticSearchService.cs @@ -93,13 +93,13 @@ public ValueTask CompileQueryAsync( string referenceAssembliesDir, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { var services = GetWorkspaceServices(); var service = GetRequiredService(); var result = service.CompileQuery(services, query, targetLanguage, referenceAssembliesDir, TraceLogger, cancellationToken); - return ValueTask.FromResult(result); + return result; }, cancellationToken); } @@ -108,12 +108,10 @@ public ValueTask CompileQueryAsync( /// public ValueTask DiscardQueryAsync(CompiledQueryId queryId, CancellationToken cancellationToken) { - return RunServiceAsync(cancellationToken => + return RunServiceAsync(async cancellationToken => { var service = GetRequiredService(); service.DiscardQuery(queryId); - - return default; }, cancellationToken); } diff --git a/src/Workspaces/Remote/ServiceHub/Services/SourceGeneration/RemoteSourceGenerationService.cs b/src/Workspaces/Remote/ServiceHub/Services/SourceGeneration/RemoteSourceGenerationService.cs index ecc5845487b8e..2a48e1386c70f 100644 --- a/src/Workspaces/Remote/ServiceHub/Services/SourceGeneration/RemoteSourceGenerationService.cs +++ b/src/Workspaces/Remote/ServiceHub/Services/SourceGeneration/RemoteSourceGenerationService.cs @@ -153,13 +153,13 @@ public ValueTask> GetSourceGeneratorIden string analyzerReferenceFullPath, CancellationToken cancellationToken) { - return RunServiceAsync(solutionChecksum, solution => + return RunServiceAsync(solutionChecksum, async solution => { var project = solution.GetRequiredProject(projectId); var analyzerReference = project.AnalyzerReferences .First(r => r.FullPath == analyzerReferenceFullPath); - return ValueTask.FromResult(SourceGeneratorIdentity.GetIdentities(analyzerReference, project.Language)); + return SourceGeneratorIdentity.GetIdentities(analyzerReference, project.Language); }, cancellationToken); } @@ -169,19 +169,19 @@ public ValueTask HasAnalyzersOrSourceGeneratorsAsync( string analyzerReferenceFullPath, CancellationToken cancellationToken) { - return RunServiceAsync(solutionChecksum, solution => + return RunServiceAsync(solutionChecksum, async solution => { var project = solution.GetRequiredProject(projectId); var analyzerReference = project.AnalyzerReferences .First(r => r.FullPath == analyzerReferenceFullPath); - return ValueTask.FromResult(analyzerReference.HasAnalyzersOrSourceGenerators(project.Language)); + return analyzerReference.HasAnalyzersOrSourceGenerators(project.Language); }, cancellationToken); } - public ValueTask>> FetchAndClearTelemetryKeyValuePairsAsync(CancellationToken _) + public async ValueTask>> FetchAndClearTelemetryKeyValuePairsAsync(CancellationToken _) { var workspaceService = GetWorkspaceServices().GetRequiredService(); - return ValueTask.FromResult(workspaceService.FetchKeysAndAndClear()); + return workspaceService.FetchKeysAndAndClear(); } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Editing/CSharpImportAdder.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Editing/CSharpImportAdder.cs index f612474882770..424ec08eda861 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Editing/CSharpImportAdder.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Editing/CSharpImportAdder.cs @@ -133,7 +133,7 @@ public async Task AddPotentiallyConflictingImportsAsync(SyntaxNode container, Ha await ProducerConsumer.RunParallelAsync( source: nodes, - produceItems: static (node, onItemsFound, args, cancellationToken) => + produceItems: static async (node, onItemsFound, args, cancellationToken) => { var (self, containsAnonymousMethods, _) = args; if (node is SimpleNameSyntax nameSyntaxNode) @@ -142,8 +142,6 @@ await ProducerConsumer.RunParallelAsync( self.ProduceConflicts(memberAccessExpressionNode, containsAnonymousMethods, onItemsFound, cancellationToken); else throw ExceptionUtilities.Unreachable(); - - return Task.CompletedTask; }, consumeItems: static async (items, args, cancellationToken) => { diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/ForkingSyntaxEditorBasedCodeFixProvider.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/ForkingSyntaxEditorBasedCodeFixProvider.cs index e8b6f1d6bbe88..f334a07d3e652 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/ForkingSyntaxEditorBasedCodeFixProvider.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/ForkingSyntaxEditorBasedCodeFixProvider.cs @@ -45,11 +45,10 @@ protected sealed override bool IncludeDiagnosticDuringFixAll(Diagnostic diagnost // Never try to fix the secondary diagnostics that were produced just to fade out code. => !diagnostic.Descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.Unnecessary); - public sealed override Task RegisterCodeFixesAsync(CodeFixContext context) + public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var (title, equivalenceKey) = GetTitleAndEquivalenceKey(context); RegisterCodeFix(context, title, equivalenceKey); - return Task.CompletedTask; } protected sealed override async Task FixAllAsync( diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/MultiProjectSafeFixAllProvider.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/MultiProjectSafeFixAllProvider.cs index 80d4f64262154..c16a605f8bf08 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/MultiProjectSafeFixAllProvider.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeFixes/MultiProjectSafeFixAllProvider.cs @@ -44,7 +44,7 @@ internal abstract class MultiProjectSafeFixAllProvider : FixAllProvider return CodeAction.Create( fixAllContext.GetDefaultFixAllTitle(), - (_, _) => Task.FromResult(updatedSolution), + async (_, _) => updatedSolution, equivalenceKey: null, CodeActionPriority.Default #if WORKSPACE diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/TextDocumentExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/TextDocumentExtensions.cs index 40f6a6abce8d6..f388d23ca2a00 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/TextDocumentExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Extensions/TextDocumentExtensions.cs @@ -12,12 +12,12 @@ namespace Microsoft.CodeAnalysis.Shared.Extensions; internal static partial class TextDocumentExtensions { #if !WORKSPACE - public static ValueTask GetValueTextAsync(this TextDocument document, CancellationToken cancellationToken) + public static async ValueTask GetValueTextAsync(this TextDocument document, CancellationToken cancellationToken) { if (document.TryGetText(out var text)) - return ValueTask.FromResult(text); + return text; - return new ValueTask(document.GetTextAsync(cancellationToken)); + return await document.GetTextAsync(cancellationToken).ConfigureAwait(false); } #endif diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Options/OptionsProvider.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Options/OptionsProvider.cs index acf7fef59183e..79192aaf593cb 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Options/OptionsProvider.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Options/OptionsProvider.cs @@ -20,8 +20,8 @@ internal static class OptionsProvider { private sealed class OptionsReaderProvider(IOptionsReader optionsReader, Func reader) : OptionsProvider { - public ValueTask GetOptionsAsync(LanguageServices languageServices, CancellationToken cancellationToken) - => ValueTask.FromResult(reader(optionsReader, languageServices.Language)); + public async ValueTask GetOptionsAsync(LanguageServices languageServices, CancellationToken cancellationToken) + => reader(optionsReader, languageServices.Language); } public static OptionsProvider GetProvider(this IOptionsReader optionsReader, Func reader) diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/SymbolFinder/SymbolFinderInternal.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/SymbolFinder/SymbolFinderInternal.cs index c6cee45a9fc67..4312b86087ff0 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/SymbolFinder/SymbolFinderInternal.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/SymbolFinder/SymbolFinderInternal.cs @@ -15,7 +15,7 @@ namespace Microsoft.CodeAnalysis.FindSymbols; internal static class SymbolFinderInternal { /// - internal static ValueTask FindSourceDefinitionAsync( + internal static async ValueTask FindSourceDefinitionAsync( ISymbol? symbol, Solution solution, CancellationToken cancellationToken) { if (symbol != null) @@ -32,11 +32,11 @@ internal static class SymbolFinderInternal case SymbolKind.Property: case SymbolKind.TypeParameter: case SymbolKind.Namespace: - return FindSourceDefinitionWorkerAsync(symbol, solution, cancellationToken); + return await FindSourceDefinitionWorkerAsync(symbol, solution, cancellationToken).ConfigureAwait(false); } } - return new ValueTask(result: null); + return null; } private static async ValueTask FindSourceDefinitionWorkerAsync( diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Utilities/AsyncSymbolVisitor`1.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Utilities/AsyncSymbolVisitor`1.cs index cc5811efb3aa5..fbe93246ae201 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Utilities/AsyncSymbolVisitor`1.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/Utilities/AsyncSymbolVisitor`1.cs @@ -14,6 +14,6 @@ internal abstract class AsyncSymbolVisitor : SymbolVisitor Visit(ISymbol? symbol) => symbol?.Accept(this) ?? ValueTask.FromResult(DefaultResult); - public override ValueTask DefaultVisit(ISymbol symbol) - => ValueTask.FromResult(DefaultResult); + public override async ValueTask DefaultVisit(ISymbol symbol) + => DefaultResult; } diff --git a/src/Workspaces/TestAnalyzerReference/NonSourceFileRefactoring.cs b/src/Workspaces/TestAnalyzerReference/NonSourceFileRefactoring.cs index d2b9df631ad53..59cabddbb16ce 100644 --- a/src/Workspaces/TestAnalyzerReference/NonSourceFileRefactoring.cs +++ b/src/Workspaces/TestAnalyzerReference/NonSourceFileRefactoring.cs @@ -18,7 +18,7 @@ namespace Microsoft.CodeAnalysis.CodeRefactorings; [Shared] public sealed class NonSourceFileRefactoring : CodeRefactoringProvider { - public override Task ComputeRefactoringsAsync(CodeRefactoringContext context) + public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context) { context.RegisterRefactoring(CodeAction.Create(nameof(NonSourceFileRefactoring), createChangedSolution: async ct => @@ -30,8 +30,6 @@ public override Task ComputeRefactoringsAsync(CodeRefactoringContext context) return document.Project.Solution.WithAdditionalDocumentText(document.Id, newText); return document.Project.Solution.WithAnalyzerConfigDocumentText(document.Id, newText); })); - - return Task.CompletedTask; } }