Fix resolving mixed + array

phpstan-baseline.neon

@@ -48,11 +48,6 @@ parameters:
 			count: 1
 			path: src/Collectors/Collector.php
 
-		-
-			message: "#^Binary operation \"\\+\" between array\\{class\\-string\\<TNodeType of PhpParser\\\\Node\\>\\} and array\\<string, class\\-string\\>\\|false results in an error\\.$#"
-			count: 1
-			path: src/Collectors/Registry.php
-
 		-
 			message: "#^Method PHPStan\\\\Collectors\\\\Registry\\:\\:__construct\\(\\) has parameter \\$collectors with generic interface PHPStan\\\\Collectors\\\\Collector but does not specify its types\\: TNodeType, TValue$#"
 			count: 1
@@ -307,11 +302,6 @@ parameters:
 			count: 1
 			path: src/Reflection/SignatureMap/Php8SignatureMapProvider.php
 
-		-
-			message: "#^Binary operation \"\\+\" between array\\{class\\-string\\<TNodeType of PhpParser\\\\Node\\>\\} and array\\<string, class\\-string\\>\\|false results in an error\\.$#"
-			count: 1
-			path: src/Rules/Registry.php
-
 		-
 			message: "#^Method PHPStan\\\\Rules\\\\Registry\\:\\:__construct\\(\\) has parameter \\$rules with generic interface PHPStan\\\\Rules\\\\Rule but does not specify its types\\: TNodeType$#"
 			count: 1

src/Reflection/InitializerExprTypeResolver.php

@@ -859,6 +859,10 @@ public function getPlusType(Expr $left, Expr $right, callable $getTypeCallback):
 		$leftType = $getTypeCallback($left);
 		$rightType = $getTypeCallback($right);
 
+		if ($leftType instanceof NeverType || $rightType instanceof NeverType) {
+			return new NeverType();
+		}
+
 		$leftTypes = TypeUtils::getConstantScalars($leftType);
 		$rightTypes = TypeUtils::getConstantScalars($rightType);
 		$leftTypesCount = count($leftTypes);
@@ -921,7 +925,9 @@ public function getPlusType(Expr $left, Expr $right, callable $getTypeCallback):
 			return TypeCombinator::union(...$resultTypes);
 		}
 
-		if ($leftType->isArray()->yes() && $rightType->isArray()->yes()) {
+		$leftIsArray = $leftType->isArray();
+		$rightIsArray = $rightType->isArray();
+		if ($leftIsArray->yes() && $rightIsArray->yes()) {
 			if ($leftType->getIterableKeyType()->equals($rightType->getIterableKeyType())) {
 				// to preserve BenevolentUnionType
 				$keyType = $leftType->getIterableKeyType();
@@ -955,6 +961,39 @@ public function getPlusType(Expr $left, Expr $right, callable $getTypeCallback):
 			]);
 		}
 
+		if (
+			($leftIsArray->yes() && $rightIsArray->no())
+			|| ($leftIsArray->no() && $rightIsArray->yes())
+		) {
+			return new ErrorType();
+		}
+
+		if (
+			($leftIsArray->yes() && $rightIsArray->maybe())
+			|| ($leftIsArray->maybe() && $rightIsArray->yes())
+		) {
+			$resultType = new ArrayType(new MixedType(), new MixedType());
+			if ($leftType->isIterableAtLeastOnce()->yes() || $rightType->isIterableAtLeastOnce()->yes()) {
+				return TypeCombinator::intersect($resultType, new NonEmptyArrayType());
+			}
+
+			return $resultType;
+		}
+
+		if ($leftIsArray->maybe() && $rightIsArray->maybe()) {
+			$plusable = new UnionType([
+				new StringType(),
+				new FloatType(),
+				new IntegerType(),
+				new ArrayType(new MixedType(), new MixedType()),
+				new BooleanType(),
+			]);
+
+			if ($plusable->isSuperTypeOf($leftType)->yes() && $plusable->isSuperTypeOf($rightType)->yes()) {
+				return TypeCombinator::union($leftType, $rightType);
+			}
+		}
+
 		return $this->resolveCommonMath(new BinaryOp\Plus($left, $right), $leftType, $rightType);
 	}
 

tests/PHPStan/Analyser/LegacyNodeScopeResolverTest.php

@@ -2696,9 +2696,49 @@ public function dataBinaryOperations(): array
 				'$mixed - $mixed',
 			],
 			[
-				'*ERROR*',
+				'array',
 				'$mixed + []',
 			],
+			[
+				'array|int',
+				'$intOrArray + $intOrArray',
+			],
+			[
+				'float|int',
+				'$intOrFloat + $intOrFloat',
+			],
+			[
+				'array|float',
+				'$floatOrArray + $floatOrArray',
+			],
+			[
+				'array|bool|float|int|string',
+				'$plusable + $plusable',
+			],
+			[
+				'array',
+				'$mixedNoFloat + []',
+			],
+			[
+				'(float|int)',
+				'$mixedNoFloat + 5',
+			],
+			[
+				'(float|int)',
+				'$mixedNoInt + 5',
+			],
+			[
+				'*ERROR*',
+				'$mixedNoArray + []',
+			],
+			[
+				'*ERROR*',
+				'$mixedNoArrayOrInt + []',
+			],
+			[
+				'*ERROR*',
+				'$integer + []',
+			],
 			[
 				'124',
 				'1 + "123"',

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -1000,6 +1000,7 @@ public function dataFileAsserts(): iterable
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/array-intersect-key-constant.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/composer-array-bug.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/tagged-unions.php');
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-7492.php');
 	}
 
 	/**

tests/PHPStan/Analyser/data/binary.php

@@ -190,6 +190,33 @@ public function doFoo(array $generalArray)
 		$severalSumWithStaticConst2 = 1 + static::INT_CONST + 1;
 		$severalSumWithStaticConst3 = 1 + 1 + static::INT_CONST;
 
+		if (!is_array($mixed)) {
+			$mixedNoArray = $mixed;
+		}
+		if (!is_int($mixed)) {
+			$mixedNoInt = $mixed;
+		}
+		if (!is_float($mixed)) {
+			$mixedNoFloat = $mixed;
+		}
+		if (!is_array($mixed)) {
+			if (!is_int($mixed)) {
+				$mixedNoArrayOrInt = $mixed;
+			}
+		}
+
+		/** @var int|array $intOrArray */
+		$intOrArray = doFoo();
+
+		/** @var array|float $floatOrArray */
+		$floatOrArray = doFoo();
+
+		/** @var int|float $intOrFloat */
+		$intOrFloat = doFoo();
+
+		/** @var array|float|int|string|bool $plusable */
+		$plusable = doFoo();
+
 		die;
 	}
 

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

@@ -0,0 +1,14 @@
+<?php declare(strict_types = 1);
+
+namespace Bug7492;
+
+use function PHPStan\Testing\assertType;
+
+class HelloWorld
+{
+	public function sayHello(array $config): void
+	{
+		$x = ($config['db'][1] ?? []) + ['host' => '', 'login' => '', 'password' => '', 'name' => ''];
+		assertType('non-empty-array', $x);
+	}
+}

tests/PHPStan/Rules/Operators/InvalidBinaryOperationRuleTest.php

@@ -242,6 +242,10 @@ public function testRule(): void
 				'Binary operation "/" between 10 and literal-string results in an error.',
 				222,
 			],
+			[
+				'Binary operation "+" between int and array{} results in an error.',
+				259,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Operators/data/invalid-binary.php

@@ -254,3 +254,7 @@ function benevolentPlus(array $a, int $i): void {
 		echo $k + $i;
 	}
 };
+
+function (int $int) {
+	$int + [];
+};