array_merge lost non-empty-string keys type

phpstan · Mar 30, 2022 · 565248d · 565248d
1 parent ae67ac8
commit 565248d
Show file tree

Hide file tree

Showing 4 changed files with 121 additions and 11 deletions.
diff --git a/src/Type/Php/ArrayMergeFunctionDynamicReturnTypeExtension.php b/src/Type/Php/ArrayMergeFunctionDynamicReturnTypeExtension.php
@@ -6,15 +6,17 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\Accessory\NonEmptyArrayType;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
-use PHPStan\Type\GeneralizePrecision;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\UnionType;
+use function in_array;
 
 class ArrayMergeFunctionDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
 {
@@ -26,15 +28,58 @@ public function isFunctionSupported(FunctionReflection $functionReflection): boo
 
 	public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, Scope $scope): Type
 	{
-		if (!isset($functionCall->getArgs()[0])) {
+		$args = $functionCall->getArgs();
+
+		if (!isset($args[0])) {
 			return ParametersAcceptorSelector::selectSingle($functionReflection->getVariants())->getReturnType();
 		}
 
+		$argTypes = [];
+		$allConstant = true;
+		foreach ($args as $i => $arg) {
+			$argType = $scope->getType($arg->value);
+			$argTypes[$i] = $argType;
+
+			if (!$arg->unpack && $argType instanceof ConstantArrayType) {
+				continue;
+			}
+
+			$allConstant = false;
+		}
+
+		if ($allConstant) {
+			$newArrayBuilder = ConstantArrayTypeBuilder::createEmpty();
+			foreach ($args as $i => $arg) {
+				$argType = $argTypes[$i];
+
+				if (!$argType instanceof ConstantArrayType) {
+					throw new ShouldNotHappenException();
+				}
+
+				$keyTypes = $argType->getKeyTypes();
+				$valueTypes = $argType->getValueTypes();
+				$optionalKeys = $argType->getOptionalKeys();
+
+				foreach ($keyTypes as $k => $keyType) {
+					$isOptional = in_array($k, $optionalKeys, true);
+
+					$newArrayBuilder->setOffsetValueType(
+						$keyType,
+						$valueTypes[$k],
+						$isOptional,
+					);
+				}
+			}
+
+			return $newArrayBuilder->getArray();
+		}
+
 		$keyTypes = [];
 		$valueTypes = [];
 		$nonEmpty = false;
-		foreach ($functionCall->getArgs() as $arg) {
-			$argType = $scope->getType($arg->value);
+		foreach ($args as $i => $arg) {
+			$argType = $argTypes[$i];
+
 			if ($arg->unpack) {
 				$argType = $argType->getIterableValueType();
 				if ($argType instanceof UnionType) {
@@ -44,7 +89,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 				}
 			}
 
-			$keyTypes[] = $argType->getIterableKeyType()->generalize(GeneralizePrecision::moreSpecific());
+			$keyTypes[] = $argType->getIterableKeyType();
 			$valueTypes[] = $argType->getIterableValueType();
 
 			if (!$argType->isIterableAtLeastOnce()->yes()) {

diff --git a/tests/PHPStan/Analyser/LegacyNodeScopeResolverTest.php b/tests/PHPStan/Analyser/LegacyNodeScopeResolverTest.php
@@ -4707,31 +4707,31 @@ public function dataArrayFunctions(): array
 				'array_values($generalStringKeys)',
 			],
 			[
-				'non-empty-array<int|(literal-string&non-empty-string), stdClass>',
+				'array{foo: stdClass, 1: stdClass}',
 				'array_merge($stringOrIntegerKeys)',
 			],
 			[
 				'array<int|string, DateTimeImmutable|int>',
 				'array_merge($generalStringKeys, $generalDateTimeValues)',
 			],
 			[
-				'non-empty-array<int|string, int|stdClass>',
+				'non-empty-array<1|string, int|stdClass>',
 				'array_merge($generalStringKeys, $stringOrIntegerKeys)',
 			],
 			[
-				'non-empty-array<int|string, int|stdClass>',
+				'non-empty-array<1|string, int|stdClass>',
 				'array_merge($stringOrIntegerKeys, $generalStringKeys)',
 			],
 			[
-				'non-empty-array<int|(literal-string&non-empty-string), \'foo\'|stdClass>',
+				'array{foo: stdClass, bar: stdClass, 1: stdClass}',
 				'array_merge($stringKeys, $stringOrIntegerKeys)',
 			],
 			[
-				'non-empty-array<int|(literal-string&non-empty-string), \'foo\'|stdClass>',
+				"array{foo: 'foo', 1: stdClass, bar: stdClass}",
 				'array_merge($stringOrIntegerKeys, $stringKeys)',
 			],
 			[
-				'non-empty-array<int|(literal-string&non-empty-string), 2|4|\'a\'|\'b\'|\'green\'|\'red\'|\'trapezoid\'>',
+				"array{color: 'green', 0: 'a', 1: 'b', shape: 'trapezoid', 2: 4}",
 				'array_merge(array("color" => "red", 2, 4), array("a", "b", "color" => "green", "shape" => "trapezoid", 4))',
 			],
 			[

diff --git a/tests/PHPStan/Analyser/NodeScopeResolverTest.php b/tests/PHPStan/Analyser/NodeScopeResolverTest.php
@@ -846,6 +846,7 @@ public function dataFileAsserts(): iterable
 
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-6917.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-6936-limit.php');
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-6927.php');
 	}
 
 	/**

diff --git a/tests/PHPStan/Analyser/data/bug-6927.php b/tests/PHPStan/Analyser/data/bug-6927.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace Bug6927;
+
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+	/**
+	 * @param array<non-empty-string, string> $params1
+	 * @param array<non-empty-string, string> $params2
+	 */
+	function foo1(array $params1, array $params2): void
+	{
+		$params2 = array_merge($params1, $params2);
+
+		assertType('array<non-empty-string, string>', $params2);
+	}
+
+	/**
+	 * @param array<non-empty-string, string> $params1
+	 * @param array<string, string> $params2
+	 */
+	function foo2(array $params1, array $params2): void
+	{
+		$params2 = array_merge($params1, $params2);
+
+		assertType('array<string, string>', $params2);
+	}
+
+	/**
+	 * @param array<string, string> $params1
+	 * @param array<non-empty-string, string> $params2
+	 */
+	function foo3(array $params1, array $params2): void
+	{
+		$params2 = array_merge($params1, $params2);
+
+		assertType('array<string, string>', $params2);
+	}
+
+	/**
+	 * @param array<literal-string&non-empty-string, string> $params1
+	 * @param array<non-empty-string, string> $params2
+	 */
+	function foo4(array $params1, array $params2): void
+	{
+		$params2 = array_merge($params1, $params2);
+
+		assertType('array<non-empty-string, string>', $params2);
+	}
+
+	/**
+	 * @param array{return: int, stdout: string, stderr: string} $params1
+	 * @param array{return: int, stdout?: string, stderr?: string} $params2
+	 */
+	function foo5(array $params1, array $params2): void
+	{
+		$params3 = array_merge($params1, $params2);
+
+		assertType('array{return: int, stdout: string, stderr: string}', $params3);
+	}
+
+}