Add Type::isConstantArray()

herndlm · ondrejmirtes · commit 788bd0bc51e4 · 2022-10-12T21:34:38.000+02:00
diff --git a/src/Analyser/MutatingScope.php b/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]);
diff --git a/src/Reflection/Php/PhpClassReflectionExtension.php b/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));
 			}
 
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($acceptedType->getConstantArrays()) === 0
-			&& count($acceptingType->getConstantArrays()) === 0
+			&& $acceptedType->isConstantArray()->no()
+			&& $acceptingType->isConstantArray()->no()
 		) {
 			return self::accepts(
 				$acceptingType->getIterableKeyType(),
diff --git a/src/Type/Accessory/AccessoryArrayListType.php b/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();
diff --git a/src/Type/Accessory/NonEmptyArrayType.php b/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();
diff --git a/src/Type/Accessory/OversizedArrayType.php b/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();
diff --git a/src/Type/ArrayType.php b/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());
 		}
 
diff --git a/src/Type/Constant/ConstantArrayType.php b/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) {
diff --git a/src/Type/IntersectionType.php b/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());
diff --git a/src/Type/MixedType.php b/src/Type/MixedType.php
@@ -470,6 +470,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		if ($this->subtractedType !== null) {
diff --git a/src/Type/Php/IsCallableFunctionTypeSpecifyingExtension.php b/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) {
diff --git a/src/Type/Php/MinMaxFunctionReturnTypeExtension.php b/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;
 		}
diff --git a/src/Type/StaticType.php b/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();
diff --git a/src/Type/Traits/LateResolvableTypeTrait.php b/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();
diff --git a/src/Type/Traits/MaybeArrayTypeTrait.php b/src/Type/Traits/MaybeArrayTypeTrait.php
@@ -22,6 +22,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createMaybe();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createMaybe();
diff --git a/src/Type/Traits/NonArrayTypeTrait.php b/src/Type/Traits/NonArrayTypeTrait.php
@@ -22,6 +22,11 @@ public function isArray(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function isConstantArray(): TrinaryLogic
+	{
+		return TrinaryLogic::createNo();
+	}
+
 	public function isOversizedArray(): TrinaryLogic
 	{
 		return TrinaryLogic::createNo();
diff --git a/src/Type/Type.php b/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;
diff --git a/src/Type/UnionType.php b/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());

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,6 @@`
`35`	`35`	`use PHPStan\ShouldNotHappenException;`
`36`	`36`	`use PHPStan\TrinaryLogic;`
`37`	`37`	`use PHPStan\Type\ArrayType;`
`38`		`-use PHPStan\Type\Constant\ConstantArrayType;`
`39`	`38`	`use PHPStan\Type\Constant\ConstantArrayTypeBuilder;`
`40`	`39`	`use PHPStan\Type\Constant\ConstantStringType;`
`41`	`40`	`use PHPStan\Type\Enum\EnumCaseObjectType;`
`@@ -946,7 +945,7 @@ private function inferAndCachePropertyTypes(`
`946`	`945`	`}`
`947`	`946`
`948`	`947`	`$propertyType = $propertyType->generalize(GeneralizePrecision::lessSpecific());`
`949`		`- if ($propertyType instanceof ConstantArrayType) {`
	`948`	`+ if ($propertyType->isConstantArray()->yes()) {`
`950`	`949`	`$propertyType = new ArrayType(new MixedType(true), new MixedType(true));`
`951`	`950`	`}`
`952`	`951`
Original file line number	Diff line number	Diff line change
`@@ -182,6 +182,11 @@ public function isArray(): TrinaryLogic`
`182`	`182`	`return TrinaryLogic::createYes();`
`183`	`183`	`}`
`184`	`184`
	`185`	`+ public function isConstantArray(): TrinaryLogic`
	`186`	`+ {`
	`187`	`+ return TrinaryLogic::createMaybe();`
	`188`	`+ }`
	`189`	`+`
`185`	`190`	`public function isOversizedArray(): TrinaryLogic`
`186`	`191`	`{`
`187`	`192`	`return TrinaryLogic::createMaybe();`
Original file line number	Diff line number	Diff line change
`@@ -171,6 +171,11 @@ public function isArray(): TrinaryLogic`
`171`	`171`	`return TrinaryLogic::createYes();`
`172`	`172`	`}`
`173`	`173`
	`174`	`+ public function isConstantArray(): TrinaryLogic`
	`175`	`+ {`
	`176`	`+ return TrinaryLogic::createMaybe();`
	`177`	`+ }`
	`178`	`+`
`174`	`179`	`public function isOversizedArray(): TrinaryLogic`
`175`	`180`	`{`
`176`	`181`	`return TrinaryLogic::createMaybe();`
Original file line number	Diff line number	Diff line change
`@@ -170,6 +170,11 @@ public function isArray(): TrinaryLogic`
`170`	`170`	`return TrinaryLogic::createYes();`
`171`	`171`	`}`
`172`	`172`
	`173`	`+ public function isConstantArray(): TrinaryLogic`
	`174`	`+ {`
	`175`	`+ return TrinaryLogic::createMaybe();`
	`176`	`+ }`
	`177`	`+`
`173`	`178`	`public function isOversizedArray(): TrinaryLogic`
`174`	`179`	`{`
`175`	`180`	`return TrinaryLogic::createYes();`
Original file line number	Diff line number	Diff line change
`@@ -126,8 +126,8 @@ public function isSuperTypeOf(Type $type): TrinaryLogic`
`126`	`126`	`public function equals(Type $type): bool`
`127`	`127`	`{`
`128`	`128`	`return $type instanceof self`
`129`		`- && !$type instanceof ConstantArrayType`
`130`		`- && $this->getItemType()->equals($type->getItemType())`
	`129`	`+ && $type->isConstantArray()->no()`
	`130`	`+ && $this->getItemType()->equals($type->getIterableValueType())`
`131`	`131`	`&& $this->keyType->equals($type->keyType);`
`132`	`132`	`}`
`133`	`133`
`@@ -238,6 +238,11 @@ public function isArray(): TrinaryLogic`
`238`	`238`	`return TrinaryLogic::createYes();`
`239`	`239`	`}`
`240`	`240`
	`241`	`+ public function isConstantArray(): TrinaryLogic`
	`242`	`+ {`
	`243`	`+ return TrinaryLogic::createNo();`
	`244`	`+ }`
	`245`	`+`
`241`	`246`	`public function isOversizedArray(): TrinaryLogic`
`242`	`247`	`{`
`243`	`248`	`return TrinaryLogic::createMaybe();`
`@@ -509,19 +514,19 @@ public function traverse(callable $cb): Type`
`509`	`514`
`510`	`515`	`public function tryRemove(Type $typeToRemove): ?Type`
`511`	`516`	`{`
`512`		`- if ($typeToRemove instanceof ConstantArrayType && $typeToRemove->isIterableAtLeastOnce()->no()) {`
	`517`	`+ if ($typeToRemove->isConstantArray()->yes() && $typeToRemove->isIterableAtLeastOnce()->no()) {`
`513`	`518`	`return TypeCombinator::intersect($this, new NonEmptyArrayType());`
`514`	`519`	`}`
`515`	`520`
`516`	`521`	`if ($typeToRemove instanceof NonEmptyArrayType) {`
`517`	`522`	`return new ConstantArrayType([], []);`
`518`	`523`	`}`
`519`	`524`
`520`		`- if ($this instanceof ConstantArrayType && $typeToRemove instanceof HasOffsetType) {`
	`525`	`+ if ($this->isConstantArray()->yes() && $typeToRemove instanceof HasOffsetType) {`
`521`	`526`	`return $this->unsetOffset($typeToRemove->getOffsetType());`
`522`	`527`	`}`
`523`	`528`
`524`		`- if ($this instanceof ConstantArrayType && $typeToRemove instanceof HasOffsetValueType) {`
	`529`	`+ if ($this->isConstantArray()->yes() && $typeToRemove instanceof HasOffsetValueType) {`
`525`	`530`	`return $this->unsetOffset($typeToRemove->getOffsetType());`
`526`	`531`	`}`
`527`	`532`
Original file line number	Diff line number	Diff line change
`@@ -736,6 +736,11 @@ public function getLastIterableValueType(): Type`
`736`	`736`	`return TypeCombinator::union(...$valueTypes);`
`737`	`737`	`}`
`738`	`738`
	`739`	`+ public function isConstantArray(): TrinaryLogic`
	`740`	`+ {`
	`741`	`+ return TrinaryLogic::createYes();`
	`742`	`+ }`
	`743`	`+`
`739`	`744`	`public function isList(): TrinaryLogic`
`740`	`745`	`{`
`741`	`746`	`if ($this->isList) {`
Original file line number	Diff line number	Diff line change
`@@ -441,6 +441,11 @@ public function isArray(): TrinaryLogic`
`441`	`441`	`return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isArray());`
`442`	`442`	`}`
`443`	`443`
	`444`	`+ public function isConstantArray(): TrinaryLogic`
	`445`	`+ {`
	`446`	`+ return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isConstantArray());`
	`447`	`+ }`
	`448`	`+`
`444`	`449`	`public function isOversizedArray(): TrinaryLogic`
`445`	`450`	`{`
`446`	`451`	`return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isOversizedArray());`
Original file line number	Diff line number	Diff line change
`@@ -470,6 +470,11 @@ public function isArray(): TrinaryLogic`
`470`	`470`	`return TrinaryLogic::createMaybe();`
`471`	`471`	`}`
`472`	`472`
	`473`	`+ public function isConstantArray(): TrinaryLogic`
	`474`	`+ {`
	`475`	`+ return TrinaryLogic::createMaybe();`
	`476`	`+ }`
	`477`	`+`
`473`	`478`	`public function isOversizedArray(): TrinaryLogic`
`474`	`479`	`{`
`475`	`480`	`if ($this->subtractedType !== null) {`
Original file line number	Diff line number	Diff line change
`@@ -161,15 +161,15 @@ private function compareTypes(`
`161`	`161`	`): ?Type`
`162`	`162`	`{`
`163`	`163`	`if (`
`164`		`- $firstType instanceof ConstantArrayType`
	`164`	`+ $firstType->isConstantArray()->yes()`
`165`	`165`	`&& $secondType instanceof ConstantScalarType`
`166`	`166`	`) {`
`167`	`167`	`return $secondType;`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`if (`
`171`	`171`	`$firstType instanceof ConstantScalarType`
`172`		`- && $secondType instanceof ConstantArrayType`
	`172`	`+ && $secondType->isConstantArray()->yes()`
`173`	`173`	`) {`
`174`	`174`	`return $firstType;`
`175`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -362,6 +362,11 @@ public function isArray(): TrinaryLogic`
`362`	`362`	`return $this->getStaticObjectType()->isArray();`
`363`	`363`	`}`
`364`	`364`
	`365`	`+ public function isConstantArray(): TrinaryLogic`
	`366`	`+ {`
	`367`	`+ return $this->getStaticObjectType()->isConstantArray();`
	`368`	`+ }`
	`369`	`+`
`365`	`370`	`public function isOversizedArray(): TrinaryLogic`
`366`	`371`	`{`
`367`	`372`	`return $this->getStaticObjectType()->isOversizedArray();`