Keep template argument facts of catch and finally blocks

A catch block that ends by throwing or returning is left out of the scope
after the try-catch, and the finally block reaches it only through
processFinallyScope(), which carries variable state. The facts the
observation pass collected in them - a new Collection([1]) sent to
Collection<int> - were lost with the scopes, the site stayed unresolved and
the second pass reported Collection<unresolved(1)>. The constraints of
every block are now joined into the scope after the try-catch.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VpbB99tJfUmeArX74xqvHv

Author: ondrejmirtes

src/Analyser/StmtHandler/TryCatchHandler.php

@@ -71,6 +71,9 @@ public function processStmt(
 		$branchScopeResult = $nodeScopeResolver->processStmtNodesInternal($stmt, $stmt->stmts, $scope, $storage, $nodeCallback, $context);
 		$branchScope = $branchScopeResult->getScope();
 		$finalScope = $branchScopeResult->isAlwaysTerminating() ? null : $branchScope;
+		// what the template argument observation collected in every block,
+		// including the ones that end by leaving the try-catch
+		$blockScopes = [$branchScope];
 
 		$exitPoints = [];
 		$finallyExitPoints = [];
@@ -246,6 +249,7 @@ public function processStmt(
 
 			$catchScopeResult = $nodeScopeResolver->processStmtNodesInternal($catchNode, $catchNode->stmts, $catchScope->enterCatchType($catchType, $variableName), $storage, $nodeCallback, $context);
 			$catchScopeForFinally = $catchScopeResult->getScope();
+			$blockScopes[] = $catchScopeForFinally;
 			$catchFlows[] = [$originalCatchType, VariableFlow::sequence($catchNode->var !== null ? VariableFlowBuilder::targetWrite($catchNode->var, VariableWrite::KIND_CATCH, $catchScopeForFinally, $storage) : null, $catchScopeResult->getVariableFlow())];
 
 			$finalScope = $catchScopeResult->isAlwaysTerminating() ? $finalScope : $catchScopeResult->getScope()->mergeWith($finalScope);
@@ -297,6 +301,7 @@ public function processStmt(
 			$throwPointsForLater = array_merge($throwPointsForLater, $finallyResult->getThrowPoints());
 			$impurePoints = array_merge($impurePoints, $finallyResult->getImpurePoints());
 			$finallyScope = $finallyResult->getScope();
+			$blockScopes[] = $finallyScope;
 			$finalScope = $finallyResult->isAlwaysTerminating() ? $finalScope : $finalScope->processFinallyScope($finallyScope, $originalFinallyScope);
 			if (!$finallyResult->isAlwaysTerminating()) {
 				// the finally block runs after the exit point, so its changes are
@@ -329,6 +334,10 @@ public function processStmt(
 			$exitPoints = array_merge($exitPoints, $finallyResult->getExitPoints());
 		}
 
+		foreach ($blockScopes as $blockScope) {
+			$finalScope = $finalScope->addTemplateArgumentConstraints($blockScope->getTemplateArgumentConstraints());
+		}
+
 		return new InternalStatementResult($finalScope, hasYield: $hasYield, isAlwaysTerminating: $alwaysTerminating, exitPoints: $exitPoints, throwPoints: array_merge($throwPoints, $throwPointsForLater), impurePoints: $impurePoints, variableFlow: VariableFlow::tryCatch($branchScopeResult->getVariableFlow(), $catchFlows, $finallyFlow));
 	}
 

tests/PHPStan/Analyser/nsrt/template-argument-try-catch.php

@@ -0,0 +1,71 @@
+<?php declare(strict_types = 1);
+
+namespace TemplateArgumentTryCatch;
+
+use function PHPStan\Testing\assertType;
+
+/** @template T */
+class Collection
+{
+
+	/** @param list<T> $items */
+	public function __construct(array $items)
+	{
+	}
+
+}
+
+/** @param Collection<int> $collection */
+function takeInts(Collection $collection): void
+{
+}
+
+function mayThrow(): void
+{
+}
+
+function catchThatThrows(): void
+{
+	try {
+		mayThrow();
+	} catch (\Exception $e) {
+		$collection = new Collection([1]);
+		takeInts($collection);
+		assertType('TemplateArgumentTryCatch\Collection<int>', $collection);
+		throw $e;
+	}
+}
+
+function catchThatReturns(): void
+{
+	try {
+		mayThrow();
+	} catch (\Exception $e) {
+		$collection = new Collection([1]);
+		takeInts($collection);
+		assertType('TemplateArgumentTryCatch\Collection<int>', $collection);
+		return;
+	}
+}
+
+function finallyBlock(): void
+{
+	try {
+		mayThrow();
+	} finally {
+		$collection = new Collection([1]);
+		takeInts($collection);
+		assertType('TemplateArgumentTryCatch\Collection<int>', $collection);
+	}
+}
+
+function tryThatThrows(): void
+{
+	try {
+		$collection = new Collection([1]);
+		takeInts($collection);
+		assertType('TemplateArgumentTryCatch\Collection<int>', $collection);
+		throw new \Exception();
+	} catch (\Exception $e) {
+	}
+}

turbo-ext/src/TryCatchHandler.cpp

@@ -164,6 +164,10 @@ class TryCatchHandler
 		bool alwaysTerminating;
 		if (UNEXPECTED(!pt_internal_statement_result_is_always_terminating(branch, alwaysTerminating))) return zv::Val();
 		zv::Val finalScope = alwaysTerminating ? zv::Val::null() : zv::Val::copyOf(branchScope.ref());
+		// what the template argument observation collected in every block,
+		// including the ones that end by leaving the try-catch
+		zv::Arr blockScopes = zv::Arr::empty();
+		blockScopes.push(zv::Val::copyOf(branchScope.ref()));
 
 		zv::Arr exitPoints = zv::Arr::empty();
 		zv::Arr finallyExitPoints = zv::Arr::empty();
@@ -489,6 +493,7 @@ class TryCatchHandler
 				if (UNEXPECTED(resultScope == NULL)) return zv::Val();
 				catchScopeForFinally = zv::Val::copyOf(zv::Ref(resultScope));
 			}
+			blockScopes.push(zv::Val::copyOf(catchScopeForFinally.ref()));
 			{
 				zv::Val writeFlow = zv::Val::null();
 				zval *catchVar = ptsh::readNodeProperty(pt_tch_catch_var_site, catchNode, PT_LC("var"));
@@ -626,6 +631,7 @@ class TryCatchHandler
 				if (UNEXPECTED(resultScope == NULL)) return zv::Val();
 				finallyScope = zv::Val::copyOf(zv::Ref(resultScope));
 			}
+			blockScopes.push(zv::Val::copyOf(finallyScope.ref()));
 			if (!finallyAlwaysTerminating) {
 				zv::Val processed = pt_mutating_scope_process_finally_scope(Z_OBJ_P(finalScope.raw()), Z_OBJ_P(finallyScope.raw()), Z_OBJ_P(originalFinallyScope.raw()));
 				if (UNEXPECTED(processed.isUndef())) return zv::Val();
@@ -695,6 +701,13 @@ class TryCatchHandler
 			variableFlow = pt_variable_flow_try_catch(bodyFlow, catchFlows.raw(), finallyFlow.raw());
 			if (UNEXPECTED(variableFlow.isUndef())) return zv::Val();
 		}
+		for (auto entry : blockScopes.arrRef()) {
+			zv::Val constraints = pt_mutating_scope_get_template_argument_constraints(Z_OBJ_P(entry.value().raw()));
+			if (UNEXPECTED(constraints.isUndef())) return zv::Val();
+			zv::Val joined = pt_mutating_scope_add_template_argument_constraints(Z_OBJ_P(finalScope.raw()), constraints.raw());
+			if (UNEXPECTED(joined.isUndef())) return zv::Val();
+			finalScope = std::move(joined);
+		}
 		return pt_internal_statement_result_new(finalScope.raw(), hasYield, alwaysTerminating, exitPoints.raw(), throwPoints.raw(), impurePoints.raw(), NULL, variableFlow.raw());
 	}