Speed up cold starts of PSSA by another 35% by parallelising the expensive command lookup in AvoidAlias, which is the most expensive rule. To accomodate the higher parallel demand, increase runspace pool.

Author: bergmeister

Engine/Helper.cs

@@ -115,8 +115,9 @@ internal set
         /// </summary>
         private Helper()
         {
-            // There are 5 rules that use the CommandInfo cache and each rule does not request more than one concurrent command info request
-            _runSpacePool = RunspaceFactory.CreateRunspacePool(1, 6);
+            // There are 5 rules that use the CommandInfo cache but one rule (AvoidAlias) makes parallel queries.
+            // Therefore 10 runspaces was a heuristic measure where no more speed improvement was seen.
+            _runSpacePool = RunspaceFactory.CreateRunspacePool(1, 10);
             _runSpacePool.Open();
             _commandInfoCacheLazy = new Lazy<CommandInfoCache>(() => new CommandInfoCache(pssaHelperInstance: this, runspacePool: _runSpacePool));
         }

Rules/AvoidAlias.cs

@@ -11,6 +11,8 @@
 using System.Globalization;
 using System.Linq;
 using System.Management.Automation;
+using System.Threading.Tasks;
+using System.Collections.Concurrent;
 
 namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
 {
@@ -95,7 +97,8 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
             // Finds all CommandAsts.
             IEnumerable<Ast> foundAsts = ast.FindAll(testAst => testAst is CommandAst, true);
 
-            // Iterates all CommandAsts and check the command name.
+            // Iterates all CommandAsts and check the command name. Expensive operations are run in background tasks
+            var tasks = new List<Task<DiagnosticRecord>>();
             foreach (CommandAst cmdAst in foundAsts)
             {
                 // Check if the command ast should be ignored
@@ -128,24 +131,50 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
                         suggestedCorrections: GetCorrectionExtent(cmdAst, cmdletNameIfCommandNameWasAlias));
                 }
 
-                var isNativeCommand = Helper.Instance.GetCommandInfo(commandName, CommandTypes.Application | CommandTypes.ExternalScript) != null;
-                if (!isNativeCommand)
+                // Checking for implicit 'Get-' aliasing is done in a background task as it can be quite expensive during a cold-start
+                tasks.Add(Task<DiagnosticRecord>.Run(() =>
                 {
-                    var commdNameWithGetPrefix = $"Get-{commandName}";
-                    var cmdletNameIfCommandWasMissingGetPrefix = Helper.Instance.GetCommandInfo($"Get-{commandName}");
-                    if (cmdletNameIfCommandWasMissingGetPrefix != null)
-                    {
-                        yield return new DiagnosticRecord(
-                            string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingCmdletAliasesMissingGetPrefixError, commandName, commdNameWithGetPrefix),
-                            GetCommandExtent(cmdAst),
-                            GetName(),
-                            DiagnosticSeverity.Warning,
-                            fileName,
-                            commandName,
-                            suggestedCorrections: GetCorrectionExtent(cmdAst, commdNameWithGetPrefix));
-                    }
+                    return CheckForImplicitGetAliasing(commandName, cmdAst, fileName);
+                }));
+            }
+            foreach(var task in tasks)
+            {
+                var diagnosticRecordResult = task.Result;
+                if (diagnosticRecordResult != null)
+                {
+                    yield return task.Result;
+                }
+            }
+        }
+
+        /// <summary>
+        /// If one omitts, 'Get-' for a command, PowerShell will pre-pend it if such a command exists, therefore relying on such implicit aliasing is not desirable.
+        /// </summary>
+        /// <param name="commandName"></param>
+        /// <param name="commandAst"></param>
+        /// <param name="fileName"></param>
+        /// <returns></returns>
+        private DiagnosticRecord CheckForImplicitGetAliasing(string commandName, CommandAst commandAst, string fileName)
+        {
+            var isNativeCommand = Helper.Instance.GetCommandInfo(commandName, CommandTypes.Application | CommandTypes.ExternalScript) != null;
+            if (!isNativeCommand)
+            {
+                var commdNameWithGetPrefix = $"Get-{commandName}";
+                var cmdletNameIfCommandWasMissingGetPrefix = Helper.Instance.GetCommandInfo($"Get-{commandName}");
+                if (cmdletNameIfCommandWasMissingGetPrefix != null)
+                {
+                    var diagnosticRecord = new DiagnosticRecord(
+                        string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingCmdletAliasesMissingGetPrefixError, commandName, commdNameWithGetPrefix),
+                        GetCommandExtent(commandAst),
+                        GetName(),
+                        DiagnosticSeverity.Warning,
+                        fileName,
+                        commandName,
+                        suggestedCorrections: GetCorrectionExtent(commandAst, commdNameWithGetPrefix));
+                    return diagnosticRecord;
                 }
             }
+            return null;
         }
 
         /// <summary>