Fix match regression

ondrejmirtes · ondrejmirtes · commit 87004e7fee41 · 2026-02-23T09:46:08.000+01:00
diff --git a/src/Analyser/NodeScopeResolver.php b/src/Analyser/NodeScopeResolver.php
@@ -4215,10 +4215,10 @@ function (MutatingScope $scope) use ($stmt, $expr, $nodeCallback, $context, $sto
 							continue;
 						}
 
-						$condNodes = [];
-						$conditionCases = [];
-						$conditionExprs = [];
-						foreach ($arm->conds as $j => $cond) {
+						// Pre-validate all conditions before processing to avoid
+						// partial consumption of enum cases when a later condition
+						// causes the arm to be skipped
+						foreach ($arm->conds as $cond) {
 							if (!$cond instanceof Expr\ClassConstFetch) {
 								continue 2;
 							}
@@ -4233,14 +4233,38 @@ function (MutatingScope $scope) use ($stmt, $expr, $nodeCallback, $context, $sto
 							if (!array_key_exists($loweredFetchedClassName, $indexedEnumCases)) {
 								continue 2;
 							}
+							$caseName = $cond->name->toString();
+							if (!array_key_exists($caseName, $indexedEnumCases[$loweredFetchedClassName])) {
+								continue 2;
+							}
+						}
+
+						$condNodes = [];
+						$conditionCases = [];
+						$conditionExprs = [];
+						foreach ($arm->conds as $j => $cond) {
+							if (!$cond instanceof Expr\ClassConstFetch) {
+								throw new ShouldNotHappenException();
+							}
+							if (!$cond->class instanceof Name) {
+								throw new ShouldNotHappenException();
+							}
+							if (!$cond->name instanceof Node\Identifier) {
+								throw new ShouldNotHappenException();
+							}
+							$fetchedClassName = $scope->resolveName($cond->class);
+							$loweredFetchedClassName = strtolower($fetchedClassName);
+							if (!array_key_exists($loweredFetchedClassName, $indexedEnumCases)) {
+								throw new ShouldNotHappenException();
+							}
 
 							if (!array_key_exists($loweredFetchedClassName, $unusedIndexedEnumCases)) {
 								throw new ShouldNotHappenException();
 							}
 
 							$caseName = $cond->name->toString();
 							if (!array_key_exists($caseName, $indexedEnumCases[$loweredFetchedClassName])) {
-								continue 2;
+								throw new ShouldNotHappenException();
 							}
 
 							$enumCase = $indexedEnumCases[$loweredFetchedClassName][$caseName];
diff --git a/tests/PHPStan/Rules/Comparison/MatchEnumPartialArmRegressionTest.php b/tests/PHPStan/Rules/Comparison/MatchEnumPartialArmRegressionTest.php
@@ -0,0 +1,41 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Comparison;
+
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\RequiresPhp;
+
+/**
+ * Regression test: when a match arm has multiple enum case conditions and the
+ * enum fast-path analysis cannot handle all of them (e.g. because the condition
+ * type is narrowed to a single case), the analysis must not partially consume
+ * enum cases from the unused pool. Partial consumption caused the remaining
+ * type to become NeverType, corrupting the scope for subsequent match expressions.
+ *
+ * @extends RuleTestCase<MatchCallbackScopeRegressionRule>
+ */
+class MatchEnumPartialArmRegressionTest extends RuleTestCase
+{
+
+	protected function getRule(): Rule
+	{
+		return new MatchCallbackScopeRegressionRule();
+	}
+
+	#[RequiresPhp('>= 8.1')]
+	public function testEnumPartialArmConsumption(): void
+	{
+		$this->analyse([__DIR__ . '/data/match-enum-partial-arm-regression.php'], [
+			[
+				'MatchEnumPartialArmRegression\MyEnum::A',
+				19,
+			],
+			[
+				'MatchEnumPartialArmRegression\MyEnum::A',
+				25,
+			],
+		]);
+	}
+
+}
diff --git a/tests/PHPStan/Rules/Comparison/MatchExpressionRuleTest.php b/tests/PHPStan/Rules/Comparison/MatchExpressionRuleTest.php
@@ -152,6 +152,11 @@ public function testEnums(): void
 				'Match arm comparison between *NEVER* and MatchEnums\DifferentEnum::ONE is always false.',
 				113,
 			],
+			[
+				'Match arm comparison between MatchEnums\Foo::ONE and MatchEnums\Foo::ONE is always true.',
+				113,
+				'Remove remaining cases below this one and this error will disappear too.',
+			],
 		]);
 	}
 
diff --git a/tests/PHPStan/Rules/Comparison/data/match-enum-partial-arm-regression.php b/tests/PHPStan/Rules/Comparison/data/match-enum-partial-arm-regression.php
@@ -0,0 +1,28 @@
+<?php // lint >= 8.1
+
+namespace MatchEnumPartialArmRegression;
+
+enum MyEnum
+{
+	case A;
+	case B;
+}
+
+function test(): void
+{
+	$enum = MyEnum::A;
+
+	// This match has both cases in a single arm, but $enum is known to be
+	// MyEnum::A only. The enum fast-path analysis should not partially consume
+	// case A from unused cases and then bail out on case B, as that would
+	// incorrectly narrow the remaining type to never.
+	match ($enum) {
+		MyEnum::A, MyEnum::B => null,
+	};
+
+	// Without the fix, this second match would see $enum as *NEVER* because
+	// the first match corrupted the scope via partial enum case consumption.
+	match ($enum) {
+		default => null,
+	};
+}
