Extract Type::sortArray() for sort / rsort / usort

Replaces `FuncCallHandler::getArraySortPreserveListFunctionType()`'s
hand-rolled `TypeTraverser::map` callback with a polymorphic `Type`
method. The call site shrinks to `$type->sortArray()`.

The semantics — values reordered, array re-indexed as a list — are
similar to `shuffleArray()` but differ in two ways that ruled out
direct reuse:

- Empty arrays stay empty (`array{}` does not degrade to
  `list<never>`). The check moves into `ArrayTypeTrait::sortArray()`
  via `isIterableAtLeastOnce()->no()`, so per-leaf decisions also
  preserve emptiness inside unions (precision improvement vs. the
  closure-captured outer flag in the original).
- Non-array leaves pass through unchanged (rather than
  `ErrorType` like `shuffleArray()`), because `sort($x)` where `$x`
  is a `mixed` / template / non-array variable should not erase the
  variable's type — the arg-type rule is responsible for the
  diagnostic.

Implementation:

- `ArrayTypeTrait::sortArray()`: shared body for `ArrayType` and
  `ConstantArrayType`. Returns the input unchanged if
  `isIterableAtLeastOnce()->no()`; otherwise builds
  `IntersectionType[ArrayType<int<0,max>, valueType>,
  AccessoryArrayListType]`, intersected with `NonEmptyArrayType`
  when the leaf's own `isIterableAtLeastOnce()` is `Yes`.
- `NonArrayTypeTrait`, `MaybeArrayTypeTrait`, `MixedType`,
  `StrictMixedType`, `StaticType`, `NeverType`, and the array
  accessory types (`AccessoryArrayListType`, `NonEmptyArrayType`,
  `OversizedArrayType`, `HasOffsetType`, `HasOffsetValueType`):
  return `$this`.
- `UnionType` / `IntersectionType`: distribute via `unionTypes` /
  `intersectTypes`.
- `LateResolvableTypeTrait`: delegates to `resolve()`.

Pure refactor: full test suite + phpstan + cs pass.

Author: ondrejmirtes

src/Analyser/ExprHandler/FuncCallHandler.php

@@ -60,7 +60,6 @@
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeTraverser;
 use PHPStan\Type\UnionType;
 use Throwable;
 use function array_filter;
@@ -462,7 +461,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 				$storage,
 				$stmt,
 				$arrayArg,
-				new NativeTypeExpr($this->getArraySortPreserveListFunctionType($scope->getType($arrayArg)), $this->getArraySortPreserveListFunctionType($scope->getNativeType($arrayArg))),
+				new NativeTypeExpr($scope->getType($arrayArg)->sortArray(), $scope->getNativeType($arrayArg)->sortArray()),
 				$nodeCallback,
 			)->getScope();
 		}
@@ -722,31 +721,6 @@ static function (?Type $offsetType, Type $valueType, bool $optional) use (&$arra
 		return $arrayType;
 	}
 
-	private function getArraySortPreserveListFunctionType(Type $type): Type
-	{
-		$isIterableAtLeastOnce = $type->isIterableAtLeastOnce();
-		if ($isIterableAtLeastOnce->no()) {
-			return $type;
-		}
-
-		return TypeTraverser::map($type, static function (Type $type, callable $traverse) use ($isIterableAtLeastOnce): Type {
-			if ($type instanceof UnionType || $type instanceof IntersectionType) {
-				return $traverse($type);
-			}
-
-			if (!$type instanceof ArrayType && !$type instanceof ConstantArrayType) {
-				return $type;
-			}
-
-			$newArrayType = new IntersectionType([new ArrayType(IntegerRangeType::createAllGreaterThanOrEqualTo(0), $type->getIterableValueType()), new AccessoryArrayListType()]);
-			if ($isIterableAtLeastOnce->yes()) {
-				$newArrayType = TypeCombinator::intersect($newArrayType, new NonEmptyArrayType());
-			}
-
-			return $newArrayType;
-		});
-	}
-
 	private function getArraySortDoNotPreserveListFunctionType(Type $type): Type
 	{
 		return $type->makeListMaybe();

src/Type/Accessory/AccessoryArrayListType.php

@@ -242,6 +242,11 @@ public function shuffleArray(): Type
 		return $this;
 	}
 
+	public function sortArray(): Type
+	{
+		return $this;
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		if ($preserveKeys->no()) {

src/Type/Accessory/HasOffsetType.php

@@ -202,6 +202,11 @@ public function shuffleArray(): Type
 		return new NonEmptyArrayType();
 	}
 
+	public function sortArray(): Type
+	{
+		return $this;
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		if (

src/Type/Accessory/HasOffsetValueType.php

@@ -291,6 +291,11 @@ public function shuffleArray(): Type
 		return new NonEmptyArrayType();
 	}
 
+	public function sortArray(): Type
+	{
+		return $this;
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		if (

src/Type/Accessory/NonEmptyArrayType.php

@@ -226,6 +226,11 @@ public function shuffleArray(): Type
 		return $this;
 	}
 
+	public function sortArray(): Type
+	{
+		return $this;
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		if ((new ConstantIntegerType(0))->isSuperTypeOf($offsetType)->yes() && $lengthType->isNull()->yes()) {

src/Type/Accessory/OversizedArrayType.php

@@ -214,6 +214,11 @@ public function shuffleArray(): Type
 		return $this;
 	}
 
+	public function sortArray(): Type
+	{
+		return $this;
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		return $this;

src/Type/IntersectionType.php

@@ -1164,6 +1164,11 @@ public function shuffleArray(): Type
 		return $this->intersectTypes(static fn (Type $type): Type => $type->shuffleArray());
 	}
 
+	public function sortArray(): Type
+	{
+		return $this->intersectTypes(static fn (Type $type): Type => $type->sortArray());
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		$result = $this->intersectTypes(static fn (Type $type): Type => $type->sliceArray($offsetType, $lengthType, $preserveKeys));

src/Type/MixedType.php

@@ -288,6 +288,11 @@ public function shuffleArray(): Type
 		return new IntersectionType([new ArrayType(IntegerRangeType::createAllGreaterThanOrEqualTo(0), new MixedType($this->isExplicitMixed)), new AccessoryArrayListType()]);
 	}
 
+	public function sortArray(): Type
+	{
+		return $this;
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		if ($this->isArray()->no()) {

src/Type/NeverType.php

@@ -375,6 +375,11 @@ public function shuffleArray(): Type
 		return new NeverType();
 	}
 
+	public function sortArray(): Type
+	{
+		return $this;
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		return new NeverType();

src/Type/StaticType.php

@@ -550,6 +550,11 @@ public function shuffleArray(): Type
 		return $this->getStaticObjectType()->shuffleArray();
 	}
 
+	public function sortArray(): Type
+	{
+		return $this;
+	}
+
 	public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type
 	{
 		return $this->getStaticObjectType()->sliceArray($offsetType, $lengthType, $preserveKeys);