Fix intermittent "The term 'Get-Command' is not recognized" failures during recursive analysis and improve performance while doing so.

Engine/CommandLookupKey.cs

@@ -30,7 +30,7 @@ public override int GetHashCode()
             unchecked
             {
                 int hash = 17;
-                hash = hash * 31 + Name.ToUpperInvariant().GetHashCode();
+                hash = hash * 31 + StringComparer.OrdinalIgnoreCase.GetHashCode(Name);
                 hash = hash * 31 + CommandTypes.GetHashCode();
                 return hash;
             }

Engine/CommandParameterSnapshot.cs

@@ -0,0 +1,24 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Management.Automation;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
+{
+    /// <summary>Detached parameter facts, safe to consume without driving a PowerShell runspace.</summary>
+    public sealed class CommandParameterSnapshot
+    {
+        public string Name { get; }
+        public bool SwitchParameter { get; }
+        public ReadOnlyCollection<string> Aliases { get; }
+
+        internal CommandParameterSnapshot(ParameterMetadata parameter)
+        {
+            Name = parameter.Name;
+            SwitchParameter = parameter.SwitchParameter;
+            Aliases = new ReadOnlyCollection<string>(parameter.Aliases.ToArray());
+        }
+    }
+}

Engine/Helper.cs

@@ -330,6 +330,15 @@ public PSModuleInfo GetModuleManifest(string filePath, out IEnumerable<ErrorReco
             return psModuleInfo;
         }
 
+        /// <summary>Shares validation between built-in rules during one syntax-tree analysis only.</summary>
+        public PSModuleInfo GetModuleManifestForAnalysis(string filePath, out IEnumerable<ErrorRecord> errorRecords)
+        {
+            var cache = ModuleManifestAnalysisCache.Current;
+            return cache == null
+                ? GetModuleManifest(filePath, out errorRecords)
+                : cache.Get(this, filePath, out errorRecords);
+        }
+
         /// <summary>
         /// Checks if the error record is MissingMemberException
         /// </summary>
@@ -399,18 +408,22 @@ public HashSet<string> GetExportedFunction(Ast ast)
             List<string> exportFunctionsCmdlet = Helper.Instance.CmdletNameAndAliases("export-modulemember");
 
             // find functions exported
-            IEnumerable<Ast> cmdAsts = ast.FindAll(item => item is CommandAst
-                && exportFunctionsCmdlet.Contains((item as CommandAst).GetCommandName(), StringComparer.OrdinalIgnoreCase), true);
-
-            CommandInfo exportMM = Helper.Instance.GetCommandInfo("export-modulemember", CommandTypes.Cmdlet);
-
-            // switch parameters
-            IEnumerable<ParameterMetadata> switchParams = (exportMM != null) ? exportMM.Parameters.Values.Where<ParameterMetadata>(pm => pm.SwitchParameter) : Enumerable.Empty<ParameterMetadata>();
+            var cmdAsts = ast.FindAll(item => item is CommandAst
+                && exportFunctionsCmdlet.Contains((item as CommandAst).GetCommandName(), StringComparer.OrdinalIgnoreCase), true).ToArray();
+            if (cmdAsts.Length == 0)
+            {
+                return exportedFunctions;
+            }
 
-            if (exportMM == null)
+            // Export-ModuleMember has no dynamic parameters. Resolve names from its static
+            // metadata instead of ResolveParameter(), which re-enters the cached command's
+            // runspace and races with command lookups and metadata queries on other rule threads.
+            var parameters = GetCommandParameterSnapshot("Microsoft.PowerShell.Core\\Export-ModuleMember", CommandTypes.Cmdlet);
+            if (parameters == null)
             {
                 return exportedFunctions;
             }
+            var switchParams = parameters.Values.Where(pm => pm.SwitchParameter);
 
             foreach (CommandAst cmdAst in cmdAsts)
             {
@@ -429,7 +442,20 @@ public HashSet<string> GetExportedFunction(Ast ast)
                     if (ceAst is CommandParameterAst)
                     {
                         var paramAst = ceAst as CommandParameterAst;
-                        var param = exportMM.ResolveParameter(paramAst.ParameterName);
+                        CommandParameterSnapshot param;
+                        if (!parameters.TryGetValue(paramAst.ParameterName, out param))
+                        {
+                            param = parameters.Values.FirstOrDefault(pm =>
+                                pm.Aliases.Contains(paramAst.ParameterName, StringComparer.OrdinalIgnoreCase));
+                            if (param == null)
+                            {
+                                var matches = parameters.Values.Where(pm =>
+                                    pm.Name.StartsWith(paramAst.ParameterName, StringComparison.OrdinalIgnoreCase)
+                                    || pm.Aliases.Any(alias => alias.StartsWith(paramAst.ParameterName, StringComparison.OrdinalIgnoreCase)))
+                                    .Take(2).ToArray();
+                                param = matches.Length == 1 ? matches[0] : null;
+                            }
+                        }
 
                         if (param == null)
                         {
@@ -613,7 +639,7 @@ public bool IsKnownCmdletFunctionOrExternalScript(CommandAst cmdAst, out Command
                 return false;
             }
 
-            commandInfo = GetCommandInfo(cmdAst.GetCommandName());
+            commandInfo = GetCommandInfo(cmdAst.GetCommandName(), callSite: cmdAst);
             if (commandInfo == null)
             {
                 return false;
@@ -666,9 +692,47 @@ public bool PositionalParameterUsed(CommandAst cmdAst, bool moreThanTwoPositiona
         /// <param name="commandType"></param>
         /// <param name="bypassCache"></param>
         /// <returns></returns>
-        public CommandInfo GetCommandInfo(string name, CommandTypes? commandType = null, bool bypassCache = false)
+        public CommandInfo GetCommandInfo(string name, CommandTypes? commandType, bool bypassCache)
+        {
+            return GetCommandInfo(name, commandType, bypassCache, null);
+        }
+
+        /// <summary>
+        /// Given a command's name, checks whether it exists, taking the call site into account.
+        /// </summary>
+        public CommandInfo GetCommandInfo(string name, CommandTypes? commandType = null, bool bypassCache = false, Ast callSite = null)
         {
-            return CommandInfoCache.GetCommandInfo(name, commandTypes: commandType, bypassCache: bypassCache);
+            return CommandInfoCache.GetCommandInfo(name, commandTypes: commandType, bypassCache: bypassCache, callSite: callSite);
+        }
+
+        /// <summary>
+        /// Retrieves command parameters with centralized recovery; returns null when metadata is unavailable.
+        /// </summary>
+        public Dictionary<string, ParameterMetadata> GetCommandParameters(
+            string name, CommandTypes? commandType = null, bool bypassCache = false, Ast callSite = null)
+        {
+            return CommandInfoCache.GetCommandParameters(name, commandType, bypassCache, callSite);
+        }
+
+        /// <summary>
+        /// Retrieves command parameter sets with centralized recovery; returns null when metadata is unavailable.
+        /// </summary>
+        public ReadOnlyCollection<CommandParameterSetInfo> GetCommandParameterSets(string name, Ast callSite = null)
+        {
+            return CommandInfoCache.GetCommandParameterSets(name, callSite);
+        }
+
+        /// <summary>Gets detached parameter facts or null when unavailable; only static cmdlet metadata is cached.</summary>
+        public IReadOnlyDictionary<string, CommandParameterSnapshot> GetCommandParameterSnapshot(
+            string name, CommandTypes? commandType = null, bool bypassCache = false, Ast callSite = null)
+        {
+            return CommandInfoCache.GetParameterSnapshot(name, commandType, bypassCache, callSite);
+        }
+
+        /// <summary>Gets the mandatory parameter summary under a single runspace lock, or null when unavailable.</summary>
+        public IReadOnlyList<string> GetMandatoryParameterNames(string name, Ast callSite = null)
+        {
+            return CommandInfoCache.GetMandatoryParameterNames(name, callSite);
         }
 
         /// <summary>
@@ -1142,24 +1206,28 @@ public Dictionary<string, List<RuleSuppression>> GetRuleSuppression(Ast ast)
                 ruleSuppressionList.AddRange(RuleSuppression.GetSuppressions(sbAst.ParamBlock.Attributes, sbAst.Extent.StartOffset, sbAst.Extent.EndOffset, sbAst));
             }
 
+            // Walk the tree once, retaining the existing function/class/configuration processing order.
+            var declarationAsts = ast.FindAll(item => item is FunctionDefinitionAst
+                || item is TypeDefinitionAst || item is ConfigurationDefinitionAst, true).ToArray();
+
             // Get rule suppression from functions
-            IEnumerable<FunctionDefinitionAst> funcAsts = ast.FindAll(item => item is FunctionDefinitionAst, true).Cast<FunctionDefinitionAst>();
+            IEnumerable<FunctionDefinitionAst> funcAsts = declarationAsts.OfType<FunctionDefinitionAst>();
 
             foreach (var funcAst in funcAsts)
             {
                 ruleSuppressionList.AddRange(GetSuppressionsFunction(funcAst));
             }
 
             // Get rule suppression from classes
-            IEnumerable<TypeDefinitionAst> typeAsts = ast.FindAll(item => item is TypeDefinitionAst, true).Cast<TypeDefinitionAst>();
+            IEnumerable<TypeDefinitionAst> typeAsts = declarationAsts.OfType<TypeDefinitionAst>();
 
             foreach (var typeAst in typeAsts)
             {
                 ruleSuppressionList.AddRange(GetSuppressionsClass(typeAst));
             }
 
             // Get rule suppression from configuration definitions
-            IEnumerable<ConfigurationDefinitionAst> configDefAsts = ast.FindAll(item => item is ConfigurationDefinitionAst, true).Cast<ConfigurationDefinitionAst>();
+            IEnumerable<ConfigurationDefinitionAst> configDefAsts = declarationAsts.OfType<ConfigurationDefinitionAst>();
 
             foreach (var configDefAst in configDefAsts)
             {