Narrow variable type in switch cases

Author: dmytro-dymarchuk

src/Analyser/NodeScopeResolver.php

@@ -204,6 +204,7 @@
 use function array_merge;
 use function array_pop;
 use function array_reverse;
+use function array_shift;
 use function array_slice;
 use function array_values;
 use function base64_decode;
@@ -1513,9 +1514,11 @@ private function processStmtNode(
 			$exitPointsForOuterLoop = [];
 			$throwPoints = $condResult->getThrowPoints();
 			$impurePoints = $condResult->getImpurePoints();
+			$defaultCondExprs = [];
 			foreach ($stmt->cases as $caseNode) {
 				if ($caseNode->cond !== null) {
 					$condExpr = new BinaryOp\Equal($stmt->cond, $caseNode->cond);
+					$defaultCondExprs[] = new BinaryOp\NotEqual($stmt->cond, $caseNode->cond);
 					$caseResult = $this->processExprNode($stmt, $caseNode->cond, $scopeForBranches, $nodeCallback, ExpressionContext::createDeep());
 					$scopeForBranches = $caseResult->getScope();
 					$hasYield = $hasYield || $caseResult->hasYield();
@@ -1525,6 +1528,16 @@ private function processStmtNode(
 				} else {
 					$hasDefaultCase = true;
 					$branchScope = $scopeForBranches;
+					$defaultConditions = $this->createBooleanAndFromExpressions($defaultCondExprs);
+					if ($defaultConditions !== null) {
+						$branchScope = $this->processExprNode(
+							$stmt,
+							$defaultConditions,
+							$scope,
+							static function (): void {},
+							ExpressionContext::createDeep(),
+						)->getTruthyScope()->filterByTruthyValue($defaultConditions);
+					}
 				}
 
 				$branchScope = $branchScope->mergeWith($prevScope);
@@ -6548,6 +6561,24 @@ private function getPhpDocReturnType(ResolvedPhpDocBlock $resolvedPhpDoc, Type $
 		return null;
 	}
 
+	/**
+	 * @param array<Expr> $expressions
+	 */
+	private function createBooleanAndFromExpressions(array $expressions): ?Expr {
+		if (count($expressions) === 0) {
+			return null;
+		}
+
+		if (count($expressions) === 1) {
+			return $expressions[0];
+		}
+
+		$left = array_shift($expressions);
+		$right = $this->createBooleanAndFromExpressions($expressions);
+
+		return new BooleanAnd($left, $right);
+	}
+
 	/**
 	 * @param array<Node> $nodes
 	 * @return list<Node\Stmt>

src/Analyser/TypeSpecifier.php

@@ -48,6 +48,7 @@
 use PHPStan\Type\Constant\ConstantIntegerType;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\ConstantScalarType;
+use PHPStan\Type\Enum\EnumCaseObjectType;
 use PHPStan\Type\FloatType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
 use PHPStan\Type\Generic\GenericClassStringType;
@@ -1565,7 +1566,7 @@ private function processBooleanNotSureConditionalTypes(Scope $scope, SpecifiedTy
 	}
 
 	/**
-	 * @return array{Expr, ConstantScalarType, Type}|null
+	 * @return array{Expr, ConstantScalarType|EnumCaseObjectType, Type}|null
 	 */
 	private function findTypeExpressionsFromBinaryOperation(Scope $scope, Node\Expr\BinaryOp $binaryOperation): ?array
 	{
@@ -1583,13 +1584,13 @@ private function findTypeExpressionsFromBinaryOperation(Scope $scope, Node\Expr\
 		}
 
 		if (
-			$leftType instanceof ConstantScalarType
+			($leftType instanceof ConstantScalarType || $leftType instanceof EnumCaseObjectType)
 			&& !$rightExpr instanceof ConstFetch
 			&& !$rightExpr instanceof ClassConstFetch
 		) {
 			return [$binaryOperation->right, $leftType, $rightType];
 		} elseif (
-			$rightType instanceof ConstantScalarType
+			($rightType instanceof ConstantScalarType || $rightType instanceof EnumCaseObjectType)
 			&& !$leftExpr instanceof ConstFetch
 			&& !$leftExpr instanceof ClassConstFetch
 		) {
@@ -1897,6 +1898,10 @@ public function resolveEqual(Expr\BinaryOp\Equal $expr, Scope $scope, TypeSpecif
 			$constantType = $expressions[1];
 			$otherType = $expressions[2];
 
+			if (!$context->null() && $constantType instanceof EnumCaseObjectType) {
+				return $this->create($exprNode, TypeCombinator::intersect($constantType, $otherType), $context, $scope)->setRootExpr($expr);
+			}
+
 			if (!$context->null() && $constantType->getValue() === null) {
 				$trueTypes = [
 					new NullType(),
@@ -1990,6 +1995,17 @@ public function resolveEqual(Expr\BinaryOp\Equal $expr, Scope $scope, TypeSpecif
 			) {
 				return $this->specifyTypesInCondition($scope, new Expr\BinaryOp\Identical($expr->left, $expr->right), $context)->setRootExpr($expr);
 			}
+
+			if (!$context->null() && TypeCombinator::containsNull($otherType)) {
+				$boolType = $constantType->toBoolean();
+				if ($boolType instanceof ConstantBooleanType && $boolType->getValue()) {
+					$otherType = TypeCombinator::remove($otherType, new NullType());
+				}
+
+				if (!$otherType->isSuperTypeOf($constantType)->no()) {
+					return $this->create($exprNode, TypeCombinator::intersect($constantType, $otherType), $context, $scope)->setRootExpr($expr);
+				}
+			}
 		}
 
 		$leftType = $scope->getType($expr->left);

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -104,6 +104,8 @@ private static function findTestFiles(): iterable
 			yield __DIR__ . '/data/new-in-initializers-runtime.php';
 		}
 
+		yield __DIR__ . '/data/bug-12432.php';
+
 		yield __DIR__ . '/../Rules/Comparison/data/bug-6473.php';
 
 		yield __DIR__ . '/../Rules/Methods/data/filter-iterator-child-class.php';

tests/PHPStan/Analyser/data/bug-12432.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Bug12432;
+
+use function PHPStan\Testing\assertType;
+
+function requireNullableInt(?int $nullable): ?int
+{
+	switch ($nullable) {
+		case 1:
+			assertType('1', $nullable);
+		case 2:
+			assertType('1|2', $nullable);
+			break;
+		case '':
+			assertType('0|null', $nullable);
+		case 0:
+			assertType('0|null', $nullable);
+			break;
+		default:
+			assertType('int<min, -1>|int<3, max>', $nullable);
+			break;
+	}
+
+	return $nullable;
+}
+
+enum Foo: int
+{
+	case BAR = 1;
+	case BAZ = 2;
+	case QUX = 3;
+}
+
+function requireNullableEnum(?Foo $nullable): ?Foo
+{
+	switch ($nullable) {
+		case Foo::BAR:
+			assertType('Bug12432\Foo::BAR', $nullable);
+		case Foo::BAZ:
+			assertType('Bug12432\Foo::BAR|Bug12432\Foo::BAZ', $nullable);
+			break;
+		case '':
+			assertType('null', $nullable);
+		case null:
+			assertType('null', $nullable);
+			break;
+		case 0:
+			assertType('*NEVER*', $nullable);
+		default:
+			assertType('Bug12432\Foo::QUX', $nullable);
+			break;
+	}
+
+	return $nullable;
+}
+

tests/PHPStan/Analyser/nsrt/in_array_loose.php

@@ -42,7 +42,7 @@ public function looseComparison(
 			assertType('int|string', $stringOrInt); // could be '1'|'2'|1|2
 		}
 		if (in_array($stringOrNull, ['1', 'a'])) {
-			assertType('string|null', $stringOrNull); // could be '1'|'a'
+			assertType("'1'|'a'", $stringOrNull);
 		}
 	}
 }