More code cleanup

Author: Robert Holt

Engine/Helper.cs

@@ -28,20 +28,20 @@ public class Helper
 
         private readonly CommandInvocationIntrinsics _invokeCommand;
 
+        private readonly Lazy<CommandInfoCache> _commandInfoCache;
+
         private Dictionary<string, Dictionary<string, object>> _ruleArguments;
 
         private PSVersionTable _psVersionTable;
 
-        private Lazy<CommandInfoCache> _commandInfoCache;
-
         private CommandInfoCache CommandInfoCache => _commandInfoCache.Value;
 
         #endregion
 
         #region Singleton
-        private static object syncRoot = new Object();
+        private static readonly object s_syncRoot = new object();
 
-        private static Helper instance;
+        private static Helper s_instance;
 
         /// <summary>
         /// The helper instance that handles utility functions
@@ -50,20 +50,20 @@ public static Helper Instance
         {
             get
             {
-                if (instance == null)
+                if (s_instance == null)
                 {
                     Instance = new Helper();
                 }
 
-                return instance;
+                return s_instance;
             }
             internal set
             {
-                lock (syncRoot)
+                lock (s_syncRoot)
                 {
-                    if (instance == null)
+                    if (s_instance == null)
                     {
-                        instance = value;
+                        s_instance = value;
                     }
                 }
             }
@@ -76,14 +76,14 @@ internal set
         /// <summary>
         /// Dictionary contains mapping of cmdlet to alias
         /// </summary>
-        private Dictionary<String, List<String>> CmdletToAliasDictionary;
+        private readonly Dictionary<string, List<string>> _cmdletToAliasDictionary;
 
         /// <summary>
         /// Dictionary contains mapping of alias to cmdlet
         /// </summary>
-        private Dictionary<String, String> AliasToCmdletDictionary;
+        private readonly Dictionary<string, string> _aliasToCmdletDictionary;
 
-        internal TupleComparer tupleComparer = new TupleComparer();
+        internal TupleComparer TupleComparer { get; } = new TupleComparer();
 
         /// <summary>
         /// My Tokens
@@ -96,24 +96,30 @@ internal set
         /// the starting position of the open curly brace and the second item
         /// is the closing position of the closing curly brace.
         /// </summary>
-        private Dictionary<String, List<Tuple<int, int>>> KeywordBlockDictionary;
+        private readonly Dictionary<string, List<Tuple<int, int>>> _keywordBlockDictionary;
 
         /// <summary>
         /// Key of dictionary is ast, value is the corresponding variableanalysis
         /// </summary>
-        private Dictionary<Ast, VariableAnalysis> VariableAnalysisDictionary;
+        private readonly Dictionary<Ast, VariableAnalysis> VariableAnalysisDictionary;
+
+        private readonly IReadOnlyList<string> functionScopes = new string[] { "global:", "local:", "script:", "private:"};
 
-        private string[] functionScopes = new string[] { "global:", "local:", "script:", "private:"};
+        private readonly IReadOnlyList<string> variableScopes = new string[] { "global:", "local:", "script:", "private:", "variable:", ":"};
 
-        private string[] variableScopes = new string[] { "global:", "local:", "script:", "private:", "variable:", ":"};
         #endregion
 
         /// <summary>
         /// Initializes the Helper class.
         /// </summary>
         private Helper()
         {
-
+            _ruleArguments = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);
+            _commandInfoCache = new Lazy<CommandInfoCache>(() => new CommandInfoCache());
+            _cmdletToAliasDictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
+            _aliasToCmdletDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            _keywordBlockDictionary = new Dictionary<string, List<Tuple<int, int>>>(StringComparer.OrdinalIgnoreCase);
+            VariableAnalysisDictionary = new Dictionary<Ast, VariableAnalysis>();
         }
 
         /// <summary>
@@ -123,37 +129,34 @@ private Helper()
         /// A CommandInvocationIntrinsics instance for use in gathering
         /// information about available commands and aliases.
         /// </param>
-        public Helper(CommandInvocationIntrinsics invokeCommand)
+        public Helper(CommandInvocationIntrinsics invokeCommand) : base()
         {
             _invokeCommand = invokeCommand;
-            _ruleArguments = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);
-            _commandInfoCache = new Lazy<CommandInfoCache>(() => new CommandInfoCache());
-            CmdletToAliasDictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
-            AliasToCmdletDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-            KeywordBlockDictionary = new Dictionary<string, List<Tuple<int, int>>>(StringComparer.OrdinalIgnoreCase);
-            VariableAnalysisDictionary = new Dictionary<Ast, VariableAnalysis>();
         }
 
         #region Methods
         /// <summary>
-        /// Initialize : Initializes dictionary of alias.
+        /// Creates the alias dictionary from the current PowerShell session.
         /// </summary>
         public void Initialize()
         {
-            IEnumerable<CommandInfo> aliases = _invokeCommand.GetCommands("*", CommandTypes.Alias, nameIsPattern: true);
-
-            foreach (AliasInfo aliasInfo in aliases)
+            if (_invokeCommand != null)
             {
-                if (!CmdletToAliasDictionary.ContainsKey(aliasInfo.Definition))
-                {
-                    CmdletToAliasDictionary.Add(aliasInfo.Definition, new List<string>() { aliasInfo.Name });
-                }
-                else
+                IEnumerable<CommandInfo> aliases = _invokeCommand.GetCommands("*", CommandTypes.Alias, nameIsPattern: true);
+
+                foreach (AliasInfo aliasInfo in aliases)
                 {
-                    CmdletToAliasDictionary[aliasInfo.Definition].Add(aliasInfo.Name);
-                }
+                    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);
+                    _aliasToCmdletDictionary.Add(aliasInfo.Name, aliasInfo.Definition);
+                }
             }
         }
 
@@ -221,9 +224,9 @@ public List<String> CmdletNameAndAliases(String Cmdlet)
             List<String> results = new List<String>();
             results.Add(Cmdlet);
 
-            if (CmdletToAliasDictionary.ContainsKey(Cmdlet))
+            if (_cmdletToAliasDictionary.ContainsKey(Cmdlet))
             {
-                results.AddRange(CmdletToAliasDictionary[Cmdlet]);
+                results.AddRange(_cmdletToAliasDictionary[Cmdlet]);
             }
 
             return results;
@@ -236,9 +239,9 @@ public List<String> CmdletNameAndAliases(String Cmdlet)
         /// <returns></returns>
         public string GetCmdletNameFromAlias(String Alias)
         {
-            if (AliasToCmdletDictionary.ContainsKey(Alias))
+            if (_aliasToCmdletDictionary.ContainsKey(Alias))
             {
-                return AliasToCmdletDictionary[Alias];
+                return _aliasToCmdletDictionary[Alias];
             }
 
             return String.Empty;
@@ -525,7 +528,7 @@ item is TypeDefinitionAst
             return false;
         }
 
-        private string NameWithoutScope(string name, string[] scopes)
+        private string NameWithoutScope(string name, IReadOnlyList<string> scopes)
         {
             if (String.IsNullOrWhiteSpace(name) || scopes == null)
             {
@@ -765,14 +768,14 @@ public bool SkipBlock(string keyword, Ast namedBlockAst)
 
             FindClosingParenthesis(keyword);
 
-            List<Tuple<int, int>> listTuples = KeywordBlockDictionary[keyword];
+            List<Tuple<int, int>> listTuples = _keywordBlockDictionary[keyword];
 
             if (listTuples == null || listTuples.Count == 0)
             {
                 return false;
             }
 
-            int index = listTuples.BinarySearch(Tuple.Create(namedBlockAst.Extent.StartOffset, namedBlockAst.Extent.EndOffset), tupleComparer);
+            int index = listTuples.BinarySearch(Tuple.Create(namedBlockAst.Extent.StartOffset, namedBlockAst.Extent.EndOffset), TupleComparer);
 
             if (index < 0 || index >= Tokens.Length)
             {
@@ -828,12 +831,12 @@ private void FindClosingParenthesis(string keyword)
             }
 
             // Only do this one time per script. The keywordblockdictionary is cleared everytime we run a new script
-            if (KeywordBlockDictionary.ContainsKey(keyword))
+            if (_keywordBlockDictionary.ContainsKey(keyword))
             {
                 return;
             }
 
-            KeywordBlockDictionary[keyword] = new List<Tuple<int, int>>();
+            _keywordBlockDictionary[keyword] = new List<Tuple<int, int>>();
 
             int[] tokenIndices = Tokens
                 .Select((token, index) =>
@@ -888,7 +891,7 @@ private void FindClosingParenthesis(string keyword)
                     continue;
                 }
 
-                KeywordBlockDictionary[keyword].Add(Tuple.Create(Tokens[openCurly].Extent.StartOffset,
+                _keywordBlockDictionary[keyword].Add(Tuple.Create(Tokens[openCurly].Extent.StartOffset,
                     Tokens[closeCurly].Extent.EndOffset));
             }
         }