Add Type::reverseArray()

herndlm · ondrejmirtes · commit 3116a1be707b · 2024-09-05T17:51:26.000+02:00
diff --git a/src/Type/Accessory/AccessoryArrayListType.php b/src/Type/Accessory/AccessoryArrayListType.php
@@ -218,6 +218,15 @@ public function popArray(): Type
 		return $this;
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		if ($preserveKeys->no()) {
+			return $this;
+		}
+
+		return new MixedType();
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return new MixedType();
diff --git a/src/Type/Accessory/HasOffsetType.php b/src/Type/Accessory/HasOffsetType.php
@@ -189,6 +189,15 @@ public function intersectKeyArray(Type $otherArraysType): Type
 		return new MixedType();
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		if ($preserveKeys->yes()) {
+			return $this;
+		}
+
+		return new NonEmptyArrayType();
+	}
+
 	public function shuffleArray(): Type
 	{
 		return new NonEmptyArrayType();
diff --git a/src/Type/Accessory/HasOffsetValueType.php b/src/Type/Accessory/HasOffsetValueType.php
@@ -233,6 +233,15 @@ public function intersectKeyArray(Type $otherArraysType): Type
 		return new MixedType();
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		if ($preserveKeys->yes()) {
+			return $this;
+		}
+
+		return new NonEmptyArrayType();
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		if (
diff --git a/src/Type/Accessory/NonEmptyArrayType.php b/src/Type/Accessory/NonEmptyArrayType.php
@@ -199,6 +199,11 @@ public function popArray(): Type
 		return new MixedType();
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return $this;
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return new MixedType();
diff --git a/src/Type/Accessory/OversizedArrayType.php b/src/Type/Accessory/OversizedArrayType.php
@@ -195,6 +195,11 @@ public function popArray(): Type
 		return $this;
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return $this;
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return new MixedType();
diff --git a/src/Type/ArrayType.php b/src/Type/ArrayType.php
@@ -552,6 +552,11 @@ public function popArray(): Type
 		return $this;
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return $this;
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return TypeCombinator::union($this->getIterableKeyType(), new ConstantBooleanType(false));
diff --git a/src/Type/Constant/ConstantArrayType.php b/src/Type/Constant/ConstantArrayType.php
@@ -837,6 +837,23 @@ public function popArray(): Type
 		return $this->removeLastElements(1);
 	}
 
+	private function reverseConstantArray(TrinaryLogic $preserveKeys): self
+	{
+		$keyTypesReversed = array_reverse($this->keyTypes, true);
+		$keyTypes = array_values($keyTypesReversed);
+		$keyTypesReversedKeys = array_keys($keyTypesReversed);
+		$optionalKeys = array_map(static fn (int $optionalKey): int => $keyTypesReversedKeys[$optionalKey], $this->optionalKeys);
+
+		$reversed = new self($keyTypes, array_reverse($this->valueTypes), $this->nextAutoIndexes, $optionalKeys, TrinaryLogic::createNo());
+
+		return $preserveKeys->yes() ? $reversed : $reversed->reindex();
+	}
+
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return $this->reverseConstantArray($preserveKeys);
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		$matches = [];
@@ -1121,9 +1138,9 @@ public function slice(int $offset, ?int $limit, bool $preserveKeys = false): sel
 			$offset *= -1;
 			$reversedLimit = min($limit, $offset);
 			$reversedOffset = $offset - $reversedLimit;
-			return $this->reverse(true)
+			return $this->reverseConstantArray(TrinaryLogic::createYes())
 				->slice($reversedOffset, $reversedLimit, $preserveKeys)
-				->reverse(true);
+				->reverseConstantArray(TrinaryLogic::createYes());
 		}
 
 		if ($offset > 0) {
@@ -1162,16 +1179,10 @@ public function slice(int $offset, ?int $limit, bool $preserveKeys = false): sel
 		return $preserveKeys ? $slice : $slice->reindex();
 	}
 
+	/** @deprecated Use reverseArray() instead */
 	public function reverse(bool $preserveKeys = false): self
 	{
-		$keyTypesReversed = array_reverse($this->keyTypes, true);
-		$keyTypes = array_values($keyTypesReversed);
-		$keyTypesReversedKeys = array_keys($keyTypesReversed);
-		$optionalKeys = array_map(static fn (int $optionalKey): int => $keyTypesReversedKeys[$optionalKey], $this->optionalKeys);
-
-		$reversed = new self($keyTypes, array_reverse($this->valueTypes), $this->nextAutoIndexes, $optionalKeys, TrinaryLogic::createNo());
-
-		return $preserveKeys ? $reversed : $reversed->reindex();
+		return $this->reverseConstantArray(TrinaryLogic::createFromBoolean($preserveKeys));
 	}
 
 	/** @param positive-int $length */
diff --git a/src/Type/IntersectionType.php b/src/Type/IntersectionType.php
@@ -744,6 +744,11 @@ public function popArray(): Type
 		return $this->intersectTypes(static fn (Type $type): Type => $type->popArray());
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return $this->intersectTypes(static fn (Type $type): Type => $type->reverseArray($preserveKeys));
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return $this->intersectTypes(static fn (Type $type): Type => $type->searchArray($needleType));
diff --git a/src/Type/MixedType.php b/src/Type/MixedType.php
@@ -225,6 +225,15 @@ public function popArray(): Type
 		return new ArrayType(new MixedType($this->isExplicitMixed), new MixedType($this->isExplicitMixed));
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		if ($this->isArray()->no()) {
+			return new ErrorType();
+		}
+
+		return new ArrayType(new MixedType($this->isExplicitMixed), new MixedType($this->isExplicitMixed));
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		if ($this->isArray()->no()) {
diff --git a/src/Type/NeverType.php b/src/Type/NeverType.php
@@ -316,6 +316,11 @@ public function popArray(): Type
 		return new NeverType();
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return new NeverType();
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return new NeverType();
diff --git a/src/Type/Php/ArrayReverseFunctionReturnTypeExtension.php b/src/Type/Php/ArrayReverseFunctionReturnTypeExtension.php
@@ -4,16 +4,21 @@
 
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
+use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
 use PHPStan\Type\NeverType;
+use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
-use PHPStan\Type\TypeCombinator;
-use function count;
 
 final class ArrayReverseFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
 {
 
+	public function __construct(private PhpVersion $phpVersion)
+	{
+	}
+
 	public function isFunctionSupported(FunctionReflection $functionReflection): bool
 	{
 		return $functionReflection->getName() === 'array_reverse';
@@ -26,24 +31,14 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		}
 
 		$type = $scope->getType($functionCall->getArgs()[0]->value);
-		$preserveKeysType = isset($functionCall->getArgs()[1]) ? $scope->getType($functionCall->getArgs()[1]->value) : new NeverType();
-		$preserveKeys = $preserveKeysType->isTrue()->yes();
-
-		if (!$type->isArray()->yes()) {
-			return null;
+		if ($type->isArray()->no()) {
+			return $this->phpVersion->arrayFunctionsReturnNullWithNonArray() ? new NullType() : new NeverType();
 		}
 
-		$constantArrays = $type->getConstantArrays();
-		if (count($constantArrays) > 0) {
-			$results = [];
-			foreach ($constantArrays as $constantArray) {
-				$results[] = $constantArray->reverse($preserveKeys);
-			}
-
-			return TypeCombinator::union(...$results);
-		}
+		$preserveKeysType = isset($functionCall->getArgs()[1]) ? $scope->getType($functionCall->getArgs()[1]->value) : new ConstantBooleanType(false);
+		$preserveKeys = (new ConstantBooleanType(true))->isSuperTypeOf($preserveKeysType);
 
-		return $type;
+		return $type->reverseArray($preserveKeys);
 	}
 
 }
diff --git a/src/Type/StaticType.php b/src/Type/StaticType.php
@@ -435,6 +435,11 @@ public function popArray(): Type
 		return $this->getStaticObjectType()->popArray();
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return $this->getStaticObjectType()->reverseArray($preserveKeys);
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return $this->getStaticObjectType()->searchArray($needleType);
diff --git a/src/Type/Traits/LateResolvableTypeTrait.php b/src/Type/Traits/LateResolvableTypeTrait.php
@@ -282,6 +282,11 @@ public function popArray(): Type
 		return $this->resolve()->popArray();
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return $this->resolve()->reverseArray($preserveKeys);
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return $this->resolve()->searchArray($needleType);
diff --git a/src/Type/Traits/MaybeArrayTypeTrait.php b/src/Type/Traits/MaybeArrayTypeTrait.php
@@ -69,6 +69,11 @@ public function popArray(): Type
 		return new ErrorType();
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return new ErrorType();
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return new ErrorType();
diff --git a/src/Type/Traits/NonArrayTypeTrait.php b/src/Type/Traits/NonArrayTypeTrait.php
@@ -69,6 +69,11 @@ public function popArray(): Type
 		return new ErrorType();
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return new ErrorType();
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return new ErrorType();
diff --git a/src/Type/Type.php b/src/Type/Type.php
@@ -159,6 +159,8 @@ public function intersectKeyArray(Type $otherArraysType): Type;
 
 	public function popArray(): Type;
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type;
+
 	public function searchArray(Type $needleType): Type;
 
 	public function shiftArray(): Type;
diff --git a/src/Type/UnionType.php b/src/Type/UnionType.php
@@ -721,6 +721,11 @@ public function popArray(): Type
 		return $this->unionTypes(static fn (Type $type): Type => $type->popArray());
 	}
 
+	public function reverseArray(TrinaryLogic $preserveKeys): Type
+	{
+		return $this->unionTypes(static fn (Type $type): Type => $type->reverseArray($preserveKeys));
+	}
+
 	public function searchArray(Type $needleType): Type
 	{
 		return $this->unionTypes(static fn (Type $type): Type => $type->searchArray($needleType));
diff --git a/tests/PHPStan/Analyser/nsrt/array-reverse-php7.php b/tests/PHPStan/Analyser/nsrt/array-reverse-php7.php
@@ -0,0 +1,16 @@
+<?php // lint < 8.0
+
+declare(strict_types = 1);
+
+namespace ArrayReversePhp7;
+
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+	public function notArray(bool $bool): void
+	{
+		assertType('null', array_reverse($bool));
+		assertType('null', array_reverse($bool, true));
+	}
+}
diff --git a/tests/PHPStan/Analyser/nsrt/array-reverse-php8.php b/tests/PHPStan/Analyser/nsrt/array-reverse-php8.php
@@ -0,0 +1,16 @@
+<?php // lint >= 8.0
+
+declare(strict_types = 1);
+
+namespace ArrayReversePhp8;
+
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+	public function notArray(bool $bool): void
+	{
+		assertType('*NEVER*', array_reverse($bool));
+		assertType('*NEVER*', array_reverse($bool, true));
+	}
+}
diff --git a/tests/PHPStan/Analyser/nsrt/array-reverse.php b/tests/PHPStan/Analyser/nsrt/array-reverse.php
@@ -46,4 +46,28 @@ public function constantArrays(array $a, array $b): void
 		assertType('array{\'bar\', \'foo\'}|array{bar: 19, foo: 17}', array_reverse($b));
 		assertType('array{19: \'bar\', 17: \'foo\'}|array{bar: 19, foo: 17}', array_reverse($b, true));
 	}
+
+	/**
+	 * @param list<string> $a
+	 * @param non-empty-list<string> $b
+	 */
+	public function list(array $a, array $b): void
+	{
+		assertType('list<string>', array_reverse($a));
+		assertType('array<int<0, max>, string>', array_reverse($a, true));
+
+		assertType('non-empty-list<string>', array_reverse($b));
+		assertType('non-empty-array<int<0, max>, string>', array_reverse($b, true));
+	}
+
+	public function mixed(mixed $mixed): void
+	{
+		assertType('array', array_reverse($mixed));
+		assertType('array', array_reverse($mixed, true));
+
+		if (array_key_exists('foo', $mixed)) {
+			assertType('non-empty-array', array_reverse($mixed));
+			assertType("array&hasOffset('foo')", array_reverse($mixed, true));
+		}
+	}
 }

Original file line number	Diff line number	Diff line change
`@@ -199,6 +199,11 @@ public function popArray(): Type`
`199`	`199`	`return new MixedType();`
`200`	`200`	`}`
`201`	`201`
	`202`	`+ public function reverseArray(TrinaryLogic $preserveKeys): Type`
	`203`	`+ {`
	`204`	`+ return $this;`
	`205`	`+ }`
	`206`	`+`
`202`	`207`	`public function searchArray(Type $needleType): Type`
`203`	`208`	`{`
`204`	`209`	`return new MixedType();`
Original file line number	Diff line number	Diff line change
`@@ -195,6 +195,11 @@ public function popArray(): Type`
`195`	`195`	`return $this;`
`196`	`196`	`}`
`197`	`197`
	`198`	`+ public function reverseArray(TrinaryLogic $preserveKeys): Type`
	`199`	`+ {`
	`200`	`+ return $this;`
	`201`	`+ }`
	`202`	`+`
`198`	`203`	`public function searchArray(Type $needleType): Type`
`199`	`204`	`{`
`200`	`205`	`return new MixedType();`
Original file line number	Diff line number	Diff line change
`@@ -552,6 +552,11 @@ public function popArray(): Type`
`552`	`552`	`return $this;`
`553`	`553`	`}`
`554`	`554`
	`555`	`+ public function reverseArray(TrinaryLogic $preserveKeys): Type`
	`556`	`+ {`
	`557`	`+ return $this;`
	`558`	`+ }`
	`559`	`+`
`555`	`560`	`public function searchArray(Type $needleType): Type`
`556`	`561`	`{`
`557`	`562`	`return TypeCombinator::union($this->getIterableKeyType(), new ConstantBooleanType(false));`
Original file line number	Diff line number	Diff line change
`@@ -744,6 +744,11 @@ public function popArray(): Type`
`744`	`744`	`return $this->intersectTypes(static fn (Type $type): Type => $type->popArray());`
`745`	`745`	`}`
`746`	`746`
	`747`	`+ public function reverseArray(TrinaryLogic $preserveKeys): Type`
	`748`	`+ {`
	`749`	`+ return $this->intersectTypes(static fn (Type $type): Type => $type->reverseArray($preserveKeys));`
	`750`	`+ }`
	`751`	`+`
`747`	`752`	`public function searchArray(Type $needleType): Type`
`748`	`753`	`{`
`749`	`754`	`return $this->intersectTypes(static fn (Type $type): Type => $type->searchArray($needleType));`
Original file line number	Diff line number	Diff line change
`@@ -316,6 +316,11 @@ public function popArray(): Type`
`316`	`316`	`return new NeverType();`
`317`	`317`	`}`
`318`	`318`
	`319`	`+ public function reverseArray(TrinaryLogic $preserveKeys): Type`
	`320`	`+ {`
	`321`	`+ return new NeverType();`
	`322`	`+ }`
	`323`	`+`
`319`	`324`	`public function searchArray(Type $needleType): Type`
`320`	`325`	`{`
`321`	`326`	`return new NeverType();`