test unions

Author: staabm

src/Type/Php/ArrayMergeFunctionDynamicReturnTypeExtension.php

@@ -18,6 +18,7 @@
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
 use PHPStan\Type\IntegerType;
+use PHPStan\Type\MixedType;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
@@ -86,21 +87,23 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			/** @var array<int|string, ConstantIntegerType|ConstantStringType> $keyTypes */
 			$keyTypes = [];
 			foreach ($argType->getConstantArrays() as $constantArray) {
-				foreach ($constantArray->getKeyTypes() as $i => $keyType) {
+				foreach ($constantArray->getKeyTypes() as $keyType) {
 					$keyTypes[$keyType->getValue()] = $keyType;
 
-					if ($constantArray->isOptionalKey($i)) {
-						continue;
-					}
-
-					$offsetValueType = $constantArray->getOffsetValueType($keyType);
-					$offsetTypes[$keyType->getValue()] = [false, $offsetValueType];
+					$hasOffset = TrinaryLogic::createFromBoolean($argType->hasOffsetValueType($keyType)->yes());
+					$offsetTypes[$keyType->getValue()] = [
+						$hasOffset,
+						$argType->getOffsetValueType($keyType),
+					];
 				}
 			}
 
 			if ($keyTypes === []) {
-				foreach ($offsetTypes as $key => [$generalize, $offsetValueType]) {
-					$offsetTypes[$key][0] = true;
+				foreach ($offsetTypes as $key => [$hasOffset, $offsetValueType]) {
+					$offsetTypes[$key] = [
+						$hasOffset->and(TrinaryLogic::createMaybe()),
+						new MixedType(),
+					];
 				}
 			}
 
@@ -113,8 +116,10 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 				}
 
 				$offsetType = $accessoryType->getOffsetType();
-				$offsetValueType = $argType->getOffsetValueType($offsetType);
-				$offsetTypes[$offsetType->getValue()] = [false, $offsetValueType];
+				$offsetTypes[$offsetType->getValue()] = [
+					TrinaryLogic::createYes(),
+					$argType->getOffsetValueType($offsetType),
+				];
 			}
 
 			if ($newArrayBuilder === null) {
@@ -172,24 +177,26 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		}
 		if ($offsetTypes !== []) {
 			$knownOffsetValues = [];
-			foreach ($offsetTypes as $key => [$generalize, $offsetType]) {
+			foreach ($offsetTypes as $key => [$hasOffset, $offsetType]) {
 				if (is_int($key)) {
 					// int keys will be appended and renumbered.
 					// at this point we can't reason about them, because unknown arrays are in the mix.
 					continue;
 				}
 				$keyType = new ConstantStringType($key);
 
-				if (!$generalize) {
+				if ($hasOffset->yes()) {
 					// the last string-keyed offset will overwrite previous values
 					$hasOffsetType = new HasOffsetValueType(
 						$keyType,
 						$offsetType,
 					);
-				} else {
+				} elseif ($hasOffset->maybe()) {
 					$hasOffsetType = new HasOffsetType(
 						$keyType,
 					);
+				} else {
+					continue;
 				}
 
 				$knownOffsetValues[] = $hasOffsetType;

tests/PHPStan/Analyser/nsrt/array-merge-const-non-const.php

@@ -62,6 +62,29 @@ function hasOffsetValueKeys(array $hasB, array $mixedArray, array $hasC): void {
 
 	assertType("non-empty-array&hasOffset('c')&hasOffsetValue('b', 123)", array_merge($hasC, $mixedArray, $hasB));
 	assertType("non-empty-array&hasOffset('b')&hasOffset('c')", array_merge($hasC, $hasB, $mixedArray));
+
+	if (rand(0, 1)) {
+		$hasBorC = ['b' => 1];
+	} else {
+		$hasBorC = ['c' => 2];
+	}
+	assertType('array{b: 1}|array{c: 2}', $hasBorC);
+	assertType("non-empty-array", array_merge($mixedArray, $hasBorC));
+	assertType("non-empty-array", array_merge($hasBorC, $mixedArray));
+
+	if (rand(0, 1)) {
+		$differentCs = ['c' => 10];
+	} else {
+		$differentCs = ['c' => 20];
+	}
+	assertType('array{c: 10}|array{c: 20}', $differentCs);
+	assertType("non-empty-array&hasOffsetValue('c', 10|20)", array_merge($mixedArray, $differentCs));
+	assertType("non-empty-array&hasOffset('c')", array_merge($differentCs, $mixedArray));
+
+	assertType("non-empty-array&hasOffsetValue('c', 10|20)", array_merge($mixedArray, $hasBorC, $differentCs));
+	assertType("non-empty-array", array_merge($differentCs, $mixedArray, $hasBorC)); // could be non-empty-array&hasOffset('c')
+	assertType("non-empty-array&hasOffsetValue('c', 10|20)", array_merge($hasBorC, $mixedArray, $differentCs));
+	assertType("non-empty-array", array_merge($differentCs, $hasBorC, $mixedArray)); // could be non-empty-array&hasOffset('c')
 }
 
 /**