Generics

Author: ondrejmirtes

src/Type/Constant/ConstantArrayType.php

@@ -2085,6 +2085,43 @@ public function inferTemplateTypes(Type $receivedType): TemplateTypeMap
 				$typeMap = $typeMap->union($valueType->inferTemplateTypes($receivedValueType));
 			}
 
+			$unsealed = $this->getUnsealedTypes();
+			if ($unsealed !== null) {
+				[$unsealedKeyType, $unsealedValueType] = $unsealed;
+
+				// Received's explicit keys not in $this's explicit keys are
+				// candidates for matching $this's unsealed extras pattern.
+				// Only contribute when the key type matches; mismatched explicit
+				// keys are extra entries the parameter wouldn't accept anyway,
+				// surfaced by the regular argument-type check.
+				$receivedKeyTypes = $receivedType->getKeyTypes();
+				$receivedValueTypes = $receivedType->getValueTypes();
+				foreach ($receivedKeyTypes as $j => $receivedKeyType) {
+					if ($this->hasOffsetValueType($receivedKeyType)->yes()) {
+						continue;
+					}
+					if (!$unsealedKeyType->isSuperTypeOf($receivedKeyType)->yes()) {
+						continue;
+					}
+					$typeMap = $typeMap->union($unsealedKeyType->inferTemplateTypes($receivedKeyType));
+					$typeMap = $typeMap->union($unsealedValueType->inferTemplateTypes($receivedValueTypes[$j]));
+				}
+
+				// Received's own unsealed extras describe "all the rest" — when
+				// the key type doesn't fit $this's unsealed key pattern there
+				// is no valid template assignment, so force NEVER.
+				$receivedUnsealed = $receivedType->getUnsealedTypes();
+				if ($receivedUnsealed !== null) {
+					[$receivedUnsealedKey, $receivedUnsealedValue] = $receivedUnsealed;
+					if ($unsealedKeyType->isSuperTypeOf($receivedUnsealedKey)->no()) {
+						$typeMap = $typeMap->union($unsealedValueType->inferTemplateTypes(new NeverType()));
+					} else {
+						$typeMap = $typeMap->union($unsealedKeyType->inferTemplateTypes($receivedUnsealedKey));
+						$typeMap = $typeMap->union($unsealedValueType->inferTemplateTypes($receivedUnsealedValue));
+					}
+				}
+			}
+
 			return $typeMap;
 		}
 

tests/PHPStan/Analyser/nsrt/unsealed-array-shapes.php

@@ -3,6 +3,7 @@
 namespace UnsealedArrayShapes;
 
 use DateTimeImmutable;
+use stdClass;
 use function PHPStan\Testing\assertType;
 
 class Foo
@@ -83,3 +84,45 @@ public function edgeCases(array $a, array $b, array $c): void
 	}
 
 }
+
+class Generics
+{
+
+	/**
+	 * @template T
+	 * @param T $a
+	 * @return array{a: int, ...<int, T>}
+	 */
+	public function replace($a): array
+	{
+
+	}
+
+	/**
+	 * @template T
+	 * @param array{a: int, ...<int, T>} $a
+	 * @return T
+	 */
+	public function infer(array $a)
+	{
+
+	}
+
+}
+
+/**
+ * @param Generics $g
+ * @param array{a: 1, b: 2, ...<int, stdClass>} $a
+ * @param array{a: 1, b: 2, ...<string, stdClass>} $b
+ * @param array<int, stdClass> $c
+ * @param array<string, stdClass> $d
+ * @return void
+ */
+function doFoo(Generics $g, array $a, array $b, array $c, array $d): void {
+	assertType('array{a: int, ...<int, stdClass>}', $g->replace(new stdClass()));
+	assertType('1|2|3', $g->infer([1, 2, 3, 'a' => 4]));
+	assertType('stdClass', $g->infer($a));
+	assertType('*NEVER*', $g->infer($b));
+	assertType('stdClass', $g->infer($c));
+	assertType('stdClass', $g->infer($d));
+};