From 210f892d1466d8292678f2229d52187072a15dd5 Mon Sep 17 00:00:00 2001 From: Abdul Malik Ikhsan Date: Wed, 18 Nov 2026 16:25:51 +0700 Subject: [PATCH] Allow processing unreachable statements after an unused label --- src/Analyser/StatementsHandler.php | 10 +++ .../DeadCode/UnreachableStatementRuleTest.php | 27 +++++++ .../data/unreachable-after-unused-label.php | 79 +++++++++++++++++++ turbo-ext/src/StatementsHandler.cpp | 27 ++++++- 4 files changed, 141 insertions(+), 2 deletions(-) create mode 100644 tests/PHPStan/Rules/DeadCode/data/unreachable-after-unused-label.php diff --git a/src/Analyser/StatementsHandler.php b/src/Analyser/StatementsHandler.php index 504f3f46987..3bbbaad776b 100644 --- a/src/Analyser/StatementsHandler.php +++ b/src/Analyser/StatementsHandler.php @@ -161,6 +161,11 @@ public function processNodesWithStorage( ); if ($alreadyTerminated) { + if ($node->getAttribute(GotoLabelVisitor::LABEL_IS_USED_ATTRIBUTE) !== true) { + $nextStmts = $this->getNextUnreachableStatements(array_slice($nodes, $stmtToNodeIndex[$si] + 1), true); + $this->processUnreachableStatement($nodeScopeResolver, $nextStmts, $scope, $expressionResultStorage, $nodeCallback); + } + continue; } @@ -681,6 +686,11 @@ private function processStatementStep( ); if ($state->alreadyTerminated) { + if ($stmt->getAttribute(GotoLabelVisitor::LABEL_IS_USED_ATTRIBUTE) !== true) { + $nextStmts = $this->getNextUnreachableStatements(array_slice($stmts, $i + 1), $parentNode instanceof Node\Stmt\Namespace_); + $this->processUnreachableStatement($nodeScopeResolver, $nextStmts, $state->scope, $storage, $nodeCallback); + } + return; } diff --git a/tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php b/tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php index 584ed7a0953..ffcf62bd307 100644 --- a/tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php +++ b/tests/PHPStan/Rules/DeadCode/UnreachableStatementRuleTest.php @@ -453,4 +453,31 @@ public function testNullsafeShortCircuitTerminating(): void ]); } + public function testUnreachableAfterUnusedLabel(): void + { + $this->treatPhpDocTypesAsCertain = true; + $this->analyse([__DIR__ . '/data/unreachable-after-unused-label.php'], [ + [ + 'Unreachable statement - code above always terminates.', + 10, + ], + [ + 'Unreachable statement - code above always terminates.', + 20, + ], + [ + 'Unreachable statement - code above always terminates.', + 68, + ], + [ + 'Unreachable statement - code above always terminates.', + 73, + ], + [ + 'Unreachable statement - code above always terminates.', + 78, + ], + ]); + } + } diff --git a/tests/PHPStan/Rules/DeadCode/data/unreachable-after-unused-label.php b/tests/PHPStan/Rules/DeadCode/data/unreachable-after-unused-label.php new file mode 100644 index 00000000000..5b834bd8cd6 --- /dev/null +++ b/tests/PHPStan/Rules/DeadCode/data/unreachable-after-unused-label.php @@ -0,0 +1,79 @@ + 1) { + goto end; + dead: + $items = [$value, 1]; + foreach ($items as $item) { + $value += $item; + } + + end: + } + + return $value; + unreachable: + $value = $value * 1; + return $value; +} + +function unusedLabelInReachableCode(int $value): int +{ + unused: + $value++; + return $value; +} + +function usedLabel(int $value): int +{ + if ($value > 1) { + goto end; + } + return 1; + end: + return $value; +} + +function reachedOnlyByBackwardGoto(int $value): int +{ + goto second; + first: + $value++; + return $value; + second: + goto first; +} + +function reachedByJumpIntoBlock(int $value): int +{ + if ($value > 1) { + return 1; + inside: + $value++; + } + if ($value === 0) { + goto inside; + } + return $value; +} + +function severalUnusedLabels(): void +{ + return; + one: + echo 1; + echo 2; + two: + + three: + echo 3; +} + +goto end; +lbl: +$a = array(1); +end: diff --git a/turbo-ext/src/StatementsHandler.cpp b/turbo-ext/src/StatementsHandler.cpp index ae7614e3fdd..293a1f5a00c 100644 --- a/turbo-ext/src/StatementsHandler.cpp +++ b/turbo-ext/src/StatementsHandler.cpp @@ -595,7 +595,20 @@ class StatementsHandler zv::Val labelName = nameToString(nameNode); if (UNEXPECTED(labelName.isUndef())) return zv::Val(); if (UNEXPECTED(!mergeForwardGotoExitPoints(labelName.raw(), scope, alreadyTerminated, exitPoints))) return zv::Val(); - if (alreadyTerminated) continue; + if (alreadyTerminated) { + zv::Val labelIsUsed = pt_engine_node_get_attribute(Z_OBJ_P(node), PT_LC("labelIsUsed")); + if (UNEXPECTED(labelIsUsed.isUndef())) return zv::Val(); + if (!labelIsUsed.ref().isTrue()) { + zval *labelNodeIndex = zend_hash_index_find(stmtToNodeIndex.table(), si); + zend_long labelNodeOffset; + if (UNEXPECTED(!offsetAfter(labelNodeIndex, labelNodeOffset))) return zv::Val(); + zv::Val labelRest = arraySlice(nodesHeld.raw(), labelNodeOffset); + zv::Val labelNextStmts = getNextUnreachableStatements(labelRest.raw(), true); + if (UNEXPECTED(labelNextStmts.isUndef())) return zv::Val(); + if (UNEXPECTED(!processUnreachableStatement(nodeScopeResolver, labelNextStmts.raw(), scope.raw(), storage, nodeCallback))) return zv::Val(); + } + continue; + } zv::Val hasBackwardGoto = pt_engine_node_get_attribute(Z_OBJ_P(node), PT_LC("hasBackwardGoto")); if (UNEXPECTED(hasBackwardGoto.isUndef())) return zv::Val(); @@ -1555,7 +1568,17 @@ class StatementsHandler ZVAL_BOOL(OBJ_PROP_NUM(stateObject, stateSlots::alreadyTerminated), alreadyTerminated); zv::Ref(OBJ_PROP_NUM(stateObject, stateSlots::exitPoints)).assign(std::move(exitPoints)); - if (alreadyTerminated) return true; + if (alreadyTerminated) { + zv::Val labelIsUsed = pt_engine_node_get_attribute(Z_OBJ_P(stmt), PT_LC("labelIsUsed")); + if (UNEXPECTED(labelIsUsed.isUndef())) return false; + if (labelIsUsed.ref().isTrue()) return true; + zv::Val labelRest = arraySlice(stmts, i + 1); + bool labelEarlyBinding; + if (UNEXPECTED(!isInstance(parentNode, PT_CLASS_NAMESPACE_STMT, labelEarlyBinding))) return false; + zv::Val labelNextStmts = getNextUnreachableStatements(labelRest.raw(), labelEarlyBinding); + if (UNEXPECTED(labelNextStmts.isUndef())) return false; + return processUnreachableStatement(nodeScopeResolver, labelNextStmts.raw(), OBJ_PROP_NUM(stateObject, stateSlots::scope), storage, nodeCallback); + } zv::Val hasBackwardGoto = pt_engine_node_get_attribute(Z_OBJ_P(stmt), PT_LC("hasBackwardGoto")); if (UNEXPECTED(hasBackwardGoto.isUndef())) return false;