Propagate array dim fetch narrowings to parent variable in BooleanAnd falsey and BooleanOr truthy intersectWith

- Add `propagateArrayDimFetchNarrowingsToParent()` to `TypeSpecifier` that
  enriches normalized `SpecifiedTypes` by computing a parent array variable's
  narrowed type from its child `ArrayDimFetch` sureType using
  `HasOffsetValueType`, mirroring what `MutatingScope::specifyExpressionType`
  already does when applying narrowings
- Call the new method in the `BooleanAnd` falsey branch and the `BooleanOr`
  truthy branch before `intersectWith`, so that both sides have a sureType
  for the parent variable and the intersection correctly produces the union
- Skip propagation for nested `ArrayDimFetch` parents to avoid
  over-narrowing in cases where the intermediate offset may not exist
- The fix handles all type-check functions (`is_string`, `is_int`,
  `is_array`, etc.) and `instanceof` uniformly since they all go through
  the same conditional return type / type specifier machinery

Author: VincentLanglet

src/Analyser/TypeSpecifier.php

@@ -734,7 +734,15 @@ public function specifyTypesInCondition(
 			$leftTypes = $this->specifyTypesInCondition($scope, $expr->left, $context)->setRootExpr($expr);
 			$rightScope = $scope->filterByTruthyValue($expr->left);
 			$rightTypes = $this->specifyTypesInCondition($rightScope, $expr->right, $context)->setRootExpr($expr);
-			$types = $context->true() ? $leftTypes->unionWith($rightTypes) : $leftTypes->normalize($scope)->intersectWith($rightTypes->normalize($rightScope));
+			if ($context->true()) {
+				$types = $leftTypes->unionWith($rightTypes);
+			} else {
+				$normalizedLeft = $leftTypes->normalize($scope);
+				$normalizedRight = $rightTypes->normalize($rightScope);
+				$normalizedLeft = $this->propagateArrayDimFetchNarrowingsToParent($normalizedLeft, $scope);
+				$normalizedRight = $this->propagateArrayDimFetchNarrowingsToParent($normalizedRight, $rightScope);
+				$types = $normalizedLeft->intersectWith($normalizedRight);
+			}
 			if ($context->false()) {
 				$leftTypesForHolders = $leftTypes;
 				$rightTypesForHolders = $rightTypes;
@@ -788,7 +796,11 @@ public function specifyTypesInCondition(
 				) {
 					$types = $leftTypes->normalize($scope);
 				} else {
-					$types = $leftTypes->normalize($scope)->intersectWith($rightTypes->normalize($rightScope));
+					$normalizedLeft = $leftTypes->normalize($scope);
+					$normalizedRight = $rightTypes->normalize($rightScope);
+					$normalizedLeft = $this->propagateArrayDimFetchNarrowingsToParent($normalizedLeft, $scope);
+					$normalizedRight = $this->propagateArrayDimFetchNarrowingsToParent($normalizedRight, $rightScope);
+					$types = $normalizedLeft->intersectWith($normalizedRight);
 					$types = $this->augmentBooleanOrTruthyWithConditionalHolders($scope, $rightScope, $expr, $types);
 				}
 			} else {
@@ -2076,6 +2088,54 @@ private function augmentBooleanOrTruthyWithConditionalHolders(MutatingScope $sco
 		return $types;
 	}
 
+	private function propagateArrayDimFetchNarrowingsToParent(SpecifiedTypes $normalizedTypes, Scope $scope): SpecifiedTypes
+	{
+		$additionalSureTypes = [];
+		foreach ($normalizedTypes->getSureTypes() as $exprString => [$exprNode, $type]) {
+			if (
+				!$exprNode instanceof ArrayDimFetch
+				|| $exprNode->dim === null
+				|| $exprNode->var instanceof ArrayDimFetch
+			) {
+				continue;
+			}
+
+			$dimType = $scope->getType($exprNode->dim)->toArrayKey();
+			if (!$dimType instanceof ConstantIntegerType && !$dimType instanceof ConstantStringType) { // @phpstan-ignore phpstanApi.instanceofType
+				continue;
+			}
+
+			$parentExprString = $this->exprPrinter->printExpr($exprNode->var);
+			if (isset($normalizedTypes->getSureTypes()[$parentExprString]) || isset($additionalSureTypes[$parentExprString])) {
+				continue;
+			}
+
+			$parentType = $scope->getType($exprNode->var);
+			if ($parentType instanceof MixedType || !$parentType->isArray()->yes()) {
+				continue;
+			}
+
+			$narrowedParentType = TypeCombinator::intersect(
+				$parentType,
+				new HasOffsetValueType($dimType, $type),
+			);
+			if ($narrowedParentType instanceof NeverType) {
+				continue;
+			}
+
+			$additionalSureTypes[$parentExprString] = [$exprNode->var, $narrowedParentType];
+		}
+
+		if ($additionalSureTypes === []) {
+			return $normalizedTypes;
+		}
+
+		return new SpecifiedTypes(
+			$normalizedTypes->getSureTypes() + $additionalSureTypes,
+			[],
+		);
+	}
+
 	/**
 	 * @return array<string, ConditionalExpressionHolder[]>
 	 */

tests/PHPStan/Analyser/nsrt/bug-14566.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace Bug14566;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @param array{}|array{hi: 'hello'}|array{hi: array{0: 42, 1?: 42}} $test
+ */
+function foo(array $test): void {
+	if (isset($test['hi']) && is_string($test['hi'])) {
+		return;
+	}
+	assertType("array{}|array{hi: array{0: 42, 1?: 42}}", $test);
+	assertType("array{0: 42, 1?: 42}", $test['hi']);
+}
+
+/**
+ * @param array{}|array{hi: 'hello'}|array{hi: array{0: 42, 1?: 42}} $test
+ */
+function fooOr(array $test): void {
+	if (!isset($test['hi']) || !is_string($test['hi'])) {
+		assertType("array{}|array{hi: array{0: 42, 1?: 42}}", $test);
+		return;
+	}
+	assertType("array{hi: 'hello'}", $test);
+}
+
+/**
+ * @param array{}|array{hi: 42}|array{hi: 'hello'} $test
+ */
+function fooIsInt(array $test): void {
+	if (isset($test['hi']) && is_int($test['hi'])) {
+		return;
+	}
+	assertType("array{}|array{hi: 'hello'}", $test);
+}
+
+/**
+ * @param array{}|array{hi: 'hello'}|array{hi: array{0: 42}} $test
+ */
+function fooIsArray(array $test): void {
+	if (isset($test['hi']) && is_array($test['hi'])) {
+		return;
+	}
+	assertType("array{}|array{hi: 'hello'}", $test);
+}
+
+/**
+ * @param array{}|array{hi: \stdClass}|array{hi: 'hello'} $test
+ */
+function fooInstanceof(array $test): void {
+	if (isset($test['hi']) && $test['hi'] instanceof \stdClass) {
+		return;
+	}
+	assertType("array{}|array{hi: 'hello'}", $test);
+}