fix func args

Author: staabm

src/Analyser/NodeScopeResolver.php

@@ -2554,6 +2554,7 @@ function (MutatingScope $scope) use ($stmt, $expr, $nodeCallback, $context): Exp
 $scope = $nameResult->getScope();
 $throwPoints = $nameResult->getThrowPoints();
 $impurePoints = $nameResult->getImpurePoints();
+$isAlwaysTerminating = $nameResult->isAlwaysTerminating();
 if (
 $nameType->isObject()->yes()
 && $nameType->isCallable()->yes()
@@ -2569,6 +2570,7 @@ static function (): void {
 );
 $throwPoints = array_merge($throwPoints, $invokeResult->getThrowPoints());
 $impurePoints = array_merge($impurePoints, $invokeResult->getImpurePoints());
+$isAlwaysTerminating = $isAlwaysTerminating || $invokeResult->isAlwaysTerminating();
 } elseif ($parametersAcceptor instanceof CallableParametersAcceptor) {
 $callableThrowPoints = array_map(static fn (SimpleThrowPoint $throwPoint) => $throwPoint->isExplicit() ? ThrowPoint::createExplicit($scope, $throwPoint->getType(), $expr, $throwPoint->canContainAnyThrowable()) : ThrowPoint::createImplicit($scope, $expr), $parametersAcceptor->getThrowPoints());
 if (!$this->implicitThrows) {
@@ -2604,13 +2606,14 @@ static function (): void {
 if ($parametersAcceptor !== null) {
 $expr = ArgumentsNormalizer::reorderFuncArguments($parametersAcceptor, $expr) ?? $expr;
 $returnType = $parametersAcceptor->getReturnType();
-$isAlwaysTerminating = $returnType instanceof NeverType && $returnType->isExplicit();
+$isAlwaysTerminating = $isAlwaysTerminating || $returnType instanceof NeverType && $returnType->isExplicit();
 }
 $result = $this->processArgs($stmt, $functionReflection, null, $parametersAcceptor, $expr, $scope, $nodeCallback, $context);
 $scope = $result->getScope();
 $hasYield = $result->hasYield();
 $throwPoints = array_merge($throwPoints, $result->getThrowPoints());
 $impurePoints = array_merge($impurePoints, $result->getImpurePoints());
+$isAlwaysTerminating = $isAlwaysTerminating || $result->isAlwaysTerminating();
 
 if ($functionReflection !== null) {
 $functionThrowPoint = $this->getFunctionThrowPoint($functionReflection, $parametersAcceptor, $expr, $scope);
@@ -5012,6 +5015,7 @@ private function processArgs(
 $hasYield = false;
 $throwPoints = [];
 $impurePoints = [];
+$isAlwaysTerminating = false;
 foreach ($args as $i => $arg) {
 $assignByReference = false;
 $parameter = null;
@@ -5161,6 +5165,7 @@ private function processArgs(
 $exprResult = $this->processExprNode($stmt, $arg->value, $scopeToPass, $nodeCallback, $context->enterDeep());
 $throwPoints = array_merge($throwPoints, $exprResult->getThrowPoints());
 $impurePoints = array_merge($impurePoints, $exprResult->getImpurePoints());
+$isAlwaysTerminating = $isAlwaysTerminating || $exprResult->isAlwaysTerminating();
 $scope = $exprResult->getScope();
 $hasYield = $hasYield || $exprResult->hasYield();
 
@@ -5285,7 +5290,7 @@ static function (Node $node, Scope $scope) use ($nodeCallback): void {
 }
 }
 
-return new ExpressionResult($scope, $hasYield, $throwPoints, $impurePoints);
+return new ExpressionResult($scope, $hasYield, $throwPoints, $impurePoints, isAlwaysTerminating: $isAlwaysTerminating);
 }
 
 /**

tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php

@@ -259,12 +259,16 @@ public function testBug13232a(): void
 $this->analyse([__DIR__ . '/data/bug-13232a.php'], [
 [
 'Unreachable statement - code above always terminates.',
-11,
+10,
 ],
 [
 'Unreachable statement - code above always terminates.',
 17,
 ],
+[
+'Unreachable statement - code above always terminates.',
+23,
+],
 ]);
 }
 

tests/PHPStan/Rules/DeadCode/data/bug-13232a.php

@@ -4,6 +4,12 @@
 
 final class HelloWorld
 {
+public function sayHa(): void
+{
+echo sprintf("Hello, %s no way", $this->neverReturnsMethod());
+echo 'this will never happen';
+}
+
 public function sayHi(): void
 {
 echo 'Hello, ' . neverReturns()
@@ -17,7 +23,11 @@ public function sayHo(): void
 echo 'this will never happen';
 }
 
-function neverReturnsMethod(): never {}
+function neverReturnsMethod(): never {
+exit();
+}
+}
+function neverReturns(): never {
+exit();
 }
-function neverReturns(): never {}