Add Type::chunkArray()

herndlm · web-flow · commit c1076529ae1a · 2024-09-22T11:11:52.000+02:00
diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
@@ -1283,11 +1283,6 @@ parameters:
 			count: 4
 			path: src/Type/ObjectWithoutClassType.php
 
-		-
-			message: "#^Doing instanceof PHPStan\\\\Type\\\\Constant\\\\ConstantBooleanType is error\\-prone and deprecated\\. Use Type\\:\\:isTrue\\(\\) or Type\\:\\:isFalse\\(\\) instead\\.$#"
-			count: 1
-			path: src/Type/Php/ArrayChunkFunctionReturnTypeExtension.php
-
 		-
 			message: "#^Doing instanceof PHPStan\\\\Type\\\\Constant\\\\ConstantArrayType is error\\-prone and deprecated\\. Use Type\\:\\:getConstantArrays\\(\\) instead\\.$#"
 			count: 2
diff --git a/src/Type/Accessory/AccessoryArrayListType.php b/src/Type/Accessory/AccessoryArrayListType.php
@@ -194,6 +194,11 @@ public function getValuesArray(): Type
 		return $this;
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return $this;
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return new MixedType();
diff --git a/src/Type/Accessory/HasOffsetType.php b/src/Type/Accessory/HasOffsetType.php
@@ -175,6 +175,11 @@ public function unsetOffset(Type $offsetType): Type
 		return $this;
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return new NonEmptyArrayType();
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return new NonEmptyArrayType();
diff --git a/src/Type/Accessory/HasOffsetValueType.php b/src/Type/Accessory/HasOffsetValueType.php
@@ -209,6 +209,11 @@ public function getValuesArray(): Type
 		return new NonEmptyArrayType();
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return new NonEmptyArrayType();
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return new NonEmptyArrayType();
diff --git a/src/Type/Accessory/NonEmptyArrayType.php b/src/Type/Accessory/NonEmptyArrayType.php
@@ -179,6 +179,11 @@ public function getValuesArray(): Type
 		return $this;
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return $this;
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return $this;
diff --git a/src/Type/Accessory/OversizedArrayType.php b/src/Type/Accessory/OversizedArrayType.php
@@ -175,6 +175,11 @@ public function getValuesArray(): Type
 		return $this;
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return $this;
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return $this;
diff --git a/src/Type/ArrayType.php b/src/Type/ArrayType.php
@@ -513,6 +513,20 @@ public function unsetOffset(Type $offsetType): Type
 		return $this;
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		$chunkType = $preserveKeys->yes()
+			? $this
+			: AccessoryArrayListType::intersectWith(new ArrayType(new IntegerType(), $this->getIterableValueType()));
+		$chunkType = TypeCombinator::intersect($chunkType, new NonEmptyArrayType());
+
+		$arrayType = AccessoryArrayListType::intersectWith(new ArrayType(new IntegerType(), $chunkType));
+
+		return $this->isIterableAtLeastOnce()->yes()
+			? TypeCombinator::intersect($arrayType, new NonEmptyArrayType())
+			: $arrayType;
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		$itemType = $this->getItemType();
diff --git a/src/Type/Constant/ConstantArrayType.php b/src/Type/Constant/ConstantArrayType.php
@@ -73,6 +73,7 @@ class ConstantArrayType extends ArrayType implements ConstantType
 {
 
 	private const DESCRIBE_LIMIT = 8;
+	private const CHUNK_FINITE_TYPES_LIMIT = 5;
 
 	private TrinaryLogic $isList;
 
@@ -780,6 +781,36 @@ public function unsetOffset(Type $offsetType): Type
 		return new self($this->keyTypes, $this->valueTypes, $this->nextAutoIndexes, $optionalKeys, $isList);
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		$biggerOne = IntegerRangeType::fromInterval(1, null);
+		$finiteTypes = $lengthType->getFiniteTypes();
+		if ($biggerOne->isSuperTypeOf($lengthType)->yes() && count($finiteTypes) < self::CHUNK_FINITE_TYPES_LIMIT) {
+			$results = [];
+			foreach ($finiteTypes as $finiteType) {
+				if (!$finiteType instanceof ConstantIntegerType || $finiteType->getValue() < 1) {
+					return parent::chunkArray($lengthType, $preserveKeys);
+				}
+
+				$length = $finiteType->getValue();
+
+				$builder = ConstantArrayTypeBuilder::createEmpty();
+
+				$keyTypesCount = count($this->keyTypes);
+				for ($i = 0; $i < $keyTypesCount; $i += $length) {
+					$chunk = $this->slice($i, $length, true);
+					$builder->setOffsetValueType(null, $preserveKeys->yes() ? $chunk : $chunk->getValuesArray());
+				}
+
+				$results[] = $builder->getArray();
+			}
+
+			return TypeCombinator::union(...$results);
+		}
+
+		return parent::chunkArray($lengthType, $preserveKeys);
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		$builder = ConstantArrayTypeBuilder::createEmpty();
@@ -1185,7 +1216,10 @@ public function reverse(bool $preserveKeys = false): self
 		return $this->reverseConstantArray(TrinaryLogic::createFromBoolean($preserveKeys));
 	}
 
-	/** @param positive-int $length */
+	/**
+	 * @deprecated Use chunkArray() instead
+	 * @param positive-int $length
+	 */
 	public function chunk(int $length, bool $preserveKeys = false): self
 	{
 		$builder = ConstantArrayTypeBuilder::createEmpty();
diff --git a/src/Type/IntersectionType.php b/src/Type/IntersectionType.php
@@ -724,6 +724,11 @@ public function getValuesArray(): Type
 		return $this->intersectTypes(static fn (Type $type): Type => $type->getValuesArray());
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return $this->intersectTypes(static fn (Type $type): Type => $type->chunkArray($lengthType, $preserveKeys));
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return $this->intersectTypes(static fn (Type $type): Type => $type->fillKeysArray($valueType));
diff --git a/src/Type/MixedType.php b/src/Type/MixedType.php
@@ -189,6 +189,15 @@ public function getValuesArray(): Type
 		return AccessoryArrayListType::intersectWith(new ArrayType(new IntegerType(), new MixedType($this->isExplicitMixed)));
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		if ($this->isArray()->no()) {
+			return new ErrorType();
+		}
+
+		return AccessoryArrayListType::intersectWith(new ArrayType(new IntegerType(), new MixedType($this->isExplicitMixed)));
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		if ($this->isArray()->no()) {
diff --git a/src/Type/NeverType.php b/src/Type/NeverType.php
@@ -296,6 +296,11 @@ public function getValuesArray(): Type
 		return new NeverType();
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return new NeverType();
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return new NeverType();
diff --git a/src/Type/Php/ArrayChunkFunctionReturnTypeExtension.php b/src/Type/Php/ArrayChunkFunctionReturnTypeExtension.php
@@ -6,25 +6,17 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\FunctionReflection;
-use PHPStan\Type\Accessory\AccessoryArrayListType;
-use PHPStan\Type\Accessory\NonEmptyArrayType;
-use PHPStan\Type\ArrayType;
 use PHPStan\Type\Constant\ConstantBooleanType;
-use PHPStan\Type\Constant\ConstantIntegerType;
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
 use PHPStan\Type\IntegerRangeType;
-use PHPStan\Type\IntegerType;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
-use PHPStan\Type\TypeCombinator;
 use function count;
 
 final class ArrayChunkFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
 {
 
-	private const FINITE_TYPES_LIMIT = 5;
-
 	public function __construct(private PhpVersion $phpVersion)
 	{
 	}
@@ -41,68 +33,20 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		}
 
 		$arrayType = $scope->getType($functionCall->getArgs()[0]->value);
-		$lengthType = $scope->getType($functionCall->getArgs()[1]->value);
-		if (isset($functionCall->getArgs()[2])) {
-			$preserveKeysType = $scope->getType($functionCall->getArgs()[2]->value);
-			$preserveKeys = $preserveKeysType instanceof ConstantBooleanType ? $preserveKeysType->getValue() : null;
-		} else {
-			$preserveKeys = false;
+		if ($arrayType->isArray()->no()) {
+			return $this->phpVersion->arrayFunctionsReturnNullWithNonArray() ? new NullType() : new NeverType();
 		}
 
+		$lengthType = $scope->getType($functionCall->getArgs()[1]->value);
 		$negativeOrZero = IntegerRangeType::fromInterval(null, 0);
 		if ($negativeOrZero->isSuperTypeOf($lengthType)->yes()) {
 			return $this->phpVersion->throwsValueErrorForInternalFunctions() ? new NeverType() : new NullType();
 		}
 
-		if (!$arrayType->isArray()->yes()) {
-			return null;
-		}
-
-		if ($preserveKeys !== null) {
-			$constantArrays = $arrayType->getConstantArrays();
-			$biggerOne = IntegerRangeType::fromInterval(1, null);
-			$finiteTypes = $lengthType->getFiniteTypes();
-			if (count($constantArrays) > 0
-				&& $biggerOne->isSuperTypeOf($lengthType)->yes()
-				&& count($finiteTypes) < self::FINITE_TYPES_LIMIT
-			) {
-				$results = [];
-				foreach ($constantArrays as $constantArray) {
-					foreach ($finiteTypes as $finiteType) {
-						if (!$finiteType instanceof ConstantIntegerType || $finiteType->getValue() < 1) {
-							return null;
-						}
-
-						$results[] = $constantArray->chunk($finiteType->getValue(), $preserveKeys);
-					}
-				}
-
-				return TypeCombinator::union(...$results);
-			}
-		}
-
-		$chunkType = self::getChunkType($arrayType, $preserveKeys);
-
-		$resultType = AccessoryArrayListType::intersectWith(new ArrayType(new IntegerType(), $chunkType));
-		if ($arrayType->isIterableAtLeastOnce()->yes()) {
-			$resultType = TypeCombinator::intersect($resultType, new NonEmptyArrayType());
-		}
-
-		return $resultType;
-	}
-
-	private static function getChunkType(Type $type, ?bool $preserveKeys): Type
-	{
-		if ($preserveKeys === null) {
-			$chunkType = new ArrayType(TypeCombinator::union($type->getIterableKeyType(), new IntegerType()), $type->getIterableValueType());
-		} elseif ($preserveKeys) {
-			$chunkType = $type;
-		} else {
-			$chunkType = new ArrayType(new IntegerType(), $type->getIterableValueType());
-			$chunkType = AccessoryArrayListType::intersectWith($chunkType);
-		}
+		$preserveKeysType = isset($functionCall->getArgs()[2]) ? $scope->getType($functionCall->getArgs()[2]->value) : new ConstantBooleanType(false);
+		$preserveKeys = (new ConstantBooleanType(true))->isSuperTypeOf($preserveKeysType);
 
-		return TypeCombinator::intersect($chunkType, new NonEmptyArrayType());
+		return $arrayType->chunkArray($lengthType, $preserveKeys);
 	}
 
 }
diff --git a/src/Type/StaticType.php b/src/Type/StaticType.php
@@ -415,6 +415,11 @@ public function getValuesArray(): Type
 		return $this->getStaticObjectType()->getValuesArray();
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return $this->getStaticObjectType()->chunkArray($lengthType, $preserveKeys);
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return $this->getStaticObjectType()->fillKeysArray($valueType);
diff --git a/src/Type/Traits/LateResolvableTypeTrait.php b/src/Type/Traits/LateResolvableTypeTrait.php
@@ -262,6 +262,11 @@ public function getValuesArray(): Type
 		return $this->resolve()->getValuesArray();
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return $this->resolve()->chunkArray($lengthType, $preserveKeys);
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return $this->resolve()->fillKeysArray($valueType);
diff --git a/src/Type/Traits/MaybeArrayTypeTrait.php b/src/Type/Traits/MaybeArrayTypeTrait.php
@@ -49,6 +49,11 @@ public function getValuesArray(): Type
 		return new ErrorType();
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return new ErrorType();
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return new ErrorType();
diff --git a/src/Type/Traits/NonArrayTypeTrait.php b/src/Type/Traits/NonArrayTypeTrait.php
@@ -49,6 +49,11 @@ public function getValuesArray(): Type
 		return new ErrorType();
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return new ErrorType();
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return new ErrorType();
diff --git a/src/Type/Type.php b/src/Type/Type.php
@@ -151,6 +151,8 @@ public function getKeysArray(): Type;
 
 	public function getValuesArray(): Type;
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type;
+
 	public function fillKeysArray(Type $valueType): Type;
 
 	public function flipArray(): Type;
diff --git a/src/Type/UnionType.php b/src/Type/UnionType.php
@@ -701,6 +701,11 @@ public function getValuesArray(): Type
 		return $this->unionTypes(static fn (Type $type): Type => $type->getValuesArray());
 	}
 
+	public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type
+	{
+		return $this->unionTypes(static fn (Type $type): Type => $type->chunkArray($lengthType, $preserveKeys));
+	}
+
 	public function fillKeysArray(Type $valueType): Type
 	{
 		return $this->unionTypes(static fn (Type $type): Type => $type->fillKeysArray($valueType));
diff --git a/tests/PHPStan/Analyser/nsrt/array-chunk.php b/tests/PHPStan/Analyser/nsrt/array-chunk.php
@@ -74,5 +74,26 @@ function testLimits(array $arr, int $oneToFour, int $tooBig) {
 		assertType('non-empty-list<non-empty-list<0|1|2|3>>', array_chunk($arr, $tooBig));
 	}
 
+	/** @param array<string, string> $map */
+	public function offsets(array $arr, array $map): void
+	{
+		if (array_key_exists('foo', $arr)) {
+			assertType('non-empty-list<non-empty-list<mixed>>', array_chunk($arr, 2));
+			assertType('non-empty-list<non-empty-array>', array_chunk($arr, 2, true));
+		}
+		if (array_key_exists('foo', $arr) && $arr['foo'] === 'bar') {
+			assertType('non-empty-list<non-empty-list<mixed>>', array_chunk($arr, 2));
+			assertType('non-empty-list<non-empty-array>', array_chunk($arr, 2, true));
+		}
+
+		if (array_key_exists('foo', $map)) {
+			assertType('non-empty-list<non-empty-list<string>>', array_chunk($map, 2));
+			assertType('non-empty-list<non-empty-array<string, string>>', array_chunk($map, 2, true));
+		}
+		if (array_key_exists('foo', $map) && $map['foo'] === 'bar') {
+			assertType('non-empty-list<non-empty-list<string>>', array_chunk($map, 2));
+			assertType('non-empty-list<non-empty-array<string, string>>', array_chunk($map, 2, true));
+		}
+	}
 
 }

Original file line number	Diff line number	Diff line change
`@@ -194,6 +194,11 @@ public function getValuesArray(): Type`
`194`	`194`	`return $this;`
`195`	`195`	`}`
`196`	`196`
	`197`	`+ public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type`
	`198`	`+ {`
	`199`	`+ return $this;`
	`200`	`+ }`
	`201`	`+`
`197`	`202`	`public function fillKeysArray(Type $valueType): Type`
`198`	`203`	`{`
`199`	`204`	`return new MixedType();`
Original file line number	Diff line number	Diff line change
`@@ -175,6 +175,11 @@ public function unsetOffset(Type $offsetType): Type`
`175`	`175`	`return $this;`
`176`	`176`	`}`
`177`	`177`
	`178`	`+ public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type`
	`179`	`+ {`
	`180`	`+ return new NonEmptyArrayType();`
	`181`	`+ }`
	`182`	`+`
`178`	`183`	`public function fillKeysArray(Type $valueType): Type`
`179`	`184`	`{`
`180`	`185`	`return new NonEmptyArrayType();`
Original file line number	Diff line number	Diff line change
`@@ -209,6 +209,11 @@ public function getValuesArray(): Type`
`209`	`209`	`return new NonEmptyArrayType();`
`210`	`210`	`}`
`211`	`211`
	`212`	`+ public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type`
	`213`	`+ {`
	`214`	`+ return new NonEmptyArrayType();`
	`215`	`+ }`
	`216`	`+`
`212`	`217`	`public function fillKeysArray(Type $valueType): Type`
`213`	`218`	`{`
`214`	`219`	`return new NonEmptyArrayType();`
Original file line number	Diff line number	Diff line change
`@@ -179,6 +179,11 @@ public function getValuesArray(): Type`
`179`	`179`	`return $this;`
`180`	`180`	`}`
`181`	`181`
	`182`	`+ public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type`
	`183`	`+ {`
	`184`	`+ return $this;`
	`185`	`+ }`
	`186`	`+`
`182`	`187`	`public function fillKeysArray(Type $valueType): Type`
`183`	`188`	`{`
`184`	`189`	`return $this;`
Original file line number	Diff line number	Diff line change
`@@ -175,6 +175,11 @@ public function getValuesArray(): Type`
`175`	`175`	`return $this;`
`176`	`176`	`}`
`177`	`177`
	`178`	`+ public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type`
	`179`	`+ {`
	`180`	`+ return $this;`
	`181`	`+ }`
	`182`	`+`
`178`	`183`	`public function fillKeysArray(Type $valueType): Type`
`179`	`184`	`{`
`180`	`185`	`return $this;`
Original file line number	Diff line number	Diff line change
`@@ -724,6 +724,11 @@ public function getValuesArray(): Type`
`724`	`724`	`return $this->intersectTypes(static fn (Type $type): Type => $type->getValuesArray());`
`725`	`725`	`}`
`726`	`726`
	`727`	`+ public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type`
	`728`	`+ {`
	`729`	`+ return $this->intersectTypes(static fn (Type $type): Type => $type->chunkArray($lengthType, $preserveKeys));`
	`730`	`+ }`
	`731`	`+`
`727`	`732`	`public function fillKeysArray(Type $valueType): Type`
`728`	`733`	`{`
`729`	`734`	`return $this->intersectTypes(static fn (Type $type): Type => $type->fillKeysArray($valueType));`