Add rule for missing process block when command supports the pipeline

RuleDocumentation/README.md

@@ -50,6 +50,7 @@
 |[UseDeclaredVarsMoreThanAssignments](./UseDeclaredVarsMoreThanAssignments.md) | Warning | |
 |[UseLiteralInitializerForHashtable](./UseLiteralInitializerForHashtable.md) | Warning | |
 |[UseOutputTypeCorrectly](./UseOutputTypeCorrectly.md) | Information | |
+|[UseProcessBlockForPipelineCommand](./UseProcessBlockForPipelineCommand.md) | Warning | |
 |[UsePSCredentialType](./UsePSCredentialType.md) | Warning | |
 |[UseShouldProcessForStateChangingFunctions](./UseShouldProcessForStateChangingFunctions.md) | Warning | |
 |[UseSingularNouns<sup>*</sup>](./UseSingularNouns.md) | Warning | |

RuleDocumentation/UseProcessBlockForPipelineCommand.md

@@ -0,0 +1,62 @@
+# UseProcessBlockForPipelineCommand
+
+**Severity Level: Warning**
+
+## Description
+
+Functions that support pipeline input should always handle parameter input in a process block. Unexpected behavior can result if input is handled directly in the body of a function where parameters declare pipeline support.
+
+## Example
+
+### Wrong
+
+``` PowerShell
+Function Get-Number
+{
+	[CmdletBinding()]
+	Param(
+		[Parameter(ValueFromPipeline)]
+		[int]
+		$Number
+	)
+
+	$Number
+}
+```
+
+#### Result
+
+```
+PS C:\> 1..5 | Get-Number
+5
+```
+
+### Correct
+
+``` PowerShell
+Function Get-Number
+{
+	[CmdletBinding()]
+	Param(
+		[Parameter(ValueFromPipeline)]
+		[int]
+		$Number
+	)
+
+	process
+	{
+		$Number
+	}
+}
+```
+
+#### Result
+
+```
+PS C:\> 1..5 | Get-Number
+1
+2
+3
+4
+5
+```

Rules/Strings.resx

@@ -1080,4 +1080,16 @@
   <data name="UseCorrectCasingName" xml:space="preserve">
     <value>UseCorrectCasing</value>
   </data>
+  <data name="UseProcessBlockForPipelineCommandCommonName" xml:space="preserve">
+    <value>Use process block for command that accepts input from pipeline.</value>
+  </data>
+  <data name="UseProcessBlockForPipelineCommandDescription" xml:space="preserve">
+    <value>If a function parameter takes its value from the pipeline, the function must use a process block to bind the input objects from the pipeline to that parameter.</value>
+  </data>
+  <data name="UseProcessBlockForPipelineCommandError" xml:space="preserve">
+    <value>Command accepts pipeline input but has not defined a process block.</value>
+  </data>
+  <data name="UseProcessBlockForPipelineCommandName" xml:space="preserve">
+    <value>UseProcessBlockForPipelineCommand</value>
+  </data>
 </root>

Rules/UseProcessBlockForPipelineCommand.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.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
+{
+#if !CORECLR
+    [Export(typeof(IScriptRule))]
+#endif
+    public class UseProcessBlockForPipelineCommand : IScriptRule
+    {
+        public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
+        {
+            if (ast == null)
+            {
+                throw new ArgumentNullException(Strings.NullAstErrorMessage);
+            }
+
+            IEnumerable<Ast> scriptblockAsts = ast.FindAll(testAst => testAst is ScriptBlockAst, true);
+
+            foreach (ScriptBlockAst scriptblockAst in scriptblockAsts)
+            {
+                if (scriptblockAst.ProcessBlock != null
+                    || scriptblockAst.ParamBlock?.Attributes == null
+                    || scriptblockAst.ParamBlock.Parameters == null)
+                {
+                    continue;
+                }
+
+                foreach (var paramAst in scriptblockAst.ParamBlock.Parameters)
+                {
+                    foreach (var paramAstAttribute in paramAst.Attributes)
+                    {
+                        if (!(paramAstAttribute is AttributeAst paramAttributeAst)) { continue; }
+
+                        if (paramAttributeAst.NamedArguments == null) { continue; }
+
+                        foreach (NamedAttributeArgumentAst namedArgument in paramAttributeAst.NamedArguments)
+                        {
+                            if (!namedArgument.ArgumentName.Equals("valuefrompipeline", StringComparison.OrdinalIgnoreCase)
+                                && !namedArgument.ArgumentName.Equals("valuefrompipelinebypropertyname", StringComparison.OrdinalIgnoreCase))
+                            {
+                                continue;
+                            }
+
+                            yield return new DiagnosticRecord(
+                                string.Format(CultureInfo.CurrentCulture, Strings.UseProcessBlockForPipelineCommandError, paramAst.Name.VariablePath.UserPath),
+                                paramAst.Name.Extent,
+                                GetName(),
+                                DiagnosticSeverity.Warning,
+                                fileName,
+                                paramAst.Name.VariablePath.UserPath
+                            );
+                        }
+                    }
+                }
+            }
+        }
+
+        public string GetName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.NameSpaceFormat, GetSourceName(), Strings.UseProcessBlockForPipelineCommandName);
+        }
+
+        public string GetCommonName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.UseProcessBlockForPipelineCommandCommonName);
+        }
+
+        public string GetDescription()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.UseProcessBlockForPipelineCommandDescription);
+        }
+
+        public SourceType GetSourceType()
+        {
+            return SourceType.Builtin;
+        }
+
+        public RuleSeverity GetSeverity()
+        {
+            return RuleSeverity.Warning;
+        }
+
+        public string GetSourceName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.SourceName);
+        }
+    }
+}

Tests/Engine/GetScriptAnalyzerRule.tests.ps1

@@ -59,7 +59,7 @@ Describe "Test Name parameters" {
 
         It "get Rules with no parameters supplied" {
 			$defaultRules = Get-ScriptAnalyzerRule
-            $expectedNumRules = 60
+            $expectedNumRules = 61
             if ((Test-PSEditionCoreClr) -or (Test-PSVersionV3) -or (Test-PSVersionV4))
             {
                 # for PSv3 PSAvoidGlobalAliases is not shipped because