Adjust CallTo*StatementWithNoDiscardRule for pipe operator

Author: ondrejmirtes

src/Rules/Functions/CallToFunctionStatementWithNoDiscardRule.php

@@ -41,6 +41,18 @@ public function processNode(Node $node, Scope $scope): array
 			$funcCall = $funcCall->expr;
 		}
 
+		if ($funcCall instanceof Node\Expr\BinaryOp\Pipe) {
+			if ($funcCall->right instanceof Node\Expr\FuncCall) {
+				if (!$funcCall->right->isFirstClassCallable()) {
+					return [];
+				}
+
+				$funcCall = new Node\Expr\FuncCall($funcCall->right->name, []);
+			} elseif ($funcCall->right instanceof Node\Expr\ArrowFunction) {
+				$funcCall = $funcCall->right->expr;
+			}
+		}
+
 		if (!$funcCall instanceof Node\Expr\FuncCall) {
 			return [];
 		}

src/Rules/Methods/CallToMethodStatementWithNoDiscardRule.php

@@ -42,6 +42,18 @@ public function processNode(Node $node, Scope $scope): array
 			$methodCall = $methodCall->expr;
 		}
 
+		if ($methodCall instanceof Node\Expr\BinaryOp\Pipe) {
+			if ($methodCall->right instanceof Node\Expr\MethodCall || $methodCall->right instanceof Node\Expr\NullsafeMethodCall) {
+				if (!$methodCall->right->isFirstClassCallable()) {
+					return [];
+				}
+
+				$methodCall = new Node\Expr\MethodCall($methodCall->right->var, $methodCall->right->name, []);
+			} elseif ($methodCall->right instanceof Node\Expr\ArrowFunction) {
+				$methodCall = $methodCall->right->expr;
+			}
+		}
+
 		if (!$methodCall instanceof Node\Expr\MethodCall
 			&& !$methodCall instanceof Node\Expr\NullsafeMethodCall
 		) {

src/Rules/Methods/CallToStaticMethodStatementWithNoDiscardRule.php

@@ -44,6 +44,19 @@ public function processNode(Node $node, Scope $scope): array
 			$isInVoidCast = true;
 			$methodCall = $methodCall->expr;
 		}
+
+		if ($methodCall instanceof Node\Expr\BinaryOp\Pipe) {
+			if ($methodCall->right instanceof Node\Expr\StaticCall) {
+				if (!$methodCall->right->isFirstClassCallable()) {
+					return [];
+				}
+
+				$methodCall = new Node\Expr\StaticCall($methodCall->right->class, $methodCall->right->name, []);
+			} elseif ($methodCall->right instanceof Node\Expr\ArrowFunction) {
+				$methodCall = $methodCall->right->expr;
+			}
+		}
+
 		if (!$methodCall instanceof Node\Expr\StaticCall) {
 			return [];
 		}

tests/PHPStan/Rules/Functions/CallToFunctionStatementWithNoDiscardRuleTest.php

@@ -36,7 +36,7 @@ public function testRule(): void
 				30,
 			],
 			[
-				'Call to callable Closure(): array on a separate line discards return value.',
+				'Call to callable Closure(int): array on a separate line discards return value.',
 				35,
 			],
 			[
@@ -55,6 +55,22 @@ public function testRule(): void
 				'Call to callable \'FunctionCallStateme…\' in (void) cast but callable allows discarding return value.',
 				59,
 			],
+			[
+				'Call to function FunctionCallStatementResultDiscarded\withSideEffects() on a separate line discards return value.',
+				61,
+			],
+			[
+				'Call to function FunctionCallStatementResultDiscarded\canDiscard() in (void) cast but function allows discarding return value.',
+				64,
+			],
+			[
+				'Call to function FunctionCallStatementResultDiscarded\withSideEffects() on a separate line discards return value.',
+				66,
+			],
+			[
+				'Call to function FunctionCallStatementResultDiscarded\canDiscard() in (void) cast but function allows discarding return value.',
+				69,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Functions/data/function-call-statement-result-discarded.php

@@ -3,16 +3,16 @@
 namespace FunctionCallStatementResultDiscarded;
 
 #[\NoDiscard]
-function withSideEffects(): array {
+function withSideEffects(int $i): array {
 	echo __FUNCTION__ . "\n";
 	return [1];
 }
 
-withSideEffects();
+withSideEffects(5);
 
-(void)withSideEffects();
+(void)withSideEffects(5);
 
-foreach (withSideEffects() as $num) {
+foreach (withSideEffects(5) as $num) {
 	var_dump($num);
 }
 
@@ -30,9 +30,9 @@ function differentCase(): array {
 $callable();
 
 $firstClassCallable = withSideEffects(...);
-$firstClasCallableResult = $firstClassCallable();
+$firstClasCallableResult = $firstClassCallable(5);
 
-$firstClassCallable();
+$firstClassCallable(5);
 
 $closureWithNoDiscard = #[\NoDiscard] function () { return 1; };
 $a = $closureWithNoDiscard();
@@ -46,14 +46,24 @@ function differentCase(): array {
 
 withSideEffects(...);
 
-function canDiscard(): int
+function canDiscard(int $i): int
 {
 	return 1;
 }
 
-canDiscard();
-(void) canDiscard();
+canDiscard(5);
+(void) canDiscard(5);
 
 $canDiscardCb = 'FunctionCallStatementResultDiscarded\\canDiscard';
 $canDiscardCb();
 (void) $canDiscardCb();
+
+5 |> withSideEffects(...);
+5 |> canDiscard(...);
+(void) 5 |> withSideEffects(...);
+(void) 5 |> canDiscard(...);
+
+5 |> fn ($x) => withSideEffects($x);
+5 |> fn ($x) => canDiscard($x);
+(void) 5 |> fn ($x) => withSideEffects($x);
+(void) 5 |> fn ($x) => canDiscard($x);

tests/PHPStan/Rules/Methods/CallToMethodStatementWithNoDiscardRuleTest.php

@@ -40,6 +40,22 @@ public function testRule(): void
 				'Call to method MethodCallStatementResultDiscarded\Foo::canDiscard() in (void) cast but method allows discarding return value.',
 				45,
 			],
+			[
+				'Call to method MethodCallStatementResultDiscarded\ClassWithInstanceSideEffects::instanceMethod() on a separate line discards return value.',
+				47,
+			],
+			[
+				'Call to method MethodCallStatementResultDiscarded\Foo::canDiscard() in (void) cast but method allows discarding return value.',
+				50,
+			],
+			[
+				'Call to method MethodCallStatementResultDiscarded\ClassWithInstanceSideEffects::instanceMethod() on a separate line discards return value.',
+				52,
+			],
+			[
+				'Call to method MethodCallStatementResultDiscarded\Foo::canDiscard() in (void) cast but method allows discarding return value.',
+				55,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Methods/CallToStaticMethodStatementWithNoDiscardRuleTest.php

@@ -41,6 +41,22 @@ public function testRule(): void
 				'Call to static method StaticMethodCallStatementResultDiscarded\Foo::canDiscard() in (void) cast but method allows discarding return value.',
 				41,
 			],
+			[
+				'Call to static method StaticMethodCallStatementResultDiscarded\ClassWithStaticSideEffects::staticMethod() on a separate line discards return value.',
+				43,
+			],
+			[
+				'Call to static method StaticMethodCallStatementResultDiscarded\Foo::canDiscard() in (void) cast but method allows discarding return value.',
+				46,
+			],
+			[
+				'Call to static method StaticMethodCallStatementResultDiscarded\ClassWithStaticSideEffects::staticMethod() on a separate line discards return value.',
+				48,
+			],
+			[
+				'Call to static method StaticMethodCallStatementResultDiscarded\Foo::canDiscard() in (void) cast but method allows discarding return value.',
+				51,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Methods/data/method-call-statement-result-discarded.php

@@ -43,3 +43,13 @@ public function canDiscard(): array {
 $foo = new Foo();
 $foo->canDiscard();
 (void) $foo->canDiscard();
+
+5 |> $o->instanceMethod(...);
+5 |> $foo->canDiscard(...);
+(void) 5 |> $o->instanceMethod(...);
+(void) 5 |> $foo->canDiscard(...);
+
+5 |> fn ($x) => $o->instanceMethod($x);
+5 |> fn ($x) => $foo->canDiscard($x);
+(void) 5 |> fn ($x) => $o->instanceMethod($x);
+(void) 5 |> fn ($x) => $foo->canDiscard($x);

tests/PHPStan/Rules/Methods/data/static-method-call-statement-result-discarded.php

@@ -39,3 +39,13 @@ public static function canDiscard(): array {
 
 Foo::canDiscard();
 (void) Foo::canDiscard();
+
+5 |> ClassWithStaticSideEffects::staticMethod(...);
+5 |> Foo::canDiscard(...);
+(void) 5 |> ClassWithStaticSideEffects::staticMethod(...);
+(void) 5 |> Foo::canDiscard(...);
+
+5 |> fn ($x) => ClassWithStaticSideEffects::staticMethod($x);
+5 |> fn ($x) => Foo::canDiscard($x);
+(void) 5 |> fn ($x) => ClassWithStaticSideEffects::staticMethod($x);
+(void) 5 |> fn ($x) => Foo::canDiscard($x);