Add more type check to UseLiteralInitializerForHashtable rule

Author: Kapil Borle

Rules/UseLiteralInitializerForHashtable.cs

@@ -38,7 +38,8 @@ public UseLiteralInitializerForHashtable()
         {
             var presetTypeNames = new string[]
             {
-                "system.collection.hashtable",
+                "system.collections.hashtable",
+                "collections.hashtable",
                 "hashtable"
             };
             presetTypeNameSet = new HashSet<string>(presetTypeNames, StringComparer.OrdinalIgnoreCase);
@@ -204,12 +205,11 @@ private void AnalyzeNewObjectCommand(CommandAst commandAst)
                 return;
             }
 
-            if (argumentList != null)
+
+            if (argumentList != null
+                && HasIgnoreCaseComparerArg(argumentList))
             {
-                if (argumentList.Any(arg => arg != null && arg.EndsWith("ignorecase", StringComparison.OrdinalIgnoreCase)))
-                {
-                    return;
-                }
+                return;
             }
 
             var dr = new DiagnosticRecord(
@@ -225,6 +225,9 @@ private void AnalyzeNewObjectCommand(CommandAst commandAst)
 
         /// <summary>
         /// Interpret the named and unnamed arguments and assign them their corresponding parameters
+        ///
+        /// PSv4 onwards there exists System.Management.Automation.Language.StaticParameterBinder.BindCommand to
+        /// achieve identical objective. But since we support PSSA on PSv3 too we need this implementation.
         /// </summary>
         /// <param name="commandAst">An non-null instance of CommandAst. Expects it be commandast of "new-object" command</param>
         /// <param name="typeName">Returns the TypeName argument</param>
@@ -356,9 +359,11 @@ private List<CommandElementAst> GetNamedArguments(ReadOnlyCollection<CommandElem
         /// <param name="arguments">A collection of argument asts. Neither this nor any elements within it should be null</param>
         private bool HasIgnoreCaseComparerArg(ReadOnlyCollection<ExpressionAst> arguments)
         {
+            var argumentsAsStrings = new List<string>();
             foreach (var arg in arguments)
             {
                 var memberExprAst = arg as MemberExpressionAst;
+                argumentsAsStrings.Add(null);
                 if (memberExprAst == null)
                 {
                     continue;
@@ -369,13 +374,30 @@ private bool HasIgnoreCaseComparerArg(ReadOnlyCollection<ExpressionAst> argument
                 {
                     continue;
                 }
+                argumentsAsStrings[argumentsAsStrings.Count - 1] = strConstExprAst.Value;
+            }
+            return HasIgnoreCaseComparerArg(argumentsAsStrings);
+        }
 
-                if (strConstExprAst.Value.EndsWith("ignorecase"))
+        /// <summary>
+        /// Checks if any argument in the given collection ends with "ignorecase"
+        /// </summary>
+        /// <param name="arguments">An enumerable of type string. Elements can be null but the collection must be non-null  .</param>
+        /// <returns></returns>
+        private bool HasIgnoreCaseComparerArg(IEnumerable<string> arguments)
+        {
+
+            foreach (var arg in arguments)
+            {
+                if (arg == null)
+                {
+                    continue;
+                }
+                if (arg.EndsWith("ignorecase", StringComparison.OrdinalIgnoreCase))
                 {
                     return true;
                 }
             }
-
             return false;
         }
 

Tests/Rules/UseLiteralInitializerForHashtable.tests.ps1

@@ -6,11 +6,12 @@ Describe "UseLiteralInitlializerForHashtable" {
         It "has violation" {
             $violationScriptDef = @'
             $htable1 = new-object hashtable
-            $htable2 = new-object system.collection.hashtable
+            $htable2 = new-object system.collections.hashtable
             $htable3 = new-object -Typename hashtable -ArgumentList 10
+            $htable4 = new-object collections.hashtable
 '@
             $violations = Invoke-ScriptAnalyzer -ScriptDefinition $violationScriptDef -IncludeRule $ruleName
-            $violations.Count | Should Be 3
+            $violations.Count | Should Be 4
         }
 
         It "does not detect violation if arguments given to new-object contain ignore case string comparer" {
@@ -37,11 +38,12 @@ Describe "UseLiteralInitlializerForHashtable" {
         It "has violation" {
             $violationScriptDef = @'
             $htable1 = [hashtable]::new()
-            $htable2 = [system.collection.hashtable]::new()
+            $htable2 = [system.collections.hashtable]::new()
             $htable3 = [hashtable]::new(10)
+            $htable4 = [collections.hashtable]::new()
 '@
             $violations = Invoke-ScriptAnalyzer -ScriptDefinition $violationScriptDef -IncludeRule $ruleName
-            $violations.Count | Should Be 3
+            $violations.Count | Should Be 4
         }
 
         It "does not detect violation if arguments given to [hashtable]::new contain ignore case string comparer" {