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

phpstan-baseline.neon

@@ -24,6 +24,12 @@ parameters:
 			count: 3
 			path: src/Analyser/ExprHandler/AssignHandler.php
 
+		-
+			rawMessage: Casting to string something that's already string.
+			identifier: cast.useless
+			count: 3
+			path: src/Analyser/ExprHandler/Helper/ConditionalExpressionHolderHelper.php
+
 		-
 			rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantStringType is error-prone and deprecated. Use Type::getConstantStrings() instead.'
 			identifier: phpstanApi.instanceofType
@@ -36,40 +42,22 @@ 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
-			count: 2
-			path: src/Analyser/ExprHandler/Helper/EqualityTypeSpecifyingHelper.php
-
-		-
-			rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantBooleanType is error-prone and deprecated. Use Type::isTrue() or Type::isFalse() instead.'
-			identifier: phpstanApi.instanceofType
-			count: 3
-			path: src/Analyser/ExprHandler/Helper/EqualityTypeSpecifyingHelper.php
-
 		-
 			rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantStringType is error-prone and deprecated. Use Type::getConstantStrings() instead.'
 			identifier: phpstanApi.instanceofType
 			count: 2
-			path: src/Analyser/ExprHandler/IssetHandler.php
+			path: src/Analyser/ExprHandler/Helper/DefaultNarrowingHelper.php
 
 		-
 			rawMessage: 'Only numeric types are allowed in pre-increment, float|int|string|null given.'
 			identifier: preInc.nonNumeric
 			count: 1
-			path: src/Analyser/ExprHandler/PreIncHandler.php
+			path: src/Analyser/ExprHandler/Helper/IncDecTypeHelper.php
 
 		-
 			rawMessage: Casting to string something that's already string.
 			identifier: cast.useless
-			count: 2
+			count: 4
 			path: src/Analyser/MutatingScope.php
 
 		-
@@ -114,18 +102,6 @@ parameters:
 			count: 1
 			path: src/Analyser/RuleErrorTransformer.php
 
-		-
-			rawMessage: Casting to string something that's already string.
-			identifier: cast.useless
-			count: 2
-			path: src/Analyser/ScopeOps.php
-
-		-
-			rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantBooleanType is error-prone and deprecated. Use Type::isTrue() or Type::isFalse() instead.'
-			identifier: phpstanApi.instanceofType
-			count: 2
-			path: src/Analyser/TypeSpecifier.php
-
 		-
 			rawMessage: 'Template type TNodeType is declared as covariant, but occurs in contravariant position in parameter node of method PHPStan\Collectors\Collector::processNode().'
 			identifier: generics.variance

src/Analyser/ArgsResult.php

@@ -2,26 +2,41 @@
 
 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's return
- * type. Null when the call had no variants (dynamic callee).
+ * 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();

src/Analyser/ConditionalExpressionHolderRecipe.php

@@ -15,7 +15,7 @@
  * composed. The state-dependent math - the condition complements against the
  * current type, the holder target types, the vacuity checks - runs in
  * evaluate() against the scope the narrowing is applied to
- * (MutatingScope::filterBySpecifiedTypes()), never the scope the composition ran
+ * (MutatingScope::applySpecifiedTypes()), never the scope the composition ran
  * on.
  */
 final class ConditionalExpressionHolderRecipe
@@ -44,7 +44,7 @@ public function evaluate(MutatingScope $scope): array
 		// dropped-self-condition complement below
 		$conditionOriginalTypes = [];
 		foreach ($this->conditionEntries as [$exprString, $expr, $fromSureTypes, $type]) {
-			$scopeType = $scope->getType($expr);
+			$scopeType = $scope->getStateType($expr);
 			$conditionType = $fromSureTypes
 				? TypeCombinator::remove($scopeType, $type)
 				: TypeCombinator::intersect($scopeType, $type);
@@ -81,7 +81,7 @@ public function evaluate(MutatingScope $scope): array
 				continue;
 			}
 
-			$targetType = $pinnedTargetType ?? $scope->getType($expr);
+			$targetType = $pinnedTargetType ?? $scope->getStateType($expr);
 			$holderType = $this->holdersFromSureTypes
 				? TypeCombinator::intersect($targetType, $type)
 				: TypeCombinator::remove($targetType, $type);

src/Analyser/DirectInternalScopeFactory.php

@@ -20,6 +20,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
@@ -40,8 +42,10 @@ public function __construct(
 		private $nodeCallback,
 		private ConstantResolver $constantResolver,
 		private bool $fiber = false,
+		?ExpressionResultStorageStack $expressionResultStorageStack = null,
 	)
 	{
+		$this->expressionResultStorageStack = $expressionResultStorageStack ?? new ExpressionResultStorageStack();
 	}
 
 	public function create(
@@ -79,6 +83,7 @@ public function create(
 			$this->propertyReflectionFinder,
 			$this->parser,
 			$this->constantResolver,
+			$this->expressionResultStorageStack,
 			$context,
 			$this->phpVersion,
 			$this->attributeReflectionFactory,
@@ -104,25 +109,15 @@ public function create(
 
 	public function toFiberFactory(): InternalScopeFactory
 	{
-		return new self(
-			$this->container,
-			$this->reflectionProvider,
-			$this->initializerExprTypeResolver,
-			$this->expressionTypeResolverExtensions,
-			$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,
@@ -138,7 +133,8 @@ public function toMutatingFactory(): InternalScopeFactory
 			$this->configPhpVersion,
 			$this->nodeCallback,
 			$this->constantResolver,
-			false,
+			$fiber,
+			$this->expressionResultStorageStack,
 		);
 	}
 

src/Analyser/DisjunctionBranchUnionAugment.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Analyser;
 
 use PhpParser\Node\Expr;
+use PHPStan\Analyser\ExprHandler\Helper\DefaultNarrowingHelper;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\TypeUtils;
@@ -23,7 +24,8 @@ final class DisjunctionBranchUnionAugment implements DeferredSpecifiedTypesAugme
 	 * @param list<array{Expr, Type, Type}> $candidates [target expr, left branch type, right branch type]
 	 */
 	public function __construct(
-		private TypeSpecifier $typeSpecifier,
+		private NodeScopeResolver $nodeScopeResolver,
+		private DefaultNarrowingHelper $defaultNarrowingHelper,
 		private array $candidates,
 	)
 	{
@@ -38,7 +40,7 @@ public function evaluate(MutatingScope $scope): ?SpecifiedTypes
 			}
 
 			// the guard above pins the target as tracked on the applying scope
-			$originalType = $scope->getType($targetExpr);
+			$originalType = $this->nodeScopeResolver->readScopeStateOrSyntheticType($targetExpr, $scope);
 			// re-pinning eagerly priced branch forms of a template-typed subject
 			// stacks the template inside its own bound (`T of T of ...` - the
 			// pin intersects with the declared template); its narrowing already
@@ -62,7 +64,7 @@ public function evaluate(MutatingScope $scope): ?SpecifiedTypes
 				continue;
 			}
 
-			$created = $this->typeSpecifier->create($targetExpr, $unionType, TypeSpecifierContext::createTrue(), $scope);
+			$created = $this->defaultNarrowingHelper->createForSubject($targetExpr, $unionType, TypeSpecifierContext::createTrue(), $scope);
 			$result = $result === null ? $created : $result->unionWith($created);
 		}
 

src/Analyser/DisjunctionHolderProjectionAugment.php

@@ -2,6 +2,7 @@
 
 namespace PHPStan\Analyser;
 
+use PHPStan\Analyser\ExprHandler\Helper\DefaultNarrowingHelper;
 use PHPStan\Type\TypeCombinator;
 use function array_key_first;
 
@@ -29,7 +30,8 @@ final class DisjunctionHolderProjectionAugment implements DeferredSpecifiedTypes
 	 *        be added on top
 	 */
 	public function __construct(
-		private TypeSpecifier $typeSpecifier,
+		private NodeScopeResolver $nodeScopeResolver,
+		private DefaultNarrowingHelper $defaultNarrowingHelper,
 		private $leftTruthyScope,
 		private MutatingScope $leftFalseyScope,
 		private $rightTruthyScope,
@@ -69,19 +71,24 @@ public function evaluate(MutatingScope $scope): ?SpecifiedTypes
 				}
 				$leftTruthyScope ??= ($this->leftTruthyScope)();
 				$rightTruthyScope ??= ($this->rightTruthyScope)();
+				if (!$leftTruthyScope->hasExpressionType($targetExpr)->yes()) {
+					continue;
+				}
+				if (!$rightTruthyScope->hasExpressionType($targetExpr)->yes()) {
+					continue;
+				}
 
-				// the guard above pins the target as tracked on the applying
-				// scope; the branch scopes are its own filtered views, so their
-				// reads answer from state (or price the same tracked state)
-				$origType = $scope->getType($targetExpr);
+				// the guards above pin the target as tracked on all three scopes -
+				// scope state answers without a walk
+				$origType = $this->nodeScopeResolver->readScopeStateOrSyntheticType($targetExpr, $scope);
 
-				$leftType = $leftTruthyScope->getType($targetExpr);
+				$leftType = $this->nodeScopeResolver->readScopeStateOrSyntheticType($targetExpr, $leftTruthyScope);
 				$leftNarrowed = !$leftType->equals($origType) && $origType->isSuperTypeOf($leftType)->yes();
 				if (!$leftNarrowed) {
 					continue;
 				}
 
-				$rightType = $rightTruthyScope->getType($targetExpr);
+				$rightType = $this->nodeScopeResolver->readScopeStateOrSyntheticType($targetExpr, $rightTruthyScope);
 				$rightNarrowed = !$rightType->equals($origType) && $origType->isSuperTypeOf($rightType)->yes();
 				if (!$rightNarrowed) {
 					continue;
@@ -92,7 +99,7 @@ public function evaluate(MutatingScope $scope): ?SpecifiedTypes
 					continue;
 				}
 
-				$created = $this->typeSpecifier->create($targetExpr, $unionType, TypeSpecifierContext::createTrue(), $scope);
+				$created = $this->defaultNarrowingHelper->createSubjectTypes($scope, $targetExpr, null, $unionType, TypeSpecifierContext::createTrue());
 				$result = $result === null ? $created : $result->unionWith($created);
 			}
 		}

src/Analyser/ExprHandler.php

@@ -6,7 +6,6 @@
 use PhpParser\Node\Expr;
 use PhpParser\Node\Stmt;
 use PHPStan\DependencyInjection\ExtensionInterface;
-use PHPStan\Type\Type;
 
 /**
  * @template T of Expr
@@ -34,19 +33,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;
-
 }