reportUnsafeArrayStringKeyCasting - detect implementation

Author: ondrejmirtes

conf/config.neon

@@ -82,6 +82,7 @@ parameters:
 	reportWrongPhpDocTypeInVarTag: false
 	reportAnyTypeWideningInVarTag: false
 	reportNonIntStringArrayKey: false
+	reportUnsafeArrayStringKeyCasting: null
 	reportPossiblyNonexistentGeneralArrayOffset: false
 	reportPossiblyNonexistentConstantArrayOffset: false
 	checkMissingOverrideMethodAttribute: false

conf/parametersSchema.neon

@@ -91,6 +91,7 @@ parametersSchema:
 	reportWrongPhpDocTypeInVarTag: bool()
 	reportAnyTypeWideningInVarTag: bool()
 	reportNonIntStringArrayKey: bool()
+	reportUnsafeArrayStringKeyCasting: schema(string(), pattern('detect|prevent'), nullable())
 	reportPossiblyNonexistentGeneralArrayOffset: bool()
 	reportPossiblyNonexistentConstantArrayOffset: bool()
 	checkMissingOverrideMethodAttribute: bool()

src/DependencyInjection/ContainerFactory.php

@@ -202,6 +202,7 @@ public static function postInitializeContainer(Container $container): void
 		$container->getService('typeSpecifier');
 
 		BleedingEdgeToggle::setBleedingEdge($container->getParameter('featureToggles')['bleedingEdge']);
+		ReportUnsafeArrayStringKeyCastingToggle::setLevel($container->getParameter('reportUnsafeArrayStringKeyCasting'));
 	}
 
 	public function getCurrentWorkingDirectory(): string

src/DependencyInjection/ReportUnsafeArrayStringKeyCastingToggle.php

@@ -0,0 +1,34 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\DependencyInjection;
+
+/**
+ * @phpstan-type Level = self::DETECT|self::PREVENT|null
+ */
+final class ReportUnsafeArrayStringKeyCastingToggle
+{
+
+	public const DETECT = 'detect';
+
+	public const PREVENT = 'prevent';
+
+	/** @var Level */
+	private static ?string $level = null;
+
+	/**
+	 * @return Level
+	 */
+	public static function getLevel(): ?string
+	{
+		return self::$level;
+	}
+
+	/**
+	 * @param Level $level
+	 */
+	public static function setLevel(?string $level): void
+	{
+		self::$level = $level;
+	}
+
+}

src/Type/Accessory/AccessoryDecimalIntegerStringType.php

@@ -246,7 +246,7 @@ public function toArray(): Type
 	public function toArrayKey(): Type
 	{
 		if ($this->inverse) {
-			return new StringType();
+			return $this;
 		}
 
 		return new IntegerType();

src/Type/ArrayType.php

@@ -2,6 +2,7 @@
 
 namespace PHPStan\Type;
 
+use PHPStan\DependencyInjection\ReportUnsafeArrayStringKeyCastingToggle;
 use PHPStan\Php\PhpVersion;
 use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
@@ -12,6 +13,7 @@
 use PHPStan\ShouldNotHappenException;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Accessory\AccessoryArrayListType;
+use PHPStan\Type\Accessory\AccessoryDecimalIntegerStringType;
 use PHPStan\Type\Accessory\HasOffsetValueType;
 use PHPStan\Type\Accessory\NonEmptyArrayType;
 use PHPStan\Type\Constant\ConstantArrayType;
@@ -47,6 +49,8 @@ class ArrayType implements Type
 
 	private Type $keyType;
 
+	private ?Type $cachedIterableKeyType = null;
+
 	/** @api */
 	public function __construct(Type $keyType, private Type $itemType)
 	{
@@ -198,15 +202,44 @@ public function getArraySize(): Type
 
 	public function getIterableKeyType(): Type
 	{
+		if ($this->cachedIterableKeyType !== null) {
+			return $this->cachedIterableKeyType;
+		}
 		$keyType = $this->keyType;
 		if ($keyType instanceof MixedType && !$keyType instanceof TemplateMixedType) {
-			return new BenevolentUnionType([new IntegerType(), new StringType()]);
+			$keyType = new BenevolentUnionType([new IntegerType(), new StringType()]);
 		}
 		if ($keyType instanceof StrictMixedType) {
-			return new BenevolentUnionType([new IntegerType(), new StringType()]);
+			$keyType = new BenevolentUnionType([new IntegerType(), new StringType()]);
+		}
+
+		$level = ReportUnsafeArrayStringKeyCastingToggle::getLevel();
+		if ($level === null) {
+			return $this->cachedIterableKeyType = $keyType;
+		}
+
+		if ($level === ReportUnsafeArrayStringKeyCastingToggle::PREVENT) {
+			return $this->cachedIterableKeyType = $keyType;
+		}
+
+		if ($level !== ReportUnsafeArrayStringKeyCastingToggle::DETECT) { // @phpstan-ignore notIdentical.alwaysFalse
+			throw new ShouldNotHappenException();
 		}
 
-		return $keyType;
+		return $this->cachedIterableKeyType = TypeTraverser::map($keyType, static function (Type $type, callable $traverse): Type {
+			if ($type instanceof UnionType) {
+				return $traverse($type);
+			}
+
+			if ($type->isString()->yes() && !$type->isDecimalIntegerString()->no()) {
+				return TypeCombinator::union(
+					new IntegerType(),
+					TypeCombinator::intersect($type, new AccessoryDecimalIntegerStringType(inverse: true)),
+				);
+			}
+
+			return $type;
+		});
 	}
 
 	public function getFirstIterableKeyType(): Type

tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingDetectTypeAcceptanceTest.php

@@ -0,0 +1,45 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Rules\Methods\CallMethodsRule;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use function array_merge;
+
+/**
+ * @extends RuleTestCase<CallMethodsRule>
+ */
+class ReportUnsafeArrayStringKeyCastingDetectTypeAcceptanceTest extends RuleTestCase
+{
+
+	public function getRule(): Rule
+	{
+		return self::getContainer()->getByType(CallMethodsRule::class);
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/report-unsafe-array-string-key-casting-accepts.php'], [
+			[
+				'Parameter #1 $a of method ReportUnsafeArrayStringKeyCastingAccepts\Foo::doBaz() expects array<non-decimal-int-string, stdClass>, non-empty-array<string, stdClass> given.',
+				33,
+			],
+			[
+				'Parameter #1 $a of method ReportUnsafeArrayStringKeyCastingAccepts\Foo::doBaz() expects array<non-decimal-int-string, stdClass>, non-empty-array<string, stdClass> given.',
+				39,
+			],
+		]);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return array_merge(
+			parent::getAdditionalConfigFiles(),
+			[
+				__DIR__ . '/reportUnsafeArrayStringKeyCastingDetect.neon',
+			],
+		);
+	}
+
+}

tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingDetectTypeInferenceTest.php

@@ -0,0 +1,40 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+use function array_merge;
+
+class ReportUnsafeArrayStringKeyCastingDetectTypeInferenceTest extends TypeInferenceTestCase
+{
+
+	public static function dataAsserts(): iterable
+	{
+		yield from self::gatherAssertTypes(__DIR__ . '/data/report-unsafe-array-string-key-casting-detect.php');
+	}
+
+	/**
+	 * @param mixed ...$args
+	 */
+	#[DataProvider('dataAsserts')]
+	public function testAsserts(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return array_merge(
+			parent::getAdditionalConfigFiles(),
+			[
+				__DIR__ . '/reportUnsafeArrayStringKeyCastingDetect.neon',
+			],
+		);
+	}
+
+}

tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingUnsafeTypeAcceptanceTest.php

@@ -0,0 +1,34 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Rules\Methods\CallMethodsRule;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<CallMethodsRule>
+ */
+class ReportUnsafeArrayStringKeyCastingUnsafeTypeAcceptanceTest extends RuleTestCase
+{
+
+	public function getRule(): Rule
+	{
+		return self::getContainer()->getByType(CallMethodsRule::class);
+	}
+
+	public function testRule(): void
+	{
+		$this->analyse([__DIR__ . '/data/report-unsafe-array-string-key-casting-accepts.php'], [
+			[
+				'Parameter #1 $a of method ReportUnsafeArrayStringKeyCastingAccepts\Foo::doBaz() expects array<non-decimal-int-string, stdClass>, non-empty-array<string, stdClass> given.',
+				33,
+			],
+			[
+				'Parameter #1 $a of method ReportUnsafeArrayStringKeyCastingAccepts\Foo::doBaz() expects array<non-decimal-int-string, stdClass>, non-empty-array<string, stdClass> given.',
+				39,
+			],
+		]);
+	}
+
+}

tests/PHPStan/Analyser/data/report-unsafe-array-string-key-casting-accepts.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace ReportUnsafeArrayStringKeyCastingAccepts;
+
+use stdClass;
+
+class Foo
+{
+
+	/** @param array<string, stdClass> $a */
+	public function doFoo(array $a): void
+	{
+
+	}
+
+	/** @param array<int|string, stdClass> $a */
+	public function doBar(array $a): void
+	{
+
+	}
+
+	/** @param array<non-decimal-int-string, stdClass> $a */
+	public function doBaz(array $a): void
+	{
+
+	}
+
+	public function doTest(string $s): void
+	{
+		$a = [$s => new stdClass()];
+		$this->doFoo($a);
+		$this->doBar($a);
+		$this->doBaz($a);
+
+		$b = [];
+		$b[$s] = new stdClass();
+		$this->doFoo($b);
+		$this->doBar($b);
+		$this->doBaz($b);
+	}
+
+}