add AvoidMultipleTypesParameter Rule

RuleDocumentation/AvoidMultipleTypesParameter.md

@@ -0,0 +1,50 @@
+# AvoidMultipleTypesParameter
+
+**Severity Level: Warning**
+
+## Description
+
+Parameter should not have more than one type specifier.
+
+## How
+
+Make each parameter has only 1 type spcifier.
+
+## Example
+
+### Wrong
+
+``` PowerShell
+function Test-Script
+{
+    [CmdletBinding()]
+    Param
+    (
+        [String]
+        $Param1,
+
+        [switch]
+        [boolean]
+        $Switch=$True
+    )
+    ...
+}
+```
+
+### Correct
+
+``` PowerShell
+function Test-Script
+{
+    [CmdletBinding()]
+    Param
+    (
+        [String]
+        $Param1,
+
+        [switch]
+        $Switch=$False
+    )
+    ...
+}
+```

RuleDocumentation/README.md

@@ -13,6 +13,7 @@
 |[AvoidGlobalVars](./AvoidGlobalVars.md) | Warning | |
 |[AvoidInvokingEmptyMembers](./AvoidInvokingEmptyMembers.md) | Warning | |
 |[AvoidLongLines](./AvoidLongLines.md) | Warning | |
+|[AvoidMultipleTypesParameter](./AvoidMultipleTypesParameter.md) | Warning | |
 |[AvoidOverwritingBuiltInCmdlets](./AvoidOverwritingBuiltInCmdlets.md) | Warning | |
 |[AvoidNullOrEmptyHelpMessageAttribute](./AvoidNullOrEmptyHelpMessageAttribute.md) | Warning | |
 |[AvoidShouldContinueWithoutForce](./AvoidShouldContinueWithoutForce.md) | Warning | |

Rules/AvoidMultipleTypesParameter.cs

@@ -0,0 +1,98 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Management.Automation.Language;
+using Microsoft.Windows.PowerShell.ScriptAnalyzer.Generic;
+#if !CORECLR
+using System.ComponentModel.Composition;
+#endif
+using System.Globalization;
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer.BuiltinRules
+{
+    /// <summary>
+    /// AvoidMultipleTypesParameter: Check that parameter does not be assigned to multiple types.
+    /// </summary>
+#if !CORECLR
+    [Export(typeof(IScriptRule))]
+#endif
+    public sealed class AvoidMultipleTypesParameter : IScriptRule
+    {
+        /// <summary>
+        /// AvoidMultipleTypesParameter: Check that parameter does not be assigned to multiple types.
+        /// </summary>
+        public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
+        {
+            if (ast == null) throw new ArgumentNullException(Strings.NullAstErrorMessage);
+
+            // Finds all ParamAsts.
+            IEnumerable<Ast> paramAsts = ast.FindAll(testAst => testAst is ParameterAst, true);
+
+            // Iterates all ParamAsts and check the number of its types.
+            foreach (ParameterAst paramAst in paramAsts)
+            {
+                if (paramAst.Attributes.Where(typeAst => typeAst is TypeConstraintAst).Count() > 1)
+                {
+                    yield return new DiagnosticRecord(
+                        String.Format(CultureInfo.CurrentCulture, Strings.AvoidMultipleTypesParameterError, paramAst.Name),
+                        paramAst.Name.Extent, GetName(), DiagnosticSeverity.Warning, fileName);
+                }
+            }
+        }
+
+        /// <summary>
+        /// GetName: Retrieves the name of this rule.
+        /// </summary>
+        /// <returns>The name of this rule</returns>
+        public string GetName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.NameSpaceFormat, GetSourceName(), Strings.AvoidMultipleTypesParameterName);
+        }
+
+        /// <summary>
+        /// GetCommonName: Retrieves the common name of this rule.
+        /// </summary>
+        /// <returns>The common name of this rule</returns>
+        public string GetCommonName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidMultipleTypesParameterCommonName);
+        }
+
+        /// <summary>
+        /// GetDescription: Retrieves the description of this rule.
+        /// </summary>
+        /// <returns>The description of this rule</returns>
+        public string GetDescription()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidMultipleTypesParameterDescription);
+        }
+
+        /// <summary>
+        /// GetSourceType: Retrieves the type of the rule, Builtin, Managed or Module.
+        /// </summary>
+        public SourceType GetSourceType()
+        {
+            return SourceType.Builtin;
+        }
+
+        /// <summary>
+        /// GetSeverity: Retrieves the severity of the rule: error, warning or information.
+        /// </summary>
+        /// <returns></returns>
+        public RuleSeverity GetSeverity()
+        {
+            return RuleSeverity.Warning;
+        }
+
+        /// <summary>
+        /// GetSourceName: Retrieves the name of the module/assembly the rule is from.
+        /// </summary>
+        public string GetSourceName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.SourceName);
+        }
+    }
+}

Rules/Strings.resx

@@ -1152,4 +1152,16 @@
   <data name="InvalidSyntaxAroundProcessBlockError" xml:space="preserve">
     <value>When using an explicit process block, no preceding code is allowed, only begin, end and dynamicparams blocks.</value>
   </data>
-</root>
+  <data name="AvoidMultipleTypesParameterCommonName" xml:space="preserve">
+    <value>Avoid Multiple Types Parameter</value>
+  </data>
+  <data name="AvoidMultipleTypesParameterDescription" xml:space="preserve">
+    <value>Prameter should not have more than one type specifier.</value>
+  </data>
+  <data name="AvoidMultipleTypesParameterError" xml:space="preserve">
+    <value>Parameter '{0}' has more than one type specifier.</value>
+  </data>
+  <data name="AvoidMultipleTypesParameterName" xml:space="preserve">
+    <value>AvoidMultipleTypesParameter</value>
+  </data>
+</root>

Tests/Engine/GetScriptAnalyzerRule.tests.ps1

@@ -63,7 +63,7 @@ Describe "Test Name parameters" {
 
         It "get Rules with no parameters supplied" {
             $defaultRules = Get-ScriptAnalyzerRule
-            $expectedNumRules = 65
+            $expectedNumRules = 66
             if ($PSVersionTable.PSVersion.Major -le 4)
             {
                 # for PSv3 PSAvoidGlobalAliases is not shipped because

Tests/Rules/AvoidMultipleTypesParameter.ps1

@@ -0,0 +1,7 @@
+# Double typing is not allowed
+function F10 ([int] [switch] $s1, [int] $p1){}
+
+# Double typing is not allowed even for switch and boolean, because:
+# switch maps to System.Management.Automation.SwitchParameter
+# boolean maps to System.Boolean
+function F11 ([switch][boolean] $s1, [int] $p1){}

Tests/Rules/AvoidMultipleTypesParameter.tests.ps1

@@ -0,0 +1,25 @@
+BeforeAll {
+    $violationMessage = 'Parameter ''\$s1'' has more than one type specifier.'
+    $violationName = "PSAvoidMultipleTypesParameter"
+    $violations = Invoke-ScriptAnalyzer $PSScriptRoot\AvoidMultipleTypesParameter.ps1 | Where-Object {$_.RuleName -eq $violationName}
+    $noViolations = Invoke-ScriptAnalyzer $PSScriptRoot\AvoidMultipleTypesParameterNoViolations.ps1 | Where-Object {$_.RuleName -eq $violationName}
+}
+
+Describe "AvoidMultipleTypesParameter" {
+    Context "When there are violations" {
+        It "has two AvoidMultipleTypesParameter violations" {
+            $violations.Count | Should -Be 2
+        }
+
+        It "has the correct description message" {
+            $violations[0].Message | Should -Match $violationMessage
+            $violations[1].Message | Should -Match $violationMessage
+        }
+    }
+
+    Context "When there are no violations" {
+        It "returns no violations" {
+            $noViolations.Count | Should -Be 0
+        }
+    }
+}

Tests/Rules/AvoidMultipleTypesParameterNoViolations.ps1

@@ -0,0 +1,3 @@
+function F10 ([int] $s1, [int] $p1){}
+
+function F11 ([switch] $s1, [int] $p1){}