Narrow variable type in switch cases

Author: dmytro-dymarchuk

src/Analyser/NodeScopeResolver.php

@@ -206,6 +206,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;
@@ -1566,10 +1567,12 @@ private function processStmtNode(
 $throwPoints = $condResult->getThrowPoints();
 $impurePoints = $condResult->getImpurePoints();
 $fullCondExpr = null;
+$defaultCondExprs = [];
 foreach ($stmt->cases as $caseNode) {
 if ($caseNode->cond !== null) {
 $condExpr = new BinaryOp\Equal($stmt->cond, $caseNode->cond);
 $fullCondExpr = $fullCondExpr === null ? $condExpr : new BooleanOr($fullCondExpr, $condExpr);
+$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();
@@ -1580,6 +1583,11 @@ private function processStmtNode(
 $hasDefaultCase = true;
 $fullCondExpr = null;
 $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);
@@ -6701,6 +6709,29 @@ private function getPhpDocReturnType(ResolvedPhpDocBlock $resolvedPhpDoc, Type $
 return null;
 }
 
+/**
+ * @param list<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);
+
+if ($right === null) {
+throw new ShouldNotHappenException();
+}
+
+return new BooleanAnd($left, $right);
+}
+
 /**
  * @param array<Node> $nodes
  * @return list<Node\Stmt>

src/Analyser/TypeSpecifier.php

@@ -1643,15 +1643,8 @@ private function findTypeExpressionsFromBinaryOperation(Scope $scope, Node\Expr\
 $leftType = $scope->getType($binaryOperation->left);
 $rightType = $scope->getType($binaryOperation->right);
 
-$rightExpr = $binaryOperation->right;
-if ($rightExpr instanceof AlwaysRememberedExpr) {
-$rightExpr = $rightExpr->getExpr();
-}
-
-$leftExpr = $binaryOperation->left;
-if ($leftExpr instanceof AlwaysRememberedExpr) {
-$leftExpr = $leftExpr->getExpr();
-}
+$rightExpr = $this->extractExpression($binaryOperation->right);
+$leftExpr = $this->extractExpression($binaryOperation->left);
 
 if (
 $leftType instanceof ConstantScalarType
@@ -1670,6 +1663,39 @@ private function findTypeExpressionsFromBinaryOperation(Scope $scope, Node\Expr\
 return null;
 }
 
+/**
+ * @return array{Expr, Type, Type}|null
+ */
+private function findEnumTypeExpressionsFromBinaryOperation(Scope $scope, Node\Expr\BinaryOp $binaryOperation): ?array
+{
+$leftType = $scope->getType($binaryOperation->left);
+$rightType = $scope->getType($binaryOperation->right);
+
+$rightExpr = $this->extractExpression($binaryOperation->right);
+$leftExpr = $this->extractExpression($binaryOperation->left);
+
+if (
+$leftType->getEnumCases() === [$leftType]
+&& !$rightExpr instanceof ConstFetch
+&& !$rightExpr instanceof ClassConstFetch
+) {
+return [$binaryOperation->right, $leftType, $rightType];
+} elseif (
+$rightType->getEnumCases() === [$rightType]
+&& !$leftExpr instanceof ConstFetch
+&& !$leftExpr instanceof ClassConstFetch
+) {
+return [$binaryOperation->left, $rightType, $leftType];
+}
+
+return null;
+}
+
+private function extractExpression(Expr $expr): Expr
+{
+return $expr instanceof AlwaysRememberedExpr ? $expr->getExpr() : $expr;
+}
+
 /** @api */
 public function create(
 Expr $expr,
@@ -2061,6 +2087,27 @@ 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)) {
+if ($constantType->toBoolean()->isTrue()->yes()) {
+$otherType = TypeCombinator::remove($otherType, new NullType());
+}
+
+if (!$otherType->isSuperTypeOf($constantType)->no()) {
+return $this->create($exprNode, TypeCombinator::intersect($constantType, $otherType), $context, $scope)->setRootExpr($expr);
+}
+}
+}
+
+$expressions = $this->findEnumTypeExpressionsFromBinaryOperation($scope, $expr);
+if ($expressions !== null) {
+$exprNode = $expressions[0];
+$enumCaseObjectType = $expressions[1];
+$otherType = $expressions[2];
+
+if (!$context->null()) {
+return $this->create($exprNode, TypeCombinator::intersect($enumCaseObjectType, $otherType), $context, $scope)->setRootExpr($expr);
+}
 }
 
 $leftType = $scope->getType($expr->left);

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -101,10 +101,13 @@ private static function findTestFiles(): iterable
 define('TEST_FALSE_CONSTANT', false);
 define('TEST_ARRAY_CONSTANT', [true, false, null]);
 define('TEST_ENUM_CONSTANT', Foo::ONE);
+yield __DIR__ . '/data/bug-12432-nullable-enum.php';
 yield __DIR__ . '/data/new-in-initializers-runtime.php';
 yield __DIR__ . '/data/scope-in-enum-match-arm-body.php';
 }
 
+yield __DIR__ . '/data/bug-12432-nullable-int.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-nullable-enum.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Bug12432;
+
+use function PHPStan\Testing\assertType;
+
+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/data/bug-12432-nullable-int.php

@@ -0,0 +1,26 @@
+<?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;
+}

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);
 }
 }
 }