Type::getEnumCases()

src/Analyser/TypeSpecifier.php

@@ -40,7 +40,6 @@
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\ConstantScalarType;
 use PHPStan\Type\ConstantType;
-use PHPStan\Type\Enum\EnumCaseObjectType;
 use PHPStan\Type\FloatType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
 use PHPStan\Type\Generic\GenericClassStringType;
@@ -232,7 +231,7 @@ public function specifyTypesInCondition(
 			$exprRightType = $scope->getType($expr->right);
 			if (
 				$exprLeftType instanceof ConstantScalarType
-				|| $exprLeftType instanceof EnumCaseObjectType
+				|| count($exprLeftType->getEnumCases()) === 1
 				|| ($exprLeftType instanceof ConstantType && !$exprRightType->equals($exprLeftType) && $exprRightType->isSuperTypeOf($exprLeftType)->yes())
 			) {
 				$types = $this->create(
@@ -246,7 +245,7 @@ public function specifyTypesInCondition(
 			}
 			if (
 				$exprRightType instanceof ConstantScalarType
-				|| $exprRightType instanceof EnumCaseObjectType
+				|| count($exprRightType->getEnumCases()) === 1
 				|| ($exprRightType instanceof ConstantType && !$exprLeftType->equals($exprRightType) && $exprLeftType->isSuperTypeOf($exprRightType)->yes())
 			) {
 				$leftType = $this->create(

src/Rules/Comparison/MatchExpressionRule.php

@@ -9,19 +9,13 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\Constant\ConstantBooleanType;
-use PHPStan\Type\Enum\EnumCaseObjectType;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\ObjectType;
-use PHPStan\Type\SubtractableType;
 use PHPStan\Type\TypeCombinator;
-use PHPStan\Type\TypeUtils;
-use PHPStan\Type\TypeWithClassName;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
 use UnhandledMatchError;
-use function array_keys;
 use function array_map;
-use function array_values;
 use function count;
 use function sprintf;
 
@@ -92,44 +86,13 @@ public function processNode(Node $node, Scope $scope): array
 
 		if (!$hasDefault && !$nextArmIsDead) {
 			$remainingType = $node->getEndScope()->getType($matchCondition);
-			if ($remainingType instanceof TypeWithClassName && $remainingType instanceof SubtractableType) {
-				$subtractedType = $remainingType->getSubtractedType();
-				if ($subtractedType !== null && $remainingType->getClassReflection() !== null) {
-					$classReflection = $remainingType->getClassReflection();
-					if ($classReflection->isEnum()) {
-						$cases = [];
-						foreach (array_keys($classReflection->getEnumCases()) as $name) {
-							$cases[$name] = new EnumCaseObjectType($classReflection->getName(), $name);
-						}
-
-						$subtractedTypes = TypeUtils::flattenTypes($subtractedType);
-						$set = true;
-						foreach ($subtractedTypes as $subType) {
-							if (!$subType instanceof EnumCaseObjectType) {
-								$set = false;
-								break;
-							}
-
-							if ($subType->getClassName() !== $classReflection->getName()) {
-								$set = false;
-								break;
-							}
-
-							unset($cases[$subType->getEnumCaseName()]);
-						}
-
-						$cases = array_values($cases);
-						$casesCount = count($cases);
-						if ($set) {
-							if ($casesCount > 1) {
-								$remainingType = new UnionType($cases);
-							}
-							if ($casesCount === 1) {
-								$remainingType = $cases[0];
-							}
-						}
-					}
-				}
+			$cases = $remainingType->getEnumCases();
+			$casesCount = count($cases);
+			if ($casesCount > 1) {
+				$remainingType = new UnionType($cases);
+			}
+			if ($casesCount === 1) {
+				$remainingType = $cases[0];
 			}
 			if (
 				!$remainingType instanceof NeverType

src/Type/Accessory/HasMethodType.php

@@ -143,6 +143,11 @@ public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope)
 		];
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		return $this;

src/Type/Accessory/HasOffsetType.php

@@ -284,6 +284,11 @@ public function toArrayKey(): Type
 		return new ErrorType();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		return $this;

src/Type/Accessory/HasOffsetValueType.php

@@ -325,6 +325,11 @@ public function toArrayKey(): Type
 		return new ErrorType();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		$newValueType = $cb($this->valueType);

src/Type/Accessory/HasPropertyType.php

@@ -104,6 +104,11 @@ public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope)
 		return [new TrivialParametersAcceptor()];
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		return $this;

src/Type/CallableType.php

@@ -397,6 +397,11 @@ public function isScalar(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	public function isCommonCallable(): bool
 	{
 		return $this->isCommonCallable;

src/Type/ClosureType.php

@@ -250,6 +250,11 @@ public function isCallable(): TrinaryLogic
 		return TrinaryLogic::createYes();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	/**
 	 * @return ParametersAcceptor[]
 	 */

src/Type/Enum/EnumCaseObjectType.php

@@ -145,6 +145,11 @@ public function isSmallerThanOrEqual(Type $otherType): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [$this];
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 */

src/Type/IntersectionType.php

@@ -639,6 +639,18 @@ public function shuffleArray(): Type
 		return $this->intersectTypes(static fn (Type $type): Type => $type->shuffleArray());
 	}
 
+	public function getEnumCases(): array
+	{
+		$enumCases = [];
+		foreach ($this->types as $type) {
+			foreach ($type->getEnumCases() as $enumCase) {
+				$enumCases[] = $enumCase;
+			}
+		}
+
+		return $enumCases;
+	}
+
 	public function isCallable(): TrinaryLogic
 	{
 		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isCallable());

src/Type/IterableType.php

@@ -335,6 +335,11 @@ public function isScalar(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	public function inferTemplateTypes(Type $receivedType): TemplateTypeMap
 	{
 		if ($receivedType instanceof UnionType || $receivedType instanceof IntersectionType) {

src/Type/MixedType.php

@@ -241,6 +241,11 @@ public function isCallable(): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	/**
 	 * @return ParametersAcceptor[]
 	 */

src/Type/NeverType.php

@@ -408,6 +408,11 @@ public function isScalar(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 */

src/Type/NonexistentParentClassType.php

@@ -139,6 +139,11 @@ public function isScalar(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 */

src/Type/ObjectType.php

@@ -1039,6 +1039,35 @@ public function unsetOffset(Type $offsetType): Type
 		return $this;
 	}
 
+	public function getEnumCases(): array
+	{
+		$classReflection = $this->getClassReflection();
+		if ($classReflection === null) {
+			return [];
+		}
+
+		if (!$classReflection->isEnum()) {
+			return [];
+		}
+
+		$subtracted = [];
+		if ($this->subtractedType !== null) {
+			foreach ($this->subtractedType->getEnumCases() as $enumCase) {
+				$subtracted[$enumCase->getEnumCaseName()] = true;
+			}
+		}
+
+		$cases = [];
+		foreach ($classReflection->getEnumCases() as $enumCase) {
+			if (array_key_exists($enumCase->getName(), $subtracted)) {
+				continue;
+			}
+			$cases[] = new EnumCaseObjectType($classReflection->getName(), $enumCase->getName(), $classReflection);
+		}
+
+		return $cases;
+	}
+
 	public function isCallable(): TrinaryLogic
 	{
 		$parametersAcceptors = $this->findCallableParametersAcceptors();

src/Type/ObjectWithoutClassType.php

@@ -119,6 +119,11 @@ function () use ($level): string {
 		);
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	public function subtract(Type $type): Type
 	{
 		if ($type instanceof self) {

src/Type/StaticType.php

@@ -411,6 +411,11 @@ public function isCallable(): TrinaryLogic
 		return $this->getStaticObjectType()->isCallable();
 	}
 
+	public function getEnumCases(): array
+	{
+		return $this->getStaticObjectType()->getEnumCases();
+	}
+
 	public function isArray(): TrinaryLogic
 	{
 		return $this->getStaticObjectType()->isArray();

src/Type/StrictMixedType.php

@@ -312,6 +312,11 @@ public function getReferencedTemplateTypes(TemplateTypeVariance $positionVarianc
 		return [];
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 	public function traverse(callable $cb): Type
 	{
 		return $this;

src/Type/Traits/LateResolvableTypeTrait.php

@@ -260,6 +260,11 @@ public function isCallable(): TrinaryLogic
 		return $this->resolve()->isCallable();
 	}
 
+	public function getEnumCases(): array
+	{
+		return $this->resolve()->getEnumCases();
+	}
+
 	public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope): array
 	{
 		return $this->resolve()->getCallableParametersAcceptors($scope);

src/Type/Traits/NonObjectTypeTrait.php

@@ -79,4 +79,9 @@ public function isCloneable(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function getEnumCases(): array
+	{
+		return [];
+	}
+
 }

src/Type/Type.php

@@ -12,6 +12,7 @@
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\Type\Enum\EnumCaseObjectType;
 use PHPStan\Type\Generic\TemplateTypeMap;
 use PHPStan\Type\Generic\TemplateTypeReference;
 use PHPStan\Type\Generic\TemplateTypeVariance;
@@ -118,6 +119,11 @@ public function shiftArray(): Type;
 
 	public function shuffleArray(): Type;
 
+	/**
+	 * @return list<EnumCaseObjectType>
+	 */
+	public function getEnumCases(): array;
+
 	public function isCallable(): TrinaryLogic;
 
 	/**

src/Type/UnionType.php

@@ -622,6 +622,11 @@ public function shuffleArray(): Type
 		return $this->unionTypes(static fn (Type $type): Type => $type->shuffleArray());
 	}
 
+	public function getEnumCases(): array
+	{
+		return $this->pickTypes(static fn (Type $type) => $type->getEnumCases());
+	}
+
 	public function isCallable(): TrinaryLogic
 	{
 		return $this->unionResults(static fn (Type $type): TrinaryLogic => $type->isCallable());