Fix #9908: isset condition doesn't refine type

phpstan-baseline.neon

@@ -87,7 +87,7 @@ parameters:
 		-
 			rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantStringType is error-prone and deprecated. Use Type::getConstantStrings() instead.'
 			identifier: phpstanApi.instanceofType
-			count: 4
+			count: 5
 			path: src/Analyser/TypeSpecifier.php
 
 		-

src/Analyser/TypeSpecifier.php

@@ -920,6 +920,52 @@
 					return $exprType;
 				}
 
+				if (
+					$issetExpr instanceof ArrayDimFetch
+					&& $issetExpr->dim !== null
+				) {
+					$varType = $scope->getType($issetExpr->var);
+					if (!$varType instanceof MixedType) {
+						$dimType = $scope->getType($issetExpr->dim);
+
+						if ($dimType instanceof ConstantIntegerType || $dimType instanceof ConstantStringType) {
+							$types = $varType instanceof UnionType ? $varType->getTypes() : [$varType];
+							$typesToRemove = [];
+							foreach ($types as $innerType) {
+								$hasOffset = $innerType->hasOffsetValueType($dimType);
+								if (!$hasOffset->yes() || !$innerType->getOffsetValueType($dimType)->isNull()->no()) {
+									continue;
+								}
+
+								$typesToRemove[] = $innerType;
+							}
+
+							if ($typesToRemove !== []) {
+								$typeToRemove = TypeCombinator::union(...$typesToRemove);
+								$result = $this->create(
+									$issetExpr->var,
+									$typeToRemove,
+									TypeSpecifierContext::createFalse(),
+									$scope,
+								)->setRootExpr($expr);
+
+								if ($scope->hasExpressionType($issetExpr->var)->maybe()) {
+									$result = $result->unionWith(
+										$this->create(
+											new IssetExpr($issetExpr->var),
+											new NullType(),
+											TypeSpecifierContext::createTruthy(),
+											$scope,
+										)->setRootExpr($expr),
+									);
+								}
+
+								return $result;
+							}
+						}
+					}
+				}
+
 				return new SpecifiedTypes();
 			}
 

tests/PHPStan/Analyser/nsrt/bug-10544.php

@@ -0,0 +1,19 @@
+<?php declare(strict_types = 1);
+
+namespace Bug10544;
+
+use function PHPStan\Testing\assertType;
+
+class Boo {
+	/**
+	 * @param array{check1:bool,boo:string}|array{check2:bool,foo:string} $param
+	 */
+	public function foo(array $param): string {
+		if (isset($param['check1'])) {
+			assertType('array{check1: bool, boo: string}', $param);
+			return $param['boo'];
+		}
+		assertType('array{check2: bool, foo: string}', $param);
+		return $param['foo'];
+	}
+}

tests/PHPStan/Analyser/nsrt/bug-12401.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types = 1);
+
+namespace Bug12401;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @param array{a: string, b: string}|array{c: string} $data
+ */
+function test(array $data): void {
+	if (isset($data['a'])) {
+		assertType('array{a: string, b: string}', $data);
+	} else {
+		assertType('array{c: string}', $data);
+	}
+
+	if (isset($data['a'])) {
+		assertType('array{a: string, b: string}', $data);
+	} elseif (isset($data['c'])) {
+		assertType('array{c: string}', $data);
+	} else {
+		assertType('*NEVER*', $data);
+	}
+}

tests/PHPStan/Analyser/nsrt/bug-5128.php

@@ -0,0 +1,18 @@
+<?php declare(strict_types = 1);
+
+namespace Bug5128;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @param array{a: string}|array{b: string} $array
+ */
+function a(array $array): string {
+	if (isset($array['a'])) {
+		assertType('array{a: string}', $array);
+		return $array['a'];
+	}
+
+	assertType('array{b: string}', $array);
+	return $array['b'];
+}

tests/PHPStan/Analyser/nsrt/bug-8724.php

@@ -0,0 +1,28 @@
+<?php declare(strict_types = 1);
+
+namespace Bug8724;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @phpstan-type NumberFilterStructure array{
+ *      type: 'equals'|'notEqual'|'lessThan'|'lessThanOrEqual'|'greaterThan'|'greaterThanOrEqual'|'inRange'|'blank'|'notBlank',
+ * }
+ * @phpstan-type CombinedNumberFilterStructure array{
+ *      operator: 'AND'|'OR'
+ * }
+ */
+class HelloWorld
+{
+	/** @param NumberFilterStructure|CombinedNumberFilterStructure $filter */
+	public function test(array $filter): void
+	{
+		if (isset($filter['operator'])) {
+			assertType("array{operator: 'AND'|'OR'}", $filter);
+			return;
+		}
+
+		assertType("array{type: 'blank'|'equals'|'greaterThan'|'greaterThanOrEqual'|'inRange'|'lessThan'|'lessThanOrEqual'|'notBlank'|'notEqual'}", $filter);
+		echo $filter['type'];
+	}
+}

tests/PHPStan/Analyser/nsrt/bug-9908.php

@@ -0,0 +1,44 @@
+<?php declare(strict_types = 1);
+
+namespace Bug9908;
+
+use function PHPStan\Testing\assertType;
+
+class HelloWorld
+{
+	public function test(): void
+	{
+		$a = [];
+		if (rand() % 2) {
+			$a = ['bar' => 'string'];
+		}
+
+		if (isset($a['bar'])) {
+			$a['bar'] = 1;
+		}
+
+		assertType("array{}|array{bar: 1}", $a);
+	}
+
+	/**
+	 * @param array{bar?: int} $foo
+	 */
+	public function sayHello(array $foo): void
+	{
+		echo 'Hello' . print_r($foo, true);
+	}
+
+	public function test2(): void
+	{
+		$a = [];
+		if (rand() % 2) {
+			$a = ['bar' => 'string'];
+		}
+
+		if (isset($a['bar'])) {
+			$a['bar'] = 1;
+		}
+
+		$this->sayHello($a);
+	}
+}

tests/PHPStan/Analyser/nsrt/tagged-unions.php

@@ -55,7 +55,7 @@ public function doFoo4(array $foo)
 		if (isset($foo['C'])) {
 			assertType("array{A: string, C: 1}", $foo);
 		} else {
-			assertType("array{A: int, B: 1}|array{A: string, C: 1}", $foo); // could be array{A: int, B: 1}
+			assertType("array{A: int, B: 1}", $foo);
 		}
 
 		assertType('array{A: int, B: 1}|array{A: string, C: 1}', $foo);