Make ResolveCodeLens return a Task (again)

Ironically this was clearly how it used to work, and was for some reason
changed, even though it does need to be a task and was previously
relying on synchronous side effects.

Author: andyleejordan

src/PowerShellEditorServices/Services/CodeLens/ICodeLensProvider.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Threading.Tasks;
 using Microsoft.PowerShell.EditorServices.Services.TextDocument;
 using OmniSharp.Extensions.LanguageServer.Protocol.Models;
 
@@ -34,13 +35,12 @@ internal interface ICodeLensProvider
         /// The CodeLens to resolve.
         /// </param>
         /// <param name="scriptFile">
-        /// A CancellationToken which can be used to cancel the
-        /// request.
+        /// The ScriptFile to resolve it in (sometimes unused).
         /// </param>
         /// <returns>
         /// A Task which returns the resolved CodeLens when completed.
         /// </returns>
-        CodeLens ResolveCodeLens(
+        Task<CodeLens> ResolveCodeLens(
             CodeLens codeLens,
             ScriptFile scriptFile);
     }

src/PowerShellEditorServices/Services/CodeLens/PesterCodeLensProvider.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.Symbols;
 using Microsoft.PowerShell.EditorServices.Services.TextDocument;
@@ -133,11 +134,11 @@ public CodeLens[] ProvideCodeLenses(ScriptFile scriptFile)
         /// <param name="codeLens">The code lens to resolve.</param>
         /// <param name="scriptFile">The script file.</param>
         /// <returns>The given CodeLens, wrapped in a task.</returns>
-        public CodeLens ResolveCodeLens(CodeLens codeLens, ScriptFile scriptFile)
+        public Task<CodeLens> ResolveCodeLens(CodeLens codeLens, ScriptFile scriptFile)
         {
             // This provider has no specific behavior for
             // resolving CodeLenses.
-            return codeLens;
+            return Task.FromResult(codeLens);
         }
     }
 }

src/PowerShellEditorServices/Services/CodeLens/ReferencesCodeLensProvider.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Text;
+using System.Threading.Tasks;
 using Microsoft.PowerShell.EditorServices.Services;
 using Microsoft.PowerShell.EditorServices.Services.Symbols;
 using Microsoft.PowerShell.EditorServices.Services.TextDocument;
@@ -79,10 +80,10 @@ public CodeLens[] ProvideCodeLenses(ScriptFile scriptFile)
         /// Take a codelens and create a new codelens object with updated references.
         /// </summary>
         /// <param name="codeLens">The old code lens to get updated references for.</param>
+        /// <param name="scriptFile"></param>
         /// <returns>A new code lens object describing the same data as the old one but with updated references.</returns>
-        public CodeLens ResolveCodeLens(CodeLens codeLens, ScriptFile scriptFile)
+        public async Task<CodeLens> ResolveCodeLens(CodeLens codeLens, ScriptFile scriptFile)
         {
-
             ScriptFile[] references = _workspaceService.ExpandScriptReferences(
                 scriptFile);
 
@@ -91,10 +92,10 @@ public CodeLens ResolveCodeLens(CodeLens codeLens, ScriptFile scriptFile)
                 codeLens.Range.Start.Line + 1,
                 codeLens.Range.Start.Character + 1);
 
-            List<SymbolReference> referencesResult = _symbolsService.FindReferencesOfSymbol(
+            List<SymbolReference> referencesResult = await _symbolsService.FindReferencesOfSymbol(
                 foundSymbol,
                 references,
-                _workspaceService);
+                _workspaceService).ConfigureAwait(false);
 
             Location[] referenceLocations;
             if (referencesResult == null)

src/PowerShellEditorServices/Services/Symbols/SymbolsService.cs

@@ -48,6 +48,10 @@ internal class SymbolsService
         /// the given Runspace to execute language service operations.
         /// </summary>
         /// <param name="factory">An ILoggerFactory implementation used for writing log messages.</param>
+        /// <param name="runspaceContext"></param>
+        /// <param name="executionService"></param>
+        /// <param name="workspaceService"></param>
+        /// <param name="configurationService"></param>
         public SymbolsService(
             ILoggerFactory factory,
             IRunspaceContext runspaceContext,
@@ -175,7 +179,7 @@ public static SymbolReference FindSymbolAtLocation(
         /// <param name="referencedFiles">An array of scriptFiles too search for references in</param>
         /// <param name="workspace">The workspace that will be searched for symbols</param>
         /// <returns>FindReferencesResult</returns>
-        public List<SymbolReference> FindReferencesOfSymbol(
+        public async Task<List<SymbolReference>> FindReferencesOfSymbol(
             SymbolReference foundSymbol,
             ScriptFile[] referencedFiles,
             WorkspaceService workspace)
@@ -303,7 +307,7 @@ public static SymbolReference FindFunctionDefinitionAtLocation(
         /// <param name="lineNumber">The line number at which the symbol can be located.</param>
         /// <param name="columnNumber">The column number at which the symbol can be located.</param>
         /// <returns></returns>
-        public async Task<SymbolDetails> FindSymbolDetailsAtLocationAsync(
+        public Task<SymbolDetails> FindSymbolDetailsAtLocationAsync(
             ScriptFile scriptFile,
             int lineNumber,
             int columnNumber)
@@ -316,16 +320,14 @@ public async Task<SymbolDetails> FindSymbolDetailsAtLocationAsync(
 
             if (symbolReference == null)
             {
-                return null;
+                return Task.FromResult<SymbolDetails>(null);
             }
 
             symbolReference.FilePath = scriptFile.FilePath;
-            SymbolDetails symbolDetails = await SymbolDetails.CreateAsync(
+            return SymbolDetails.CreateAsync(
                 symbolReference,
                 _runspaceContext.CurrentRunspace,
-                _executionService).ConfigureAwait(false);
-
-            return symbolDetails;
+                _executionService);
         }
 
         /// <summary>
@@ -443,8 +445,7 @@ public async Task<SymbolReference> GetDefinitionOfSymbolAsync(
             if (foundDefinition == null)
             {
                 // Get a list of all powershell files in the workspace path
-                IEnumerable<string> allFiles = _workspaceService.EnumeratePSFiles();
-                foreach (string file in allFiles)
+                foreach (string file in _workspaceService.EnumeratePSFiles())
                 {
                     if (filesSearched.Contains(file))
                     {
@@ -540,7 +541,7 @@ private ScriptFile[] GetBuiltinCommandScriptFiles(
             }
 
             string modPath = moduleInfo.Path;
-            List<ScriptFile> scriptFiles = new List<ScriptFile>();
+            List<ScriptFile> scriptFiles = new();
             ScriptFile newFile;
 
             // find any files where the moduleInfo's path ends with ps1 or psm1
@@ -595,7 +596,7 @@ public static FunctionDefinitionAst GetFunctionDefinitionForHelpComment(
             IEnumerable<Ast> foundAsts = scriptFile.ScriptAst.FindAll(
                 ast =>
                 {
-                    if (!(ast is FunctionDefinitionAst fdAst))
+                    if (ast is not FunctionDefinitionAst fdAst)
                     {
                         return false;
                     }
@@ -605,7 +606,7 @@ public static FunctionDefinitionAst GetFunctionDefinitionForHelpComment(
                 },
                 true);
 
-            if (foundAsts == null || !foundAsts.Any())
+            if (foundAsts?.Any() != true)
             {
                 helpLocation = null;
                 return null;

src/PowerShellEditorServices/Services/TextDocument/Handlers/CodeLensHandlers.cs

@@ -75,8 +75,7 @@ public Task<CodeLens> Handle(CodeLens request, CancellationToken cancellationTok
                 _workspaceService.GetFile(
                     codeLensData.Uri);
 
-            var resolvedCodeLens = originalProvider.ResolveCodeLens(request, scriptFile);
-            return Task.FromResult(resolvedCodeLens);
+            return originalProvider.ResolveCodeLens(request, scriptFile);
         }
 
         public void SetCapability(CodeLensCapability capability)

src/PowerShellEditorServices/Services/TextDocument/Handlers/ReferencesHandler.cs

@@ -34,7 +34,7 @@ public PsesReferencesHandler(ILoggerFactory factory, SymbolsService symbolsServi
             DocumentSelector = LspUtils.PowerShellDocumentSelector
         };
 
-        public override Task<LocationContainer> Handle(ReferenceParams request, CancellationToken cancellationToken)
+        public async override Task<LocationContainer> Handle(ReferenceParams request, CancellationToken cancellationToken)
         {
             ScriptFile scriptFile = _workspaceService.GetFile(request.TextDocument.Uri);
 
@@ -45,10 +45,10 @@ public override Task<LocationContainer> Handle(ReferenceParams request, Cancella
                     request.Position.Character + 1);
 
             List<SymbolReference> referencesResult =
-                _symbolsService.FindReferencesOfSymbol(
+                await _symbolsService.FindReferencesOfSymbol(
                     foundSymbol,
                     _workspaceService.ExpandScriptReferences(scriptFile),
-                    _workspaceService);
+                    _workspaceService).ConfigureAwait(false);
 
             var locations = new List<Location>();
 
@@ -64,7 +64,7 @@ public override Task<LocationContainer> Handle(ReferenceParams request, Cancella
                 }
             }
 
-            return Task.FromResult(new LocationContainer(locations));
+            return new LocationContainer(locations);
         }
 
         private static Range GetRangeFromScriptRegion(ScriptRegion scriptRegion)

test/PowerShellEditorServices.Test/Language/SymbolsServiceTests.cs

@@ -71,7 +71,7 @@ private Task<SymbolReference> GetDefinition(ScriptRegion scriptRegion)
             return symbolsService.GetDefinitionOfSymbolAsync(scriptFile, symbolReference);
         }
 
-        private List<SymbolReference> GetReferences(ScriptRegion scriptRegion)
+        private Task<List<SymbolReference>> GetReferences(ScriptRegion scriptRegion)
         {
             ScriptFile scriptFile = GetScriptFile(scriptRegion);
 
@@ -126,9 +126,9 @@ public async Task FindsFunctionDefinition()
         }
 
         [Fact]
-         public void FindsReferencesOnFunction()
+         public async Task FindsReferencesOnFunction()
         {
-            List<SymbolReference> referencesResult = GetReferences(FindsReferencesOnFunctionData.SourceDetails);
+            List<SymbolReference> referencesResult = await GetReferences(FindsReferencesOnFunctionData.SourceDetails).ConfigureAwait(true);
             Assert.Equal(3, referencesResult.Count);
             Assert.Equal(1, referencesResult[0].ScriptRegion.StartLineNumber);
             Assert.Equal(10, referencesResult[0].ScriptRegion.StartColumnNumber);
@@ -177,9 +177,9 @@ public async Task FindsVariableDefinition()
         }
 
         [Fact]
-        public void FindsReferencesOnVariable()
+        public async Task FindsReferencesOnVariable()
         {
-            List<SymbolReference> referencesResult = GetReferences(FindsReferencesOnVariableData.SourceDetails);
+            List<SymbolReference> referencesResult = await GetReferences(FindsReferencesOnVariableData.SourceDetails).ConfigureAwait(true);
             Assert.Equal(3, referencesResult.Count);
             Assert.Equal(10, referencesResult[referencesResult.Count - 1].ScriptRegion.StartLineNumber);
             Assert.Equal(13, referencesResult[referencesResult.Count - 1].ScriptRegion.StartColumnNumber);
@@ -204,26 +204,26 @@ public void FindsOccurrencesOnParameter()
         }
 
         [Fact]
-        public void FindsReferencesOnCommandWithAlias()
+        public async Task FindsReferencesOnCommandWithAlias()
         {
-            List<SymbolReference> referencesResult = GetReferences(FindsReferencesOnBuiltInCommandWithAliasData.SourceDetails);
+            List<SymbolReference> referencesResult = await GetReferences(FindsReferencesOnBuiltInCommandWithAliasData.SourceDetails).ConfigureAwait(true);
             Assert.Equal(4, referencesResult.Count);
             Assert.Equal("gci", referencesResult[1].SymbolName);
             Assert.Equal("dir", referencesResult[2].SymbolName);
             Assert.Equal("Get-ChildItem", referencesResult[referencesResult.Count - 1].SymbolName);
         }
 
         [Fact]
-        public void FindsReferencesOnFileWithReferencesFileB()
+        public async Task FindsReferencesOnFileWithReferencesFileB()
         {
-            List<SymbolReference> referencesResult = GetReferences(FindsReferencesOnFunctionMultiFileDotSourceFileB.SourceDetails);
+            List<SymbolReference> referencesResult = await GetReferences(FindsReferencesOnFunctionMultiFileDotSourceFileB.SourceDetails).ConfigureAwait(true);
             Assert.Equal(4, referencesResult.Count);
         }
 
         [Fact]
-        public void FindsReferencesOnFileWithReferencesFileC()
+        public async Task FindsReferencesOnFileWithReferencesFileC()
         {
-            List<SymbolReference> referencesResult = GetReferences(FindsReferencesOnFunctionMultiFileDotSourceFileC.SourceDetails);
+            List<SymbolReference> referencesResult = await GetReferences(FindsReferencesOnFunctionMultiFileDotSourceFileC.SourceDetails).ConfigureAwait(true);
             Assert.Equal(4, referencesResult.Count);
         }