@@ -72,12 +72,15 @@ final class ClosureTypeResolver implements PerFileAnalysisResettable
 	 * file's analysis ends - the per-file reset releases the Types and
 	 * throw/impure points with the rest of the file's result graph.
 	 *
-	 * Keyed by the closure node's spl_object_id(). The keys are AST nodes that
-	 * live for the whole file's analysis (the parser cache retains them), so
-	 * ids of live entries never collide; the per-file reset empties the map
-	 * before another file could reuse them.
+	 * Keyed by the closure node's spl_object_id(), which PHP hands out again
+	 * as soon as a node is freed. The parsed file's nodes live for its whole
+	 * analysis, but a closure node that is built or parsed and dropped mid-file
+	 * - by a handler desugaring a call, or by an extension or a test walking
+	 * its own nodes through NodeScopeResolver - frees its id for the next
+	 * allocation. Each entry therefore pins the node it was built for, and
+	 * findCachedTypes() answers for that very node only.
 	 *
-	 * @var array<int, array<string, array{returnType: Type, throwPoints: SimpleThrowPoint[], impurePoints: SimpleImpurePoint[], invalidateExpressions: InvalidateExprNode[], usedVariables: string[]}>>
+	 * @var array<int, array{expr: Node\Expr\Closure|ArrowFunction, types: array<string, array{returnType: Type, throwPoints: SimpleThrowPoint[], impurePoints: SimpleImpurePoint[], invalidateExpressions: InvalidateExprNode[], usedVariables: string[]}>}>
 	 */
 	private array $cachedTypes = [];
 
@@ -93,6 +96,19 @@ public function resetFileAnalysisState(): void
 		$this->cachedTypes = [];
 	}
 
+	/**
+	 * @return array<string, array{returnType: Type, throwPoints: SimpleThrowPoint[], impurePoints: SimpleImpurePoint[], invalidateExpressions: InvalidateExprNode[], usedVariables: string[]}>
+	 */
+	private function findCachedTypes(Node\Expr\Closure|ArrowFunction $expr): array
+	{
+		$entry = $this->cachedTypes[spl_object_id($expr)] ?? null;
+		if ($entry === null || $entry['expr'] !== $expr) {
+			return [];
+		}
+
+		return $entry['types'];
+	}
+
 	/**
 	 * Resolves a closure/arrow function type by walking its body itself. Used by
 	 * the paths that have no prior walk to read return/yield types from. A
@@ -128,7 +144,7 @@ public function getClosureType(
 			);
 		}
 
-		$cachedTypes = $this->cachedTypes[spl_object_id($expr)] ?? [];
+		$cachedTypes = $this->findCachedTypes($expr);
 		$cacheKey = $this->closureContextCacheKey($scope, $expr, $callableParameters, $parameters);
 		if (array_key_exists($cacheKey, $cachedTypes)) {
 			return $this->createClosureTypeFromCache($expr, $parameters, $isVariadic, $cachedTypes[$cacheKey]);
@@ -387,15 +403,15 @@ public function seedCacheFromClosureWalk(MutatingScope $scope, Node\Expr\Closure
 
 		[$parameters, , $callableParameters] = $this->buildParametersAndAcceptors($scope, $expr);
 		$phpdocKey = $this->closureContextCacheKey($scope, $expr, $callableParameters, $parameters);
-		$cachedTypes = $this->cachedTypes[spl_object_id($expr)] ?? [];
+		$cachedTypes = $this->findCachedTypes($expr);
 		if (!array_key_exists($phpdocKey, $cachedTypes)) {
 			return;
 		}
 
 		$promotedScope = $scope->doNotTreatPhpDocTypesAsCertain();
 		[$promotedParameters, , $promotedCallableParameters] = $this->buildParametersAndAcceptors($promotedScope, $expr);
 		$cachedTypes[$this->closureContextCacheKey($promotedScope, $expr, $promotedCallableParameters, $promotedParameters)] = $cachedTypes[$phpdocKey];
-		$this->cachedTypes[spl_object_id($expr)] = $cachedTypes;
+		$this->cachedTypes[spl_object_id($expr)] = ['expr' => $expr, 'types' => $cachedTypes];
 	}
 
 	/**
@@ -912,7 +928,7 @@ private function assembleClosureType(
 		$impurePointsForClosureType = array_map(static fn (ImpurePoint $impurePoint) => new SimpleImpurePoint($impurePoint->getIdentifier(), $impurePoint->getDescription(), $impurePoint->isCertain()), $impurePoints);
 
 		if ($writeCache) {
-			$cachedTypes = $this->cachedTypes[spl_object_id($expr)] ?? [];
+			$cachedTypes = $this->findCachedTypes($expr);
 			$cacheKey ??= $this->closureContextCacheKey($scope, $expr, null, $parameters);
 			$cachedTypes[$cacheKey] = [
 				'returnType' => $returnType,
@@ -921,7 +937,7 @@ private function assembleClosureType(
 				'invalidateExpressions' => $invalidateExpressions,
 				'usedVariables' => $usedVariables,
 			];
-			$this->cachedTypes[spl_object_id($expr)] = $cachedTypes;
+			$this->cachedTypes[spl_object_id($expr)] = ['expr' => $expr, 'types' => $cachedTypes];
 		}
 
 		$mustUseReturnValue = TrinaryLogic::createNo();
 
@@ -2,6 +2,9 @@
 
 namespace PHPStan\Analyser;
 
+use PhpParser\Node\Expr\ArrowFunction;
+use PhpParser\Node\Expr\Exit_;
+use PhpParser\Node\Expr\FuncCall;
 use PhpParser\Node\Stmt;
 use PHPStan\Parser\Parser;
 use PHPStan\ShouldNotHappenException;
@@ -193,9 +196,33 @@ public function testIsAlwaysTerminating(
 		if (!$stmts[0] instanceof Stmt\Expression) {
 			throw new ShouldNotHappenException('Expecting code contains a single statement expression, got: ' . get_class($stmts[0]));
 		}
-		$stmt = $stmts[0];
-		$expr = $stmt->expr;
+		$this->assertSame($expectedIsAlwaysTerminating, $this->processExpressionStatement($stmts[0])->isAlwaysTerminating());
+	}
+
+	public function testClosureTypeIsNotReusedForClosureWithRecycledObjectId(): void
+	{
+		/** @var Parser $parser */
+		$parser = self::getContainer()->getService('currentPhpVersionRichParser');
 
+		/** @var Stmt\Expression $generatorStmt */
+		$generatorStmt = $parser->parseString('<?php fn() => yield (exit());')[0];
+		$generatorArrowFunction = $generatorStmt->expr;
+		$this->assertInstanceOf(ArrowFunction::class, $generatorArrowFunction);
+		$this->assertFalse($this->processExpressionStatement($generatorStmt)->isAlwaysTerminating());
+
+		// PHP hands the most recently freed object id to the next allocation - drop the
+		// generator arrow function last, and build the next arrow function right after,
+		// so it gets the same spl_object_id() unless something still holds the first one
+		$exit = new Exit_();
+		unset($generatorStmt);
+		unset($generatorArrowFunction);
+		$arrowFunction = new ArrowFunction(['expr' => $exit], ['isImmediatelyInvokedClosure' => true, 'immediatelyInvokedClosureArgs' => []]);
+
+		$this->assertTrue($this->processExpressionStatement(new Stmt\Expression(new FuncCall($arrowFunction)))->isAlwaysTerminating());
+	}
+
+	private function processExpressionStatement(Stmt\Expression $stmt): ExpressionResult
+	{
 		/** @var NodeScopeResolver $nodeScopeResolver */
 		$nodeScopeResolver = self::getContainer()->getByType(NodeScopeResolver::class);
 		/** @var ScopeFactory $scopeFactory */
@@ -204,16 +231,15 @@ public function testIsAlwaysTerminating(
 			->assignVariable('x', new IntegerType(), new IntegerType(), TrinaryLogic::createYes())
 			->assignVariable('arr', new ArrayType(new MixedType(), new MixedType()), new ArrayType(new MixedType(), new MixedType()), TrinaryLogic::createYes());
 
-		$result = $nodeScopeResolver->processExprNode(
+		return $nodeScopeResolver->processExprNode(
 			$stmt,
-			$expr,
+			$stmt->expr,
 			$scope,
 			new ExpressionResultStorage(),
 			static function (): void {
 			},
 			ExpressionContext::createTopLevel(),
 		);
-		$this->assertSame($expectedIsAlwaysTerminating, $result->isAlwaysTerminating());
 	}
 
 }