Do not fail analysis on transient command lookup failures (issue 2205)

Co-authored-by: jessehouwing <4173387+jessehouwing@users.noreply.github.com>

Author: Copilot

Engine/CommandInfoCache.cs

@@ -14,6 +14,13 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
     /// </summary>
     internal class CommandInfoCache : IDisposable
     {
+        /// <summary>
+        /// Number of times a command lookup is attempted before giving up.
+        /// Command lookups can fail transiently because the PowerShell engine is not thread safe,
+        /// see https://github.com/PowerShell/PowerShell/issues/4003
+        /// </summary>
+        private const int MaxLookupAttempts = 3;
+
         private readonly ConcurrentDictionary<CommandLookupKey, Lazy<CommandInfo>> _commandInfoCache;
         private readonly RunspacePool _runspacePool;
         private bool disposed = false;
@@ -70,7 +77,19 @@ public CommandInfo GetCommandInfo(string commandName, CommandTypes? commandTypes
                 return GetCommandInfoInternal(commandName, commandTypes);
             }
             // Atomically either use PowerShell to query a command info object, or fetch it from the cache
-            return _commandInfoCache.GetOrAdd(key, new Lazy<CommandInfo>(() => GetCommandInfoInternal(commandName, commandTypes))).Value;
+            var lazyCommandInfo = _commandInfoCache.GetOrAdd(key, new Lazy<CommandInfo>(() => GetCommandInfoInternal(commandName, commandTypes)));
+            try
+            {
+                return lazyCommandInfo.Value;
+            }
+            catch
+            {
+                // Lazy<T> caches exceptions forever, which would make every subsequent lookup of this
+                // command fail for the lifetime of the process. Evict the entry so that the next lookup
+                // can try again.
+                _commandInfoCache.TryRemove(key, out _);
+                throw;
+            }
         }
 
 
@@ -99,26 +118,46 @@ private CommandInfo GetCommandInfoInternal(string cmdName, CommandTypes? command
             // For more details see https://github.com/PowerShell/PowerShell/issues/9308
             actualCmdName = WildcardPattern.Escape(actualCmdName);
 
-            using (var ps = System.Management.Automation.PowerShell.Create())
+            for (int attempt = 1; ; attempt++)
             {
-                ps.RunspacePool = _runspacePool;
-
-                ps.AddCommand("Get-Command")
-                    .AddParameter("Name", actualCmdName)
-                    .AddParameter("ErrorAction", "SilentlyContinue");
-
-                if (commandType != null)
-                {
-                    ps.AddParameter("CommandType", commandType);
-                }
-
-                if (!string.IsNullOrEmpty(moduleName))
+                using (var ps = System.Management.Automation.PowerShell.Create())
                 {
-                    ps.AddParameter("Module", moduleName);
+                    ps.RunspacePool = _runspacePool;
+
+                    ps.AddCommand("Get-Command")
+                        .AddParameter("Name", actualCmdName)
+                        .AddParameter("ErrorAction", "SilentlyContinue");
+
+                    if (commandType != null)
+                    {
+                        ps.AddParameter("CommandType", commandType);
+                    }
+
+                    if (!string.IsNullOrEmpty(moduleName))
+                    {
+                        ps.AddParameter("Module", moduleName);
+                    }
+
+                    try
+                    {
+                        return ps.Invoke<CommandInfo>()
+                            .FirstOrDefault();
+                    }
+                    // 'Get-Command' is invoked with 'SilentlyContinue', so a CommandNotFoundException can only
+                    // mean that the engine failed to resolve 'Get-Command' itself in the pooled runspace.
+                    // That happens intermittently because the PowerShell engine is not thread safe, see
+                    // https://github.com/PowerShell/PowerShell/issues/4003 and
+                    // https://github.com/PowerShell/PSScriptAnalyzer/issues/2205
+                    // Retrying usually succeeds, but rather than failing the whole analysis when it does not,
+                    // treat the command as unresolvable.
+                    catch (CommandNotFoundException)
+                    {
+                        if (attempt >= MaxLookupAttempts)
+                        {
+                            return null;
+                        }
+                    }
                 }
-
-                return ps.Invoke<CommandInfo>()
-                    .FirstOrDefault();
             }
         }
 

Rules/UseCorrectCasing.cs

@@ -128,10 +128,17 @@ public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string file
                     // 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)
+                    // The affinity problem surfaces as an InvalidOperationException or as a
+                    // NullReferenceException, see https://github.com/PowerShell/PSScriptAnalyzer/issues/1708
+                    catch (Exception exception) when (exception is InvalidOperationException || exception is NullReferenceException)
                     {
-                        commandInfo = Helper.Instance.GetCommandInfo(commandName, bypassCache: true);
-                        availableParameters = commandInfo.Parameters;
+                        availableParameters = GetParametersFromFreshCommandInfo(commandName);
+                    }
+                    if (availableParameters is null)
+                    {
+                        // 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)
                     {
@@ -161,6 +168,22 @@ public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string file
             }
         }
 
+        /// <summary>
+        /// Queries a fresh <see cref="CommandInfo"/> object to work around the runspace affinity problem
+        /// of the PowerShell engine and returns its parameters, or null if they cannot be determined.
+        /// </summary>
+        private Dictionary<string, ParameterMetadata> GetParametersFromFreshCommandInfo(string commandName)
+        {
+            try
+            {
+                return Helper.Instance.GetCommandInfo(commandName, bypassCache: true)?.Parameters;
+            }
+            catch (Exception exception) when (exception is InvalidOperationException || exception is NullReferenceException)
+            {
+                return null;
+            }
+        }
+
         /// <summary>
         /// For a command like "gci -path c:", returns the extent of "gci" in the command
         /// </summary>

Tests/Rules/Issue2205.tests.ps1

@@ -2,7 +2,7 @@
 # Licensed under the MIT License.
 
 Describe 'Issue 2205' {
-    It "reproduces the Linux recursive analysis failure" -Skip:(-not $IsLinux) {
+    It "does not fail the analysis when a command lookup hits the runspace affinity problem" -Skip:(-not $IsLinux) {
         $settingsPath = Join-Path $PSScriptRoot 'Issue2205/PSScriptAnalyzerSettings.psd1'
         $repositoryRoot = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)