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

phpstan-baseline.neon

@@ -36,12 +36,6 @@ parameters:
 			count: 2
 			path: src/Analyser/ExprHandler/BinaryOpHandler.php
 
-		-
-			rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantBooleanType is error-prone and deprecated. Use Type::isTrue() or Type::isFalse() instead.'
-			identifier: phpstanApi.instanceofType
-			count: 1
-			path: src/Analyser/ExprHandler/BooleanNotHandler.php
-
 		-
 			rawMessage: 'Doing instanceof PHPStan\Type\ConstantScalarType is error-prone and deprecated. Use Type::isConstantScalarValue() or Type::getConstantScalarTypes() or Type::getConstantScalarValues() instead.'
 			identifier: phpstanApi.instanceofType
@@ -69,7 +63,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/ArgsResult.php

@@ -0,0 +1,76 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PhpParser\Node\Expr;
+use PHPStan\Reflection\ParametersAcceptor;
+use function spl_object_id;
+
+/**
+ * Result of NodeScopeResolver::processArgs(): the scope/throw/impure state after
+ * processing all arguments (wrapped ExpressionResult) plus the ParametersAcceptor
+ * resolved from the arg types gathered on the arg-to-arg evolving scope. The
+ * resolved acceptor is type-driven (selectFromTypes) so its generics are resolved
+ * against the actual argument types - callers wire it into the call expression's
+ * stored return type. Null when the call had no variants (dynamic callee).
+ */
+final class ArgsResult
+{
+
+	/**
+	 * @param array<int, ExpressionResult> $argResults keyed by spl_object_id of each argument's value expression
+	 */
+	public function __construct(
+		private ExpressionResult $expressionResult,
+		private ?ParametersAcceptor $resolvedParametersAcceptor,
+		private array $argResults = [],
+	)
+	{
+	}
+
+	/**
+	 * The already-processed ExpressionResult of a call argument's value expression,
+	 * so callers read its type via the result instead of re-asking the scope.
+	 */
+	public function getArgResult(Expr $argValue): ?ExpressionResult
+	{
+		return $this->argResults[spl_object_id($argValue)] ?? null;
+	}
+
+	public function getScope(): MutatingScope
+	{
+		return $this->expressionResult->getScope();
+	}
+
+	public function hasYield(): bool
+	{
+		return $this->expressionResult->hasYield();
+	}
+
+	public function isAlwaysTerminating(): bool
+	{
+		return $this->expressionResult->isAlwaysTerminating();
+	}
+
+	/**
+	 * @return InternalThrowPoint[]
+	 */
+	public function getThrowPoints(): array
+	{
+		return $this->expressionResult->getThrowPoints();
+	}
+
+	/**
+	 * @return ImpurePoint[]
+	 */
+	public function getImpurePoints(): array
+	{
+		return $this->expressionResult->getImpurePoints();
+	}
+
+	public function getResolvedParametersAcceptor(): ?ParametersAcceptor
+	{
+		return $this->resolvedParametersAcceptor;
+	}
+
+}

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,21 +11,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\ExprHandler\Helper\NullsafeShortCircuitingHelper;
+use PHPStan\Analyser\ExprHandler\Helper\DefaultNarrowingHelper;
+use PHPStan\Analyser\IssetabilityDescriptor;
 use PHPStan\Analyser\MutatingScope;
 use PHPStan\Analyser\NodeScopeResolver;
 use PHPStan\Analyser\NoopNodeCallback;
-use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\SpecifiedTypes;
-use PHPStan\Analyser\TypeSpecifier;
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\DependencyInjection\AutowiredService;
 use PHPStan\Node\Expr\TypeExpr;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use function array_merge;
 
 /**
@@ -35,59 +36,37 @@
 final class ArrayDimFetchHandler implements ExprHandler
 {
 
-	public function supports(Expr $expr): bool
+	public function __construct(
+		private ExpressionResultFactory $expressionResultFactory,
+		private DefaultNarrowingHelper $defaultNarrowingHelper,
+	)
 	{
-		return $expr instanceof ArrayDimFetch;
 	}
 
-	public function resolveType(MutatingScope $scope, Expr $expr): Type
+	public function supports(Expr $expr): bool
 	{
-		if ($expr->dim === null) {
-			return new NeverType();
-		}
-
-		$offsetAccessibleType = $scope->getType($expr->var);
-		if (
-			!$offsetAccessibleType->isArray()->yes()
-			&& (new ObjectType(ArrayAccess::class))->isSuperTypeOf($offsetAccessibleType)->yes()
-		) {
-			return NullsafeShortCircuitingHelper::getType(
-				$scope,
-				$expr->var,
-				$scope->getType(
-					new MethodCall(
-						$expr->var,
-						new Identifier('offsetGet'),
-						[
-							new Arg($expr->dim),
-						],
-					),
-				),
-			);
-		}
-
-		$offsetType = $scope->getType($expr->dim);
-		return NullsafeShortCircuitingHelper::getType(
-			$scope,
-			$expr->var,
-			$offsetAccessibleType->getOffsetValueType($offsetType),
-		);
+		return $expr instanceof ArrayDimFetch;
 	}
 
 	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),
+				containsNullsafe: $varResult->containsNullsafe(),
+				// `$arr[]` only appears as an assignment target; reading it is a NeverType
+				typeCallback: static fn (): Type => new NeverType(),
+				specifyTypesCallback: fn (MutatingScope $s, TypeSpecifierContext $context): SpecifiedTypes => $this->defaultNarrowingHelper->specifyDefaultTypes($expr, $context),
 			);
 		}
 
@@ -97,7 +76,8 @@ 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->getTypeForScope($scope);
+		$offsetGetResult = null;
 		if (!$varType->isArray()->yes() && !(new ObjectType(ArrayAccess::class))->isSuperTypeOf($varType)->no()) {
 			$throwPoints = array_merge($throwPoints, $nodeScopeResolver->processExprNode(
 				$stmt,
@@ -107,22 +87,45 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 				new NoopNodeCallback(),
 				$context,
 			)->getThrowPoints());
+			// process the offsetGet here (storage is available, so the result is
+			// captured - not the storage - avoiding a reference cycle) so the
+			// typeCallback reads its result instead of Scope::getType(). Gated by
+			// the same maybe-ArrayAccess condition, so plain arrays never reach it.
+			$offsetGetResult = $nodeScopeResolver->processExprOnDemand(
+				new MethodCall($expr->var, new Identifier('offsetGet'), [new Arg($expr->dim)]),
+				$scope,
+				$storage,
+			);
 		}
 
-		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),
-		);
-	}
+			containsNullsafe: $varResult->containsNullsafe(),
+			issetabilityDescriptor: IssetabilityDescriptor::offset($varResult, $dimResult),
+			typeCallback: static function (bool $nativeTypesPromoted) use ($varResult, $dimResult, $offsetGetResult): Type {
+				$offsetAccessibleType = ($nativeTypesPromoted ? $varResult->getNativeType() : $varResult->getType());
+				$shortCircuit = static fn (Type $type): Type => $varResult->containsNullsafe() && TypeCombinator::containsNull($offsetAccessibleType)
+					? TypeCombinator::addNull($type)
+					: $type;
 
-	public function specifyTypes(TypeSpecifier $typeSpecifier, Scope $scope, Expr $expr, TypeSpecifierContext $context): SpecifiedTypes
-	{
-		return $typeSpecifier->specifyDefaultTypes($scope, $expr, $context);
+				if (
+					$offsetGetResult !== null
+					&& !$offsetAccessibleType->isArray()->yes()
+					&& (new ObjectType(ArrayAccess::class))->isSuperTypeOf($offsetAccessibleType)->yes()
+				) {
+					return $shortCircuit(($nativeTypesPromoted ? $offsetGetResult->getNativeType() : $offsetGetResult->getType()));
+				}
+
+				return $shortCircuit($offsetAccessibleType->getOffsetValueType(($nativeTypesPromoted ? $dimResult->getNativeType() : $dimResult->getType())));
+			},
+			specifyTypesCallback: fn (MutatingScope $s, TypeSpecifierContext $context): SpecifiedTypes => $this->defaultNarrowingHelper->specifyDefaultTypes($expr, $context),
+		);
 	}
 
 }