ArrayType - use getIterableKeyType, it preserves array-key

phpstan · Mar 16, 2024 · d5bf23b · d5bf23b
1 parent fc4e589
commit d5bf23b
Show file tree

Hide file tree

Showing 8 changed files with 70 additions and 12 deletions.
diff --git a/src/Type/ArrayType.php b/src/Type/ArrayType.php
@@ -132,7 +132,7 @@ public function isSuperTypeOf(Type $type): TrinaryLogic
 	{
 		if ($type instanceof self) {
 			return $this->getItemType()->isSuperTypeOf($type->getItemType())
-				->and($this->keyType->isSuperTypeOf($type->keyType));
+				->and($this->getIterableKeyType()->isSuperTypeOf($type->getIterableKeyType()));
 		}
 
 		if ($type instanceof CompoundType) {
@@ -637,7 +637,7 @@ public function inferTemplateTypes(Type $receivedType): TemplateTypeMap
 		}
 
 		if ($receivedType->isArray()->yes()) {
-			$keyTypeMap = $this->getKeyType()->inferTemplateTypes($receivedType->getIterableKeyType());
+			$keyTypeMap = $this->getIterableKeyType()->inferTemplateTypes($receivedType->getIterableKeyType());
 			$itemTypeMap = $this->getItemType()->inferTemplateTypes($receivedType->getIterableValueType());
 
 			return $keyTypeMap->union($itemTypeMap);
@@ -651,7 +651,7 @@ public function getReferencedTemplateTypes(TemplateTypeVariance $positionVarianc
 		$variance = $positionVariance->compose(TemplateTypeVariance::createCovariant());
 
 		return array_merge(
-			$this->getKeyType()->getReferencedTemplateTypes($variance),
+			$this->getIterableKeyType()->getReferencedTemplateTypes($variance),
 			$this->getItemType()->getReferencedTemplateTypes($variance),
 		);
 	}

diff --git a/src/Type/Constant/ConstantArrayType.php b/src/Type/Constant/ConstantArrayType.php
@@ -875,7 +875,7 @@ public function shuffleArray(): Type
 			return $valuesArray;
 		}
 
-		$generalizedArray = new ArrayType($valuesArray->getKeyType(), $valuesArray->getItemType());
+		$generalizedArray = new ArrayType($valuesArray->getIterableKeyType(), $valuesArray->getItemType());
 
 		if ($isIterableAtLeastOnce->yes()) {
 			$generalizedArray = TypeCombinator::intersect($generalizedArray, new NonEmptyArrayType());
@@ -1229,7 +1229,7 @@ public function generalize(GeneralizePrecision $precision): Type
 		}
 
 		$arrayType = new ArrayType(
-			$this->getKeyType()->generalize($precision),
+			$this->getIterableKeyType()->generalize($precision),
 			$this->getItemType()->generalize($precision),
 		);
 
@@ -1281,7 +1281,7 @@ public function generalizeToArray(): Type
 			return $this;
 		}
 
-		$arrayType = new ArrayType($this->getKeyType(), $this->getItemType());
+		$arrayType = new ArrayType($this->getIterableKeyType(), $this->getItemType());
 
 		if ($isIterableAtLeastOnce->yes()) {
 			$arrayType = TypeCombinator::intersect($arrayType, new NonEmptyArrayType());

diff --git a/src/Type/TypeCombinator.php b/src/Type/TypeCombinator.php
@@ -671,7 +671,7 @@ private static function processArrayTypes(array $arrayTypes): array
 		foreach ($arrayTypes as $arrayType) {
 			if ($generalArrayOccurred || !$arrayType->isConstantArray()->yes()) {
 				foreach ($arrayType->getArrays() as $type) {
-					$keyTypesForGeneralArray[] = $type->getKeyType();
+					$keyTypesForGeneralArray[] = $type->getIterableKeyType();
 					$valueTypesForGeneralArray[] = $type->getItemType();
 					$generalArrayOccurred = true;
 				}
@@ -1200,7 +1200,7 @@ public static function intersect(Type ...$types): Type
 						($types[$i] instanceof ArrayType || $types[$i] instanceof IterableType) &&
 						($types[$j] instanceof ArrayType || $types[$j] instanceof IterableType)
 					) {
-						$keyType = self::intersect($types[$i]->getKeyType(), $types[$j]->getKeyType());
+						$keyType = self::intersect($types[$i]->getIterableKeyType(), $types[$j]->getKeyType());
 						$itemType = self::intersect($types[$i]->getItemType(), $types[$j]->getItemType());
 						if ($types[$i] instanceof IterableType && $types[$j] instanceof IterableType) {
 							$types[$j] = new IterableType($keyType, $itemType);

diff --git a/src/Type/TypehintHelper.php b/src/Type/TypehintHelper.php
@@ -184,7 +184,7 @@ public static function decideType(
 					foreach ($phpDocType->getTypes() as $innerType) {
 						if ($innerType instanceof ArrayType) {
 							$innerTypes[] = new IterableType(
-								$innerType->getKeyType(),
+								$innerType->getIterableKeyType(),
 								$innerType->getItemType(),
 							);
 						} else {

diff --git a/tests/PHPStan/Analyser/data/bug-4498.php b/tests/PHPStan/Analyser/data/bug-4498.php
@@ -38,7 +38,7 @@ public function fcn(iterable $iterable): iterable
 	public function bar(iterable $iterable): iterable
 	{
 		if (is_array($iterable)) {
-			assertType('array<TKey (method Bug4498\Foo::bar(), argument), TValue (method Bug4498\Foo::bar(), argument)>', $iterable);
+			assertType('array<((int&TKey (method Bug4498\Foo::bar(), argument))|(string&TKey (method Bug4498\Foo::bar(), argument))), TValue (method Bug4498\Foo::bar(), argument)>', $iterable);
 			return $iterable;
 		}
 

diff --git a/tests/PHPStan/Analyser/data/bug-7805.php b/tests/PHPStan/Analyser/data/bug-7805.php
@@ -21,10 +21,10 @@ function foo(array $params)
 		assertNativeType("array<mixed~'help', mixed>", $params);
 		$params = $params === [] ? ['list'] : $params;
 		assertType("array{'list'}", $params);
-		assertNativeType("non-empty-array<mixed~'help', mixed>", $params);
+		assertNativeType("non-empty-array', mixed>", $params);
 		array_unshift($params, 'help');
 		assertType("array{'help', 'list'}", $params);
-		assertNativeType("non-empty-array<mixed~'help', mixed>", $params);
+		assertNativeType("non-empty-array", $params);
 	}
 	assertType("array{}|array{'help', 'list'}", $params);
 	assertNativeType('array', $params);

diff --git a/tests/PHPStan/Rules/Variables/ParameterOutAssignedTypeRuleTest.php b/tests/PHPStan/Rules/Variables/ParameterOutAssignedTypeRuleTest.php
@@ -59,4 +59,9 @@ public function testBug10699(): void
 		$this->analyse([__DIR__ . '/../../Analyser/data/bug-10699.php'], []);
 	}
 
+	public function testBenevolentArrayKey(): void
+	{
+		$this->analyse([__DIR__ . '/data/benevolent-array-key.php'], []);
+	}
+
 }
diff --git a/tests/PHPStan/Rules/Variables/data/benevolent-array-key.php b/tests/PHPStan/Rules/Variables/data/benevolent-array-key.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace ParamOutBenevolentArrayKey;
+
+class HelloWorld
+{
+	/**
+	 * @param array<mixed> $matches
+	 * @param-out array<int|string, list<string>> $matches
+	 */
+	public static function matchAllStrictGroups(array &$matches): int
+	{
+		$result = self::matchAll($matches);
+
+		return $result;
+	}
+
+	/**
+	 * @param array<mixed> $matches
+	 * @param-out array<list<string>> $matches
+	 */
+	public static function matchAll(array &$matches): int
+	{
+		$matches = [['foo']];
+
+		return 1;
+	}
+}
+
+class HelloWorld2
+{
+	/**
+	 * @param array<mixed> $matches
+	 * @param-out array<list<string>> $matches
+	 */
+	public static function matchAllStrictGroups(array &$matches): int
+	{
+		$result = self::matchAll($matches);
+
+		return $result;
+	}
+
+	/**
+	 * @param array<mixed> $matches
+	 * @param-out array<int|string, list<string>> $matches
+	 */
+	public static function matchAll(array &$matches): int
+	{
+		$matches = [['foo']];
+
+		return 1;
+	}
+}