Handle PSSA settings hashtable input

This enables the client to send settings as a hashtable instead of pointing to a settings file for script analysis. Our current code structure allows us to pass either a set of rules or a settings file path but not both. However, to provide code formatting settings we not only need to send a settings file to configure the given rules but also the rules in a particular order. The best approach in this case is to update and send a settings hashtable everytime we request code formatting markers.

Author: Kapil Borle

src/PowerShellEditorServices.Protocol/LanguageServer/ScriptFileMarkersRequest.cs

@@ -18,6 +18,7 @@ class ScriptFileMarkerRequestParams
     {
         public string filePath;
         public string[] rules;
+        public string settings;
     }
 
     class ScriptFileMarkerRequestResultParams

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -12,6 +12,7 @@
 using Microsoft.PowerShell.EditorServices.Utility;
 using Newtonsoft.Json.Linq;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -239,7 +240,7 @@ private async Task HandleScriptFileMarkersRequest(
             var markers = editorSession.AnalysisService.GetSemanticMarkers(
                 editorSession.Workspace.GetFile(requestParams.filePath),
                 requestParams.rules,
-                null);
+                editorSession.LanguageService.GetHashtableFromString(requestParams.settings));
             await requestContext.SendResult(new ScriptFileMarkerRequestResultParams {
                 markers = markers
             });

src/PowerShellEditorServices/Analysis/AnalysisService.cs

@@ -13,6 +13,7 @@
 using System.Management.Automation;
 using System.Collections.Generic;
 using System.Text;
+using System.Collections;
 
 namespace Microsoft.PowerShell.EditorServices
 {
@@ -127,9 +128,36 @@ public AnalysisService(IConsoleHost consoleHost, string settingsPath = null)
 
         #region Public Methods
 
+        /// <summary>
+        /// Performs semantic analysis on the given ScriptFile and returns
+        /// an array of ScriptFileMarkers.
+        /// </summary>
+        /// <param name="file">The ScriptFile which will be analyzed for semantic markers.</param>
+        /// <returns>An array of ScriptFileMarkers containing semantic analysis results.</returns>
+        public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file)
+        {
+            return GetSemanticMarkers(file, activeRules, settingsPath);
+        }
+
         public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file, string[] rules, string settingsPath)
         {
-            if (this.scriptAnalyzerModuleInfo != null && file.IsAnalysisEnabled)
+            return GetSemanticMarkers<string>(file, rules, settingsPath);
+        }
+
+        public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file, string[] rules, Hashtable settings)
+        {
+            return GetSemanticMarkers<Hashtable>(file, rules, settings);
+        }
+
+        private ScriptFileMarker[] GetSemanticMarkers<TSettings>(
+            ScriptFile file,
+            string[] rules,
+            TSettings settings) where TSettings: class
+        {
+            if (this.scriptAnalyzerModuleInfo != null
+                && file.IsAnalysisEnabled
+                && (typeof(TSettings) == typeof(string)
+                    || typeof(TSettings) == typeof(Hashtable)))
             {
                 // TODO: This is a temporary fix until we can change how
                 // ScriptAnalyzer invokes their async tasks.
@@ -139,7 +167,7 @@ public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file, string[] rules, st
                         () =>
                         {
                             return
-                                 GetDiagnosticRecords(file, rules, settingsPath)
+                                 GetDiagnosticRecords(file, rules, settings)
                                 .Select(ScriptFileMarker.FromDiagnosticRecord)
                                 .ToArray();
                         },
@@ -156,17 +184,6 @@ public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file, string[] rules, st
             }
         }
 
-        /// <summary>
-        /// Performs semantic analysis on the given ScriptFile and returns
-        /// an array of ScriptFileMarkers.
-        /// </summary>
-        /// <param name="file">The ScriptFile which will be analyzed for semantic markers.</param>
-        /// <returns>An array of ScriptFileMarkers containing semantic analysis results.</returns>
-        public ScriptFileMarker[] GetSemanticMarkers(ScriptFile file)
-        {
-            return GetSemanticMarkers(file, activeRules, settingsPath);
-        }
-
         /// <summary>
         /// Returns a list of builtin-in PSScriptAnalyzer rules
         /// </summary>
@@ -300,11 +317,18 @@ private IEnumerable<PSObject> GetDiagnosticRecords(ScriptFile file)
             return GetDiagnosticRecords(file, this.activeRules, this.settingsPath);
         }
 
-        private IEnumerable<PSObject> GetDiagnosticRecords(ScriptFile file, string[] rules, string settingsPath)
+        // TSettings can either be of type Hashtable or string
+        // as scriptanalyzer settings parameter takes either a hashtable or string
+        private IEnumerable<PSObject> GetDiagnosticRecords<TSettings>(
+            ScriptFile file,
+            string[] rules,
+            TSettings settings) where TSettings: class
         {
             IEnumerable<PSObject> diagnosticRecords = Enumerable.Empty<PSObject>();
 
-            if (this.scriptAnalyzerModuleInfo != null)
+            if (this.scriptAnalyzerModuleInfo != null
+                && (typeof(TSettings) == typeof(string)
+                    || typeof(TSettings) == typeof(Hashtable)))
             {
                 lock (runspaceLock)
                 {
@@ -320,9 +344,9 @@ private IEnumerable<PSObject> GetDiagnosticRecords(ScriptFile file, string[] rul
                             .AddParameter("ScriptDefinition", file.Contents);
 
                         // Use a settings file if one is provided, otherwise use the default rule list.
-                        if (!string.IsNullOrWhiteSpace(settingsPath))
+                        if (settings != null)
                         {
-                            powerShell.AddParameter("Settings", settingsPath);
+                            powerShell.AddParameter("Settings", settings);
                         }
                         else
                         {

src/PowerShellEditorServices/Language/LanguageService.cs

@@ -5,9 +5,11 @@
 
 using Microsoft.PowerShell.EditorServices.Utility;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Management.Automation;
+using System.Management.Automation.Language;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -132,7 +134,7 @@ await this.powerShellContext.GetRunspaceHandle(
         }
 
         /// <summary>
-        /// Finds command completion details for the script given a file location 
+        /// Finds command completion details for the script given a file location
         /// </summary>
         /// <param name="file">The details and contents of a open script file</param>
         /// <param name="entryName">The name of the suggestion that needs details</param>
@@ -144,7 +146,7 @@ public CompletionDetails GetCompletionDetailsInFile(
             // Makes sure the most recent completions request was the same line and column as this request
             if (file.Id.Equals(mostRecentRequestFile))
             {
-                CompletionDetails completionResult = 
+                CompletionDetails completionResult =
                     mostRecentCompletions.Completions.FirstOrDefault(
                         result => result.CompletionText.Equals(entryName));
 
@@ -163,7 +165,7 @@ public CompletionDetails GetCompletionDetailsInFile(
         /// <param name="lineNumber">The line number of the cursor for the given script</param>
         /// <param name="columnNumber">The coulumn number of the cursor for the given script</param>
         /// <returns>A SymbolReference of the symbol found at the given location
-        /// or null if there is no symbol at that location 
+        /// or null if there is no symbol at that location
         /// </returns>
         public SymbolReference FindSymbolAtLocation(
             ScriptFile scriptFile,
@@ -255,7 +257,7 @@ public FindOccurrencesResult FindSymbolsInFile(ScriptFile scriptFile)
         public async Task<FindReferencesResult> FindReferencesOfSymbol(
             SymbolReference foundSymbol,
             ScriptFile[] referencedFiles)
-        {                
+        {
             if (foundSymbol != null)
             {
                 int symbolOffset = referencedFiles[0].GetOffsetAtPosition(
@@ -336,7 +338,7 @@ public async Task<GetDefinitionResult> GetDefinitionOfSymbol(
                 }
             }
 
-            // if definition is not found in referenced files 
+            // if definition is not found in referenced files
             // look for it in the builtin commands
             if (foundDefinition == null)
             {
@@ -345,9 +347,9 @@ await CommandHelpers.GetCommandInfo(
                         foundSymbol.SymbolName,
                         this.powerShellContext);
 
-                foundDefinition = 
+                foundDefinition =
                     FindDeclarationForBuiltinCommand(
-                        cmdInfo, 
+                        cmdInfo,
                         foundSymbol,
                         workspace);
             }
@@ -448,6 +450,34 @@ await CommandHelpers.GetCommandInfo(
             }
         }
 
+        public Hashtable GetHashtableFromString(string hashtableString)
+        {
+            if (hashtableString == null)
+            {
+                return null;
+            }
+
+            ParseError[] parseErrors = null;
+            Token[] tokens = null;
+            try
+            {
+                var ast = Parser.ParseInput(hashtableString, out tokens, out parseErrors);
+                if (parseErrors.Length > 0)
+                {
+                    return null;
+                }
+
+                var hashtableAst = ast.Find(x => x is HashtableAst, false);
+                return hashtableAst == null
+                        ? null
+                        : (hashtableAst as HashtableAst).SafeGetValue() as Hashtable;
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
         #endregion
 
         #region Private Fields
@@ -533,7 +563,7 @@ private ScriptFile[] GetBuiltinCommandScriptFiles(
         }
 
         private SymbolReference FindDeclarationForBuiltinCommand(
-            CommandInfo commandInfo, 
+            CommandInfo commandInfo,
             SymbolReference foundSymbol,
             Workspace workspace)
         {