Check callables too

ondrejmirtes · ondrejmirtes · commit f2097d2f5f6f · 2025-09-18T16:08:44.000+02:00
diff --git a/src/Analyser/MutatingScope.php b/src/Analyser/MutatingScope.php
@@ -1442,6 +1442,16 @@ static function (Node $node, Scope $scope) use ($arrowScope, &$arrowFunctionImpu
 				if (array_key_exists($cacheKey, $cachedTypes)) {
 					$cachedClosureData = $cachedTypes[$cacheKey];
 
+					$mustUseReturnValue = TrinaryLogic::createNo();
+					foreach ($node->attrGroups as $attrGroup) {
+						foreach ($attrGroup->attrs as $attr) {
+							if ($attr->name->toLowerString() === 'nodiscard') {
+								$mustUseReturnValue = TrinaryLogic::createYes();
+								break;
+							}
+						}
+					}
+
 					return new ClosureType(
 						$parameters,
 						$cachedClosureData['returnType'],
@@ -1454,6 +1464,7 @@ static function (Node $node, Scope $scope) use ($arrowScope, &$arrowFunctionImpu
 						invalidateExpressions: $cachedClosureData['invalidateExpressions'],
 						usedVariables: $cachedClosureData['usedVariables'],
 						acceptsNamedArguments: TrinaryLogic::createYes(),
+						mustUseReturnValue: $mustUseReturnValue,
 					);
 				}
 				if (self::$resolveClosureTypeDepth >= 2) {
@@ -1656,6 +1667,16 @@ static function (Node $node, Scope $scope) use ($arrowScope, &$arrowFunctionImpu
 			];
 			$node->setAttribute('phpstanCachedTypes', $cachedTypes);
 
+			$mustUseReturnValue = TrinaryLogic::createNo();
+			foreach ($node->attrGroups as $attrGroup) {
+				foreach ($attrGroup->attrs as $attr) {
+					if ($attr->name->toLowerString() === 'nodiscard') {
+						$mustUseReturnValue = TrinaryLogic::createYes();
+						break;
+					}
+				}
+			}
+
 			return new ClosureType(
 				$parameters,
 				$returnType,
@@ -1668,6 +1689,7 @@ static function (Node $node, Scope $scope) use ($arrowScope, &$arrowFunctionImpu
 				invalidateExpressions: $invalidateExpressions,
 				usedVariables: $usedVariables,
 				acceptsNamedArguments: TrinaryLogic::createYes(),
+				mustUseReturnValue: $mustUseReturnValue,
 			);
 		} elseif ($node instanceof New_) {
 			if ($node->class instanceof Name) {
@@ -2716,10 +2738,12 @@ private function createFirstClassCallable(
 			$throwPoints = [];
 			$impurePoints = [];
 			$acceptsNamedArguments = TrinaryLogic::createYes();
+			$mustUseReturnValue = TrinaryLogic::createMaybe();
 			if ($variant instanceof CallableParametersAcceptor) {
 				$throwPoints = $variant->getThrowPoints();
 				$impurePoints = $variant->getImpurePoints();
 				$acceptsNamedArguments = $variant->acceptsNamedArguments();
+				$mustUseReturnValue = $variant->mustUseReturnValue();
 			} elseif ($function !== null) {
 				$returnTypeForThrow = $variant->getReturnType();
 				$throwType = $function->getThrowType();
@@ -2745,6 +2769,7 @@ private function createFirstClassCallable(
 				}
 
 				$acceptsNamedArguments = $function->acceptsNamedArguments();
+				$mustUseReturnValue = $function->mustUseReturnValue();
 			}
 
 			$parameters = $variant->getParameters();
@@ -2759,6 +2784,7 @@ private function createFirstClassCallable(
 				$throwPoints,
 				$impurePoints,
 				acceptsNamedArguments: $acceptsNamedArguments,
+				mustUseReturnValue: $mustUseReturnValue,
 			);
 		}
 
diff --git a/src/PhpDoc/TypeNodeResolver.php b/src/PhpDoc/TypeNodeResolver.php
@@ -1032,7 +1032,7 @@ function (CallableTypeParameterNode $parameterNode) use ($nameScope, &$isVariadi
 				),
 			]);
 		} elseif ($mainType instanceof ClosureType) {
-			$closure = new ClosureType($parameters, $returnType, $isVariadic, $templateTypeMap, templateTags: $templateTags, impurePoints: $mainType->getImpurePoints(), invalidateExpressions: $mainType->getInvalidateExpressions(), usedVariables: $mainType->getUsedVariables(), acceptsNamedArguments: $mainType->acceptsNamedArguments());
+			$closure = new ClosureType($parameters, $returnType, $isVariadic, $templateTypeMap, templateTags: $templateTags, impurePoints: $mainType->getImpurePoints(), invalidateExpressions: $mainType->getInvalidateExpressions(), usedVariables: $mainType->getUsedVariables(), acceptsNamedArguments: $mainType->acceptsNamedArguments(), mustUseReturnValue: $mainType->mustUseReturnValue());
 			if ($closure->isPure()->yes() && $returnType->isVoid()->yes()) {
 				return new ErrorType();
 			}
diff --git a/src/Reflection/Callables/CallableParametersAcceptor.php b/src/Reflection/Callables/CallableParametersAcceptor.php
@@ -36,4 +36,11 @@ public function getInvalidateExpressions(): array;
 	 */
 	public function getUsedVariables(): array;
 
+	/**
+	 * Has the #[\NoDiscard] attribute - on PHP 8.5+ if the function's return
+	 * value is unused at runtime a warning is emitted, PHPStan will emit the
+	 * warning during analysis and on older PHP versions too
+	 */
+	public function mustUseReturnValue(): TrinaryLogic;
+
 }
diff --git a/src/Reflection/Callables/FunctionCallableVariant.php b/src/Reflection/Callables/FunctionCallableVariant.php
@@ -168,4 +168,9 @@ public function acceptsNamedArguments(): TrinaryLogic
 		return $this->function->acceptsNamedArguments();
 	}
 
+	public function mustUseReturnValue(): TrinaryLogic
+	{
+		return $this->function->mustUseReturnValue();
+	}
+
 }
diff --git a/src/Reflection/ExtendedCallableFunctionVariant.php b/src/Reflection/ExtendedCallableFunctionVariant.php
@@ -36,6 +36,7 @@ public function __construct(
 		private array $invalidateExpressions,
 		private array $usedVariables,
 		private TrinaryLogic $acceptsNamedArguments,
+		private TrinaryLogic $mustUseReturnValue,
 	)
 	{
 		parent::__construct(
@@ -80,4 +81,9 @@ public function acceptsNamedArguments(): TrinaryLogic
 		return $this->acceptsNamedArguments;
 	}
 
+	public function mustUseReturnValue(): TrinaryLogic
+	{
+		return $this->mustUseReturnValue;
+	}
+
 }
diff --git a/src/Reflection/GenericParametersAcceptorResolver.php b/src/Reflection/GenericParametersAcceptorResolver.php
@@ -128,6 +128,7 @@ public static function resolve(array $argTypes, ParametersAcceptor $parametersAc
 				$originalParametersAcceptor->getInvalidateExpressions(),
 				$originalParametersAcceptor->getUsedVariables(),
 				$originalParametersAcceptor->acceptsNamedArguments(),
+				$originalParametersAcceptor->mustUseReturnValue(),
 			);
 		}
 
diff --git a/src/Reflection/InaccessibleMethod.php b/src/Reflection/InaccessibleMethod.php
@@ -88,4 +88,9 @@ public function acceptsNamedArguments(): TrinaryLogic
 		return $this->methodReflection->acceptsNamedArguments();
 	}
 
+	public function mustUseReturnValue(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 }
diff --git a/src/Reflection/ParametersAcceptorSelector.php b/src/Reflection/ParametersAcceptorSelector.php
@@ -639,6 +639,7 @@ public static function combineAcceptors(array $acceptors): ExtendedParametersAcc
 		$invalidateExpressions = [];
 		$usedVariables = [];
 		$acceptsNamedArguments = TrinaryLogic::createNo();
+		$mustUseReturnValue = TrinaryLogic::createMaybe();
 
 		foreach ($acceptors as $acceptor) {
 			$returnTypes[] = $acceptor->getReturnType();
@@ -655,6 +656,7 @@ public static function combineAcceptors(array $acceptors): ExtendedParametersAcc
 				$invalidateExpressions = array_merge($invalidateExpressions, $acceptor->getInvalidateExpressions());
 				$usedVariables = array_merge($usedVariables, $acceptor->getUsedVariables());
 				$acceptsNamedArguments = $acceptsNamedArguments->or($acceptor->acceptsNamedArguments());
+				$mustUseReturnValue = $mustUseReturnValue->or($acceptor->mustUseReturnValue());
 			}
 			$isVariadic = $isVariadic || $acceptor->isVariadic();
 
@@ -761,6 +763,7 @@ public static function combineAcceptors(array $acceptors): ExtendedParametersAcc
 				$invalidateExpressions,
 				$usedVariables,
 				$acceptsNamedArguments,
+				$mustUseReturnValue,
 			);
 		}
 
@@ -797,6 +800,7 @@ private static function wrapAcceptor(ParametersAcceptor $acceptor): ExtendedPara
 				$acceptor->getInvalidateExpressions(),
 				$acceptor->getUsedVariables(),
 				$acceptor->acceptsNamedArguments(),
+				$acceptor->mustUseReturnValue(),
 			);
 		}
 
diff --git a/src/Reflection/ResolvedFunctionVariantWithCallable.php b/src/Reflection/ResolvedFunctionVariantWithCallable.php
@@ -28,6 +28,7 @@ public function __construct(
 		private array $invalidateExpressions,
 		private array $usedVariables,
 		private TrinaryLogic $acceptsNamedArguments,
+		private TrinaryLogic $mustUseReturnValue,
 	)
 	{
 	}
@@ -112,4 +113,9 @@ public function acceptsNamedArguments(): TrinaryLogic
 		return $this->acceptsNamedArguments;
 	}
 
+	public function mustUseReturnValue(): TrinaryLogic
+	{
+		return $this->mustUseReturnValue;
+	}
+
 }
diff --git a/src/Reflection/TrivialParametersAcceptor.php b/src/Reflection/TrivialParametersAcceptor.php
@@ -98,4 +98,9 @@ public function acceptsNamedArguments(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function mustUseReturnValue(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 }
diff --git a/src/Rules/Functions/CallToFunctionStatementWithNoDiscardRule.php b/src/Rules/Functions/CallToFunctionStatementWithNoDiscardRule.php
@@ -8,6 +8,8 @@
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\VerbosityLevel;
 use function sprintf;
 
 /**
@@ -33,25 +35,43 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		$funcCall = $node->expr;
-		if (!($funcCall->name instanceof Node\Name)) {
-			return [];
+		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()) {
+				return [];
+			}
+
+			return [
+				RuleErrorBuilder::message(sprintf(
+					'Call to function %s() on a separate line discards return value.',
+					$function->getName(),
+				))->identifier('function.resultDiscarded')->build(),
+			];
 		}
 
-		if (!$this->reflectionProvider->hasFunction($funcCall->name, $scope)) {
+		$callableType = $scope->getType($funcCall->name);
+		if (!$callableType->isCallable()->yes()) {
 			return [];
 		}
 
-		$function = $this->reflectionProvider->getFunction($funcCall->name, $scope);
+		$mustUseReturnValue = TrinaryLogic::createNo();
+		foreach ($callableType->getCallableParametersAcceptors($scope) as $callableParametersAcceptor) {
+			$mustUseReturnValue = $mustUseReturnValue->or($callableParametersAcceptor->mustUseReturnValue());
+		}
 
-		if (!$function->mustUseReturnValue()->yes()) {
+		if (!$mustUseReturnValue->yes()) {
 			return [];
 		}
 
 		return [
 			RuleErrorBuilder::message(sprintf(
-				'Call to function %s() on a separate line discards return value.',
-				$function->getName(),
-			))->identifier('function.resultDiscarded')->build(),
+				'Call to callable %s on a separate line discards return value.',
+				$callableType->describe(VerbosityLevel::value()),
+			))->identifier('callable.resultDiscarded')->build(),
 		];
 	}
 
diff --git a/src/Rules/RuleLevelHelper.php b/src/Rules/RuleLevelHelper.php
@@ -122,6 +122,7 @@ private function transformAcceptedType(Type $acceptingType, Type $acceptedType):
 					$acceptedType->getInvalidateExpressions(),
 					$acceptedType->getUsedVariables(),
 					$acceptedType->acceptsNamedArguments(),
+					$acceptedType->mustUseReturnValue(),
 				);
 			}
 
diff --git a/src/Type/CallableType.php b/src/Type/CallableType.php
@@ -295,6 +295,11 @@ public function acceptsNamedArguments(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function mustUseReturnValue(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function toNumber(): Type
 	{
 		return new ErrorType();
diff --git a/src/Type/ClosureType.php b/src/Type/ClosureType.php
@@ -80,6 +80,8 @@ class ClosureType implements TypeWithClassName, CallableParametersAcceptor
 
 	private TrinaryLogic $acceptsNamedArguments;
 
+	private TrinaryLogic $mustUseReturnValue;
+
 	/**
 	 * @api
 	 * @param list<ParameterReflection>|null $parameters
@@ -102,12 +104,17 @@ public function __construct(
 		private array $invalidateExpressions = [],
 		private array $usedVariables = [],
 		?TrinaryLogic $acceptsNamedArguments = null,
+		?TrinaryLogic $mustUseReturnValue = null,
 	)
 	{
 		if ($acceptsNamedArguments === null) {
 			$acceptsNamedArguments = TrinaryLogic::createYes();
 		}
 		$this->acceptsNamedArguments = $acceptsNamedArguments;
+		if ($mustUseReturnValue === null) {
+			$mustUseReturnValue = TrinaryLogic::createMaybe();
+		}
+		$this->mustUseReturnValue = $mustUseReturnValue;
 
 		$this->parameters = $parameters ?? [];
 		$this->returnType = $returnType ?? new MixedType();
@@ -269,6 +276,8 @@ function (): string {
 					$this->impurePoints,
 					$this->invalidateExpressions,
 					$this->usedVariables,
+					$this->acceptsNamedArguments,
+					$this->mustUseReturnValue,
 				);
 
 				return $printer->print($selfWithoutParameterNames->toPhpDocNode());
@@ -448,6 +457,11 @@ public function acceptsNamedArguments(): TrinaryLogic
 		return $this->acceptsNamedArguments;
 	}
 
+	public function mustUseReturnValue(): TrinaryLogic
+	{
+		return $this->mustUseReturnValue;
+	}
+
 	public function isCloneable(): TrinaryLogic
 	{
 		return TrinaryLogic::createYes();
@@ -627,6 +641,7 @@ public function traverse(callable $cb): Type
 			$this->invalidateExpressions,
 			$this->usedVariables,
 			$this->acceptsNamedArguments,
+			$this->mustUseReturnValue,
 		);
 	}
 
@@ -677,6 +692,7 @@ public function traverseSimultaneously(Type $right, callable $cb): Type
 			$this->invalidateExpressions,
 			$this->usedVariables,
 			$this->acceptsNamedArguments,
+			$this->mustUseReturnValue,
 		);
 	}
 
diff --git a/src/Type/Php/ClosureFromCallableDynamicReturnTypeExtension.php b/src/Type/Php/ClosureFromCallableDynamicReturnTypeExtension.php
@@ -55,6 +55,7 @@ public function getTypeFromStaticMethodCall(MethodReflection $methodReflection,
 				invalidateExpressions: $variant->getInvalidateExpressions(),
 				usedVariables: $variant->getUsedVariables(),
 				acceptsNamedArguments: $variant->acceptsNamedArguments(),
+				mustUseReturnValue: $variant->mustUseReturnValue(),
 			);
 		}
 
diff --git a/tests/PHPStan/Rules/Functions/CallToFunctionStatementWithNoDiscardRuleTest.php b/tests/PHPStan/Rules/Functions/CallToFunctionStatementWithNoDiscardRuleTest.php
@@ -4,6 +4,7 @@
 
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\RequiresPhp;
 
 /**
  * @extends RuleTestCase<CallToFunctionStatementWithNoDiscardRule>
@@ -16,6 +17,7 @@ protected function getRule(): Rule
 		return new CallToFunctionStatementWithNoDiscardRule(self::createReflectionProvider());
 	}
 
+	#[RequiresPhp('>= 8.1')]
 	public function testRule(): void
 	{
 		$this->analyse([__DIR__ . '/data/function-call-statement-result-discarded.php'], [
@@ -27,6 +29,22 @@ public function testRule(): void
 				'Call to function FunctionCallStatementResultDiscarded\differentCase() on a separate line discards return value.',
 				25,
 			],
+			[
+				'Call to callable \'FunctionCallStateme…\' on a separate line discards return value.',
+				30,
+			],
+			[
+				'Call to callable Closure(): array on a separate line discards return value.',
+				35,
+			],
+			[
+				'Call to callable Closure(): 1 on a separate line discards return value.',
+				40,
+			],
+			[
+				'Call to callable Closure(): 1 on a separate line discards return value.',
+				45,
+			],
 		]);
 	}
 
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

Original file line number	Diff line number	Diff line change
`@@ -1032,7 +1032,7 @@ function (CallableTypeParameterNode $parameterNode) use ($nameScope, &$isVariadi`
`1032`	`1032`	`),`
`1033`	`1033`	`]);`
`1034`	`1034`	`} elseif ($mainType instanceof ClosureType) {`
`1035`		`- $closure = new ClosureType($parameters, $returnType, $isVariadic, $templateTypeMap, templateTags: $templateTags, impurePoints: $mainType->getImpurePoints(), invalidateExpressions: $mainType->getInvalidateExpressions(), usedVariables: $mainType->getUsedVariables(), acceptsNamedArguments: $mainType->acceptsNamedArguments());`
	`1035`	`+ $closure = new ClosureType($parameters, $returnType, $isVariadic, $templateTypeMap, templateTags: $templateTags, impurePoints: $mainType->getImpurePoints(), invalidateExpressions: $mainType->getInvalidateExpressions(), usedVariables: $mainType->getUsedVariables(), acceptsNamedArguments: $mainType->acceptsNamedArguments(), mustUseReturnValue: $mainType->mustUseReturnValue());`
`1036`	`1036`	`if ($closure->isPure()->yes() && $returnType->isVoid()->yes()) {`
`1037`	`1037`	`return new ErrorType();`
`1038`	`1038`	`}`
Original file line number	Diff line number	Diff line change
`@@ -168,4 +168,9 @@ public function acceptsNamedArguments(): TrinaryLogic`
`168`	`168`	`return $this->function->acceptsNamedArguments();`
`169`	`169`	`}`
`170`	`170`
	`171`	`+ public function mustUseReturnValue(): TrinaryLogic`
	`172`	`+ {`
	`173`	`+ return $this->function->mustUseReturnValue();`
	`174`	`+ }`
	`175`	`+`
`171`	`176`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ public function __construct(`
`36`	`36`	`private array $invalidateExpressions,`
`37`	`37`	`private array $usedVariables,`
`38`	`38`	`private TrinaryLogic $acceptsNamedArguments,`
	`39`	`+ private TrinaryLogic $mustUseReturnValue,`
`39`	`40`	`)`
`40`	`41`	`{`
`41`	`42`	`parent::__construct(`
`@@ -80,4 +81,9 @@ public function acceptsNamedArguments(): TrinaryLogic`
`80`	`81`	`return $this->acceptsNamedArguments;`
`81`	`82`	`}`
`82`	`83`
	`84`	`+ public function mustUseReturnValue(): TrinaryLogic`
	`85`	`+ {`
	`86`	`+ return $this->mustUseReturnValue;`
	`87`	`+ }`
	`88`	`+`
`83`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,6 +128,7 @@ public static function resolve(array $argTypes, ParametersAcceptor $parametersAc`
`128`	`128`	`$originalParametersAcceptor->getInvalidateExpressions(),`
`129`	`129`	`$originalParametersAcceptor->getUsedVariables(),`
`130`	`130`	`$originalParametersAcceptor->acceptsNamedArguments(),`
	`131`	`+ $originalParametersAcceptor->mustUseReturnValue(),`
`131`	`132`	`);`
`132`	`133`	`}`
`133`	`134`
Original file line number	Diff line number	Diff line change
`@@ -88,4 +88,9 @@ public function acceptsNamedArguments(): TrinaryLogic`
`88`	`88`	`return $this->methodReflection->acceptsNamedArguments();`
`89`	`89`	`}`
`90`	`90`
	`91`	`+ public function mustUseReturnValue(): TrinaryLogic`
	`92`	`+ {`
	`93`	`+ return TrinaryLogic::createMaybe();`
	`94`	`+ }`
	`95`	`+`
`91`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,7 @@ public function __construct(`
`28`	`28`	`private array $invalidateExpressions,`
`29`	`29`	`private array $usedVariables,`
`30`	`30`	`private TrinaryLogic $acceptsNamedArguments,`
	`31`	`+ private TrinaryLogic $mustUseReturnValue,`
`31`	`32`	`)`
`32`	`33`	`{`
`33`	`34`	`}`
`@@ -112,4 +113,9 @@ public function acceptsNamedArguments(): TrinaryLogic`
`112`	`113`	`return $this->acceptsNamedArguments;`
`113`	`114`	`}`
`114`	`115`
	`116`	`+ public function mustUseReturnValue(): TrinaryLogic`
	`117`	`+ {`
	`118`	`+ return $this->mustUseReturnValue;`
	`119`	`+ }`
	`120`	`+`
`115`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -98,4 +98,9 @@ public function acceptsNamedArguments(): TrinaryLogic`
`98`	`98`	`return TrinaryLogic::createYes();`
`99`	`99`	`}`
`100`	`100`
	`101`	`+ public function mustUseReturnValue(): TrinaryLogic`
	`102`	`+ {`
	`103`	`+ return TrinaryLogic::createMaybe();`
	`104`	`+ }`
	`105`	`+`
`101`	`106`	`}`