Move GetAliases into CommandHelpers

Author: andyleejordan

src/PowerShellEditorServices/Services/PowerShell/Utility/CommandHelpers.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 using System.Collections.Concurrent;
@@ -50,8 +50,9 @@ internal static class CommandHelpers
             };
 
         private static readonly ConcurrentDictionary<string, CommandInfo> s_commandInfoCache = new();
-
         private static readonly ConcurrentDictionary<string, string> s_synopsisCache = new();
+        private static readonly ConcurrentDictionary<string, List<string>> s_cmdletToAliasCache = new(System.StringComparer.OrdinalIgnoreCase);
+        private static readonly ConcurrentDictionary<string, string> s_aliasToCmdletCache = new(System.StringComparer.OrdinalIgnoreCase);
 
         /// <summary>
         /// Gets the CommandInfo instance for a command with a particular name.
@@ -171,5 +172,44 @@ public static async Task<string> GetCommandSynopsisAsync(
 
             return synopsisString;
         }
+
+        /// <summary>
+        /// Gets all aliases found in the runspace
+        /// </summary>
+        /// <param name="executionService"></param>
+        public static async Task<(ConcurrentDictionary<string, List<string>>, ConcurrentDictionary<string, string>)> GetAliasesAsync(IInternalPowerShellExecutionService executionService)
+        {
+            Validate.IsNotNull(nameof(executionService), executionService);
+
+            // TODO: Should we return the caches if they're not empty, or always update?
+            // if (!s_cmdletToAliasCache.IsEmpty || !s_aliasToCmdletCache.IsEmpty)
+            // {
+            //     return (s_cmdletToAliasCache, s_aliasToCmdletCache);
+            // }
+
+            IEnumerable<CommandInfo> aliases = await executionService.ExecuteDelegateAsync<IEnumerable<CommandInfo>>(
+                nameof(GetAliasesAsync),
+                Execution.ExecutionOptions.Default,
+                (pwsh, _) =>
+                {
+                    CommandInvocationIntrinsics invokeCommand = pwsh.Runspace.SessionStateProxy.InvokeCommand;
+                    return invokeCommand.GetCommands("*", CommandTypes.Alias, nameIsPattern: true);
+                },
+                CancellationToken.None).ConfigureAwait(false);
+
+            foreach (AliasInfo aliasInfo in aliases)
+            {
+                // TODO: When we move to netstandard2.1, we can use another overload which generates
+                // static delegates and thus reduces allocations.
+                s_cmdletToAliasCache.AddOrUpdate(
+                    aliasInfo.Definition,
+                    (_) => new List<string> { aliasInfo.Name },
+                    (_, v) => { v.Add(aliasInfo.Name); return v; });
+
+                s_aliasToCmdletCache.TryAdd(aliasInfo.Name, aliasInfo.Definition);
+            }
+
+            return (s_cmdletToAliasCache, s_aliasToCmdletCache);
+        }
     }
 }

src/PowerShellEditorServices/Services/Symbols/SymbolsService.cs

@@ -39,8 +39,6 @@ internal class SymbolsService
 
         private readonly ConcurrentDictionary<string, ICodeLensProvider> _codeLensProviders;
         private readonly ConcurrentDictionary<string, IDocumentSymbolProvider> _documentSymbolProviders;
-        private readonly Dictionary<String, List<String>> _cmdletToAliasDictionary;
-        private readonly Dictionary<String, String> _aliasToCmdletDictionary;
         #endregion
 
         #region Constructors
@@ -85,10 +83,6 @@ public SymbolsService(
             {
                 _documentSymbolProviders.TryAdd(documentSymbolProvider.ProviderId, documentSymbolProvider);
             }
-
-            _cmdletToAliasDictionary = new Dictionary<String, List<String>>(StringComparer.OrdinalIgnoreCase);
-            _aliasToCmdletDictionary = new Dictionary<String, String>(StringComparer.OrdinalIgnoreCase);
-            GetAliases();
         }
 
         #endregion
@@ -191,6 +185,8 @@ public List<SymbolReference> FindReferencesOfSymbol(
                 return null;
             }
 
+            (ConcurrentDictionary<string, List<string>> cmdletToAliases, ConcurrentDictionary<string, string> aliasToCmdlets) = await CommandHelpers.GetAliasesAsync(_executionService).ConfigureAwait(false);
+
             // We want to look for references first in referenced files, hence we use ordered dictionary
             // TODO: File system case-sensitivity is based on filesystem not OS, but OS is a much cheaper heuristic
             var fileMap = RuntimeInformation.IsOSPlatform(OSPlatform.Linux)
@@ -224,8 +220,8 @@ public List<SymbolReference> FindReferencesOfSymbol(
                 IEnumerable<SymbolReference> references = AstOperations.FindReferencesOfSymbol(
                     file.ScriptAst,
                     foundSymbol,
-                    _cmdletToAliasDictionary,
-                    _aliasToCmdletDictionary);
+                    cmdletToAliases,
+                    aliasToCmdlets);
 
                 foreach (SymbolReference reference in references)
                 {
@@ -494,36 +490,6 @@ await CommandHelpers.GetCommandInfoAsync(
             return foundDefinition;
         }
 
-        /// <summary>
-        /// Gets all aliases found in the runspace
-        /// </summary>
-        private async void GetAliases()
-        {
-            IEnumerable<CommandInfo> aliases = await _executionService.ExecuteDelegateAsync<IEnumerable<CommandInfo>>(
-                nameof(GetAliases),
-                PowerShell.Execution.ExecutionOptions.Default,
-                (pwsh, _) =>
-                {
-                    CommandInvocationIntrinsics invokeCommand = pwsh.Runspace.SessionStateProxy.InvokeCommand;
-                    return invokeCommand.GetCommands("*", CommandTypes.Alias, nameIsPattern: true);
-                },
-                System.Threading.CancellationToken.None).ConfigureAwait(false);
-
-            foreach (AliasInfo aliasInfo in aliases)
-            {
-                if (!_cmdletToAliasDictionary.ContainsKey(aliasInfo.Definition))
-                {
-                    _cmdletToAliasDictionary.Add(aliasInfo.Definition, new List<String>() { aliasInfo.Name });
-                }
-                else
-                {
-                    _cmdletToAliasDictionary[aliasInfo.Definition].Add(aliasInfo.Name);
-                }
-
-                _aliasToCmdletDictionary.Add(aliasInfo.Name, aliasInfo.Definition);
-            }
-        }
-
         /// <summary>
         /// Gets a path from a dot-source symbol.
         /// </summary>