Convert rule-facing FiberScope at the new-world hook boundary

Replaces the blanket processExprNode conversion with the root cause: the
hooks are the boundary between the rule-facing world and the engine.
Rules hold FiberScopes and feed them straight into the old-world
dispatcher (ImpossibleCheckTypeHelper passes the rule's scope to
specifyTypesInCondition, phpstan-phpunit's assert extension builds a
synthetic BooleanOr there), so resolveTypeOfNewWorldHandlerNode() and
specifyTypesOfNewWorldHandlerNode() can run with $this being a
FiberScope. They now call toMutatingScope() - identity on a plain scope,
a state-preserving copy on a FiberScope - before invoking result
callbacks and on-demand processing.

Without the conversion the engine processes synthetic nodes on the
rule-facing scope, whose type asks suspend: wasteful inside a rule
fiber, fatal outside one ("Cannot suspend outside of a fiber"). Found
by an ExpressionResult creation tripwire after the CI-only crash never
reproduced locally.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ondrejmirtes

src/Analyser/MutatingScope.php

@@ -1012,6 +1012,11 @@ private function resolveType(string $exprString, Expr $node): Type
 	 */
 	private function resolveTypeOfNewWorldHandlerNode(Expr $node): Type
 	{
+		// the hooks are the boundary between the rule-facing world and the
+		// engine - a rule's FiberScope must not flow into result callbacks or
+		// on-demand processing, where its suspending type asks crash outside
+		// a fiber
+		$scope = $this->toMutatingScope();
 		$storage = $this->expressionResultStorageStack->getCurrent();
 		if ($storage !== null) {
 			$result = $storage->findExpressionResult($node);
@@ -1023,18 +1028,18 @@ private function resolveTypeOfNewWorldHandlerNode(Expr $node): Type
 					));
 				}
 
-				return $result->getTypeForScope($this);
+				return $result->getTypeForScope($scope);
 			}
 		}
 
 		// a synthetic node, or no analysis in progress
 		$onDemandResult = $this->container->getByType(NodeScopeResolver::class)->processExprOnDemand(
 			$node,
-			$this,
+			$scope,
 			$storage !== null ? $storage->duplicate() : new ExpressionResultStorage(),
 		);
 
-		return $onDemandResult->getTypeForScope($this);
+		return $onDemandResult->getTypeForScope($scope);
 	}
 
 	/**
@@ -1077,22 +1082,26 @@ private function getCurrentTypesOfSpecifiedExpr(Expr $expr): ?array
 	 */
 	public function specifyTypesOfNewWorldHandlerNode(Expr $node, TypeSpecifierContext $context): ?SpecifiedTypes
 	{
+		// see resolveTypeOfNewWorldHandlerNode() - rules ask the dispatcher
+		// with their FiberScope (e.g. ImpossibleCheckTypeHelper), the engine
+		// side of the boundary works with the mutating flavor
+		$scope = $this->toMutatingScope();
 		$storage = $this->expressionResultStorageStack->getCurrent();
 		if ($storage !== null) {
 			$result = $storage->findExpressionResult($node);
 			if ($result !== null) {
-				return $result->getSpecifiedTypesForScope($this, $context);
+				return $result->getSpecifiedTypesForScope($scope, $context);
 			}
 		}
 
 		// a synthetic node, or no analysis in progress
 		$onDemandResult = $this->container->getByType(NodeScopeResolver::class)->processExprOnDemand(
 			$node,
-			$this,
+			$scope,
 			$storage !== null ? $storage->duplicate() : new ExpressionResultStorage(),
 		);
 
-		return $onDemandResult->getSpecifiedTypesForScope($this, $context);
+		return $onDemandResult->getSpecifiedTypesForScope($scope, $context);
 	}
 
 	/**

src/Analyser/NodeScopeResolver.php

@@ -52,7 +52,6 @@
 use PhpParser\NodeVisitorAbstract;
 use PHPStan\Analyser\ExprHandler\AssignHandler;
 use PHPStan\Analyser\ExprHandler\Helper\ImplicitToStringCallHelper;
-use PHPStan\Analyser\Fiber\FiberScope;
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionClass;
 use PHPStan\BetterReflection\Reflection\ReflectionEnum;
 use PHPStan\BetterReflection\Reflector\Reflector;
@@ -2804,15 +2803,6 @@ public function processExprNode(
 		ExpressionContext $context,
 	): ExpressionResult
 	{
-		if ($scope instanceof FiberScope) {
-			// the engine never processes on the rule-facing FiberScope - one can
-			// arrive here through a stored result's memoized truthy/falsey scope
-			// (first computed inside a rule fiber) consumed by a handler for a
-			// child's processing scope; its type asks would suspend outside
-			// a fiber
-			$scope = $scope->toMutatingScope();
-		}
-
 		if ($this->returnStoredExpressionResults) {
 			$storedResult = $storage->findExpressionResult($expr);
 			if ($storedResult !== null) {