Merge pull request #459 from kapilmb/fix-help-completion

Fix help completion performance for large files

Author: Kapil Borle

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -1091,22 +1091,23 @@ protected async Task HandleCommentHelpRequest(
             {
                // todo create a semantic marker api that take only string
                 var analysisResults = await EditorSession.AnalysisService.GetSemanticMarkersAsync(
-                    scriptFile,
+                    functionDefinitionAst.Extent.Text,
                     AnalysisService.GetCommentHelpRuleSettings(
                         true,
                         false,
                         requestParams.BlockComment,
                         true,
                         "before"));
 
-                var analysisResult = analysisResults?.FirstOrDefault(x =>
-                {
-                    return x.Correction != null
-                        && x.Correction.Edits[0].StartLineNumber == expectedFunctionLine;
-                });
-
                 // find the analysis result whose correction starts on
-                result.Content = analysisResult?.Correction.Edits[0].Text.Split('\n').Select(x => x.Trim('\r')).ToArray();
+                result.Content = analysisResults?
+                                    .FirstOrDefault()?
+                                    .Correction?
+                                    .Edits[0]
+                                    .Text
+                                    .Split('\n')
+                                    .Select(x => x.Trim('\r'))
+                                    .ToArray();
             }
 
             await requestContext.SendResult(result);

src/PowerShellEditorServices/Analysis/AnalysisService.cs

@@ -197,7 +197,7 @@ public static Hashtable GetPSSASettingsHashtable(IDictionary<string, Hashtable>
         /// <returns>An array of ScriptFileMarkers containing semantic analysis results.</returns>
         public async Task<ScriptFileMarker[]> GetSemanticMarkersAsync(ScriptFile file)
         {
-            return await GetSemanticMarkersAsync(file, activeRules, settingsPath);
+            return await GetSemanticMarkersAsync<string>(file, activeRules, settingsPath);
         }
 
         /// <summary>
@@ -211,6 +211,19 @@ public async Task<ScriptFileMarker[]> GetSemanticMarkersAsync(ScriptFile file, H
             return await GetSemanticMarkersAsync<Hashtable>(file, null, settings);
         }
 
+        /// <summary>
+        /// Perform semantic analysis on the given script with the given settings.
+        /// </summary>
+        /// <param name="scriptContent">The script content to be analyzed.</param>
+        /// <param name="settings">ScriptAnalyzer settings</param>
+        /// <returns></returns>
+        public async Task<ScriptFileMarker[]> GetSemanticMarkersAsync(
+           string scriptContent,
+           Hashtable settings)
+        {
+            return await GetSemanticMarkersAsync<Hashtable>(scriptContent, null, settings);
+        }
+
         /// <summary>
         /// Returns a list of builtin-in PSScriptAnalyzer rules
         /// </summary>
@@ -252,11 +265,29 @@ private async Task<ScriptFileMarker[]> GetSemanticMarkersAsync<TSettings>(
             TSettings settings) where TSettings : class
         {
             if (hasScriptAnalyzerModule
-                && file.IsAnalysisEnabled
-                && (typeof(TSettings) == typeof(string) || typeof(TSettings) == typeof(Hashtable))
+                && file.IsAnalysisEnabled)
+            {
+                return await GetSemanticMarkersAsync<TSettings>(
+                    file.Contents,
+                    rules,
+                    settings);
+            }
+            else
+            {
+                // Return an empty marker list
+                return new ScriptFileMarker[0];
+            }
+        }
+
+        private async Task<ScriptFileMarker[]> GetSemanticMarkersAsync<TSettings>(
+            string scriptContent,
+            string[] rules,
+            TSettings settings) where TSettings : class
+        {
+            if ((typeof(TSettings) == typeof(string) || typeof(TSettings) == typeof(Hashtable))
                 && (rules != null || settings != null))
             {
-                var scriptFileMarkers = await GetDiagnosticRecordsAsync(file, rules, settings);
+                var scriptFileMarkers = await GetDiagnosticRecordsAsync(scriptContent, rules, settings);
                 return scriptFileMarkers.Select(ScriptFileMarker.FromDiagnosticRecord).ToArray();
             }
             else
@@ -318,9 +349,9 @@ private void EnumeratePSScriptAnalyzerRules()
         }
 
         private async Task<PSObject[]> GetDiagnosticRecordsAsync<TSettings>(
-            ScriptFile file,
-            string[] rules,
-            TSettings settings) where TSettings : class
+             string scriptContent,
+             string[] rules,
+             TSettings settings) where TSettings : class
         {
             var diagnosticRecords = new PSObject[0];
 
@@ -346,7 +377,7 @@ private async Task<PSObject[]> GetDiagnosticRecordsAsync<TSettings>(
                     "Invoke-ScriptAnalyzer",
                     new Dictionary<string, object>
                     {
-                        { "ScriptDefinition", file.Contents },
+                        { "ScriptDefinition", scriptContent },
                         { settingParameter, settingArgument }
                     });
             }
@@ -358,6 +389,7 @@ private async Task<PSObject[]> GetDiagnosticRecordsAsync<TSettings>(
             return diagnosticRecords;
         }
 
+
         private PSObject[] InvokePowerShell(string command, IDictionary<string, object> paramArgMap)
         {
             using (var powerShell = System.Management.Automation.PowerShell.Create())
@@ -389,7 +421,8 @@ private PSObject[] InvokePowerShell(string command, IDictionary<string, object>
 
         private async Task<PSObject[]> InvokePowerShellAsync(string command, IDictionary<string, object> paramArgMap)
         {
-            var task = Task.Run(() => {
+            var task = Task.Run(() =>
+            {
                 return InvokePowerShell(command, paramArgMap);
             });