DoWhileHandler.php

<?php declare(strict_types = 1);

namespace PHPStan\Analyser\StmtHandler;

use PhpParser\Node\Stmt;
use PhpParser\Node\Stmt\Break_;
use PhpParser\Node\Stmt\Do_;
use PHPStan\Analyser\ExpressionContext;
use PHPStan\Analyser\ExpressionResultStorage;
use PHPStan\Analyser\InternalStatementResult;
use PHPStan\Analyser\LoopWrittenVariableNames;
use PHPStan\Analyser\MutatingScope;
use PHPStan\Analyser\NodeScopeResolver;
use PHPStan\Analyser\NoopNodeCallback;
use PHPStan\Analyser\RecordingNodeCallback;
use PHPStan\Analyser\StatementContext;
use PHPStan\Analyser\StmtHandler;
use PHPStan\Analyser\VariableFlow;
use PHPStan\Dependency\Dependencies;
use PHPStan\DependencyInjection\AutowiredParameter;
use PHPStan\DependencyInjection\AutowiredService;
use PHPStan\Node\DoWhileLoopConditionNode;
use PHPStan\Turbo\ShadowedByTurboExtension;
use function array_merge;
use function count;

/**
 * @implements StmtHandler<Do_>
 */
#[AutowiredService]
#[ShadowedByTurboExtension(implementation: __DIR__ . '/../../../turbo-ext/src/DoWhileHandler.cpp')]
final class DoWhileHandler implements StmtHandler
{

	public function __construct(
		#[AutowiredParameter]
		private bool $treatPhpDocTypesAsCertain,
	)
	{
	}

	public function supports(Stmt $stmt): bool
	{
		return $stmt instanceof Do_;
	}

	public function processStmt(
		NodeScopeResolver $nodeScopeResolver,
		Stmt $stmt,
		MutatingScope $scope,
		ExpressionResultStorage $storage,
		callable $nodeCallback,
		StatementContext $context,
	): InternalStatementResult
	{
		$finalScope = null;
		$bodyScope = $scope;
		$count = 0;
		$hasYield = false;
		$throwPoints = [];
		$impurePoints = [];
		$originalStorage = $storage;

		$replayBodyRecording = null;
		$replayPassStorage = null;
		$replayPassResult = null;
		$prevEntryScope = null;
		$previousPass = null;
		$previousPassStorage = null;
		if ($context->isTopLevel()) {
			$bodyIsReplayable = $nodeScopeResolver->isReplayableConvergenceBody($stmt, $stmt->stmts);
			// each pass after the first re-walks only the statements whose
			// entry state differs from the previous pass's (StatementsHandler::processLoopPassStmtNodes())
			do {
				$prevScope = $bodyScope;
				$bodyScope = $bodyScope->mergeWith($scope);
				if ($prevEntryScope !== null && $bodyScope->equals($prevEntryScope)) {
					// walking is deterministic in the entry scope - an unchanged entry
					// reproduces the previous pass's exit (and repeats only idempotent
					// merges into the final scope), so the verification walk is skipped
					$bodyScope = $prevScope;
					break;
				}
				$prevEntryScope = $bodyScope;
				$storage = $originalStorage->duplicate();
				if ($previousPassStorage !== null) {
					// the statements this pass replays answer from the results the previous pass stored
					$storage->mergeResults($previousPassStorage);
				}
				$bodyRecording = new RecordingNodeCallback();
				$scope->pushExpressionResultStorage($storage);
				try {
					$passRecord = null;
					$bodyScopeResult = $nodeScopeResolver->processLoopPassStmtNodes($stmt, $stmt->stmts, $bodyScope, $storage, $bodyRecording, $context->enterDeep()->withoutTemplateArgumentResolution(), $previousPass, $passRecord)->filterOutLoopExitPoints();
					$previousPass = $passRecord;
					$previousPassStorage = $storage;
					$backEdgeScope = $bodyScopeResult->getLoopBackEdgeScope();
					if ($backEdgeScope === null && !$bodyIsReplayable) {
						// a nested loop walks only its first iteration in a pass - its unconverged
						// types can make the back edge look dead, so a walk converging it decides
						$backEdgeScope = $nodeScopeResolver->processStmtNodesInternal($stmt, $stmt->stmts, $bodyScope, $storage->duplicate(), new NoopNodeCallback(), $context->withoutTemplateArgumentResolution())->filterOutLoopExitPoints()->getLoopBackEdgeScope();
					}
					$finalScope = $backEdgeScope === null ? $finalScope : $backEdgeScope->mergeWith($finalScope);
					foreach ($bodyScopeResult->getExitPointsByType(Break_::class) as $breakExitPoint) {
						$finalScope = $breakExitPoint->getScope()->mergeWith($finalScope);
					}
					// the candidate to replace the final body walk when this pass's
					// entry turns out to be the fixpoint
					if ($bodyIsReplayable) {
						$replayBodyRecording = $bodyRecording;
						$replayPassStorage = $storage;
						$replayPassResult = $bodyScopeResult;
					}
					if ($backEdgeScope === null) {
						$bodyScope = $prevScope;
						break;
					}
					$passCondResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $backEdgeScope, $storage, new NoopNodeCallback(), ExpressionContext::createDeep(resolveTemplateArguments: false));
					$bodyScope = $passCondResult->getTruthyScope();
				} finally {
					$scope->popExpressionResultStorage();
				}
				if ($bodyScope->equals($prevScope)) {
					break;
				}

				if ($count >= NodeScopeResolver::GENERALIZE_AFTER_ITERATION) {
					$bodyScope = $prevScope->generalizeWith(
						$bodyScope,
						LoopWrittenVariableNames::collect($stmt, VariableFlow::sequence($bodyScopeResult->getVariableFlow(), $passCondResult->getVariableFlow())),
					);
				}
				$count++;
			} while ($count < NodeScopeResolver::LOOP_SCOPE_ITERATIONS);

			$bodyScope = $bodyScope->mergeWith($scope);
		}

		$storage = $originalStorage;
		if (
			$replayBodyRecording !== null && $replayPassStorage !== null && $replayPassResult !== null
			&& $bodyScope->equals($prevEntryScope)
		) {
			// the final body walk would repeat the recorded fixpoint pass exactly
			// (same entry scope, deterministic walk) - adopt the pass's results
			// and replay its emissions through the real callback instead; the
			// condition walks below stay real
			$originalStorage->mergeResults($replayPassStorage);
			$nodeScopeResolver->replayRecording($replayBodyRecording, $nodeCallback, $originalStorage, $scope);
			$bodyScopeResult = $replayPassResult;
		} elseif ($previousPass !== null && $previousPass[1] !== null) {
			// the last pass stands in for the statements whose state it walked
			// with - they replay through the real callback
			$originalStorage->mergeResults($previousPassStorage);
			$bodyScopeResult = $nodeScopeResolver->processLoopFinalStmtNodes($stmt, $stmt->stmts, $bodyScope, $storage, $nodeCallback, $context, $previousPass)->filterOutLoopExitPoints();
		} else {
			$bodyScopeResult = $nodeScopeResolver->processStmtNodesInternal($stmt, $stmt->stmts, $bodyScope, $storage, $nodeCallback, $context)->filterOutLoopExitPoints();
		}
		$backEdgeScope = $bodyScopeResult->getLoopBackEdgeScope();
		$backEdgeDead = $backEdgeScope === null;
		$bodyScope = $backEdgeScope ?? $bodyScopeResult->getScope();

		// the condition is processed once on the post-body scope; its result
		// answers both the always-iterates check below and the falsey post-loop
		// scope - the previous scope-based read here was a guaranteed storage
		// miss (the condition was only ever stored into discarded convergence
		// duplicates) that re-priced the condition on demand before this walk
		$condResult = $nodeScopeResolver->processExprNode($stmt, $stmt->cond, $bodyScope, $storage, $nodeCallback, ExpressionContext::createDeep($context->shouldResolveTemplateArguments()));

		$alwaysIterates = false;
		if ($context->isTopLevel()) {
			$condBooleanType = ($this->treatPhpDocTypesAsCertain ? $condResult->getType() : $condResult->getNativeType())->toBoolean();
			$alwaysIterates = $condBooleanType->isTrue()->yes();
		}

		if ($alwaysIterates || $backEdgeDead) {
			$alwaysTerminating = count($bodyScopeResult->getExitPointsByType(Break_::class)) === 0;
		} else {
			$alwaysTerminating = $bodyScopeResult->isAlwaysTerminating();
		}
		$finalScope = $alwaysTerminating || $backEdgeDead ? $finalScope : $bodyScope->mergeWith($finalScope);
		if ($finalScope === null) {
			$finalScope = $scope;
		}
		if (!$alwaysTerminating && !$backEdgeDead) {
			$hasYield = $condResult->hasYield();
			$throwPoints = $condResult->getThrowPoints();
			$impurePoints = $condResult->getImpurePoints();
			$finalScope = $condResult->getFalseyScope();
		}

		// both emissions fire after the condition's final walk stored its
		// results, so rule-side asks about the condition answer from the
		// storage; the Do_ callback is deferred from processStmtNode()
		$nodeScopeResolver->callNodeCallback($nodeCallback, new DoWhileLoopConditionNode($stmt->cond, $bodyScopeResult->toPublic()->getExitPoints(), $bodyScopeResult->hasYield()), $bodyScope, $storage);
		$nodeScopeResolver->callNodeCallback($nodeCallback, $stmt, $scope, $storage);

		$breakExitPoints = $bodyScopeResult->getExitPointsByType(Break_::class);
		if (count($breakExitPoints) > 0) {
			$breakScope = $alwaysIterates || $backEdgeDead ? null : $finalScope;
			foreach ($breakExitPoints as $breakExitPoint) {
				$breakScope = $breakScope === null ? $breakExitPoint->getScope() : $breakScope->mergeWith($breakExitPoint->getScope());
			}
			$finalScope = $breakScope;
		}

		return new InternalStatementResult(
			$finalScope,
			hasYield: $bodyScopeResult->hasYield() || $hasYield,
			isAlwaysTerminating: $alwaysTerminating,
			exitPoints: $bodyScopeResult->getExitPointsForOuterLoop(),
			throwPoints: array_merge($throwPoints, $bodyScopeResult->getThrowPoints()),
			impurePoints: array_merge($impurePoints, $bodyScopeResult->getImpurePoints()),
			// the body runs once, then may repeat or not whatever the condition says
			variableFlow: VariableFlow::loop(null, $bodyScopeResult->getVariableFlow(), $condResult->getVariableFlow(), true, true),
			dependencies: Dependencies::merge($bodyScopeResult->getDependencies(), $condResult->getDependencies()),
		);
	}

}