Support for pipe operator in PossiblyPure*Collector

Author: ondrejmirtes

src/Rules/DeadCode/PossiblyPureFuncCallCollector.php

@@ -27,18 +27,33 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope)
 	{
-		if (!$node->expr instanceof Node\Expr\FuncCall || $node->expr->isFirstClassCallable()) {
+		$expr = $node->expr;
+		if ($expr instanceof Node\Expr\BinaryOp\Pipe) {
+			if ($expr->right instanceof Node\Expr\FuncCall) {
+				if (!$expr->right->isFirstClassCallable()) {
+					return null;
+				}
+
+				$expr = new Node\Expr\FuncCall($expr->right->name, []);
+			} elseif ($expr->right instanceof Node\Expr\ArrowFunction) {
+				$expr = $expr->right->expr;
+			}
+		}
+		if (!$expr instanceof Node\Expr\FuncCall) {
+			return null;
+		}
+		if ($expr->isFirstClassCallable()) {
 			return null;
 		}
-		if (!$node->expr->name instanceof Node\Name) {
+		if (!$expr->name instanceof Node\Name) {
 			return null;
 		}
 
-		if (!$this->reflectionProvider->hasFunction($node->expr->name, $scope)) {
+		if (!$this->reflectionProvider->hasFunction($expr->name, $scope)) {
 			return null;
 		}
 
-		$functionReflection = $this->reflectionProvider->getFunction($node->expr->name, $scope);
+		$functionReflection = $this->reflectionProvider->getFunction($expr->name, $scope);
 		if (!$functionReflection->isPure()->maybe()) {
 			return null;
 		}

src/Rules/DeadCode/PossiblyPureMethodCallCollector.php

@@ -26,18 +26,31 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope)
 	{
-		if (!$node->expr instanceof Node\Expr\MethodCall && !$node->expr instanceof Node\Expr\NullsafeMethodCall) {
+		$expr = $node->expr;
+		if ($expr instanceof Node\Expr\BinaryOp\Pipe) {
+			if ($expr->right instanceof Node\Expr\MethodCall || $expr->right instanceof Node\Expr\NullsafeMethodCall) {
+				if (!$expr->right->isFirstClassCallable()) {
+					return null;
+				}
+
+				$expr = new Node\Expr\MethodCall($expr->right->var, $expr->right->name, []);
+			} elseif ($expr->right instanceof Node\Expr\ArrowFunction) {
+				$expr = $expr->right->expr;
+			}
+		}
+
+		if (!$expr instanceof Node\Expr\MethodCall && !$expr instanceof Node\Expr\NullsafeMethodCall) {
 			return null;
 		}
-		if ($node->expr->isFirstClassCallable()) {
+		if ($expr->isFirstClassCallable()) {
 			return null;
 		}
-		if (!$node->expr->name instanceof Node\Identifier) {
+		if (!$expr->name instanceof Node\Identifier) {
 			return null;
 		}
 
-		$methodName = $node->expr->name->toString();
-		$calledOnType = $scope->getType($node->expr->var);
+		$methodName = $expr->name->toString();
+		$calledOnType = $scope->getType($expr->var);
 		if (!$calledOnType->hasMethod($methodName)->yes()) {
 			return null;
 		}

src/Rules/DeadCode/PossiblyPureStaticCallCollector.php

@@ -26,19 +26,31 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope)
 	{
-		if (!$node->expr instanceof Node\Expr\StaticCall || $node->expr->isFirstClassCallable()) {
+		$expr = $node->expr;
+		if ($expr instanceof Node\Expr\BinaryOp\Pipe) {
+			if ($expr->right instanceof Node\Expr\StaticCall) {
+				if (!$expr->right->isFirstClassCallable()) {
+					return null;
+				}
+
+				$expr = new Node\Expr\StaticCall($expr->right->class, $expr->right->name, []);
+			} elseif ($expr->right instanceof Node\Expr\ArrowFunction) {
+				$expr = $expr->right->expr;
+			}
+		}
+		if (!$expr instanceof Node\Expr\StaticCall || $expr->isFirstClassCallable()) {
 			return null;
 		}
-		if (!$node->expr->name instanceof Node\Identifier) {
+		if (!$expr->name instanceof Node\Identifier) {
 			return null;
 		}
 
-		if (!$node->expr->class instanceof Node\Name) {
+		if (!$expr->class instanceof Node\Name) {
 			return null;
 		}
 
-		$methodName = $node->expr->name->toString();
-		$calledOnType = $scope->resolveTypeByName($node->expr->class);
+		$methodName = $expr->name->toString();
+		$calledOnType = $scope->resolveTypeByName($expr->class);
 		$methodReflection = $scope->getMethodReflection($calledOnType, $methodName);
 
 		if ($methodReflection === null) {

tests/PHPStan/Rules/DeadCode/CallToFunctionStatementWithoutImpurePointsRuleTest.php

@@ -4,6 +4,7 @@
 
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\RequiresPhp;
 
 /**
  * @extends RuleTestCase<CallToFunctionStatementWithoutImpurePointsRule>
@@ -26,6 +27,21 @@ public function testRule(): void
 		]);
 	}
 
+	#[RequiresPhp('>= 8.5')]
+	public function testPipeOperator(): void
+	{
+		$this->analyse([__DIR__ . '/data/call-to-function-without-impure-points-pipe.php'], [
+			[
+				'Call to function CallToFunctionWithoutImpurePointsPipe\myFunc() on a separate line has no effect.',
+				9,
+			],
+			[
+				'Call to function CallToFunctionWithoutImpurePointsPipe\myFunc() on a separate line has no effect.',
+				10,
+			],
+		]);
+	}
+
 	protected function getCollectors(): array
 	{
 		return [

tests/PHPStan/Rules/DeadCode/CallToMethodStatementWithoutImpurePointsRuleTest.php

@@ -92,6 +92,21 @@ public function testBug12379(): void
 		$this->analyse([__DIR__ . '/data/bug-12379.php'], []);
 	}
 
+	#[RequiresPhp('>= 8.5')]
+	public function testPipeOperator(): void
+	{
+		$this->analyse([__DIR__ . '/data/call-to-method-without-impure-points-pipe.php'], [
+			[
+				'Call to method CallToMethodWithoutImpurePointsPipe\Foo::maybePure() on a separate line has no effect.',
+				17,
+			],
+			[
+				'Call to method CallToMethodWithoutImpurePointsPipe\Foo::maybePure() on a separate line has no effect.',
+				18,
+			],
+		]);
+	}
+
 	protected function getCollectors(): array
 	{
 		return [

tests/PHPStan/Rules/DeadCode/CallToStaticMethodStatementWithoutImpurePointsRuleTest.php

@@ -4,6 +4,7 @@
 
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\RequiresPhp;
 
 /**
  * @extends RuleTestCase<CallToStaticMethodStatementWithoutImpurePointsRule>
@@ -58,6 +59,21 @@ public function testRule(): void
 		]);
 	}
 
+	#[RequiresPhp('>= 8.5')]
+	public function testPipeOperator(): void
+	{
+		$this->analyse([__DIR__ . '/data/call-to-static-method-without-impure-points-pipe.php'], [
+			[
+				'Call to CallToStaticMethodWithoutImpurePointsPipe\Foo::doFoo() on a separate line has no effect.',
+				16,
+			],
+			[
+				'Call to CallToStaticMethodWithoutImpurePointsPipe\Foo::doFoo() on a separate line has no effect.',
+				17,
+			],
+		]);
+	}
+
 	protected function getCollectors(): array
 	{
 		return [

tests/PHPStan/Rules/DeadCode/data/call-to-function-without-impure-points-pipe.php

@@ -0,0 +1,10 @@
+<?php // lint >= 8.5
+
+namespace CallToFunctionWithoutImpurePointsPipe;
+
+function myFunc()
+{
+}
+
+5 |> myFunc(...);
+5 |> fn ($x) => myFunc($x);

tests/PHPStan/Rules/DeadCode/data/call-to-method-without-impure-points-pipe.php

@@ -0,0 +1,19 @@
+<?php // lint >= 8.5
+
+namespace CallToMethodWithoutImpurePointsPipe;
+
+class Foo
+{
+
+	public function maybePure(int $o): int
+	{
+		return 5;
+	}
+
+}
+
+function (): void {
+	$foo = new Foo();
+	5 |> $foo->maybePure(...);
+	5 |> fn ($x) => $foo->maybePure($x);
+};

tests/PHPStan/Rules/DeadCode/data/call-to-static-method-without-impure-points-pipe.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace CallToStaticMethodWithoutImpurePointsPipe;
+
+class Foo
+{
+
+	public static function doFoo(int $o): int
+	{
+		return 1;
+	}
+
+}
+
+function (): void {
+	5 |> Foo::doFoo(...);
+	5 |> fn ($x) => Foo::doFoo($x);
+};