Single-pass expression analysis groundwork - answer type questions from ExpressionResults

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

@@ -19,6 +19,8 @@
 final class DirectInternalScopeFactory implements InternalScopeFactory
 {
 
+	private ExpressionResultStorageStack $expressionResultStorageStack;
+
 	/**
 	 * @param int|array{min: int, max: int}|null $configPhpVersion
 	 * @param callable(Node $node, Scope $scope): void|null $nodeCallback
@@ -38,8 +40,10 @@ public function __construct(
 		private $nodeCallback,
 		private ConstantResolver $constantResolver,
 		private bool $fiber = false,
+		?ExpressionResultStorageStack $expressionResultStorageStack = null,
 	)
 	{
+		$this->expressionResultStorageStack = $expressionResultStorageStack ?? new ExpressionResultStorageStack();
 	}
 
 	public function create(
@@ -77,6 +81,7 @@ public function create(
 			$this->propertyReflectionFinder,
 			$this->parser,
 			$this->constantResolver,
+			$this->expressionResultStorageStack,
 			$context,
 			$this->phpVersion,
 			$this->attributeReflectionFactory,
@@ -102,25 +107,15 @@ public function create(
 
 	public function toFiberFactory(): 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,
-			true,
-		);
+		return $this->withFlavor(true);
 	}
 
 	public function toMutatingFactory(): InternalScopeFactory
+	{
+		return $this->withFlavor(false);
+	}
+
+	private function withFlavor(bool $fiber): self
 	{
 		return new self(
 			$this->container,
@@ -136,7 +131,8 @@ public function toMutatingFactory(): InternalScopeFactory
 			$this->configPhpVersion,
 			$this->nodeCallback,
 			$this->constantResolver,
-			false,
+			$fiber,
+			$this->expressionResultStorageStack,
 		);
 	}
 

src/Analyser/ExprHandler.php

@@ -5,7 +5,6 @@
 use PhpParser\Node;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Stmt;
-use PHPStan\Type\Type;
 
 /**
  * @template T of Expr
@@ -32,19 +31,4 @@ public function processExpr(
 		ExpressionContext $context,
 	): ExpressionResult;
 
-	/**
-	 * @param T $expr
-	 */
-	public function resolveType(MutatingScope $scope, Expr $expr): Type;
-
-	/**
-	 * @param T $expr
-	 */
-	public function specifyTypes(
-		TypeSpecifier $typeSpecifier,
-		Scope $scope,
-		Expr $expr,
-		TypeSpecifierContext $context,
-	): SpecifiedTypes;
-
 }

src/Analyser/ExprHandler/ArrayDimFetchHandler.php

@@ -11,14 +11,15 @@
 use PhpParser\Node\Stmt;
 use PHPStan\Analyser\ExpressionContext;
 use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultFactory;
 use PHPStan\Analyser\ExpressionResultStorage;
-use PHPStan\Analyser\ExprHandler;
 use PHPStan\Analyser\ExprHandler\Helper\NullsafeShortCircuitingHelper;
 use PHPStan\Analyser\MutatingScope;
 use PHPStan\Analyser\NodeScopeResolver;
 use PHPStan\Analyser\NoopNodeCallback;
 use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeResolvingExprHandler;
 use PHPStan\Analyser\TypeSpecifier;
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\DependencyInjection\AutowiredService;
@@ -29,12 +30,16 @@
 use function array_merge;
 
 /**
- * @implements ExprHandler<ArrayDimFetch>
+ * @implements TypeResolvingExprHandler<ArrayDimFetch>
  */
 #[AutowiredService]
-final class ArrayDimFetchHandler implements ExprHandler
+final class ArrayDimFetchHandler implements TypeResolvingExprHandler
 {
 
+	public function __construct(private ExpressionResultFactory $expressionResultFactory)
+	{
+	}
+
 	public function supports(Expr $expr): bool
 	{
 		return $expr instanceof ArrayDimFetch;
@@ -76,18 +81,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
 	{
+		$beforeScope = $scope;
 		if ($expr->dim === null) {
 			$varResult = $nodeScopeResolver->processExprNode($stmt, $expr->var, $scope, $storage, $nodeCallback, $context->enterDeep());
 			$scope = $varResult->getScope();
 
-			return new ExpressionResult(
+			return $this->expressionResultFactory->create(
 				$scope,
+				beforeScope: $beforeScope,
+				expr: $expr,
 				hasYield: $varResult->hasYield(),
 				isAlwaysTerminating: $varResult->isAlwaysTerminating(),
 				throwPoints: $varResult->getThrowPoints(),
 				impurePoints: $varResult->getImpurePoints(),
-				truthyScopeCallback: static fn (): MutatingScope => $scope->filterByTruthyValue($expr),
-				falseyScopeCallback: static fn (): MutatingScope => $scope->filterByFalseyValue($expr),
 			);
 		}
 
@@ -109,14 +115,14 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 			)->getThrowPoints());
 		}
 
-		return new ExpressionResult(
+		return $this->expressionResultFactory->create(
 			$scope,
+			beforeScope: $beforeScope,
+			expr: $expr,
 			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),
 		);
 	}
 

src/Analyser/ExprHandler/ArrayHandler.php

@@ -10,23 +10,22 @@
 use PhpParser\Node\Stmt;
 use PHPStan\Analyser\ExpressionContext;
 use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultFactory;
 use PHPStan\Analyser\ExpressionResultStorage;
 use PHPStan\Analyser\ExprHandler;
 use PHPStan\Analyser\MutatingScope;
 use PHPStan\Analyser\NodeScopeResolver;
-use PHPStan\Analyser\Scope;
-use PHPStan\Analyser\SpecifiedTypes;
-use PHPStan\Analyser\TypeSpecifier;
-use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\DependencyInjection\AutowiredService;
 use PHPStan\Node\LiteralArrayItem;
 use PHPStan\Node\LiteralArrayNode;
 use PHPStan\Reflection\InitializerExprTypeResolver;
 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 +36,7 @@ final class ArrayHandler implements ExprHandler
 
 	public function __construct(
 		private InitializerExprTypeResolver $initializerExprTypeResolver,
+		private ExpressionResultFactory $expressionResultFactory,
 	)
 	{
 	}
@@ -46,33 +46,11 @@ public function supports(Expr $expr): bool
 		return $expr instanceof Array_;
 	}
 
-	public function resolveType(MutatingScope $scope, Expr $expr): Type
-	{
-		$type = $this->initializerExprTypeResolver->getArrayType($expr, static fn (Expr $expr): Type => $scope->getType($expr));
-
-		if (
-			count($expr->items) === 2
-			&& isset($expr->items[0], $expr->items[1])
-			&& $type->isCallable()->maybe()
-		) {
-			$isCallableCall = new FuncCall(
-				new FullyQualified('is_callable'),
-				[new Arg($expr)],
-			);
-			if (
-				$scope->hasExpressionType($isCallableCall)->yes()
-				&& $scope->getType($isCallableCall)->isTrue()->yes()
-			) {
-				$type = TypeCombinator::intersect($type, new CallableType());
-			}
-		}
-
-		return $type;
-	}
-
 	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult
 	{
+		$beforeScope = $scope;
 		$itemNodes = [];
+		$itemResults = [];
 		$hasYield = false;
 		$throwPoints = [];
 		$impurePoints = [];
@@ -82,6 +60,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 			$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 +69,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,18 +78,51 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 		}
 		$nodeScopeResolver->callNodeCallback($nodeCallback, new LiteralArrayNode($expr, $itemNodes), $scope, $storage);
 
-		return new ExpressionResult(
+		return $this->expressionResultFactory->create(
 			$scope,
+			beforeScope: $beforeScope,
+			expr: $expr,
 			hasYield: $hasYield,
 			isAlwaysTerminating: $isAlwaysTerminating,
 			throwPoints: $throwPoints,
 			impurePoints: $impurePoints,
-		);
-	}
+			typeCallback: function (MutatingScope $s) use ($expr, $itemResults): Type {
+				// each item type was captured at its own evaluation point in the
+				// sequence - resolving all items on any single scope (the old world)
+				// cannot handle items with side effects like [$b = 1, $b + 1, $b++]
+				$type = $this->initializerExprTypeResolver->getArrayType($expr, static function (Expr $inner) use ($itemResults, $s): Type {
+					$id = spl_object_id($inner);
+					if (array_key_exists($id, $itemResults)) {
+						return $s->nativeTypesPromoted
+							? $itemResults[$id]->getNativeType()
+							: $itemResults[$id]->getType();
+					}
 
-	public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $expr, TypeSpecifierContext $context): SpecifiedTypes
-	{
-		return $typeSpecifier->specifyDefaultTypes($scope, $expr, $context);
+					// getArrayType only asks about item keys and values - guarded
+					// legacy bridge just in case
+					return $s->getType($inner);
+				});
+
+				if (
+					count($expr->items) === 2
+					&& isset($expr->items[0], $expr->items[1])
+					&& $type->isCallable()->maybe()
+				) {
+					$isCallableCall = new FuncCall(
+						new FullyQualified('is_callable'),
+						[new Arg($expr)],
+					);
+					if (
+						$s->hasExpressionType($isCallableCall)->yes()
+						&& $s->getType($isCallableCall)->isTrue()->yes()
+					) {
+						$type = TypeCombinator::intersect($type, new CallableType());
+					}
+				}
+
+				return $type;
+			},
+		);
 	}
 
 }

src/Analyser/ExprHandler/ArrowFunctionHandler.php

@@ -7,27 +7,29 @@
 use PhpParser\Node\Stmt;
 use PHPStan\Analyser\ExpressionContext;
 use PHPStan\Analyser\ExpressionResult;
+use PHPStan\Analyser\ExpressionResultFactory;
 use PHPStan\Analyser\ExpressionResultStorage;
-use PHPStan\Analyser\ExprHandler;
 use PHPStan\Analyser\ExprHandler\Helper\ClosureTypeResolver;
 use PHPStan\Analyser\MutatingScope;
 use PHPStan\Analyser\NodeScopeResolver;
 use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\SpecifiedTypes;
+use PHPStan\Analyser\TypeResolvingExprHandler;
 use PHPStan\Analyser\TypeSpecifier;
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\DependencyInjection\AutowiredService;
 use PHPStan\Type\Type;
 
 /**
- * @implements ExprHandler<ArrowFunction>
+ * @implements TypeResolvingExprHandler<ArrowFunction>
  */
 #[AutowiredService]
-final class ArrowFunctionHandler implements ExprHandler
+final class ArrowFunctionHandler implements TypeResolvingExprHandler
 {
 
 	public function __construct(
 		private ClosureTypeResolver $closureTypeResolver,
+		private ExpressionResultFactory $expressionResultFactory,
 	)
 	{
 	}
@@ -41,8 +43,10 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 	{
 		$result = $nodeScopeResolver->processArrowFunctionNode($stmt, $expr, $scope, $storage, $nodeCallback, null);
 
-		return new ExpressionResult(
+		return $this->expressionResultFactory->create(
 			$result->getScope(),
+			beforeScope: $scope,
+			expr: $expr,
 			hasYield: $result->hasYield(),
 			isAlwaysTerminating: false,
 			throwPoints: [],