Fix

Author: VincentLanglet

src/Rules/Arrays/NonexistentOffsetInArrayDimFetchCheck.php

@@ -12,7 +12,9 @@
 use PHPStan\Rules\RuleLevelHelper;
 use PHPStan\Type\BenevolentUnionType;
 use PHPStan\Type\ErrorType;
+use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\TypeUtils;
 use PHPStan\Type\VerbosityLevel;
 use function count;
@@ -60,6 +62,15 @@ public function check(
 		}
 
 		if ($type->hasOffsetValueType($dimType)->no()) {
+			if ($type->isArray()->yes()) {
+				$validArrayDimType = TypeCombinator::intersect(AllowedArrayKeysTypes::getType(), $dimType);
+				if ($validArrayDimType instanceof NeverType) {
+					// Already reported by InvalidKeyInArrayDimFetchRule
+					return [];
+				}
+			}
+
+
 			return [
 				RuleErrorBuilder::message(sprintf('Offset %s does not exist on %s.', $dimType->describe(count($dimType->getConstantStrings()) > 0 ? VerbosityLevel::precise() : VerbosityLevel::value()), $type->describe(VerbosityLevel::value())))
 					->identifier('offsetAccess.notFound')
@@ -76,28 +87,32 @@ public function check(
 				$flattenedTypes = TypeUtils::flattenTypes($type);
 			}
 
+			$validArrayDimType = TypeCombinator::intersect(AllowedArrayKeysTypes::getType(), $dimType);
+
 			foreach ($flattenedTypes as $innerType) {
+				$dimTypeToCheck = $innerType->isArray()->yes() ? $validArrayDimType : $dimType;
+
 				if (
 					$this->reportPossiblyNonexistentGeneralArrayOffset
 					&& $innerType->isArray()->yes()
 					&& !$innerType->isConstantArray()->yes()
-					&& !$innerType->hasOffsetValueType($dimType)->yes()
+					&& !$innerType->hasOffsetValueType($dimTypeToCheck)->yes()
 				) {
 					$report = true;
 					break;
 				}
 				if (
 					$this->reportPossiblyNonexistentConstantArrayOffset
 					&& $innerType->isConstantArray()->yes()
-					&& !$innerType->hasOffsetValueType($dimType)->yes()
+					&& !$innerType->hasOffsetValueType($dimTypeToCheck)->yes()
 				) {
 					$report = true;
 					break;
 				}
-				if ($dimType instanceof BenevolentUnionType) {
-					$flattenedInnerTypes = [$dimType];
+				if ($dimTypeToCheck instanceof BenevolentUnionType) {
+					$flattenedInnerTypes = [$dimTypeToCheck];
 				} else {
-					$flattenedInnerTypes = TypeUtils::flattenTypes($dimType);
+					$flattenedInnerTypes = TypeUtils::flattenTypes($dimTypeToCheck);
 				}
 				foreach ($flattenedInnerTypes as $innerDimType) {
 					if (

src/Type/ArrayType.php

@@ -272,6 +272,9 @@ public function hasOffsetValueType(Type $offsetType): TrinaryLogic
 		if ($offsetArrayKeyType instanceof ErrorType) {
 			$allowedArrayKeys = AllowedArrayKeysTypes::getType();
 			$offsetArrayKeyType = TypeCombinator::intersect($allowedArrayKeys, $offsetType)->toArrayKey();
+			if ($offsetArrayKeyType instanceof NeverType) {
+				return TrinaryLogic::createNo();
+			}
 		}
 		$offsetType = $offsetArrayKeyType;
 

src/Type/Constant/ConstantArrayType.php

@@ -586,6 +586,9 @@ public function hasOffsetValueType(Type $offsetType): TrinaryLogic
 		if ($offsetArrayKeyType instanceof ErrorType) {
 			$allowedArrayKeys = AllowedArrayKeysTypes::getType();
 			$offsetArrayKeyType = TypeCombinator::intersect($allowedArrayKeys, $offsetType)->toArrayKey();
+			if ($offsetArrayKeyType instanceof NeverType) {
+				return TrinaryLogic::createNo();
+			}
 		}
 
 		return $this->recursiveHasOffsetValueType($offsetArrayKeyType);

tests/PHPStan/Rules/Arrays/NonexistentOffsetInArrayDimFetchRuleTest.php

@@ -1024,6 +1024,55 @@ public function testBug13538(): void
 		]);
 	}
 
+	public function testPR4385(): void
+	{
+		$this->reportPossiblyNonexistentGeneralArrayOffset = true;
+		$this->reportPossiblyNonexistentConstantArrayOffset = true;
+
+		$this->analyse([__DIR__ . '/data/pr-4385.php'], [
+			[
+				'Offset int might not exist on array<int>.',
+				24,
+			],
+			[
+				'Offset string might not exist on array<int>.',
+				25,
+			],
+			[
+				'Offset array<int>|int might not exist on array<int>.',
+				28,
+			],
+			[
+				'Offset array<int>|string might not exist on array<int>.',
+				29,
+			],
+			[
+				'Offset 0|array<int> might not exist on array<int>.',
+				30,
+			],
+			[
+				'Offset int might not exist on array{string}.',
+				33,
+			],
+			[
+				'Offset string might not exist on array{string}.',
+				34,
+			],
+			[
+				'Offset array<int>|int might not exist on array{string}.',
+				37,
+			],
+			[
+				'Offset array<int>|string might not exist on array{string}.',
+				38,
+			],
+			[
+				'Offset array<int>|int might not exist on array<int>|string.',
+				41,
+			],
+		]);
+	}
+
 	public function testBug12805(): void
 	{
 		$this->reportPossiblyNonexistentGeneralArrayOffset = true;

tests/PHPStan/Rules/Arrays/data/pr-4385.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Pr4385;
+
+class Foo
+{
+	/**
+	 * @param array<int> $array
+	 * @param int   $int
+	 * @param string $string
+	 * @param object $object
+	 * @param array{0: string} $constantArray
+	 *
+	 * @return void
+	 */
+	public function test($array, $int, $string, $object, $constantArray)
+	{
+		$arrayOrObject = rand(0, 1) ? $array : $object;
+		$arrayOrInt = rand(0, 1) ? $array : $int;
+		$arrayOrString = rand(0, 1) ? $array : $string;
+		$arrayOrZero = rand(0, 1) ? $array : 0;
+
+		$array[$array];
+		$array[$int];
+		$array[$string];
+		$array[$object];
+		$array[$arrayOrObject];
+		$array[$arrayOrInt];
+		$array[$arrayOrString];
+		$array[$arrayOrZero];
+
+		$constantArray[$array];
+		$constantArray[$int];
+		$constantArray[$string];
+		$constantArray[$object];
+		$constantArray[$arrayOrObject];
+		$constantArray[$arrayOrInt];
+		$constantArray[$arrayOrString];
+		$constantArray[$arrayOrZero];
+
+		$arrayOrString[$arrayOrInt];
+	}
+}