Try fixing assigning array offsets on possibly undefined nested array offsets

Author: ondrejmirtes

Diff for: src/Analyser/NodeScopeResolver.php

@@ -5756,24 +5756,26 @@ static function (): void {
 	 */
 	private function produceArrayDimFetchAssignValueToWrite(array $offsetTypes, Type $offsetValueType, Type $valueToWrite): Type
 	{
-		$offsetValueTypeStack = [$offsetValueType];
+		$offsetValueTypeStack = [[$offsetValueType, TrinaryLogic::createYes()]];
 		foreach (array_slice($offsetTypes, 0, -1) as $offsetType) {
 			if ($offsetType === null) {
+				$has = TrinaryLogic::createYes();
 				$offsetValueType = new ConstantArrayType([], []);
 
 			} else {
+				$has = $offsetValueType->hasOffsetValueType($offsetType);
 				$offsetValueType = $offsetValueType->getOffsetValueType($offsetType);
 				if ($offsetValueType instanceof ErrorType) {
 					$offsetValueType = new ConstantArrayType([], []);
 				}
 			}
 
-			$offsetValueTypeStack[] = $offsetValueType;
+			$offsetValueTypeStack[] = [$offsetValueType, $has];
 		}
 
 		foreach (array_reverse($offsetTypes) as $i => $offsetType) {
 			/** @var Type $offsetValueType */
-			$offsetValueType = array_pop($offsetValueTypeStack);
+			[$offsetValueType, $has] = array_pop($offsetValueTypeStack);
 			if (
 				!$offsetValueType instanceof MixedType
 				&& !$offsetValueType->isConstantArray()->yes()
@@ -5788,7 +5790,10 @@ private function produceArrayDimFetchAssignValueToWrite(array $offsetTypes, Type
 				}
 				$offsetValueType = TypeCombinator::intersect($offsetValueType, TypeCombinator::union(...$types));
 			}
-			$valueToWrite = $offsetValueType->setOffsetValueType($offsetType, $valueToWrite, $i === 0);
+			if (!$has->yes()) {
+				$offsetValueType = TypeCombinator::union($offsetValueType, new ConstantArrayType([], []));
+			}
+			$valueToWrite = $offsetValueType->setOffsetValueType($offsetType, $valueToWrite);
 		}
 
 		return $valueToWrite;

Diff for: tests/PHPStan/Analyser/nsrt/bug-10025.php

@@ -0,0 +1,25 @@
+<?php declare(strict_types = 1);
+
+namespace Bug10025;
+
+use function PHPStan\Testing\assertType;
+
+class MyClass {
+	public int $groupId;
+}
+
+/**
+ * @param list<MyClass> $foos
+ * @param list<MyClass> $bars
+ */
+function x(array $foos, array $bars): void {
+	$arr = [];
+	foreach ($foos as $foo) {
+		$arr[$foo->groupId]['foo'][] = $foo;
+	}
+	foreach ($bars as $bar) {
+		$arr[$bar->groupId]['bar'][] = $bar;
+	}
+
+	assertType('array<int, non-empty-array{foo?: non-empty-list<Bug10025\MyClass>, bar?: non-empty-list<Bug10025\MyClass>}>', $arr);
+}

Diff for: tests/PHPStan/Analyser/nsrt/bug-10089.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Bug10089;
+
+use function PHPStan\Testing\assertType;
+
+class Test
+{
+
+	protected function create_matrix(int $size): array
+	{
+		$size = min(8, $size);
+		$matrix = [];
+		for ($i = 0; $i < $size; $i++) {
+			$matrix[] = array_fill(0, $size, 0);
+		}
+
+		assertType('list<non-empty-list<0>>', $matrix);
+
+		$matrix[$size - 1][8] = 3;
+
+		assertType('non-empty-array<int, non-empty-array<int<0, max>, 0|3>>', $matrix);
+
+		return $matrix;
+	}
+
+}
+
+

Diff for: tests/PHPStan/Analyser/nsrt/bug-10640.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Bug10640;
+
+use function PHPStan\Testing\assertType;
+
+function (array $a, array $b): void {
+	$changes = [];
+	foreach ($a as $add) {
+		$changes[$add['id']]['add'][] = 1;
+	}
+	foreach ($b as $del) {
+		$changes[$del['id']]['del'][] = 2;
+	}
+	assertType('array<non-empty-array{add?: non-empty-list<1>, del?: non-empty-list<2>}>', $changes);
+};

Diff for: tests/PHPStan/Analyser/nsrt/bug-12078.php

@@ -0,0 +1,44 @@
+<?php declare(strict_types = 1);
+
+namespace Bug12078;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @return array <string,string>
+ */
+function returnsData6M(): array
+{
+	return ["A"=>'data A',"B"=>'Data B'];
+}
+/**
+ * @return array <string,string>
+ */
+function returnsData3M(): array
+{
+	return ["A"=>'data A',"C"=>'Data C'];
+}
+
+function main(){
+	$arrDataByKey = [];
+
+	$arrData6M = returnsData6M();
+	if([] === $arrData6M){
+		echo "No data for 6M\n";
+	}else{
+		foreach($arrData6M as $key => $data){
+			$arrDataByKey[$key]['6M'][] = $data;
+		}
+	}
+
+	$arrData3M = returnsData3M();
+	if([] === $arrData3M){
+		echo "No data for 3M\n";
+	}else{
+		foreach($arrData3M as $key => $data){
+			$arrDataByKey[$key]['3M'][] = $data;
+		}
+	}
+
+	assertType('array<string, non-empty-array{6M?: non-empty-list<string>, 3M?: non-empty-list<string>}>', $arrDataByKey);
+}

Diff for: tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php

@@ -829,4 +829,10 @@ public function testArrayDimFetchAfterArraySearch(): void
 		]);
 	}
 
+	public function testBug11679(): void
+	{
+		$this->reportPossiblyNonexistentGeneralArrayOffset = true;
+		$this->analyse([__DIR__ . '/data/bug-11679.php'], []);
+	}
+
 }

Diff for: tests/PHPStan/Rules/Arrays/data/bug-11679.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace Bug11679;
+
+class WorkingExample
+{
+	/** @var array{foo?: bool} */
+	private array $arr = [];
+
+	public function sayHello(): bool
+	{
+		if (!isset($this->arr['foo'])) {
+			$this->arr['foo'] = true;
+		}
+		return $this->arr['foo'];
+	}
+}
+
+class NonworkingExample
+{
+	/** @var array<int, array{foo?: bool}> */
+	private array $arr = [];
+
+	public function sayHello(int $index): bool
+	{
+		if (!isset($this->arr[$index]['foo'])) {
+			$this->arr[$index]['foo'] = true;
+		}
+		return $this->arr[$index]['foo'];
+	}
+}