phpstan · ondrejmirtes · Oct 5, 2022 · Sep 1, 2022
diff --git a/src/Analyser/NodeScopeResolver.php b/src/Analyser/NodeScopeResolver.php
@@ -1893,7 +1893,7 @@ function (MutatingScope $scope) use ($expr, $nodeCallback, $context): Expression
 					}
 				};
 
-				$constantArrays = TypeUtils::getOldConstantArrays($arrayType);
+				$constantArrays = $arrayType->getConstantArrays();
 				if (count($constantArrays) > 0) {
 					$newArrayTypes = [];
 					$prepend = $functionReflection->getName() === 'array_unshift';

diff --git a/src/Reflection/InitializerExprTypeResolver.php b/src/Reflection/InitializerExprTypeResolver.php
@@ -907,8 +907,8 @@ public function getPlusType(Expr $left, Expr $right, callable $getTypeCallback):
 			return TypeCombinator::union(...$resultTypes);
 		}
 
-		$leftConstantArrays = TypeUtils::getOldConstantArrays($leftType);
-		$rightConstantArrays = TypeUtils::getOldConstantArrays($rightType);
+		$leftConstantArrays = $leftType->getConstantArrays();
+		$rightConstantArrays = $rightType->getConstantArrays();
 
 		$leftCount = count($leftConstantArrays);
 		$rightCount = count($rightConstantArrays);

diff --git a/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchCheck.php b/src/Rules/Arrays/NonexistentOffsetInArrayDimFetchCheck.php
@@ -48,7 +48,7 @@ public function check(
 		$hasOffsetValueType = $type->hasOffsetValueType($dimType);
 		$report = $hasOffsetValueType->no();
 		if ($hasOffsetValueType->maybe()) {
-			$constantArrays = TypeUtils::getOldConstantArrays($type);
+			$constantArrays = $type->getConstantArrays();
 			if (count($constantArrays) > 0) {
 				foreach ($constantArrays as $constantArray) {
 					if ($constantArray->hasOffsetValueType($dimType)->no()) {

diff --git a/src/Rules/Comparison/ImpossibleCheckTypeHelper.php b/src/Rules/Comparison/ImpossibleCheckTypeHelper.php
@@ -87,7 +87,7 @@ public function findSpecifiedType(
 						return null;
 					}
 
-					$constantArrays = TypeUtils::getOldConstantArrays($haystackType);
+					$constantArrays = $haystackType->getConstantArrays();
 					$needleType = $scope->getType($node->getArgs()[0]->value);
 					$valueType = $haystackType->getIterableValueType();
 					$constantNeedleTypesCount = count(TypeUtils::getConstantScalars($needleType));

diff --git a/src/Rules/FunctionCallParametersCheck.php b/src/Rules/FunctionCallParametersCheck.php
@@ -100,7 +100,7 @@ public function check(
 				$argumentName = $arg->name->toString();
 			}
 			if ($arg->unpack) {
-				$arrays = TypeUtils::getOldConstantArrays($type);
+				$arrays = $type->getConstantArrays();
 				if (count($arrays) > 0) {
 					$minKeys = null;
 					foreach ($arrays as $array) {

diff --git a/src/Rules/Regexp/RegularExpressionPatternRule.php b/src/Rules/Regexp/RegularExpressionPatternRule.php
@@ -83,7 +83,7 @@ private function extractPatterns(FuncCall $functionCall, Scope $scope): array
 			$patternStrings[] = $constantStringType->getValue();
 		}
 
-		foreach (TypeUtils::getOldConstantArrays($patternType) as $constantArrayType) {
+		foreach ($patternType->getConstantArrays() as $constantArrayType) {
 			if (
 				in_array($functionName, [
 					'preg_replace',

diff --git a/src/Rules/RuleLevelHelper.php b/src/Rules/RuleLevelHelper.php
@@ -111,8 +111,8 @@ public function accepts(Type $acceptingType, Type $acceptedType, bool $strictTyp
 			$acceptedType->isArray()->yes()
 			&& $acceptingType->isArray()->yes()
 			&& !$acceptingType->isIterableAtLeastOnce()->yes()
-			&& count(TypeUtils::getOldConstantArrays($acceptedType)) === 0
-			&& count(TypeUtils::getOldConstantArrays($acceptingType)) === 0
+			&& count($acceptedType->getConstantArrays()) === 0
+			&& count($acceptingType->getConstantArrays()) === 0
 		) {
 			return self::accepts(
 				$acceptingType->getIterableKeyType(),

diff --git a/src/Type/Accessory/AccessoryArrayListType.php b/src/Type/Accessory/AccessoryArrayListType.php
@@ -44,6 +44,11 @@ public function getReferencedClasses(): array
 		return [];
 	}
 
+	public function getConstantArrays(): array
+	{
+		return [];
+	}
+
 	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
 	{
 		if ($type instanceof CompoundType) {

diff --git a/src/Type/Accessory/NonEmptyArrayType.php b/src/Type/Accessory/NonEmptyArrayType.php
@@ -41,6 +41,11 @@ public function getReferencedClasses(): array
 		return [];
 	}
 
+	public function getConstantArrays(): array
+	{
+		return [];
+	}
+
 	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
 	{
 		if ($type instanceof CompoundType) {

diff --git a/src/Type/Accessory/OversizedArrayType.php b/src/Type/Accessory/OversizedArrayType.php
@@ -40,6 +40,11 @@ public function getReferencedClasses(): array
 		return [];
 	}
 
+	public function getConstantArrays(): array
+	{
+		return [];
+	}
+
 	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
 	{
 		if ($type instanceof CompoundType) {

diff --git a/src/Type/ArrayType.php b/src/Type/ArrayType.php
@@ -73,6 +73,11 @@ public function getReferencedClasses(): array
 		);
 	}
 
+	public function getConstantArrays(): array
+	{
+		return [];
+	}
+
 	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
 	{
 		if ($type instanceof CompoundType) {

diff --git a/src/Type/Constant/ConstantArrayType.php b/src/Type/Constant/ConstantArrayType.php
@@ -108,6 +108,11 @@ public function __construct(
 		);
 	}
 
+	public function getConstantArrays(): array
+	{
+		return [$this];
+	}
+
 	public function isEmpty(): bool
 	{
 		return count($this->keyTypes) === 0;

diff --git a/src/Type/IntersectionType.php b/src/Type/IntersectionType.php
@@ -100,6 +100,11 @@ public function getReferencedClasses(): array
 		return UnionTypeHelper::getReferencedClasses($this->types);
 	}
 
+	public function getConstantArrays(): array
+	{
+		return UnionTypeHelper::getConstantArrays($this->getTypes());
+	}
+
 	public function accepts(Type $otherType, bool $strictTypes): TrinaryLogic
 	{
 		foreach ($this->types as $type) {

diff --git a/src/Type/MixedType.php b/src/Type/MixedType.php
@@ -63,6 +63,11 @@ public function getReferencedClasses(): array
 		return [];
 	}
 
+	public function getConstantArrays(): array
+	{
+		return [];
+	}
+
 	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
 	{
 		return TrinaryLogic::createYes();

diff --git a/src/Type/Php/ArrayColumnFunctionReturnTypeExtension.php b/src/Type/Php/ArrayColumnFunctionReturnTypeExtension.php
@@ -47,7 +47,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		$columnType = $scope->getType($functionCall->getArgs()[1]->value);
 		$indexType = $numArgs >= 3 ? $scope->getType($functionCall->getArgs()[2]->value) : null;
 
-		$constantArrayTypes = TypeUtils::getOldConstantArrays($arrayType);
+		$constantArrayTypes = $arrayType->getConstantArrays();
 		if (count($constantArrayTypes) === 1) {
 			$type = $this->handleConstantArray($constantArrayTypes[0], $columnType, $indexType, $scope);
 			if ($type !== null) {

diff --git a/src/Type/Php/ArrayFillKeysFunctionReturnTypeExtension.php b/src/Type/Php/ArrayFillKeysFunctionReturnTypeExtension.php
@@ -14,7 +14,6 @@
 use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 
 class ArrayFillKeysFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -33,7 +32,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 
 		$valueType = $scope->getType($functionCall->getArgs()[1]->value);
 		$keysType = $scope->getType($functionCall->getArgs()[0]->value);
-		$constantArrays = TypeUtils::getOldConstantArrays($keysType);
+		$constantArrays = $keysType->getConstantArrays();
 		if (count($constantArrays) === 0) {
 			if ($keysType->isArray()->yes()) {
 				$itemType = $keysType->getIterableValueType();

diff --git a/src/Type/Php/ArrayFilterFunctionReturnTypeReturnTypeExtension.php b/src/Type/Php/ArrayFilterFunctionReturnTypeReturnTypeExtension.php
@@ -164,7 +164,7 @@ private function filterByTruthyValue(Scope $scope, Error|Variable|null $itemVar,
 			throw new ShouldNotHappenException();
 		}
 
-		$constantArrays = TypeUtils::getOldConstantArrays($arrayType);
+		$constantArrays = $arrayType->getConstantArrays();
 		if (count($constantArrays) > 0) {
 			$results = [];
 			foreach ($constantArrays as $constantArray) {

diff --git a/src/Type/Php/ArrayFlipFunctionReturnTypeExtension.php b/src/Type/Php/ArrayFlipFunctionReturnTypeExtension.php
@@ -12,7 +12,6 @@
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 
 class ArrayFlipFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -32,7 +31,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		$array = $functionCall->getArgs()[0]->value;
 		$argType = $scope->getType($array);
 
-		$constantArrays = TypeUtils::getOldConstantArrays($argType);
+		$constantArrays = $argType->getConstantArrays();
 		if (count($constantArrays) > 0) {
 			$flipped = [];
 			foreach ($constantArrays as $constantArray) {

diff --git a/src/Type/Php/ArrayIntersectKeyFunctionReturnTypeExtension.php b/src/Type/Php/ArrayIntersectKeyFunctionReturnTypeExtension.php
@@ -11,7 +11,6 @@
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function array_slice;
 use function count;
 
@@ -47,7 +46,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			return $firstArray;
 		}
 
-		$constantArrays = TypeUtils::getOldConstantArrays($firstArray);
+		$constantArrays = $firstArray->getConstantArrays();
 		if (count($constantArrays) === 0) {
 			return new ArrayType($firstArray->getIterableKeyType(), $firstArray->getIterableValueType());
 		}

diff --git a/src/Type/Php/ArrayKeyFirstDynamicReturnTypeExtension.php b/src/Type/Php/ArrayKeyFirstDynamicReturnTypeExtension.php
@@ -11,7 +11,6 @@
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 
 class ArrayKeyFirstDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -34,7 +33,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			return new NullType();
 		}
 
-		$constantArrays = TypeUtils::getOldConstantArrays($argType);
+		$constantArrays = $argType->getConstantArrays();
 		if (count($constantArrays) > 0) {
 			$keyTypes = [];
 			foreach ($constantArrays as $constantArray) {

diff --git a/src/Type/Php/ArrayKeyLastDynamicReturnTypeExtension.php b/src/Type/Php/ArrayKeyLastDynamicReturnTypeExtension.php
@@ -10,7 +10,6 @@
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 
 class ArrayKeyLastDynamicReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -33,7 +32,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			return new NullType();
 		}
 
-		$constantArrays = TypeUtils::getOldConstantArrays($argType);
+		$constantArrays = $argType->getConstantArrays();
 		if (count($constantArrays) > 0) {
 			$keyTypes = [];
 			foreach ($constantArrays as $constantArray) {

diff --git a/src/Type/Php/ArrayMapFunctionReturnTypeExtension.php b/src/Type/Php/ArrayMapFunctionReturnTypeExtension.php
@@ -63,7 +63,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			if ($callableIsNull) {
 				return $arrayType;
 			}
-			$constantArrays = TypeUtils::getOldConstantArrays($arrayType);
+			$constantArrays = $arrayType->getConstantArrays();
 			if (count($constantArrays) > 0) {
 				$arrayTypes = [];
 				foreach ($constantArrays as $constantArray) {

diff --git a/src/Type/Php/ArrayPointerFunctionsDynamicReturnTypeExtension.php b/src/Type/Php/ArrayPointerFunctionsDynamicReturnTypeExtension.php
@@ -10,7 +10,6 @@
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 use function in_array;
 
@@ -44,7 +43,7 @@ public function getTypeFromFunctionCall(
 			return new ConstantBooleanType(false);
 		}
 
-		$constantArrays = TypeUtils::getOldConstantArrays($argType);
+		$constantArrays = $argType->getConstantArrays();
 		if (count($constantArrays) > 0) {
 			$keyTypes = [];
 			foreach ($constantArrays as $constantArray) {

diff --git a/src/Type/Php/ArrayPopFunctionReturnTypeExtension.php b/src/Type/Php/ArrayPopFunctionReturnTypeExtension.php
@@ -10,7 +10,6 @@
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 
 class ArrayPopFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -33,7 +32,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			return new NullType();
 		}
 
-		$constantArrays = TypeUtils::getOldConstantArrays($argType);
+		$constantArrays = $argType->getConstantArrays();
 		if (count($constantArrays) > 0) {
 			$valueTypes = [];
 			foreach ($constantArrays as $constantArray) {

diff --git a/src/Type/Php/ArrayReduceFunctionReturnTypeExtension.php b/src/Type/Php/ArrayReduceFunctionReturnTypeExtension.php
@@ -11,7 +11,6 @@
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 
 class ArrayReduceFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -46,7 +45,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		}
 
 		$arraysType = $scope->getType($functionCall->getArgs()[0]->value);
-		$constantArrays = TypeUtils::getOldConstantArrays($arraysType);
+		$constantArrays = $arraysType->getConstantArrays();
 		if (count($constantArrays) > 0) {
 			$onlyEmpty = TrinaryLogic::createYes();
 			$onlyNonEmpty = TrinaryLogic::createYes();

diff --git a/src/Type/Php/ArrayShiftFunctionReturnTypeExtension.php b/src/Type/Php/ArrayShiftFunctionReturnTypeExtension.php
@@ -10,7 +10,6 @@
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 
 class ArrayShiftFunctionReturnTypeExtension implements DynamicFunctionReturnTypeExtension
@@ -33,7 +32,7 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			return new NullType();
 		}
 
-		$constantArrays = TypeUtils::getOldConstantArrays($argType);
+		$constantArrays = $argType->getConstantArrays();
 		if (count($constantArrays) > 0) {
 			$valueTypes = [];
 			foreach ($constantArrays as $constantArray) {

diff --git a/src/Type/Php/CountFunctionReturnTypeExtension.php b/src/Type/Php/CountFunctionReturnTypeExtension.php
@@ -11,7 +11,6 @@
 use PHPStan\Type\IntegerRangeType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
 use function count;
 use function in_array;
 use const COUNT_RECURSIVE;
@@ -42,7 +41,7 @@ public function getTypeFromFunctionCall(
 		}
 
 		$argType = $scope->getType($functionCall->getArgs()[0]->value);
-		$constantArrays = TypeUtils::getOldConstantArrays($scope->getType($functionCall->getArgs()[0]->value));
+		$constantArrays = $scope->getType($functionCall->getArgs()[0]->value)->getConstantArrays();
 		if (count($constantArrays) === 0) {
 			if ($argType->isIterableAtLeastOnce()->yes()) {
 				return IntegerRangeType::fromInterval(1, null);

diff --git a/src/Type/StaticType.php b/src/Type/StaticType.php
@@ -104,6 +104,11 @@ public function getReferencedClasses(): array
 		return $this->getStaticObjectType()->getReferencedClasses();
 	}
 
+	public function getConstantArrays(): array
+	{
+		return $this->getStaticObjectType()->getConstantArrays();
+	}
+
 	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
 	{
 		if ($type instanceof CompoundType) {

diff --git a/src/Type/Traits/LateResolvableTypeTrait.php b/src/Type/Traits/LateResolvableTypeTrait.php
@@ -21,6 +21,11 @@ trait LateResolvableTypeTrait
 
 	private ?Type $result = null;
 
+	public function getConstantArrays(): array
+	{
+		return $this->resolve()->getConstantArrays();
+	}
+
 	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
 	{
 		return $this->resolve()->accepts($type, $strictTypes);

diff --git a/src/Type/Traits/MaybeArrayTypeTrait.php b/src/Type/Traits/MaybeArrayTypeTrait.php
@@ -7,6 +7,11 @@
 trait MaybeArrayTypeTrait
 {
 
+	public function getConstantArrays(): array
+	{
+		return [];
+	}
+
 	public function isArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createMaybe();

diff --git a/src/Type/Traits/NonArrayTypeTrait.php b/src/Type/Traits/NonArrayTypeTrait.php
@@ -7,6 +7,11 @@
 trait NonArrayTypeTrait
 {
 
+	public function getConstantArrays(): array
+	{
+		return [];
+	}
+
 	public function isArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createNo();