Keep the list flag when a list shape is intersected with an array type (#6717)

Author: staabm

src/Turbo/TurboExtensionEnabler.php

@@ -33,7 +33,7 @@
 final class TurboExtensionEnabler
 {
 
-	public const EXPECTED_EXTENSION_VERSION = '16bf720';
+	public const EXPECTED_EXTENSION_VERSION = 'f46d060';
 
 	private static bool $active = false;
 

src/Type/TypeCombinator.php

@@ -2310,6 +2310,9 @@ public static function doIntersect(Type ...$types): Type
 								);
 							}
 							$newArrayType = $newArray->getArray();
+							if ($constArray->isList()->yes()) {
+								$newArrayType = self::intersect($newArrayType, new AccessoryArrayListType());
+							}
 						}
 
 						if ($constArrayIsI) {

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

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace Bug15391;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @param list{0: 'x', 1?: 'a'|'b', 2?: 'a'|'b'} $l
+ */
+function narrow(array $l): void
+{
+	if (!in_array('b', $l, true)) {
+		assertType("list{0: 'x', 1?: 'a', 2?: 'a'}", $l);
+	} else {
+		assertType("list{0: 'x', 1?: 'a'|'b', 2?: 'a'|'b'}", $l);
+	}
+
+	if (in_array('a', $l, true)) {
+		assertType("list{0: 'x', 1?: 'a'|'b', 2?: 'a'|'b'}", $l);
+	}
+}
+
+/**
+ * @param list{0: 'x', 1?: 'a'|'b', 2?: 'a'|'b'}&array<mixed, 'a'|'x'> $a
+ * @param array{0: 'x', 1?: 'a'|'b', 2?: 'a'|'b'}&array<mixed, 'a'|'x'> $b
+ */
+function intersect(array $a, array $b): void
+{
+	assertType("list{0: 'x', 1?: 'a', 2?: 'a'}", $a);
+	assertType("array{0: 'x', 1?: 'a', 2?: 'a'}", $b);
+}
+
+function guardedAppendsInLoops(bool $c): void
+{
+	$l = ['x'];
+	foreach ([1, 2] as $_) {
+		if ($c && !in_array('a', $l, true)) {
+			$l[] = 'a';
+		}
+	}
+	foreach ([1, 2] as $_) {
+		if (!in_array('b', $l, true)) {
+			$l[] = 'b';
+		}
+	}
+	assertType("list{0: 'x', 1: 'a'|'b', 2?: 'a'|'b', 3?: 'b', 4?: 'b'}", $l);
+}

turbo-ext/src/TypeCombinator.cpp

@@ -3177,7 +3177,8 @@ class TypeCombinator
 	/* the constant array & array arm of doIntersect(): $constArray merged
 	 * with $otherArray (a definite constant array pair through
 	 * intersectDefiniteConstantArrays(), otherwise rebuilt through the
-	 * builder); the never reason falls back on $isSuperTypeA/$isSuperTypeB;
+	 * builder, a list shape staying a list); the never reason falls back on
+	 * $isSuperTypeA/$isSuperTypeB;
 	 * UNDEF = pending exception */
 	static zv::Val intersectConstantArrayWith(zval *constArray, zval *otherArray, zval *isSuperTypeA, zval *isSuperTypeB)
 	{
@@ -3277,7 +3278,16 @@ class TypeCombinator
 			zv::Val set = call(newArray.raw(), PT_LC("setoffsetvaluetype"), 3, args);
 			PT_FAIL_IF_UNDEF(set);
 		}
-		return call(newArray.raw(), PT_LC("getarray"));
+		zv::Val newArrayType = call(newArray.raw(), PT_LC("getarray"));
+		PT_FAIL_IF_UNDEF(newArrayType);
+		zend_long isList = callTrinary(constArray, PT_LC("islist"));
+		PT_FAIL_IF_NEG(isList);
+		if (isList == PT_TRI_YES) {
+			zv::Val list = accessoryArrayListType();
+			PT_FAIL_IF_UNDEF(list);
+			return intersect2(newArrayType.raw(), list.raw());
+		}
+		return newArrayType;
 	}
 
 	/* Mirrors isPlainOrBenevolentUnion() */