Rules about #[NoDiscard] report when call is in (void) cast but should not

ondrejmirtes · ondrejmirtes · commit 099b87a7f219 · 2025-10-22T10:24:48.000+02:00
diff --git a/src/Rules/Functions/CallToFunctionStatementWithNoDiscardRule.php b/src/Rules/Functions/CallToFunctionStatementWithNoDiscardRule.php
@@ -34,26 +34,46 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope): array
 	{
-		if (!$node->expr instanceof Node\Expr\FuncCall) {
+		$funcCall = $node->expr;
+		$isInVoidCast = false;
+		if ($funcCall instanceof Node\Expr\Cast\Void_) {
+			$isInVoidCast = true;
+			$funcCall = $funcCall->expr;
+		}
+
+		if (!$funcCall instanceof Node\Expr\FuncCall) {
 			return [];
 		}
 
-		if ($node->expr->isFirstClassCallable()) {
+		if ($funcCall->isFirstClassCallable()) {
 			return [];
 		}
 
 		if (!$this->phpVersion->supportsNoDiscardAttribute()) {
 			return [];
 		}
 
-		$funcCall = $node->expr;
 		if ($funcCall->name instanceof Node\Name) {
 			if (!$this->reflectionProvider->hasFunction($funcCall->name, $scope)) {
 				return [];
 			}
 
 			$function = $this->reflectionProvider->getFunction($funcCall->name, $scope);
-			if (!$function->mustUseReturnValue()->yes()) {
+			$mustUseReturnValue = $function->mustUseReturnValue();
+			if ($isInVoidCast) {
+				if ($mustUseReturnValue->no()) {
+					return [
+						RuleErrorBuilder::message(sprintf(
+							'Call to function %s() in (void) cast but function allows discarding return value.',
+							$function->getName(),
+						))->identifier('function.inVoidCast')->build(),
+					];
+				}
+
+				return [];
+			}
+
+			if (!$mustUseReturnValue->yes()) {
 				return [];
 			}
 
@@ -75,6 +95,19 @@ public function processNode(Node $node, Scope $scope): array
 			$mustUseReturnValue = $mustUseReturnValue->or($callableParametersAcceptor->mustUseReturnValue());
 		}
 
+		if ($isInVoidCast) {
+			if ($mustUseReturnValue->no()) {
+				return [
+					RuleErrorBuilder::message(sprintf(
+						'Call to callable %s in (void) cast but callable allows discarding return value.',
+						$callableType->describe(VerbosityLevel::value()),
+					))->identifier('callable.inVoidCast')->build(),
+				];
+			}
+
+			return [];
+		}
+
 		if (!$mustUseReturnValue->yes()) {
 			return [];
 		}
diff --git a/src/Rules/Methods/CallToMethodStatementWithNoDiscardRule.php b/src/Rules/Methods/CallToMethodStatementWithNoDiscardRule.php
@@ -35,29 +35,35 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope): array
 	{
-		if (!$node->expr instanceof Node\Expr\MethodCall
-			&& !$node->expr instanceof Node\Expr\NullsafeMethodCall
+		$methodCall = $node->expr;
+		$isInVoidCast = false;
+		if ($methodCall instanceof Node\Expr\Cast\Void_) {
+			$isInVoidCast = true;
+			$methodCall = $methodCall->expr;
+		}
+
+		if (!$methodCall instanceof Node\Expr\MethodCall
+			&& !$methodCall instanceof Node\Expr\NullsafeMethodCall
 		) {
 			return [];
 		}
 
-		if ($node->expr->isFirstClassCallable()) {
+		if ($methodCall->isFirstClassCallable()) {
 			return [];
 		}
 
 		if (!$this->phpVersion->supportsNoDiscardAttribute()) {
 			return [];
 		}
 
-		$funcCall = $node->expr;
-		if (!$funcCall->name instanceof Node\Identifier) {
+		if (!$methodCall->name instanceof Node\Identifier) {
 			return [];
 		}
-		$methodName = $funcCall->name->toString();
+		$methodName = $methodCall->name->toString();
 
 		$typeResult = $this->ruleLevelHelper->findTypeToCheck(
 			$scope,
-			NullsafeOperatorHelper::getNullsafeShortcircuitedExprRespectingScope($scope, $funcCall->var),
+			NullsafeOperatorHelper::getNullsafeShortcircuitedExprRespectingScope($scope, $methodCall->var),
 			'',
 			static fn (Type $type): bool => $type->canCallMethods()->yes() && $type->hasMethod($methodName)->yes(),
 		);
@@ -74,8 +80,23 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		$method = $calledOnType->getMethod($methodName, $scope);
+		$mustUseReturnValue = $method->mustUseReturnValue();
+		if ($isInVoidCast) {
+			if ($mustUseReturnValue->no()) {
+				return [
+					RuleErrorBuilder::message(sprintf(
+						'Call to %s %s::%s() in (void) cast but method allows discarding return value.',
+						$method->isStatic() ? 'static method' : 'method',
+						$method->getDeclaringClass()->getDisplayName(),
+						$method->getName(),
+					))->identifier('method.inVoidCast')->build(),
+				];
+			}
+
+			return [];
+		}
 
-		if (!$method->mustUseReturnValue()->yes()) {
+		if (!$mustUseReturnValue->yes()) {
 			return [];
 		}
 
diff --git a/src/Rules/Methods/CallToStaticMethodStatementWithNoDiscardRule.php b/src/Rules/Methods/CallToStaticMethodStatementWithNoDiscardRule.php
@@ -38,26 +38,31 @@ public function getNodeType(): string
 
 	public function processNode(Node $node, Scope $scope): array
 	{
-		if (!$node->expr instanceof Node\Expr\StaticCall) {
+		$methodCall = $node->expr;
+		$isInVoidCast = false;
+		if ($methodCall instanceof Node\Expr\Cast\Void_) {
+			$isInVoidCast = true;
+			$methodCall = $methodCall->expr;
+		}
+		if (!$methodCall instanceof Node\Expr\StaticCall) {
 			return [];
 		}
 
-		if ($node->expr->isFirstClassCallable()) {
+		if ($methodCall->isFirstClassCallable()) {
 			return [];
 		}
 
 		if (!$this->phpVersion->supportsNoDiscardAttribute()) {
 			return [];
 		}
 
-		$funcCall = $node->expr;
-		if (!$funcCall->name instanceof Node\Identifier) {
+		if (!$methodCall->name instanceof Node\Identifier) {
 			return [];
 		}
 
-		$methodName = $funcCall->name->toString();
-		if ($funcCall->class instanceof Node\Name) {
-			$className = $scope->resolveName($funcCall->class);
+		$methodName = $methodCall->name->toString();
+		if ($methodCall->class instanceof Node\Name) {
+			$className = $scope->resolveName($methodCall->class);
 			if (!$this->reflectionProvider->hasClass($className)) {
 				return [];
 			}
@@ -66,7 +71,7 @@ public function processNode(Node $node, Scope $scope): array
 		} else {
 			$typeResult = $this->ruleLevelHelper->findTypeToCheck(
 				$scope,
-				NullsafeOperatorHelper::getNullsafeShortcircuitedExprRespectingScope($scope, $funcCall->class),
+				NullsafeOperatorHelper::getNullsafeShortcircuitedExprRespectingScope($scope, $methodCall->class),
 				'',
 				static fn (Type $type): bool => $type->canCallMethods()->yes() && $type->hasMethod($methodName)->yes(),
 			);
@@ -85,8 +90,23 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		$method = $calledOnType->getMethod($methodName, $scope);
+		$mustUseReturnValue = $method->mustUseReturnValue();
+		if ($isInVoidCast) {
+			if ($mustUseReturnValue->no()) {
+				return [
+					RuleErrorBuilder::message(sprintf(
+						'Call to %s %s::%s() in (void) cast but method allows discarding return value.',
+						$method->isStatic() ? 'static method' : 'method',
+						$method->getDeclaringClass()->getDisplayName(),
+						$method->getName(),
+					))->identifier('staticMethod.inVoidCast')->build(),
+				];
+			}
+
+			return [];
+		}
 
-		if (!$method->mustUseReturnValue()->yes()) {
+		if (!$mustUseReturnValue->yes()) {
 			return [];
 		}
 
diff --git a/tests/PHPStan/Rules/Functions/CallToFunctionStatementWithNoDiscardRuleTest.php b/tests/PHPStan/Rules/Functions/CallToFunctionStatementWithNoDiscardRuleTest.php
@@ -47,6 +47,14 @@ public function testRule(): void
 				'Call to callable Closure(): 1 on a separate line discards return value.',
 				45,
 			],
+			[
+				'Call to function FunctionCallStatementResultDiscarded\canDiscard() in (void) cast but function allows discarding return value.',
+				55,
+			],
+			[
+				'Call to callable \'FunctionCallStateme…\' in (void) cast but callable allows discarding return value.',
+				59,
+			],
 		]);
 	}
 
diff --git a/tests/PHPStan/Rules/Functions/data/function-call-statement-result-discarded.php b/tests/PHPStan/Rules/Functions/data/function-call-statement-result-discarded.php
@@ -45,3 +45,15 @@ function differentCase(): array {
 $arrowWithNoDiscard();
 
 withSideEffects(...);
+
+function canDiscard(): int
+{
+	return 1;
+}
+
+canDiscard();
+(void) canDiscard();
+
+$canDiscardCb = 'FunctionCallStatementResultDiscarded\\canDiscard';
+$canDiscardCb();
+(void) $canDiscardCb();
diff --git a/tests/PHPStan/Rules/Methods/CallToMethodStatementWithNoDiscardRuleTest.php b/tests/PHPStan/Rules/Methods/CallToMethodStatementWithNoDiscardRuleTest.php
@@ -36,6 +36,10 @@ public function testRule(): void
 				'Call to method MethodCallStatementResultDiscarded\ClassWithInstanceSideEffects::differentCase() on a separate line discards return value.',
 				30,
 			],
+			[
+				'Call to method MethodCallStatementResultDiscarded\Foo::canDiscard() in (void) cast but method allows discarding return value.',
+				45,
+			],
 		]);
 	}
 
diff --git a/tests/PHPStan/Rules/Methods/CallToStaticMethodStatementWithNoDiscardRuleTest.php b/tests/PHPStan/Rules/Methods/CallToStaticMethodStatementWithNoDiscardRuleTest.php
@@ -37,6 +37,10 @@ public function testRule(): void
 				'Call to static method MethodCallStatementResultDiscarded\ClassWithStaticSideEffects::differentCase() on a separate line discards return value.',
 				27,
 			],
+			[
+				'Call to static method MethodCallStatementResultDiscarded\Foo::canDiscard() in (void) cast but method allows discarding return value.',
+				41,
+			],
 		]);
 	}
 
diff --git a/tests/PHPStan/Rules/Methods/data/method-call-statement-result-discarded.php b/tests/PHPStan/Rules/Methods/data/method-call-statement-result-discarded.php
@@ -30,3 +30,16 @@ public function differentCase(): array {
 $o->differentCase();
 
 $o->instanceMethod(...);
+
+class Foo
+{
+
+	public function canDiscard(): array {
+		return [];
+	}
+
+}
+
+$foo = new Foo();
+$foo->canDiscard();
+(void) $foo->canDiscard();
diff --git a/tests/PHPStan/Rules/Methods/data/static-method-call-statement-result-discarded.php b/tests/PHPStan/Rules/Methods/data/static-method-call-statement-result-discarded.php
@@ -27,3 +27,15 @@ public static function differentCase(): array {
 ClassWithStaticSideEffects::differentCase();
 
 ClassWithStaticSideEffects::staticMethod(...);
+
+class Foo
+{
+
+	public static function canDiscard(): array {
+		return [];
+	}
+
+}
+
+Foo::canDiscard();
+(void) Foo::canDiscard();
