Add "DynamicFunctionReturnTypeExtension" for "array_replace"

conf/config.neon

@@ -973,6 +973,11 @@ services:
 tags:
 - phpstan.broker.dynamicFunctionReturnTypeExtension
 
+-
+class: PHPStan\Type\Php\ArrayReplaceFunctionDynamicReturnTypeExtension
+tags:
+- phpstan.broker.dynamicFunctionReturnTypeExtension
+
 -
 class: PHPStan\Type\Php\ArrayKeysFunctionDynamicReturnTypeExtension
 tags:

src/Type/Php/ArrayReplaceFunctionDynamicReturnTypeExtension.php

@@ -0,0 +1,93 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type\Php;
+
+use PhpParser\Node\Expr\FuncCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\ParametersAcceptorSelector;
+use PHPStan\Type\Accessory\NonEmptyArrayType;
+use PHPStan\Type\ArrayType;
+use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
+use PHPStan\Type\GeneralizePrecision;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypeUtils;
+
+class ArrayReplaceFunctionDynamicReturnTypeExtension implements \PHPStan\Type\DynamicFunctionReturnTypeExtension
+{
+
+public function isFunctionSupported(FunctionReflection $functionReflection): bool
+{
+return $functionReflection->getName() === 'array_replace';
+}
+
+public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, Scope $scope): Type
+{
+if (!isset($functionCall->args[0])) {
+return ParametersAcceptorSelector::selectSingle($functionReflection->getVariants())->getReturnType();
+}
+
+$keyTypes = [];
+$valueTypes = [];
+$returnedArrayBuilder = ConstantArrayTypeBuilder::createEmpty();
+$returnedArrayBuilderFilled = false;
+$nonEmpty = false;
+foreach ($functionCall->args as $arg) {
+$argType = $scope->getType($arg->value);
+
+if ($arg->unpack) {
+$argType = $argType->getIterableValueType();
+}
+
+$arrays = TypeUtils::getConstantArrays($argType);
+if (count($arrays) > 0) {
+foreach ($arrays as $constantArray) {
+foreach ($constantArray->getKeyTypes() as $i => $keyType) {
+$returnedArrayBuilderFilled = true;
+
+$returnedArrayBuilder->setOffsetValueType(
+$keyType,
+$constantArray->getValueTypes()[$i]
+);
+}
+}
+
+} else {
+$keyTypes[] = TypeUtils::generalizeType($argType->getIterableKeyType(), GeneralizePrecision::moreSpecific());
+$valueTypes[] = $argType->getIterableValueType();
+}
+
+if (!$argType->isIterableAtLeastOnce()->yes()) {
+continue;
+}
+
+$nonEmpty = true;
+}
+
+if (count($keyTypes) > 0) {
+$arrayType = new ArrayType(
+TypeCombinator::union(...$keyTypes),
+TypeCombinator::union(...$valueTypes)
+);
+
+if ($returnedArrayBuilderFilled) {
+$arrayType = TypeCombinator::union($returnedArrayBuilder->getArray(), $arrayType);
+}
+} elseif ($returnedArrayBuilderFilled) {
+$arrayType = $returnedArrayBuilder->getArray();
+} else {
+$arrayType = new ArrayType(
+TypeCombinator::union(...$keyTypes),
+TypeCombinator::union(...$valueTypes)
+);
+}
+
+if ($nonEmpty) {
+$arrayType = TypeCombinator::intersect($arrayType, new NonEmptyArrayType());
+}
+
+return $arrayType;
+}
+
+}

tests/PHPStan/Analyser/LegacyNodeScopeResolverTest.php

@@ -5152,6 +5152,10 @@ public function dataArrayFunctions(): array
 'array<int, int>',
 'array_values($generalStringKeys)',
 ],
+[
+"array('foo' => 'foo', 1 => stdClass, 'bar' => stdClass)",
+'array_replace($stringOrIntegerKeys, $stringKeys)',
+],
 [
 "array('foo' => stdClass, 0 => stdClass)",
 'array_merge($stringOrIntegerKeys)',

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -136,6 +136,8 @@ public function dataFileAsserts(): iterable
 
 yield from $this->gatherAssertTypes(__DIR__ . '/data/array-merge.php');
 
+yield from $this->gatherAssertTypes(__DIR__ . '/data/array-replace.php');
+
 yield from $this->gatherAssertTypes(__DIR__ . '/data/non-empty-array.php');
 
 if (PHP_VERSION_ID >= 80000 || self::$useStaticReflectionProvider) {

tests/PHPStan/Analyser/data/array-replace.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace NonEmptyArray;
+
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+
+/**
+ * @param array{foo: '1', bar: '2', lall: '3', 2: '2', 3: '3'} $array1
+ * @param array{foo: '1', bar: '4', lall2: '3', 2: '4', 3: '6'} $array2
+ */
+public function arrayReplaceArrayShapes($array1, $array2): void
+{
+assertType("array('foo' => '1', 'bar' => '2', 'lall' => '3', 2 => '2', 3 => '3')", array_replace($array1));
+assertType("array('foo' => '1', 'bar' => '2', 'lall' => '3', 2 => '2', 3 => '3')", array_replace([], $array1));
+assertType("array('foo' => '1', 'bar' => '2', 'lall' => '3', 2 => '2', 3 => '3')", array_replace($array1, []));
+assertType("array('foo' => '1', 'bar' => '2', 'lall' => '3', 2 => '2', 3 => '3')", array_replace($array1, $array1));
+assertType("array('foo' => '1', 'bar' => '4', 'lall' => '3', 2 => '4', 3 => '6', 'lall2' => '3')", array_replace($array1, $array2));
+assertType("array('foo' => '1', 'bar' => '2', 'lall2' => '3', 2 => '2', 3 => '3', 'lall' => '3')", array_replace($array2, $array1));
+assertType("array('foo' => 3, 'bar' => '2', 'lall2' => '3', 2 => '2', 3 => '3', 'lall' => '3')", array_replace($array2, $array1, ['foo' => 3]));
+assertType("array('foo' => 3, 'bar' => '2', 'lall2' => '3', 2 => '2', 3 => '3', 'lall' => '3')", array_replace($array2, $array1, ...[['foo' => 3]]));
+}
+
+/**
+ * @param int[] $array1
+ * @param string[] $array2
+ */
+public function arrayReplaceSimple($array1, $array2): void
+{
+assertType("array<int>", array_merge($array1, $array1));
+assertType("array<int|string>", array_merge($array1, $array2));
+assertType("array<int|string>", array_merge($array2, $array1));
+}
+
+/**
+ * @param array<int, int|string> $array1
+ * @param array<int, bool|float> $array2
+ */
+public function arrayReplaceUnionType($array1, $array2): void
+{
+assertType("array<int, int|string>", array_merge($array1, $array1));
+assertType("array<int, bool|float|int|string>", array_merge($array1, $array2));
+assertType("array<int, bool|float|int|string>", array_merge($array2, $array1));
+}
+
+/**
+ * @param array<int, array{bar: '2'}|array{foo: '1'}> $array1
+ * @param array<int, array{bar: '3'}|array{foo: '2'}> $array2
+ */
+public function arrayReplaceUnionTypeArrayShapes($array1, $array2): void
+{
+assertType("array<int, array('bar' => '2')|array('foo' => '1')>", array_merge($array1, $array1));
+assertType("array<int, array('bar' => '2'|'3')|array('foo' => '1'|'2')>", array_merge($array1, $array2));
+assertType("array<int, array('bar' => '2'|'3')|array('foo' => '1'|'2')>", array_merge($array2, $array1));
+}
+}

tests/PHPStan/Analyser/data/non-empty-array.php

@@ -49,6 +49,11 @@ public function arrayFunctions($array, $list, $stringArray): void
 assertType('array&nonEmpty', array_merge($array, []));
 assertType('array&nonEmpty', array_merge($array, $array));
 
+assertType('array&nonEmpty', array_replace($array));
+assertType('array&nonEmpty', array_replace([], $array));
+assertType('array&nonEmpty', array_replace($array, []));
+assertType('array&nonEmpty', array_replace($array, $array));
+
 assertType('array<int|string, (int|string)>&nonEmpty', array_flip($array));
 assertType('array<string, (int|string)>&nonEmpty', array_flip($stringArray));
 }