infer HasOffsetValueType for last occuring string-keys

Author: staabm

src/Type/Php/ArrayMergeFunctionDynamicReturnTypeExtension.php

@@ -23,9 +23,10 @@
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\TypeUtils;
 use function array_keys;
-use function array_values;
 use function count;
 use function in_array;
+use function is_int;
+use function is_string;
 
 #[AutowiredService]
 final class ArrayMergeFunctionDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -93,10 +94,18 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 						continue;
 					}
 
-					$offsetTypes[$keyType->getValue()] = new HasOffsetType($keyType);
+					$offsetValueType = $constantArray->getOffsetValueType($keyType);
+					$offsetTypes[$keyType->getValue()] = [false, $offsetValueType];
 				}
 			}
 
+			if ($keyTypes === []) {
+				foreach ($offsetTypes as [&$generalize, $offsetType]) {
+					$generalize = true;
+				}
+				unset($generalize);
+			}
+
 			if ($newArrayBuilder === null) {
 				foreach (TypeUtils::getAccessoryTypes($argType) as $accessoryType) {
 					if (
@@ -107,8 +116,8 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 					}
 
 					$offsetType = $accessoryType->getOffsetType();
-					$offsetTypes[$offsetType->getValue()] = new HasOffsetType($offsetType);
-
+					$offsetValueType = $argType->getOffsetValueType($offsetType);
+					$offsetTypes[$offsetType->getValue()] = [false, $offsetValueType];
 				}
 
 				continue;
@@ -164,7 +173,32 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			$arrayType = TypeCombinator::intersect($arrayType, new AccessoryArrayListType());
 		}
 		if ($offsetTypes !== []) {
-			$arrayType = TypeCombinator::intersect($arrayType, ...array_values($offsetTypes));
+			$knownOffsetValues = [];
+			foreach ($offsetTypes as $key => [$generalize, $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 && is_string($key)) {
+					// the last string-keyed offset will overwrite previous values
+					$hasOffsetType = new HasOffsetValueType(
+						$keyType,
+						$offsetType,
+					);
+				} else {
+					$hasOffsetType = new HasOffsetType(
+						$keyType,
+					);
+				}
+
+				$knownOffsetValues[] = $hasOffsetType;
+			}
+			if ($knownOffsetValues !== []) {
+				$arrayType = TypeCombinator::intersect($arrayType, ...$knownOffsetValues);
+			}
 		}
 
 		return $arrayType;

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

@@ -5,26 +5,26 @@
 use function PHPStan\Testing\assertType;
 
 function doFoo(array $post): void {
-	assertType("non-empty-array&hasOffset('a')&hasOffset('b')", array_merge(['a' => 1, 'b' => false], $post));
+	assertType("non-empty-array&hasOffset('a')&hasOffset('b')", array_merge(['a' => 1, 'b' => false, 10 => 99], $post));
 }
 
 function doBar(array $array): void {
-	assertType("non-empty-array&hasOffset('a')&hasOffset('b')", array_merge($array, ['a' => 1, 'b' => false]));
+	assertType("non-empty-array&hasOffsetValue('a', 1)&hasOffsetValue('b', false)", array_merge($array, ['a' => 1, 'b' => false, 10 => 99]));
 }
 
 function doFooBar(array $array): void {
-	assertType("non-empty-array&hasOffset('a')&hasOffset('b')&hasOffset('c')", array_merge(['c' => 'd'], $array, ['a' => 1, 'b' => false, 'c' => 'e']));
+	assertType("non-empty-array&hasOffset('x')&hasOffsetValue('a', 1)&hasOffsetValue('b', false)&hasOffsetValue('c', 'e')", array_merge(['c' => 'd', 'x' => 'y'], $array, ['a' => 1, 'b' => false, 'c' => 'e']));
 }
 
 function doFooInts(array $array): void {
-	assertType("non-empty-array&hasOffset('a')&hasOffset('c')&hasOffset(1)&hasOffset(3)", array_merge([1 => 'd'], $array, ['a' => 1, 3 => false, 'c' => 'e']));
+	assertType("non-empty-array&hasOffsetValue('a', 1)&hasOffsetValue('c', 'e')", array_merge([1 => 'd'], $array, ['a' => 1, 3 => false, 'c' => 'e']));
 }
 
 /**
  * @param array<string> $array
  */
 function floatKey(array $array): void {
-	assertType("non-empty-array<string>&hasOffset('a')&hasOffset('c')&hasOffset(3)&hasOffset(4)", array_merge([4.23 => 'd'], $array, ['a' => '1', 3 => 'false', 'c' => 'e']));
+	assertType("non-empty-array<string>&hasOffsetValue('a', '1')&hasOffsetValue('c', 'e')", array_merge([4.23 => 'd'], $array, ['a' => '1', 3 => 'false', 'c' => 'e']));
 }
 
 function doOptKeys(array $array, array $arr2): void {
@@ -38,17 +38,25 @@ function doOptKeys(array $array, array $arr2): void {
  * @param array{a?: 1, b: 2} $array
  */
 function doOptShapeKeys(array $array, array $arr2): void {
-	assertType("non-empty-array&hasOffset('b')", array_merge($arr2, $array));
+	assertType("non-empty-array&hasOffsetValue('b', 2)", array_merge($arr2, $array));
 }
 
 function hasOffsetKeys(array $array, array $arr2): void {
 	if (array_key_exists('b', $array)) {
-		assertType("non-empty-array&hasOffset('b')", array_merge($arr2, $array));
+		assertType("non-empty-array&hasOffsetValue('b', mixed)", array_merge($arr2, $array));
 	}
 }
 
 function hasOffsetValueKeys(array $array, array $arr2): void {
 	$array['b'] = 123;
 
-	assertType("non-empty-array&hasOffset('b')", array_merge($arr2, $array));
+	assertType("non-empty-array&hasOffsetValue('b', 123)", array_merge($arr2, $array));
+}
+
+/**
+ * @param array{a?: 1, b?: 2} $allOptional
+ */
+function doAllOptional(array $allOptional, array $arr2): void {
+	assertType("array", array_merge($arr2, $allOptional));
+	assertType("array", array_merge($allOptional, $arr2));
 }