New world: single-pass expression processing through ExpressionResult callbacks

phpstan-baseline.neon

@@ -69,7 +69,7 @@ parameters:
 		-
 			rawMessage: Casting to string something that's already string.
 			identifier: cast.useless
-			count: 3
+			count: 5
 			path: src/Analyser/MutatingScope.php
 
 		-

src/Analyser/DirectInternalScopeFactory.php

@@ -38,6 +38,7 @@ public function __construct(
 		private $nodeCallback,
 		private ConstantResolver $constantResolver,
 		private bool $fiber = false,
+		private bool $resultAware = false,
 	)
 	{
 	}
@@ -64,6 +65,8 @@ public function create(
 		$className = MutatingScope::class;
 		if ($this->fiber) {
 			$className = FiberScope::class;
+		} elseif ($this->resultAware) {
+			$className = ResultAwareScope::class;
 		}
 
 		return new $className(
@@ -120,6 +123,27 @@ public function toFiberFactory(): InternalScopeFactory
 		);
 	}
 
+	public function toResultAwareFactory(): InternalScopeFactory
+	{
+		return new self(
+			$this->container,
+			$this->reflectionProvider,
+			$this->initializerExprTypeResolver,
+			$this->expressionTypeResolverExtensionRegistryProvider,
+			$this->exprPrinter,
+			$this->typeSpecifier,
+			$this->propertyReflectionFinder,
+			$this->parser,
+			$this->phpVersion,
+			$this->attributeReflectionFactory,
+			$this->configPhpVersion,
+			$this->nodeCallback,
+			$this->constantResolver,
+			false,
+			true,
+		);
+	}
+
 	public function toMutatingFactory(): InternalScopeFactory
 	{
 		return new self(

src/Analyser/ExprHandler/ArrayDimFetchHandler.php

@@ -13,6 +13,7 @@
 use PHPStan\Analyser\ExpressionResult;
 use PHPStan\Analyser\ExpressionResultStorage;
 use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\ExprHandler\Helper\DefaultNarrowingHelper;
 use PHPStan\Analyser\ExprHandler\Helper\NullsafeShortCircuitingHelper;
 use PHPStan\Analyser\MutatingScope;
 use PHPStan\Analyser\NodeScopeResolver;
@@ -23,9 +24,12 @@
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\DependencyInjection\AutowiredService;
 use PHPStan\Node\Expr\TypeExpr;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\NeverType;
+use PHPStan\Type\NullType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use function array_merge;
 
 /**
@@ -35,6 +39,10 @@
 final class ArrayDimFetchHandler implements ExprHandler
 {
 
+	public function __construct(private DefaultNarrowingHelper $defaultNarrowingHelper)
+	{
+	}
+
 	public function supports(Expr $expr): bool
 	{
 		return $expr instanceof ArrayDimFetch;
@@ -86,8 +94,9 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 				isAlwaysTerminating: $varResult->isAlwaysTerminating(),
 				throwPoints: $varResult->getThrowPoints(),
 				impurePoints: $varResult->getImpurePoints(),
-				truthyScopeCallback: static fn (): MutatingScope => $scope->filterByTruthyValue($expr),
-				falseyScopeCallback: static fn (): MutatingScope => $scope->filterByFalseyValue($expr),
+				expr: $expr,
+				typeCallback: static fn (): Type => new NeverType(),
+				specifyTypesCallback: fn (Expr $e, MutatingScope $s, TypeSpecifierContext $ctx): SpecifiedTypes => $this->defaultNarrowingHelper->specifyDefaultTypes($e, $ctx),
 			);
 		}
 
@@ -97,7 +106,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 		$impurePoints = array_merge($dimResult->getImpurePoints(), $varResult->getImpurePoints());
 		$scope = $varResult->getScope();
 
-		$varType = $scope->getType($expr->var);
+		$varType = $varResult->getType();
 		if (!$varType->isArray()->yes() && !(new ObjectType(ArrayAccess::class))->isSuperTypeOf($varType)->no()) {
 			$throwPoints = array_merge($throwPoints, $nodeScopeResolver->processExprNode(
 				$stmt,
@@ -109,14 +118,62 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 			)->getThrowPoints());
 		}
 
+		// a nullsafe var that can be null short-circuits this fetch too; its
+		// handler already produced the null-union — propagate one level, no
+		// recursive chain walking (NEW_WORLD.md §3.10)
+		$isShortcircuited = static function (Expr $e, MutatingScope $s) use ($varResult): bool {
+			if (!$e instanceof ArrayDimFetch) {
+				throw new ShouldNotHappenException();
+			}
+
+			return ($e->var instanceof Expr\NullsafePropertyFetch || $e->var instanceof Expr\NullsafeMethodCall)
+				&& TypeCombinator::containsNull($varResult->getTypeForScope($s));
+		};
+		$typeCallback = static function (Expr $e, MutatingScope $s) use ($varResult, $dimResult, $isShortcircuited, $nodeScopeResolver, $stmt): Type {
+			if (!$e instanceof ArrayDimFetch || $e->dim === null) {
+				throw new ShouldNotHappenException();
+			}
+
+			$varTypeForFetch = $varResult->getTypeForScope($s);
+			if ($isShortcircuited($e, $s)) {
+				$varTypeForFetch = TypeCombinator::removeNull($varTypeForFetch);
+			}
+
+			if (
+				!$varTypeForFetch->isArray()->yes()
+				&& (new ObjectType(ArrayAccess::class))->isSuperTypeOf($varTypeForFetch)->yes()
+			) {
+				// ArrayAccess: the offsetGet() synthetic, processed on demand
+				// (ResultAwareScope tier 4)
+				$fetchedType = $s->toResultAwareScope([], $nodeScopeResolver, $stmt, new ExpressionResultStorage())->getType(
+					new MethodCall(
+						new TypeExpr($varTypeForFetch),
+						new Identifier('offsetGet'),
+						[
+							new Arg($e->dim),
+						],
+					),
+				);
+			} else {
+				$fetchedType = $varTypeForFetch->getOffsetValueType($dimResult->getTypeForScope($s));
+			}
+
+			if ($isShortcircuited($e, $s)) {
+				return TypeCombinator::union($fetchedType, new NullType());
+			}
+
+			return $fetchedType;
+		};
+
 		return new ExpressionResult(
 			$scope,
 			hasYield: $dimResult->hasYield() || $varResult->hasYield(),
 			isAlwaysTerminating: $dimResult->isAlwaysTerminating() || $varResult->isAlwaysTerminating(),
 			throwPoints: $throwPoints,
 			impurePoints: $impurePoints,
-			truthyScopeCallback: static fn (): MutatingScope => $scope->filterByTruthyValue($expr),
-			falseyScopeCallback: static fn (): MutatingScope => $scope->filterByFalseyValue($expr),
+			expr: $expr,
+			typeCallback: $typeCallback,
+			specifyTypesCallback: fn (Expr $e, MutatingScope $s, TypeSpecifierContext $ctx): SpecifiedTypes => $this->defaultNarrowingHelper->specifyDefaultTypes($e, $ctx),
 		);
 	}
 

src/Analyser/ExprHandler/ArrayHandler.php

@@ -12,7 +12,9 @@
 use PHPStan\Analyser\ExpressionResult;
 use PHPStan\Analyser\ExpressionResultStorage;
 use PHPStan\Analyser\ExprHandler;
+use PHPStan\Analyser\ExprHandler\Helper\DefaultNarrowingHelper;
 use PHPStan\Analyser\MutatingScope;
+use PHPStan\Analyser\NewWorld;
 use PHPStan\Analyser\NodeScopeResolver;
 use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\SpecifiedTypes;
@@ -22,11 +24,14 @@
 use PHPStan\Node\LiteralArrayItem;
 use PHPStan\Node\LiteralArrayNode;
 use PHPStan\Reflection\InitializerExprTypeResolver;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\CallableType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use function array_key_exists;
 use function array_merge;
 use function count;
+use function spl_object_id;
 
 /**
  * @implements ExprHandler<Array_>
@@ -37,6 +42,7 @@ final class ArrayHandler implements ExprHandler
 
 	public function __construct(
 		private InitializerExprTypeResolver $initializerExprTypeResolver,
+		private DefaultNarrowingHelper $defaultNarrowingHelper,
 	)
 	{
 	}
@@ -73,15 +79,19 @@ public function resolveType(MutatingScope $scope, Expr $expr): Type
 	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult
 	{
 		$itemNodes = [];
+		$itemResults = [];
 		$hasYield = false;
 		$throwPoints = [];
 		$impurePoints = [];
 		$isAlwaysTerminating = false;
 		foreach ($expr->items as $arrayItem) {
-			$itemNodes[] = new LiteralArrayItem($scope, $arrayItem);
+			// the embedded item scope answers the rules' getType() asks — in the
+			// new world those must go through the fiber so stored results answer
+			$itemNodes[] = new LiteralArrayItem(NewWorld::isEnabled() ? $scope->toFiberScope() : $scope, $arrayItem);
 			$nodeScopeResolver->callNodeCallback($nodeCallback, $arrayItem, $scope, $storage);
 			if ($arrayItem->key !== null) {
 				$keyResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->key, $scope, $storage, $nodeCallback, $context->enterDeep());
+				$itemResults[spl_object_id($arrayItem->key)] = $keyResult;
 				$hasYield = $hasYield || $keyResult->hasYield();
 				$throwPoints = array_merge($throwPoints, $keyResult->getThrowPoints());
 				$impurePoints = array_merge($impurePoints, $keyResult->getImpurePoints());
@@ -90,6 +100,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 			}
 
 			$valueResult = $nodeScopeResolver->processExprNode($stmt, $arrayItem->value, $scope, $storage, $nodeCallback, $context->enterDeep());
+			$itemResults[spl_object_id($arrayItem->value)] = $valueResult;
 			$hasYield = $hasYield || $valueResult->hasYield();
 			$throwPoints = array_merge($throwPoints, $valueResult->getThrowPoints());
 			$impurePoints = array_merge($impurePoints, $valueResult->getImpurePoints());
@@ -98,12 +109,55 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 		}
 		$nodeScopeResolver->callNodeCallback($nodeCallback, new LiteralArrayNode($expr, $itemNodes), $scope, $storage);
 
+		// each item type was captured at its own evaluation point in the sequence —
+		// resolving them on any single scope (the old world) cannot handle items
+		// with side effects like `[$b = 1, $b + 1, $b++]`
+		$typeCallback = function (Expr $e, MutatingScope $s) use ($itemResults): Type {
+			if (!$e instanceof Array_) {
+				throw new ShouldNotHappenException();
+			}
+
+			$type = $this->initializerExprTypeResolver->getArrayType($e, static function (Expr $inner) use ($itemResults, $s): Type {
+				$id = spl_object_id($inner);
+				if (array_key_exists($id, $itemResults)) {
+					return $itemResults[$id]->getTypeForScope($s);
+				}
+
+				// getArrayType only asks about item keys and values — guarded
+				// legacy bridge just in case (PHPSTAN_FNSR=0)
+				return $s->getType($inner);
+			});
+
+			if (
+				count($e->items) === 2
+				&& isset($e->items[0], $e->items[1])
+				&& $type->isCallable()->maybe()
+			) {
+				$isCallableCall = new FuncCall(
+					new FullyQualified('is_callable'),
+					[new Arg($e)],
+				);
+				$isCallableCallString = $s->getNodeKey($isCallableCall);
+				if (
+					array_key_exists($isCallableCallString, $s->expressionTypes)
+					&& $s->expressionTypes[$isCallableCallString]->getType()->isTrue()->yes()
+				) {
+					$type = TypeCombinator::intersect($type, new CallableType());
+				}
+			}
+
+			return $type;
+		};
+
 		return new ExpressionResult(
 			$scope,
 			hasYield: $hasYield,
 			isAlwaysTerminating: $isAlwaysTerminating,
 			throwPoints: $throwPoints,
 			impurePoints: $impurePoints,
+			expr: $expr,
+			typeCallback: $typeCallback,
+			specifyTypesCallback: fn (Expr $e, MutatingScope $s, TypeSpecifierContext $ctx): SpecifiedTypes => $this->defaultNarrowingHelper->specifyDefaultTypes($e, $ctx),
 		);
 	}