Fix false-positive when merging unions with plus operator

Author: staabm

src/Analyser/MutatingScope.php

@@ -1263,6 +1263,58 @@ private function resolveType(Expr $node): Type
 			$leftType = $this->getType($left);
 			$rightType = $this->getType($right);
 
+			if ($node instanceof Expr\AssignOp\Plus || $node instanceof Expr\BinaryOp\Plus) {
+				$leftConstantArrays = TypeUtils::getConstantArrays($leftType);
+				$rightConstantArrays = TypeUtils::getConstantArrays($rightType);
+
+				if (count($leftConstantArrays) > 0 && count($rightConstantArrays) > 0) {
+					$resultTypes = [];
+					foreach ($rightConstantArrays as $rightConstantArray) {
+						foreach ($leftConstantArrays as $leftConstantArray) {
+							$newArrayBuilder = ConstantArrayTypeBuilder::createFromConstantArray($rightConstantArray);
+							foreach ($leftConstantArray->getKeyTypes() as $leftKeyType) {
+								$newArrayBuilder->setOffsetValueType(
+									$leftKeyType,
+									$leftConstantArray->getOffsetValueType($leftKeyType)
+								);
+							}
+							$resultTypes[] = $newArrayBuilder->getArray();
+						}
+					}
+
+					return TypeCombinator::union(...$resultTypes);
+				}
+				$arrayType = new ArrayType(new MixedType(), new MixedType());
+
+				if ($arrayType->isSuperTypeOf($leftType)->yes() && $arrayType->isSuperTypeOf($rightType)->yes()) {
+					if ($leftType->getIterableKeyType()->equals($rightType->getIterableKeyType())) {
+						// to preserve BenevolentUnionType
+						$keyType = $leftType->getIterableKeyType();
+					} else {
+						$keyTypes = [];
+						foreach ([
+							$leftType->getIterableKeyType(),
+							$rightType->getIterableKeyType(),
+						] as $keyType) {
+							$keyTypes[] = $keyType;
+						}
+						$keyType = TypeCombinator::union(...$keyTypes);
+					}
+					return new ArrayType(
+						$keyType,
+						TypeCombinator::union($leftType->getIterableValueType(), $rightType->getIterableValueType())
+					);
+				}
+
+				if ($leftType instanceof MixedType && $rightType instanceof MixedType) {
+					return new BenevolentUnionType([
+						new FloatType(),
+						new IntegerType(),
+						new ArrayType(new MixedType(), new MixedType()),
+					]);
+				}
+			}
+
 			if (($leftType instanceof IntegerRangeType || $leftType instanceof ConstantIntegerType || $leftType instanceof UnionType) &&
 				($rightType instanceof IntegerRangeType || $rightType instanceof ConstantIntegerType || $rightType instanceof UnionType) &&
 				!($node instanceof Node\Expr\BinaryOp\Pow || $node instanceof Node\Expr\AssignOp\Pow)) {
@@ -1321,58 +1373,6 @@ private function resolveType(Expr $node): Type
 				}
 			}
 
-			if ($node instanceof Expr\AssignOp\Plus || $node instanceof Expr\BinaryOp\Plus) {
-				$leftConstantArrays = TypeUtils::getConstantArrays($leftType);
-				$rightConstantArrays = TypeUtils::getConstantArrays($rightType);
-
-				if (count($leftConstantArrays) > 0 && count($rightConstantArrays) > 0) {
-					$resultTypes = [];
-					foreach ($rightConstantArrays as $rightConstantArray) {
-						foreach ($leftConstantArrays as $leftConstantArray) {
-							$newArrayBuilder = ConstantArrayTypeBuilder::createFromConstantArray($rightConstantArray);
-							foreach ($leftConstantArray->getKeyTypes() as $leftKeyType) {
-								$newArrayBuilder->setOffsetValueType(
-									$leftKeyType,
-									$leftConstantArray->getOffsetValueType($leftKeyType)
-								);
-							}
-							$resultTypes[] = $newArrayBuilder->getArray();
-						}
-					}
-
-					return TypeCombinator::union(...$resultTypes);
-				}
-				$arrayType = new ArrayType(new MixedType(), new MixedType());
-
-				if ($arrayType->isSuperTypeOf($leftType)->yes() && $arrayType->isSuperTypeOf($rightType)->yes()) {
-					if ($leftType->getIterableKeyType()->equals($rightType->getIterableKeyType())) {
-						// to preserve BenevolentUnionType
-						$keyType = $leftType->getIterableKeyType();
-					} else {
-						$keyTypes = [];
-						foreach ([
-							$leftType->getIterableKeyType(),
-							$rightType->getIterableKeyType(),
-						] as $keyType) {
-							$keyTypes[] = $keyType;
-						}
-						$keyType = TypeCombinator::union(...$keyTypes);
-					}
-					return new ArrayType(
-						$keyType,
-						TypeCombinator::union($leftType->getIterableValueType(), $rightType->getIterableValueType())
-					);
-				}
-
-				if ($leftType instanceof MixedType && $rightType instanceof MixedType) {
-					return new BenevolentUnionType([
-						new FloatType(),
-						new IntegerType(),
-						new ArrayType(new MixedType(), new MixedType()),
-					]);
-				}
-			}
-
 			$types = TypeCombinator::union($leftType, $rightType);
 			if (
 				$leftType instanceof ArrayType

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -495,6 +495,7 @@ public function dataFileAsserts(): iterable
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-4602.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-4499.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-2142.php');
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-5584.php');
 
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/math.php');
 

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

@@ -0,0 +1,24 @@
+<?php
+
+namespace Analyser\Bug5584;
+
+use function PHPStan\Testing\assertType;
+
+class Foo {
+	public function unionSum(): void
+	{
+		$a = [];
+
+		if (rand(0,1) === 0) {
+			$a = ['a' => 5];
+		}
+
+		$b = [];
+
+		if (rand(0,1) === 0) {
+			$b = ['b' => 6];
+		}
+
+		assertType("array()|array(?'b' => 6, ?'a' => 5)", $a + $b);
+	}
+}