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,29 +42,11 @@ 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.'
@@ -69,7 +57,7 @@ parameters:
 		-
 			rawMessage: Casting to string something that's already string.
 			identifier: cast.useless
-			count: 3
+			count: 4
 			path: src/Analyser/MutatingScope.php
 
 		-
@@ -114,12 +102,6 @@ parameters:
 			count: 1
 			path: src/Analyser/RuleErrorTransformer.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

@@ -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/ConditionalExpressionHolderRecipe.php

@@ -0,0 +1,118 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PhpParser\Node\Expr;
+use PHPStan\Type\NeverType;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use function array_key_exists;
+
+/**
+ * A deferred description of the boolean-decomposition conditional holders
+ * (`&&` asserted false, `||` asserted true): the raw narrowing entries of the
+ * condition side and the holder side, captured where the boolean narrowing was
+ * 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::applySpecifiedTypes()), never the scope the composition ran
+ * on.
+ */
+final class ConditionalExpressionHolderRecipe
+{
+
+	/**
+	 * @param list<array{string, Expr, bool, Type}> $conditionEntries [exprString, expr, fromSureTypes, type]
+	 * @param list<array{string, Expr, Type, ?Type}> $holderEntries [exprString, expr, type, target type pinned at compose time (null = read the applying scope)]
+	 */
+	public function __construct(
+		private array $conditionEntries,
+		private array $holderEntries,
+		private bool $holdersFromSureTypes,
+	)
+	{
+	}
+
+	/**
+	 * @return array<string, ConditionalExpressionHolder[]>
+	 */
+	public function evaluate(MutatingScope $scope): array
+	{
+		$conditionExpressionTypes = [];
+		$droppedNoOpConditions = [];
+		// the unnarrowed type of each condition expression, for the
+		// dropped-self-condition complement below
+		$conditionOriginalTypes = [];
+		foreach ($this->conditionEntries as [$exprString, $expr, $fromSureTypes, $type]) {
+			$scopeType = $scope->getStateType($expr);
+			$conditionType = $fromSureTypes
+				? TypeCombinator::remove($scopeType, $type)
+				: TypeCombinator::intersect($scopeType, $type);
+			if ($scopeType->equals($conditionType)) {
+				$droppedNoOpConditions[$exprString] = true;
+				continue;
+			}
+
+			$conditionExpressionTypes[$exprString] = ExpressionTypeHolder::createYes($expr, $conditionType);
+			$conditionOriginalTypes[$exprString] = $scopeType;
+		}
+
+		if ($conditionExpressionTypes === []) {
+			return [];
+		}
+
+		$holders = [];
+		foreach ($this->holderEntries as [$exprString, $expr, $type, $pinnedTargetType]) {
+			// The target's only link to the antecedent was a no-op relation (e.g.
+			// `$a === $b`) that got dropped, so the antecedent no longer constrains
+			// it. Projecting a consequent onto it would fire unsoundly. Skip it.
+			if (array_key_exists($exprString, $droppedNoOpConditions)) {
+				continue;
+			}
+
+			$conditions = $conditionExpressionTypes;
+			$droppedSelfCondition = null;
+			if (isset($conditions[$exprString])) {
+				$droppedSelfCondition = $conditions[$exprString];
+				unset($conditions[$exprString]);
+			}
+
+			if ($conditions === []) {
+				continue;
+			}
+
+			$targetType = $pinnedTargetType ?? $scope->getStateType($expr);
+			$holderType = $this->holdersFromSureTypes
+				? TypeCombinator::intersect($targetType, $type)
+				: TypeCombinator::remove($targetType, $type);
+
+			// The dropped self-condition narrowed the target; without it the
+			// holder must allow the values it excluded, or it over-narrows when
+			// only the remaining conditions hold. So union back the complement.
+			if ($droppedSelfCondition !== null) {
+				$complement = TypeCombinator::remove($conditionOriginalTypes[$exprString], $droppedSelfCondition->getType());
+				if (!$complement instanceof NeverType) {
+					$holderType = TypeCombinator::union($holderType, $complement);
+				}
+			}
+
+			// These boolean-decomposition holders only refine an expression's
+			// type in a future scope; they must never collapse it to never and
+			// thereby mark the whole scope unreachable. A never result is an
+			// artifact (e.g. removing a non-nullable property's full type after
+			// swapping isset() narrowing), not a real contradiction.
+			if ($holderType instanceof NeverType && !$targetType instanceof NeverType) {
+				continue;
+			}
+			$holder = new ConditionalExpressionHolder(
+				$conditions,
+				ExpressionTypeHolder::createYes($expr, $holderType),
+			);
+			$holders[$exprString] ??= [];
+			$holders[$exprString][$holder->getKey()] = $holder;
+		}
+
+		return $holders;
+	}
+
+}

src/Analyser/DeferredSpecifiedTypesAugment.php

@@ -0,0 +1,17 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+/**
+ * A state-dependent augmentation of a SpecifiedTypes, deferred to the
+ * application point: MutatingScope::applySpecifiedTypes() evaluates it against
+ * the applying scope and unions the produced entries into the applied batch.
+ * The composition captures only position-fixed facts (operand-walk reads);
+ * everything that must reflect the current state runs in evaluate().
+ */
+interface DeferredSpecifiedTypesAugment
+{
+
+	public function evaluate(MutatingScope $scope): ?SpecifiedTypes;
+
+}

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,
 		);
 	}