Add new AvoidUsingArrayList rule

Rules/AvoidUsingArrayList.cs

@@ -0,0 +1,195 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+#if !CORECLR
+using System.ComponentModel.Composition;
+#endif
+using System.Globalization;
+using System.Management.Automation.Language;
+using Microsoft.Windows.PowerShell.ScriptAnalyzer.Generic;
+using System.Text.RegularExpressions;
+using System.Linq;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
+{
+    /// <summary>
+    /// AvoidUsingArrayList: Checks for use of the ArrayList class
+    /// </summary>
+#if !CORECLR
+    [Export(typeof(IScriptRule))]
+#endif
+    public class AvoidUsingArrayList : ConfigurableRule
+    {
+
+        /// <summary>
+        /// Construct an object of AvoidUsingArrayList type.
+        /// </summary>
+        public AvoidUsingArrayList() {
+            Enable = false;
+        }
+
+        /// <summary>
+        /// Analyzes the given ast to find the [violation]
+        /// </summary>
+        /// <param name="ast">AST to be analyzed. This should be non-null</param>
+        /// <param name="fileName">Name of file that corresponds to the input AST.</param>
+        /// <returns>A an enumerable type containing the violations</returns>
+        public override IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
+        {
+            if (ast == null) { throw new ArgumentNullException(nameof(ast), Strings.NullAstErrorMessage); }
+
+            // If there is an using statement for the Collections namespace, check for the full typename.
+            // Otherwise also check for the bare ArrayList name.
+            Regex arrayListName = null;
+            if (ast is ScriptBlockAst sbAst) {
+                // sbAst.UsingStatements causes an error: Method not found: ScriptBlockAst.get_UsingStatements()
+                IEnumerable<Ast> usingStatements = usingStatements = sbAst.FindAll(testAst => testAst is UsingStatementAst, false);
+                foreach (UsingStatementAst usingAst in usingStatements.Cast<UsingStatementAst>())
+                {
+                    if (
+                        usingAst.UsingStatementKind == UsingStatementKind.Namespace &&
+                        (
+                            usingAst.Name.Value.Equals("Collections", StringComparison.OrdinalIgnoreCase) ||
+                            usingAst.Name.Value.Equals("System.Collections", StringComparison.OrdinalIgnoreCase)
+                        )
+                    )
+                    {
+                        arrayListName = new Regex(@"^((System\.)?Collections\.)?ArrayList$", RegexOptions.IgnoreCase);
+                        break;
+                    }
+                }
+            }
+            if (arrayListName == null) { arrayListName = new Regex(@"^(System\.)?Collections\.ArrayList$", RegexOptions.IgnoreCase); }
+
+            // Find all type initializers that create a new instance of the ArrayList class.
+            IEnumerable<Ast> typeAsts = ast.FindAll(testAst =>
+                (
+                    testAst is ConvertExpressionAst convertAst &&
+                    convertAst.StaticType != null &&
+                    convertAst.StaticType.FullName == "System.Collections.ArrayList"
+                ) ||
+                (
+                    testAst is TypeExpressionAst typeAst &&
+                    typeAst.TypeName != null &&
+                    arrayListName.IsMatch(typeAst.TypeName.Name) &&
+                    typeAst.Parent is InvokeMemberExpressionAst parentAst &&
+                    parentAst.Member != null &&
+                    parentAst.Member is StringConstantExpressionAst memberAst &&
+                    memberAst.Value.Equals("new", StringComparison.OrdinalIgnoreCase)
+                ),
+                true
+            );
+
+            foreach (Ast typeAst in typeAsts)
+            {
+                IScriptExtent Extent = typeAst is ConvertExpressionAst? typeAst.Extent : typeAst.Parent.Extent;
+                yield return new DiagnosticRecord(
+                    string.Format(
+                        CultureInfo.CurrentCulture,
+                        Strings.AvoidUsingArrayListError,
+                        Extent.Text),
+                    Extent,
+                    GetName(),
+                    DiagnosticSeverity.Warning,
+                    fileName
+                );
+            }
+
+            // Find all New-Object cmdlets that create a new instance of the ArrayList class.
+            var newObjectCommands = ast.FindAll(testAst =>
+                testAst is CommandAst cmdAst &&
+                cmdAst.GetCommandName() != null &&
+                cmdAst.GetCommandName().Equals("New-Object", StringComparison.OrdinalIgnoreCase),
+                true);
+
+            foreach (CommandAst cmd in newObjectCommands)
+            {
+                // Use StaticParameterBinder to reliably get parameter values
+                var bindingResult = StaticParameterBinder.BindCommand(cmd, true);
+
+                // Check for -TypeName parameter
+                if (
+                    bindingResult.BoundParameters.TryGetValue("TypeName",  out ParameterBindingResult typeNameBinding) &&
+                    typeNameBinding.ConstantValue is string typeName &&
+                    arrayListName.IsMatch(typeName)
+                )
+                {
+                    yield return new DiagnosticRecord(
+                        string.Format(
+                            CultureInfo.CurrentCulture,
+                            Strings.AvoidUsingArrayListError,
+                            cmd.Extent.Text),
+                        cmd.Extent,
+                        GetName(),
+                        DiagnosticSeverity.Warning,
+                        fileName
+                    );
+                }
+            }
+        }
+
+        /// <summary>
+        /// Retrieves the common name of this rule.
+        /// </summary>
+        public override string GetCommonName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingArrayListCommonName);
+        }
+
+        /// <summary>
+        /// Retrieves the description of this rule.
+        /// </summary>
+        public override string GetDescription()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsingArrayListDescription);
+        }
+
+        /// <summary>
+        /// Retrieves the name of this rule.
+        /// </summary>
+        public override string GetName()
+        {
+            return string.Format(
+                CultureInfo.CurrentCulture,
+                Strings.NameSpaceFormat,
+                GetSourceName(),
+                Strings.AvoidUsingArrayListName);
+        }
+
+        /// <summary>
+        /// Retrieves the severity of the rule: error, warning or information.
+        /// </summary>
+        public override RuleSeverity GetSeverity()
+        {
+            return RuleSeverity.Warning;
+        }
+
+        /// <summary>
+        /// Gets the severity of the returned diagnostic record: error, warning, or information.
+        /// </summary>
+        /// <returns></returns>
+        public DiagnosticSeverity GetDiagnosticSeverity()
+        {
+            return DiagnosticSeverity.Warning;
+        }
+
+        /// <summary>
+        /// Retrieves the name of the module/assembly the rule is from.
+        /// </summary>
+        public override string GetSourceName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.SourceName);
+        }
+
+        /// <summary>
+        /// Retrieves the type of the rule, Builtin, Managed or Module.
+        /// </summary>
+        public override SourceType GetSourceType()
+        {
+            return SourceType.Builtin;
+        }
+    }
+}
+

Rules/Strings.resx

@@ -933,6 +933,18 @@
   <data name="AvoidSemicolonsAsLineTerminatorsError" xml:space="preserve">
     <value>Line ends with a semicolon</value>
   </data>
+  <data name="AvoidUsingArrayListCommonName" xml:space="preserve">
+    <value>Avoid using the ArrayList class</value>
+  </data>
+  <data name="AvoidUsingArrayListDescription" xml:space="preserve">
+      <value>Avoid using the ArrayList class in PowerShell scripts. Consider using generic collections or fixed arrays instead.</value>
+  </data>
+  <data name="AvoidUsingArrayListName" xml:space="preserve">
+      <value>AvoidUsingArrayList</value>
+  </data>
+  <data name="AvoidUsingArrayListError" xml:space="preserve">
+      <value>The ArrayList class is used in '{0}'. Consider using a generic collection or a fixed array instead.</value>
+  </data>
   <data name="PlaceOpenBraceName" xml:space="preserve">
     <value>PlaceOpenBrace</value>
   </data>