Skip to content

Commit 2e5bfcf

Browse files
VincentLangletVincentLanglet
committed
Rework ArrayReplaceFunctionReturnTypeExtension
1 parent 8a6f7e9 commit 2e5bfcf

File tree

4 files changed

+126
-36
lines changed

4 files changed

+126
-36
lines changed

Diff for: ‎src/Type/Php/ArrayReplaceFunctionReturnTypeExtension.php

+94-32
Original file line numberDiff line numberDiff line change
@@ -5,12 +5,21 @@
55
use PhpParser\Node\Expr\FuncCall;
66
use PHPStan\Analyser\Scope;
77
use PHPStan\Reflection\FunctionReflection;
8+
use PHPStan\TrinaryLogic;
9+
use PHPStan\Type\Accessory\AccessoryArrayListType;
810
use PHPStan\Type\Accessory\NonEmptyArrayType;
911
use PHPStan\Type\ArrayType;
12+
use PHPStan\Type\Constant\ConstantArrayType;
13+
use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
14+
use PHPStan\Type\Constant\ConstantIntegerType;
15+
use PHPStan\Type\Constant\ConstantStringType;
1016
use PHPStan\Type\DynamicFunctionReturnTypeExtension;
17+
use PHPStan\Type\NeverType;
1118
use PHPStan\Type\Type;
1219
use PHPStan\Type\TypeCombinator;
20+
use function array_keys;
1321
use function count;
22+
use function in_array;
1423
use function strtolower;
1524

1625
final class ArrayReplaceFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -23,54 +32,107 @@ public function isFunctionSupported(FunctionReflection $functionReflection): boo
2332

2433
public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, Scope $scope): ?Type
2534
{
26-
$arrayTypes = $this->collectArrayTypes($functionCall, $scope);
35+
$args = $functionCall->getArgs();
2736

28-
if (count($arrayTypes) === 0) {
37+
if (!isset($args[0])) {
2938
return null;
3039
}
3140

32-
return $this->getResultType(...$arrayTypes);
33-
}
41+
$argTypes = [];
42+
$optionalArgTypes = [];
43+
foreach ($args as $arg) {
44+
$argType = $scope->getType($arg->value);
3445

35-
private function getResultType(Type ...$arrayTypes): Type
36-
{
37-
$keyTypes = [];
38-
$valueTypes = [];
39-
$nonEmptyArray = false;
40-
foreach ($arrayTypes as $arrayType) {
41-
if (!$nonEmptyArray && $arrayType->isIterableAtLeastOnce()->yes()) {
42-
$nonEmptyArray = true;
46+
if ($arg->unpack) {
47+
if ($argType->isConstantArray()->yes()) {
48+
foreach ($argType->getConstantArrays() as $constantArray) {
49+
foreach ($constantArray->getValueTypes() as $valueType) {
50+
$argTypes[] = $valueType;
51+
}
52+
}
53+
} else {
54+
$argTypes[] = $argType->getIterableValueType();
55+
}
56+
57+
if (!$argType->isIterableAtLeastOnce()->yes()) {
58+
// unpacked params can be empty, making them optional
59+
$optionalArgTypesOffset = count($argTypes) - 1;
60+
foreach (array_keys($argTypes) as $key) {
61+
$optionalArgTypes[] = $optionalArgTypesOffset + $key;
62+
}
63+
}
64+
} else {
65+
$argTypes[] = $argType;
4366
}
44-
45-
$keyTypes[] = $arrayType->getIterableKeyType();
46-
$valueTypes[] = $arrayType->getIterableValueType();
4767
}
4868

49-
$keyType = TypeCombinator::union(...$keyTypes);
50-
$valueType = TypeCombinator::union(...$valueTypes);
69+
$allConstant = TrinaryLogic::createYes()->lazyAnd(
70+
$argTypes,
71+
static fn (Type $argType) => $argType->isConstantArray(),
72+
);
73+
74+
if ($allConstant->yes()) {
75+
$newArrayBuilder = ConstantArrayTypeBuilder::createEmpty();
76+
77+
foreach ($argTypes as $argType) {
78+
/** @var array<int|string, ConstantIntegerType|ConstantStringType> $keyTypes */
79+
$keyTypes = [];
80+
foreach ($argType->getConstantArrays() as $constantArray) {
81+
foreach ($constantArray->getKeyTypes() as $keyType) {
82+
$keyTypes[$keyType->getValue()] = $keyType;
83+
}
84+
}
85+
86+
foreach ($keyTypes as $keyType) {
87+
$newArrayBuilder->setOffsetValueType(
88+
$keyType,
89+
$argType->getOffsetValueType($keyType),
90+
!$argType->hasOffsetValueType($keyType)->yes(),
91+
);
92+
}
93+
}
5194

52-
$arrayType = new ArrayType($keyType, $valueType);
53-
return $nonEmptyArray ? TypeCombinator::intersect($arrayType, new NonEmptyArrayType()) : $arrayType;
54-
}
95+
return $newArrayBuilder->getArray();
96+
}
5597

56-
/**
57-
* @return Type[]
58-
*/
59-
private function collectArrayTypes(FuncCall $functionCall, Scope $scope): array
60-
{
61-
$args = $functionCall->getArgs();
98+
$keyTypes = [];
99+
$valueTypes = [];
100+
$nonEmpty = false;
101+
$isList = true;
102+
foreach ($argTypes as $key => $argType) {
103+
$keyType = $argType->getIterableKeyType();
104+
$keyTypes[] = $keyType;
105+
$valueTypes[] = $argType->getIterableValueType();
106+
107+
if (!$argType->isList()->yes()) {
108+
$isList = false;
109+
}
62110

63-
$arrayTypes = [];
64-
foreach ($args as $arg) {
65-
$argType = $scope->getType($arg->value);
66-
if (!$argType->isArray()->yes()) {
111+
if (in_array($key, $optionalArgTypes, true) || !$argType->isIterableAtLeastOnce()->yes()) {
67112
continue;
68113
}
69114

70-
$arrayTypes[] = $arg->unpack ? $argType->getIterableValueType() : $argType;
115+
$nonEmpty = true;
116+
}
117+
118+
$keyType = TypeCombinator::union(...$keyTypes);
119+
if ($keyType instanceof NeverType) {
120+
return new ConstantArrayType([], []);
121+
}
122+
123+
$arrayType = new ArrayType(
124+
$keyType,
125+
TypeCombinator::union(...$valueTypes),
126+
);
127+
128+
if ($nonEmpty) {
129+
$arrayType = TypeCombinator::intersect($arrayType, new NonEmptyArrayType());
130+
}
131+
if ($isList) {
132+
$arrayType = TypeCombinator::intersect($arrayType, new AccessoryArrayListType());
71133
}
72134

73-
return $arrayTypes;
135+
return $arrayType;
74136
}
75137

76138
}

Diff for: ‎tests/PHPStan/Analyser/nsrt/array-replace.php

+21-3
Original file line numberDiff line numberDiff line change
@@ -23,9 +23,9 @@ public function arrayReplace($array1, $array2): void
2323
*/
2424
public function arrayReplaceArrayShapes($array1, $array2): void
2525
{
26-
assertType("non-empty-array<'bar'|'foo', '1'|'2'>", array_replace($array1));
27-
assertType("non-empty-array<'bar'|'foo', '1'|'2'>", array_replace([], $array1));
28-
assertType("non-empty-array<'bar'|'foo', '1'|'2'|'4'>", array_replace($array1, $array2));
26+
assertType("array{foo: '1', bar: '2'}", array_replace($array1));
27+
assertType("array{foo: '1', bar: '2'}", array_replace([], $array1));
28+
assertType("array{foo: '1', bar: '4'}", array_replace($array1, $array2));
2929
}
3030

3131
/**
@@ -68,4 +68,22 @@ public function arrayReplaceUnionTypeArrayShapes($array1, $array2): void
6868
assertType("array<int, array{bar: '2'}|array{bar: '3'}|array{foo: '1'}|array{foo: '2'}>", array_replace($array1, $array2));
6969
assertType("array<int, array{bar: '2'}|array{bar: '3'}|array{foo: '1'}|array{foo: '2'}>", array_replace($array2, $array1));
7070
}
71+
72+
/**
73+
* @param array{0: 1, 1: 2} $array1
74+
* @param array{1: 3, 2: 4} $array2
75+
*/
76+
public function arrayReplaceNumericKeys($array1, $array2): void
77+
{
78+
assertType("array{1, 3, 4}", array_replace($array1, $array2));
79+
}
80+
81+
/**
82+
* @param list<int> $array1
83+
* @param list<int> $array2
84+
*/
85+
public function arrayReplaceLists($array1, $array2): void
86+
{
87+
assertType("list<int>", array_replace($array1, $array2));
88+
}
7189
}

Diff for: ‎tests/PHPStan/Analyser/nsrt/bug-12828.php

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
<?php declare(strict_types = 1);
2+
3+
namespace Bug12828;
4+
5+
use function PHPStan\Testing\assertType;
6+
7+
$a = ['abc' => 'def', 'hello' => 'world'];
8+
assertType("array{abc: 'def', hello: 'world'}", $a);
9+
$a = array_replace($a, ['hello' => 'country']);
10+
assertType("array{abc: 'def', hello: 'country'}", $a);

Diff for: ‎tests/PHPStan/Analyser/nsrt/native-types.php

+1-1
Original file line numberDiff line numberDiff line change
@@ -372,7 +372,7 @@ class TestPhp8Stubs
372372
public function doFoo(): void
373373
{
374374
$a = array_replace([1, 2, 3], [4, 5, 6]);
375-
assertType('non-empty-array<0|1|2, 1|2|3|4|5|6>', $a);
375+
assertType('array{4, 5, 6}', $a);
376376
assertNativeType('array', $a);
377377
}
378378

0 commit comments

Comments
 (0)