Add Type::isConstantArray()

src/Analyser/MutatingScope.php

@@ -75,7 +75,6 @@
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\BooleanType;
 use PHPStan\Type\ClosureType;
-use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\Constant\ConstantFloatType;
@@ -4619,7 +4618,7 @@ private static function generalizeType(Type $a, Type $b): Type
 					$constantStrings[$key][] = $type;
 					continue;
 				}
-				if ($type instanceof ConstantArrayType) {
+				if ($type->isConstantArray()->yes()) {
 					$constantArrays[$key][] = $type;
 					continue;
 				}
@@ -4713,9 +4712,9 @@ private static function generalizeType(Type $a, Type $b): Type
 				$bArrays = $bValueType->getArrays();
 				if (
 					count($aArrays) === 1
-					&& !$aArrays[0] instanceof ConstantArrayType
+					&& $aArrays[0]->isConstantArray()->no()
 					&& count($bArrays) === 1
-					&& !$bArrays[0] instanceof ConstantArrayType
+					&& $bArrays[0]->isConstantArray()->no()
 				) {
 					$aDepth = self::getArrayDepth($aArrays[0]);
 					$bDepth = self::getArrayDepth($bArrays[0]);

src/Reflection/Php/PhpClassReflectionExtension.php

@@ -35,7 +35,6 @@
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\ArrayType;
-use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\Enum\EnumCaseObjectType;
@@ -946,7 +945,7 @@ private function inferAndCachePropertyTypes(
 			}
 
 			$propertyType = $propertyType->generalize(GeneralizePrecision::lessSpecific());
-			if ($propertyType instanceof ConstantArrayType) {
+			if ($propertyType->isConstantArray()->yes()) {
 				$propertyType = new ArrayType(new MixedType(true), new MixedType(true));
 			}
 

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($acceptedType->getConstantArrays()) === 0
-			&& count($acceptingType->getConstantArrays()) === 0
+			&& $acceptedType->isConstantArray()->no()
+			&& $acceptingType->isConstantArray()->no()
 		) {
 			return self::accepts(
 				$acceptingType->getIterableKeyType(),

src/Type/Accessory/AccessoryArrayListType.php

@@ -182,6 +182,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createMaybe();

src/Type/Accessory/NonEmptyArrayType.php

@@ -171,6 +171,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createMaybe();

src/Type/Accessory/OversizedArrayType.php

@@ -170,6 +170,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createYes();

src/Type/ArrayType.php

@@ -126,8 +126,8 @@ public function isSuperTypeOf(Type $type): TrinaryLogic
 	public function equals(Type $type): bool
 	{
 		return $type instanceof self
-			&& !$type instanceof ConstantArrayType
-			&& $this->getItemType()->equals($type->getItemType())
+			&& $type->isConstantArray()->no()
+			&& $this->getItemType()->equals($type->getIterableValueType())
 			&& $this->keyType->equals($type->keyType);
 	}
 
@@ -238,6 +238,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createMaybe();
@@ -509,19 +514,19 @@ public function traverse(callable $cb): Type
 
 	public function tryRemove(Type $typeToRemove): ?Type
 	{
-		if ($typeToRemove instanceof ConstantArrayType && $typeToRemove->isIterableAtLeastOnce()->no()) {
+		if ($typeToRemove->isConstantArray()->yes() && $typeToRemove->isIterableAtLeastOnce()->no()) {
 			return TypeCombinator::intersect($this, new NonEmptyArrayType());
 		}
 
 		if ($typeToRemove instanceof NonEmptyArrayType) {
 			return new ConstantArrayType([], []);
 		}
 
-		if ($this instanceof ConstantArrayType && $typeToRemove instanceof HasOffsetType) {
+		if ($this->isConstantArray()->yes() && $typeToRemove instanceof HasOffsetType) {
 			return $this->unsetOffset($typeToRemove->getOffsetType());
 		}
 
-		if ($this instanceof ConstantArrayType && $typeToRemove instanceof HasOffsetValueType) {
+		if ($this->isConstantArray()->yes() && $typeToRemove instanceof HasOffsetValueType) {
 			return $this->unsetOffset($typeToRemove->getOffsetType());
 		}
 

src/Type/Constant/ConstantArrayType.php

@@ -736,6 +736,11 @@ public function getLastIterableValueType(): Type
 		return TypeCombinator::union(...$valueTypes);
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createYes();
+	}
+
 	public function isList(): TrinaryLogic
 	{
 		if ($this->isList) {

src/Type/IntersectionType.php

@@ -441,6 +441,11 @@ public function isArray(): TrinaryLogic
 		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isArray());
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isConstantArray());
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isOversizedArray());

src/Type/MixedType.php

@@ -470,6 +470,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return $this->isArray();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		if ($this->subtractedType !== null) {

src/Type/Php/IsCallableFunctionTypeSpecifyingExtension.php

@@ -14,7 +14,6 @@
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\ShouldNotHappenException;
 use PHPStan\Type\CallableType;
-use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
 use function count;
 use function strtolower;
@@ -49,7 +48,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 		if (
 			$value instanceof Array_
 			&& count($value->items) === 2
-			&& $valueType instanceof ConstantArrayType
+			&& $valueType->isConstantArray()->yes()
 			&& !$valueType->isCallable()->no()
 		) {
 			if ($value->items[0] === null || $value->items[1] === null) {

src/Type/Php/MinMaxFunctionReturnTypeExtension.php

@@ -161,15 +161,15 @@ private function compareTypes(
 	): ?Type
 	{
 		if (
-			$firstType instanceof ConstantArrayType
+			$firstType->isConstantArray()->yes()
 			&& $secondType instanceof ConstantScalarType
 		) {
 			return $secondType;
 		}
 
 		if (
 			$firstType instanceof ConstantScalarType
-			&& $secondType instanceof ConstantArrayType
+			&& $secondType->isConstantArray()->yes()
 		) {
 			return $firstType;
 		}

src/Type/StaticType.php

@@ -362,6 +362,11 @@ public function isArray(): TrinaryLogic
 		return $this->getStaticObjectType()->isArray();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return $this->getStaticObjectType()->isConstantArray();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return $this->getStaticObjectType()->isOversizedArray();

src/Type/Traits/LateResolvableTypeTrait.php

@@ -160,6 +160,11 @@ public function isArray(): TrinaryLogic
 		return $this->resolve()->isArray();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return $this->resolve()->isConstantArray();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return $this->resolve()->isOversizedArray();

src/Type/Traits/MaybeArrayTypeTrait.php

@@ -44,6 +44,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createMaybe();

src/Type/Traits/NonArrayTypeTrait.php

@@ -44,6 +44,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createNo();

src/Type/Type.php

@@ -78,6 +78,8 @@ public function getLastIterableValueType(): Type;
 
 	public function isArray(): TrinaryLogic;
 
+	public function isConstantArray(): TrinaryLogic;
+
 	public function isOversizedArray(): TrinaryLogic;
 
 	public function isList(): TrinaryLogic;

src/Type/UnionType.php

@@ -455,6 +455,11 @@ public function isArray(): TrinaryLogic
 		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $type->isArray());
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $type->isConstantArray());
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return $this->notBenevolentUnionResults(static fn (Type $type): TrinaryLogic => $type->isOversizedArray());

tests/PHPStan/Type/MixedTypeTest.php

@@ -240,6 +240,80 @@ public function testSubstractedIsArray(MixedType $mixedType, Type $typeToSubtrac
 		);
 	}
 
+	public function dataSubstractedIsConstantArray(): array
+	{
+		return [
+			[
+				new MixedType(),
+				new ArrayType(new IntegerType(), new StringType()),
+				TrinaryLogic::createMaybe(),
+			],
+			[
+				new MixedType(),
+				new ArrayType(new StringType(), new StringType()),
+				TrinaryLogic::createMaybe(),
+			],
+			[
+				new MixedType(),
+				new ArrayType(new MixedType(), new MixedType()),
+				TrinaryLogic::createNo(),
+			],
+			[
+				new MixedType(),
+				new ConstantArrayType(
+					[new ConstantIntegerType(1)],
+					[new ConstantStringType('hello')],
+				),
+				TrinaryLogic::createMaybe(),
+			],
+			[
+				new MixedType(),
+				new ConstantArrayType([], []),
+				TrinaryLogic::createMaybe(),
+			],
+			[
+				new MixedType(),
+				new UnionType([new FloatType(), new ArrayType(new MixedType(), new MixedType())]),
+				TrinaryLogic::createNo(),
+			],
+			[
+				new MixedType(),
+				new UnionType([new FloatType(), new ArrayType(new StringType(), new MixedType())]),
+				TrinaryLogic::createMaybe(),
+			],
+			[
+				new MixedType(),
+				new UnionType([new FloatType(), new IntegerType()]),
+				TrinaryLogic::createMaybe(),
+			],
+			[
+				new MixedType(),
+				new FloatType(),
+				TrinaryLogic::createMaybe(),
+			],
+			[
+				new MixedType(true),
+				new FloatType(),
+				TrinaryLogic::createMaybe(),
+			],
+		];
+	}
+
+	/**
+	 * @dataProvider dataSubstractedIsConstantArray
+	 */
+	public function testSubstractedIsConstantArray(MixedType $mixedType, Type $typeToSubtract, TrinaryLogic $expectedResult): void
+	{
+		$subtracted = $mixedType->subtract($typeToSubtract);
+		$actualResult = $subtracted->isConstantArray();
+
+		$this->assertSame(
+			$expectedResult->describe(),
+			$actualResult->describe(),
+			sprintf('%s -> isConstantArray()', $subtracted->describe(VerbosityLevel::precise())),
+		);
+	}
+
 	public function dataSubstractedIsString(): array
 	{
 		return [