Fix intermittent "The term 'Get-Command' is not recognized" failures during recursive analysis

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("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)
                         {
@@ -671,6 +697,36 @@ public CommandInfo GetCommandInfo(string name, CommandTypes? commandType = null,
             return CommandInfoCache.GetCommandInfo(name, commandTypes: commandType, bypassCache: bypassCache);
         }
 
+        /// <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)
+        {
+            return CommandInfoCache.GetCommandParameters(name, commandType, bypassCache);
+        }
+
+        /// <summary>
+        /// Retrieves command parameter sets with centralized recovery; returns null when metadata is unavailable.
+        /// </summary>
+        public ReadOnlyCollection<CommandParameterSetInfo> GetCommandParameterSets(string name)
+        {
+            return CommandInfoCache.GetCommandParameterSets(name);
+        }
+
+        /// <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)
+        {
+            return CommandInfoCache.GetParameterSnapshot(name, commandType, bypassCache);
+        }
+
+        /// <summary>Gets the mandatory parameter summary under a single runspace lock, or null when unavailable.</summary>
+        public IReadOnlyList<string> GetMandatoryParameterNames(string name)
+        {
+            return CommandInfoCache.GetMandatoryParameterNames(name);
+        }
+
         /// <summary>
         /// Returns the get, set and test targetresource dsc function
         /// </summary>

Engine/ModuleManifestAnalysisCache.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Management.Automation;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
+{
+    // Owned by one AnalyzeSyntaxTree call and explicitly installed on its rule workers.
+    // It cannot outlive that analysis or affect unrelated public GetModuleManifest callers.
+    internal sealed class ModuleManifestAnalysisCache
+    {
+        [ThreadStatic]
+        internal static ModuleManifestAnalysisCache Current;
+
+        private readonly Dictionary<string, Result> results = new Dictionary<string, Result>(StringComparer.Ordinal);
+
+        internal PSModuleInfo Get(Helper helper, string path, out IEnumerable<ErrorRecord> errors)
+        {
+            lock (results)
+            {
+                if (!results.TryGetValue(path, out var result))
+                {
+                    var module = helper.GetModuleManifest(path, out var moduleErrors);
+                    result = new Result { Module = module, Errors = moduleErrors };
+                    results.Add(path, result);
+                }
+                errors = result.Errors;
+                return result.Module;
+            }
+        }
+
+        internal Scope Enter() => new Scope(this);
+
+        internal struct Scope : IDisposable
+        {
+            private readonly ModuleManifestAnalysisCache previous;
+
+            internal Scope(ModuleManifestAnalysisCache cache)
+            {
+                previous = Current;
+                Current = cache;
+            }
+
+            public void Dispose() => Current = previous;
+        }
+
+        private sealed class Result
+        {
+            internal PSModuleInfo Module;
+            internal IEnumerable<ErrorRecord> Errors;
+        }
+    }
+}

Engine/ScriptAnalyzer.cs

@@ -2128,6 +2128,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeSyntaxTree(
             string fileName = filePathIsNullOrWhiteSpace ? String.Empty : System.IO.Path.GetFileName(filePath);
             if (this.ScriptRules != null)
             {
+                var manifestCache = new ModuleManifestAnalysisCache();
                 var allowedRules = this.ScriptRules.Where(IsRuleAllowed);
                 if (allowedRules.Any())
                 {
@@ -2139,6 +2140,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeSyntaxTree(
 
                         // Ensure that any unhandled errors from Rules are converted to non-terminating errors
                         // We want the Engine to continue functioning even if one or more Rules throws an exception
+                        using (manifestCache.Enter())
                         try
                         {
                             if (helpRule && helpFile)

README.md

@@ -137,6 +137,12 @@ To install **PSScriptAnalyzer** from source code:
   Import-Module .\out\PSScriptAnalyzer\[version]\PSScriptAnalyzer.psd1
   ```
 
+- Command metadata handling lives in `CommandInfoCache`, not individual rules. Its parameter,
+  parameter-set and snapshot APIs return null when PowerShell metadata is unavailable, while
+  unexpected exceptions still propagate. Failed lookups and command objects with failed
+  metadata are evicted so subsequent calls can recover; genuine missing commands retain
+  negative caching.
+
 To confirm installation: run `Get-ScriptAnalyzerRule` in the PowerShell console to obtain the
 built-in rules.
 

Rules/MissingModuleManifestField.cs

@@ -40,7 +40,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
             if (Helper.IsModuleManifest(fileName))
             {
                 IEnumerable<ErrorRecord> errorRecords;
-                var psModuleInfo = Helper.Instance.GetModuleManifest(fileName, out errorRecords);
+                var psModuleInfo = Helper.Instance.GetModuleManifestForAnalysis(fileName, out errorRecords);
                 if (errorRecords != null)
                 {
                     foreach (var errorRecord in errorRecords)

Rules/UseCmdletCorrectly.cs

@@ -145,41 +145,9 @@ private bool MandatoryParameterExists(CommandAst cmdAst)
 
             // Gets mandatory parameters from cmdlet.
             // If cannot find any mandatory parameter, it's not necessary to do a further check for current cmdlet.
-            var mandatoryParameters = new List<ParameterMetadata>();
-            try
-            {
-                int noOfParamSets = cmdInfo.ParameterSets.Count;
-                foreach (ParameterMetadata pm in cmdInfo.Parameters.Values)
-                {
-                    int count = 0;
-
-                    if (pm.Attributes.Count < noOfParamSets)
-                    {
-                        continue;
-                    }
+            var mandatoryParameters = Helper.Instance.GetMandatoryParameterNames(cmdAst.GetCommandName());
 
-                    foreach (Attribute attr in pm.Attributes)
-                    {
-                        if (!(attr is ParameterAttribute)) continue;
-                        if (((ParameterAttribute)attr).Mandatory)
-                        {
-                            count += 1;
-                        }
-                    }
-
-                    if (count >= noOfParamSets)
-                    {
-                        mandatoryParameters.Add(pm);
-                    }
-                }
-            }
-            catch (Exception)
-            {
-                // For cases like cmd.exe. Also for runtime exception
-                return true;
-            }
-
-            if (mandatoryParameters.Count == 0)
+            if (mandatoryParameters == null || mandatoryParameters.Count == 0)
             {
                 return true;
             }
@@ -188,8 +156,8 @@ private bool MandatoryParameterExists(CommandAst cmdAst)
             foreach (CommandElementAst commandElementAst in cmdAst.CommandElements.OfType<CommandParameterAst>())
             {
                 CommandParameterAst cpAst = (CommandParameterAst)commandElementAst;
-                if (mandatoryParameters.Count<ParameterMetadata>(item =>
-                    item.Name.Equals(cpAst.ParameterName, StringComparison.OrdinalIgnoreCase)) > 0)
+                if (mandatoryParameters.Any(item =>
+                    item.Equals(cpAst.ParameterName, StringComparison.OrdinalIgnoreCase)))
                 {
                     return true;
                 }
@@ -254,6 +222,3 @@ public string GetSourceName()
     }
 }
 
-
-
-

Rules/UseCorrectCasing.cs

@@ -119,24 +119,22 @@ public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string file
                     }
 
                     var commandParameterAsts = commandAst.FindAll(
-                        testAst => testAst is CommandParameterAst, true).Cast<CommandParameterAst>();
-                    Dictionary<string, ParameterMetadata> availableParameters;
-                    try
+                        testAst => testAst is CommandParameterAst, true).Cast<CommandParameterAst>().ToArray();
+                    if (commandParameterAsts.Length == 0)
                     {
-                        availableParameters = commandInfo.Parameters;
+                        continue;
                     }
-                    // It's a known issue that objects from PowerShell can have a runspace affinity,
-                    // therefore if that happens, we query a fresh object instead of using the cache.
-                    // https://github.com/PowerShell/PowerShell/issues/4003
-                    catch (InvalidOperationException)
+                    var availableParameters = Helper.Instance.GetCommandParameterSnapshot(commandName);
+                    if (availableParameters is null)
                     {
-                        commandInfo = Helper.Instance.GetCommandInfo(commandName, bypassCache: true);
-                        availableParameters = commandInfo.Parameters;
+                        // The parameters of this command cannot be determined reliably,
+                        // so skip the parameter casing check instead of failing the analysis.
+                        continue;
                     }
                     foreach (var commandParameterAst in commandParameterAsts)
                     {
                         var parameterName = commandParameterAst.ParameterName;
-                        if (availableParameters.TryGetValue(parameterName, out ParameterMetadata parameterMetaData))
+                        if (availableParameters.TryGetValue(parameterName, out CommandParameterSnapshot parameterMetaData))
                         {
                             var correctlyCasedParameterName = parameterMetaData.Name;
                             if (!parameterName.Equals(correctlyCasedParameterName, StringComparison.Ordinal))

Rules/UseToExportFieldsInManifest.cs

@@ -51,7 +51,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
 
             // check if valid module manifest
             IEnumerable<ErrorRecord> errorRecord = null;
-            PSModuleInfo psModuleInfo = Helper.Instance.GetModuleManifest(fileName, out errorRecord);            
+            PSModuleInfo psModuleInfo = Helper.Instance.GetModuleManifestForAnalysis(fileName, out errorRecord);
             if ((errorRecord != null && errorRecord.Count() > 0) || psModuleInfo == null)
             {                
                 yield break;