Fix incorrect analyzing of array_shift with non-empty-list property

src/Analyser/NodeScopeResolver.php

@@ -2664,11 +2664,29 @@ static function (): void {
 				$arrayArgNativeType = $scope->getNativeType($arrayArg);
 
 				$isArrayPop = $functionReflection->getName() === 'array_pop';
+				$newType = $isArrayPop ? $arrayArgType->popArray() : $arrayArgType->shiftArray();
 				$scope = $scope->invalidateExpression($arrayArg)->assignExpression(
 					$arrayArg,
-					$isArrayPop ? $arrayArgType->popArray() : $arrayArgType->shiftArray(),
+					$newType,
 					$isArrayPop ? $arrayArgNativeType->popArray() : $arrayArgNativeType->shiftArray(),
 				);
+
+				$scope = $this->processAssignVar(
+					$scope,
+					$stmt,
+					$arrayArg,
+					new TypeExpr($newType),
+					static function (Node $node, Scope $scope) use ($nodeCallback): void {
+						if (!$node instanceof PropertyAssignNode && !$node instanceof VariableAssignNode) {
+							return;
+						}
+
+						$nodeCallback($node, $scope);
+					},
+					$context,
+					static fn (MutatingScope $scope): ExpressionResult => new ExpressionResult($scope, false, false, [], []),
+					true,
+				)->getScope();
 			}
 
 			if (
@@ -2681,6 +2699,23 @@ static function (): void {
 
 				$arrayArg = $expr->getArgs()[0]->value;
 				$scope = $scope->invalidateExpression($arrayArg)->assignExpression($arrayArg, $arrayType, $arrayNativeType);
+
+				$scope = $this->processAssignVar(
+					$scope,
+					$stmt,
+					$arrayArg,
+					new TypeExpr($arrayType),
+					static function (Node $node, Scope $scope) use ($nodeCallback): void {
+						if (!$node instanceof PropertyAssignNode && !$node instanceof VariableAssignNode) {
+							return;
+						}
+
+						$nodeCallback($node, $scope);
+					},
+					$context,
+					static fn (MutatingScope $scope): ExpressionResult => new ExpressionResult($scope, false, false, [], []),
+					true,
+				)->getScope();
 			}
 
 			if (
@@ -2695,11 +2730,29 @@ static function (): void {
 				&& $functionReflection->getName() === 'shuffle'
 			) {
 				$arrayArg = $expr->getArgs()[0]->value;
+				$newType = $scope->getType($arrayArg)->shuffleArray();
 				$scope = $scope->assignExpression(
 					$arrayArg,
-					$scope->getType($arrayArg)->shuffleArray(),
+					$newType,
 					$scope->getNativeType($arrayArg)->shuffleArray(),
 				);
+
+				$scope = $this->processAssignVar(
+					$scope,
+					$stmt,
+					$arrayArg,
+					new TypeExpr($newType),
+					static function (Node $node, Scope $scope) use ($nodeCallback): void {
+						if (!$node instanceof PropertyAssignNode && !$node instanceof VariableAssignNode) {
+							return;
+						}
+
+						$nodeCallback($node, $scope);
+					},
+					$context,
+					static fn (MutatingScope $scope): ExpressionResult => new ExpressionResult($scope, false, false, [], []),
+					true,
+				)->getScope();
 			}
 
 			if (
@@ -2715,11 +2768,29 @@ static function (): void {
 				$lengthType = isset($expr->getArgs()[2]) ? $scope->getType($expr->getArgs()[2]->value) : new NullType();
 				$replacementType = isset($expr->getArgs()[3]) ? $scope->getType($expr->getArgs()[3]->value) : new ConstantArrayType([], []);
 
+				$newType = $arrayArgType->spliceArray($offsetType, $lengthType, $replacementType);
 				$scope = $scope->invalidateExpression($arrayArg)->assignExpression(
 					$arrayArg,
-					$arrayArgType->spliceArray($offsetType, $lengthType, $replacementType),
+					$newType,
 					$arrayArgNativeType->spliceArray($offsetType, $lengthType, $replacementType),
 				);
+
+				$scope = $this->processAssignVar(
+					$scope,
+					$stmt,
+					$arrayArg,
+					new TypeExpr($newType),
+					static function (Node $node, Scope $scope) use ($nodeCallback): void {
+						if (!$node instanceof PropertyAssignNode && !$node instanceof VariableAssignNode) {
+							return;
+						}
+
+						$nodeCallback($node, $scope);
+					},
+					$context,
+					static fn (MutatingScope $scope): ExpressionResult => new ExpressionResult($scope, false, false, [], []),
+					true,
+				)->getScope();
 			}
 
 			if (
@@ -2728,11 +2799,29 @@ static function (): void {
 				&& count($expr->getArgs()) >= 1
 			) {
 				$arrayArg = $expr->getArgs()[0]->value;
+				$newType = $this->getArraySortPreserveListFunctionType($scope->getType($arrayArg));
 				$scope = $scope->assignExpression(
 					$arrayArg,
-					$this->getArraySortPreserveListFunctionType($scope->getType($arrayArg)),
+					$newType,
 					$this->getArraySortPreserveListFunctionType($scope->getNativeType($arrayArg)),
 				);
+
+				$scope = $this->processAssignVar(
+					$scope,
+					$stmt,
+					$arrayArg,
+					new TypeExpr($newType),
+					static function (Node $node, Scope $scope) use ($nodeCallback): void {
+						if (!$node instanceof PropertyAssignNode && !$node instanceof VariableAssignNode) {
+							return;
+						}
+
+						$nodeCallback($node, $scope);
+					},
+					$context,
+					static fn (MutatingScope $scope): ExpressionResult => new ExpressionResult($scope, false, false, [], []),
+					true,
+				)->getScope();
 			}
 
 			if (
@@ -2741,11 +2830,29 @@ static function (): void {
 				&& count($expr->getArgs()) >= 1
 			) {
 				$arrayArg = $expr->getArgs()[0]->value;
+				$newType = $this->getArraySortDoNotPreserveListFunctionType($scope->getType($arrayArg));
 				$scope = $scope->assignExpression(
 					$arrayArg,
-					$this->getArraySortDoNotPreserveListFunctionType($scope->getType($arrayArg)),
+					$newType,
 					$this->getArraySortDoNotPreserveListFunctionType($scope->getNativeType($arrayArg)),
 				);
+
+				$scope = $this->processAssignVar(
+					$scope,
+					$stmt,
+					$arrayArg,
+					new TypeExpr($newType),
+					static function (Node $node, Scope $scope) use ($nodeCallback): void {
+						if (!$node instanceof PropertyAssignNode && !$node instanceof VariableAssignNode) {
+							return;
+						}
+
+						$nodeCallback($node, $scope);
+					},
+					$context,
+					static fn (MutatingScope $scope): ExpressionResult => new ExpressionResult($scope, false, false, [], []),
+					true,
+				)->getScope();
 			}
 
 			if (

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

@@ -0,0 +1,28 @@
+<?php
+
+namespace Bug11846;
+
+use function PHPStan\Testing\assertType;
+
+function demo(): void
+{
+	$outerList = [];
+	$idList = [1, 2];
+
+	foreach ($idList as $id) {
+		$outerList[$id] = [];
+		array_push($outerList[$id], []);
+	}
+	assertType('non-empty-array<1|2, array{}|array{array{}}>', $outerList);
+
+	foreach ($outerList as $key => $outerElement) {
+		$result = false;
+
+		assertType('array{}|array{array{}}', $outerElement);
+		foreach ($outerElement as $innerElement) {
+			$result = true;
+		}
+		assertType('bool', $result); // could be 'true'
+
+	}
+}

tests/PHPStan/Analyser/nsrt/shuffle.php

@@ -13,7 +13,7 @@ public function normalArrays1(array $arr): void
 		/** @var mixed[] $arr */
 		shuffle($arr);
 		assertType('list<mixed>', $arr);
-		assertNativeType('list', $arr);
+		assertNativeType('list<mixed>', $arr);
 		assertType('list<int<0, max>>', array_keys($arr));
 		assertType('list<mixed>', array_values($arr));
 	}
@@ -23,7 +23,7 @@ public function normalArrays2(array $arr): void
 		/** @var non-empty-array<string, int> $arr */
 		shuffle($arr);
 		assertType('non-empty-list<int>', $arr);
-		assertNativeType('list', $arr);
+		assertNativeType('non-empty-list<int>', $arr);
 		assertType('non-empty-list<int<0, max>>', array_keys($arr));
 		assertType('non-empty-list<int>', array_values($arr));
 	}
@@ -67,7 +67,7 @@ public function constantArrays2(array $arr): void
 		/** @var array{0?: 1, 1?: 2, 2?: 3} $arr */
 		shuffle($arr);
 		assertType('list<1|2|3>', $arr);
-		assertNativeType('list', $arr);
+		assertNativeType('list<1|2|3>', $arr);
 		assertType('list<0|1|2>', array_keys($arr));
 		assertType('list<1|2|3>', array_values($arr));
 	}
@@ -107,7 +107,7 @@ public function constantArrays6(array $arr): void
 		/** @var array{foo?: 1, bar: 2, }|array{baz: 3, foobar?: 4} $arr */
 		shuffle($arr);
 		assertType('non-empty-list<1|2|3|4>', $arr);
-		assertNativeType('list', $arr);
+		assertNativeType('non-empty-list<1|2|3|4>', $arr);
 		assertType('non-empty-list<0|1>', array_keys($arr));
 		assertType('non-empty-list<1|2|3|4>', array_values($arr));
 	}

tests/PHPStan/Analyser/nsrt/sort.php

@@ -91,17 +91,17 @@ public function normalArray(array $arr): void
 		$arr1 = $arr;
 		sort($arr1);
 		assertType('list<string>', $arr1);
-		assertNativeType('list', $arr1);
+		assertNativeType('list<string>', $arr1);
 
 		$arr2 = $arr;
 		rsort($arr2);
 		assertType('list<string>', $arr2);
-		assertNativeType('list', $arr2);
+		assertNativeType('list<string>', $arr2);
 
 		$arr3 = $arr;
 		usort($arr3, fn(int $a, int $b) => $a <=> $b);
 		assertType('list<string>', $arr3);
-		assertNativeType('list', $arr3);
+		assertNativeType('list<string>', $arr3);
 	}
 
 	public function mixed($arr): void

tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php

@@ -45,4 +45,14 @@ public function testBug13248(): void
 		$this->analyse([__DIR__ . '/data/bug-13248.php'], []);
 	}
 
+	public function testBug2560(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-2560.php'], []);
+	}
+
+	public function testBug2457(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-2457.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Arrays/data/bug-2457.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Bug2457;
+
+class HelloWorld
+{
+	public function sayHello(array $x, array $y): void
+	{
+		$a = [];
+		$o = [];
+
+		foreach ($x as $t) {
+			if (!isset($a[$t])) {
+				$a[$t] = [];
+			}
+			$o[] = 'x';
+			array_unshift($a[$t], count($o) - 1);
+		}
+
+		foreach ($y as $t) {
+			if (!isset($a[$t])) {
+				continue;
+			}
+			foreach ($a[$t] as $b) {
+				// this will be reached
+			}
+		}
+	}
+}

tests/PHPStan/Rules/Arrays/data/bug-2560.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Bug2560;
+
+class HelloWorld
+{
+	public function test(): void
+	{
+		$arr = [];
+		foreach ([0,1] as $i) {
+			$arr[$i] = [];
+			array_push($arr[$i], "foo");
+		}
+		foreach (array_values($arr) as $vec) {
+			foreach ($vec as $value) {
+				print_r("$value");
+			}
+		}
+	}
+}

tests/PHPStan/Rules/Comparison/NumberComparisonOperatorsConstantConditionRuleTest.php

@@ -257,4 +257,10 @@ public function testBug12716(): void
 		$this->analyse([__DIR__ . '/data/bug-12716.php'], []);
 	}
 
+	public function testBug3387(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-3387.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Comparison/data/bug-3387.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Bug3387;
+
+function (array $items, string $key) {
+	$array = [$key => []];
+	foreach ($items as $item) {
+		$array[$key][] = $item;
+		if (count($array[$key]) > 1) {
+			throw new RuntimeException();
+		}
+	}
+};
+
+function (array $items, string $key) {
+	$array = [$key => []];
+	foreach ($items as $item) {
+		array_unshift($array[$key], $item);
+		if (count($array[$key]) > 1) {
+			throw new RuntimeException();
+		}
+	}
+};
+
+function (array $items, string $key) {
+	$array = [$key => []];
+	foreach ($items as $item) {
+		array_push($array[$key], $item);
+		if (count($array[$key]) > 1) {
+			throw new RuntimeException();
+		}
+	}
+};