Skip to content

Commit e7afdd9

Browse files
herndlmherndlm
committed
Add Type::spliceArray(), improve splice_array() array type narrowing
1 parent 9ffae27 commit e7afdd9

21 files changed

+465
-22
lines changed

‎src/Analyser/NodeScopeResolver.php‎

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2675,19 +2675,20 @@ static function (): void {
26752675
if (
26762676
$functionReflection !== null
26772677
&& $functionReflection->getName() === 'array_splice'
2678-
&& count($expr->getArgs()) >= 1
2678+
&& count($expr->getArgs()) >= 2
26792679
) {
26802680
$arrayArg = $expr->getArgs()[0]->value;
26812681
$arrayArgType = $scope->getType($arrayArg);
2682-
$valueType = $arrayArgType->getIterableValueType();
2683-
if (count($expr->getArgs()) >= 4) {
2684-
$replacementType = $scope->getType($expr->getArgs()[3]->value)->toArray();
2685-
$valueType = TypeCombinator::union($valueType, $replacementType->getIterableValueType());
2686-
}
2682+
$arrayArgNativeType = $scope->getNativeType($arrayArg);
2683+
2684+
$offsetType = $scope->getType($expr->getArgs()[1]->value);
2685+
$lengthType = isset($expr->getArgs()[2]) ? $scope->getType($expr->getArgs()[2]->value) : new NullType();
2686+
$replacementType = isset($expr->getArgs()[3]) ? $scope->getType($expr->getArgs()[3]->value) : new ConstantArrayType([], []);
2687+
26872688
$scope = $scope->invalidateExpression($arrayArg)->assignExpression(
26882689
$arrayArg,
2689-
new ArrayType($arrayArgType->getIterableKeyType(), $valueType),
2690-
new ArrayType($arrayArgType->getIterableKeyType(), $valueType),
2690+
$arrayArgType->spliceArray($offsetType, $lengthType, $replacementType),
2691+
$arrayArgNativeType->spliceArray($offsetType, $lengthType, $replacementType),
26912692
);
26922693
}
26932694

‎src/Type/Accessory/AccessoryArrayListType.php‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -248,6 +248,11 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
248248
return new MixedType();
249249
}
250250

251+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
252+
{
253+
return $this;
254+
}
255+
251256
public function isIterable(): TrinaryLogic
252257
{
253258
return TrinaryLogic::createYes();

‎src/Type/Accessory/HasOffsetType.php‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -214,6 +214,15 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
214214
return new MixedType();
215215
}
216216

217+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
218+
{
219+
if ((new ConstantIntegerType(0))->isSuperTypeOf($lengthType)->yes()) {
220+
return $this;
221+
}
222+
223+
return new MixedType();
224+
}
225+
217226
public function isIterableAtLeastOnce(): TrinaryLogic
218227
{
219228
return TrinaryLogic::createYes();

‎src/Type/Accessory/HasOffsetValueType.php‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -274,6 +274,15 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
274274
return new MixedType();
275275
}
276276

277+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
278+
{
279+
if ((new ConstantIntegerType(0))->isSuperTypeOf($lengthType)->yes()) {
280+
return $this;
281+
}
282+
283+
return new MixedType();
284+
}
285+
277286
public function isIterableAtLeastOnce(): TrinaryLogic
278287
{
279288
return TrinaryLogic::createYes();

‎src/Type/Accessory/NonEmptyArrayType.php‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -226,6 +226,18 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
226226
return new MixedType();
227227
}
228228

229+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
230+
{
231+
if (
232+
(new ConstantIntegerType(0))->isSuperTypeOf($lengthType)->yes()
233+
|| $replacementType->toArray()->isIterableAtLeastOnce()->yes()
234+
) {
235+
return $this;
236+
}
237+
238+
return new MixedType();
239+
}
240+
229241
public function isIterable(): TrinaryLogic
230242
{
231243
return TrinaryLogic::createYes();

‎src/Type/Accessory/OversizedArrayType.php‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -214,6 +214,11 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
214214
return $this;
215215
}
216216

217+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
218+
{
219+
return $this;
220+
}
221+
217222
public function isIterable(): TrinaryLogic
218223
{
219224
return TrinaryLogic::createYes();

‎src/Type/ArrayType.php‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -449,6 +449,27 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
449449
return $this;
450450
}
451451

452+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
453+
{
454+
$replacementArrayType = $replacementType->toArray();
455+
$replacementArrayTypeIsIterableAtLeastOnce = $replacementArrayType->isIterableAtLeastOnce();
456+
457+
if ((new ConstantIntegerType(0))->isSuperTypeOf($offsetType)->yes() && $lengthType->isNull()->yes() && $replacementArrayTypeIsIterableAtLeastOnce->no()) {
458+
return new ConstantArrayType([], []);
459+
}
460+
461+
$arrayType = new self(
462+
TypeCombinator::union($this->getIterableKeyType(), $replacementArrayType->getKeysArray()->getIterableKeyType()),
463+
TypeCombinator::union($this->getIterableValueType(), $replacementArrayType->getIterableValueType()),
464+
);
465+
466+
if ($replacementArrayTypeIsIterableAtLeastOnce->yes()) {
467+
$arrayType = TypeCombinator::intersect($arrayType, new NonEmptyArrayType());
468+
}
469+
470+
return $arrayType;
471+
}
472+
452473
public function isCallable(): TrinaryLogic
453474
{
454475
return TrinaryLogic::createMaybe()->and($this->itemType->isString());

‎src/Type/Constant/ConstantArrayType.php‎

Lines changed: 103 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -945,7 +945,7 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
945945
}
946946

947947
if ($keyTypesCount + $offset <= 0) {
948-
// A negative offset cannot reach left outside the array
948+
// A negative offset cannot reach left outside the array twice
949949
$offset = 0;
950950
}
951951

@@ -1006,6 +1006,108 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
10061006
return $builder->getArray();
10071007
}
10081008

1009+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
1010+
{
1011+
$keyTypesCount = count($this->keyTypes);
1012+
1013+
$offset = $offsetType instanceof ConstantIntegerType ? $offsetType->getValue() : null;
1014+
1015+
if ($lengthType instanceof ConstantIntegerType) {
1016+
$length = $lengthType->getValue();
1017+
} elseif ($lengthType->isNull()->yes()) {
1018+
$length = $keyTypesCount;
1019+
} else {
1020+
$length = null;
1021+
}
1022+
1023+
if (
1024+
$offset === null || $length === null
1025+
|| count($this->optionalKeys) > 0 && $length < 0 // Negative lengths with optional keys are not supported yet
1026+
) {
1027+
return $this->degradeToGeneralArray()
1028+
->spliceArray($offsetType, $lengthType, $replacementType);
1029+
}
1030+
1031+
if ($keyTypesCount + $offset <= 0) {
1032+
// A negative offset cannot reach left outside the array twice
1033+
$offset = 0;
1034+
}
1035+
1036+
if ($keyTypesCount + $length <= 0) {
1037+
// A negative length cannot reach left outside the array twice
1038+
$length = 0;
1039+
}
1040+
1041+
$offsetWasNegative = false;
1042+
if ($offset < 0) {
1043+
$offsetWasNegative = true;
1044+
$offset = $keyTypesCount + $offset;
1045+
}
1046+
1047+
if ($length < 0) {
1048+
$length = $keyTypesCount - $offset + $length;
1049+
}
1050+
1051+
$removeKeysCount = 0;
1052+
$optionalKeysIgnored = 0;
1053+
$optionalKeysBeforeReplacement = 0;
1054+
$builder = ConstantArrayTypeBuilder::createEmpty();
1055+
for ($i = 0;; $i++) {
1056+
$isOptional = $this->isOptionalKey($i);
1057+
1058+
if (!$offsetWasNegative && $i < $offset && $isOptional) {
1059+
$optionalKeysIgnored++;
1060+
$optionalKeysBeforeReplacement++;
1061+
}
1062+
1063+
if ($i === $offset + $optionalKeysBeforeReplacement) {
1064+
// When the offset is reached we have to a) put the replacement array in and b) remove $length elements
1065+
$removeKeysCount = $length;
1066+
$optionalKeysIgnored += $optionalKeysBeforeReplacement;
1067+
1068+
$replacementArrayType = $replacementType->toArray();
1069+
$constantArrays = $replacementArrayType->getConstantArrays();
1070+
if (count($constantArrays) === 1) {
1071+
$valuesArray = $constantArrays[0]->getValuesArray();
1072+
for ($j = 0, $jMax = count($valuesArray->keyTypes); $j < $jMax; $j++) {
1073+
$builder->setOffsetValueType(null, $valuesArray->valueTypes[$j], $valuesArray->isOptionalKey($j));
1074+
}
1075+
} else {
1076+
$builder->degradeToGeneralArray();
1077+
$builder->setOffsetValueType(null, $replacementArrayType->getIterableValueType(), true);
1078+
}
1079+
}
1080+
1081+
if (!isset($this->keyTypes[$i])) {
1082+
break;
1083+
}
1084+
1085+
if ($removeKeysCount > 0) {
1086+
$removeKeysCount--;
1087+
1088+
if ($optionalKeysIgnored === 0) {
1089+
if ($isOptional && $removeKeysCount === 0) {
1090+
$optionalKeysIgnored++;
1091+
}
1092+
continue;
1093+
}
1094+
}
1095+
1096+
if (!$isOptional && $optionalKeysIgnored > 0) {
1097+
$optionalKeysIgnored--;
1098+
$isOptional = true;
1099+
}
1100+
1101+
$builder->setOffsetValueType(
1102+
$this->keyTypes[$i]->isInteger()->no() ? $this->keyTypes[$i] : null,
1103+
$this->valueTypes[$i],
1104+
$isOptional,
1105+
);
1106+
}
1107+
1108+
return $builder->getArray();
1109+
}
1110+
10091111
public function isIterableAtLeastOnce(): TrinaryLogic
10101112
{
10111113
$keysCount = count($this->keyTypes);

‎src/Type/IntersectionType.php‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -899,6 +899,11 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
899899
return $this->intersectTypes(static fn (Type $type): Type => $type->sliceArray($offsetType, $lengthType, $preserveKeys));
900900
}
901901

902+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
903+
{
904+
return $this->intersectTypes(static fn (Type $type): Type => $type->spliceArray($offsetType, $lengthType, $replacementType));
905+
}
906+
902907
public function getEnumCases(): array
903908
{
904909
$compare = [];

‎src/Type/MixedType.php‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -287,6 +287,15 @@ public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $pre
287287
return new ArrayType(new MixedType($this->isExplicitMixed), new MixedType($this->isExplicitMixed));
288288
}
289289

290+
public function spliceArray(Type $offsetType, Type $lengthType, Type $replacementType): Type
291+
{
292+
if ($this->isArray()->no()) {
293+
return new ErrorType();
294+
}
295+
296+
return new ArrayType(new MixedType($this->isExplicitMixed), new MixedType($this->isExplicitMixed));
297+
}
298+
290299
public function isCallable(): TrinaryLogic
291300
{
292301
if ($this->subtractedType !== null) {

0 commit comments

Comments
 (0)