Narrow ConstantArrayType with callable and remove IntersectionType special behavior

Move callable-array narrowing logic entirely into TypeCombinator::intersect():
- Add ConstantArrayType + CallableType handling to narrow value types at offsets 0 and 1
- Update callable-array PHPDoc resolution to use TypeCombinator::intersect()
- Remove redundant hasOffsetValueType/getOffsetValueType callable logic from IntersectionType

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: phpstan-bot

phpstan-baseline.neon

@@ -1698,13 +1698,13 @@ parameters:
 		-
 			rawMessage: 'Doing instanceof PHPStan\Type\CallableType is error-prone and deprecated. Use Type::isCallable() and Type::getCallableParametersAcceptors() instead.'
 			identifier: phpstanApi.instanceofType
-			count: 3
+			count: 5
 			path: src/Type/TypeCombinator.php
 
 		-
 			rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantArrayType is error-prone and deprecated. Use Type::getConstantArrays() instead.'
 			identifier: phpstanApi.instanceofType
-			count: 19
+			count: 21
 			path: src/Type/TypeCombinator.php
 
 		-

src/PhpDoc/TypeNodeResolver.php

@@ -429,7 +429,7 @@ private function resolveIdentifierTypeNode(IdentifierTypeNode $typeNode, NameSco
 				return new IntersectionType([new ObjectWithoutClassType(), new CallableType()]);
 
 			case 'callable-array':
-				return new IntersectionType([new ArrayType(new MixedType(), new MixedType()), new CallableType()]);
+				return TypeCombinator::intersect(new ArrayType(new MixedType(), new MixedType()), new CallableType());
 
 			case 'never':
 			case 'noreturn':

src/Type/IntersectionType.php

@@ -945,14 +945,6 @@ public function hasOffsetValueType(Type $offsetType): TrinaryLogic
 
 		$result = $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->hasOffsetValueType($offsetType));
 
-		if (!$result->yes() && $this->isCallable()->yes() && $this->isArray()->yes()) {
-			$arrayKeyOffsetType = $offsetType->toArrayKey();
-			$callableArrayOffsetType = new UnionType([new ConstantIntegerType(0), new ConstantIntegerType(1)]);
-			if ($callableArrayOffsetType->isSuperTypeOf($arrayKeyOffsetType)->yes()) {
-				return TrinaryLogic::createYes();
-			}
-		}
-
 		return $result;
 	}
 
@@ -963,21 +955,6 @@ public function getOffsetValueType(Type $offsetType): Type
 			return TypeUtils::toBenevolentUnion($result);
 		}
 
-		if ($this->isCallable()->yes() && $this->isArray()->yes()) {
-			$arrayKeyOffsetType = $offsetType->toArrayKey();
-			$callableArrayOffsetType = new UnionType([new ConstantIntegerType(0), new ConstantIntegerType(1)]);
-			if ($callableArrayOffsetType->isSuperTypeOf($arrayKeyOffsetType)->yes()) {
-				if ((new ConstantIntegerType(0))->isSuperTypeOf($arrayKeyOffsetType)->yes()) {
-					$narrowedType = new UnionType([new ClassStringType(), new ObjectWithoutClassType()]);
-				} elseif ((new ConstantIntegerType(1))->isSuperTypeOf($arrayKeyOffsetType)->yes()) {
-					$narrowedType = new StringType();
-				} else {
-					$narrowedType = new UnionType([new StringType(), new ObjectWithoutClassType()]);
-				}
-				$result = TypeCombinator::intersect($result, $narrowedType);
-			}
-		}
-
 		return $result;
 	}
 

src/Type/TypeCombinator.php

@@ -1723,6 +1723,28 @@ public static function intersect(Type ...$types): Type
 						continue;
 					}
 
+					if (
+						$types[$i] instanceof ConstantArrayType
+						&& $types[$j] instanceof CallableType
+					) {
+						$types[$i] = self::narrowConstantArrayWithCallable($types[$i]);
+						if ($types[$i] instanceof NeverType) {
+							return new NeverType();
+						}
+						continue;
+					}
+
+					if (
+						$types[$j] instanceof ConstantArrayType
+						&& $types[$i] instanceof CallableType
+					) {
+						$types[$j] = self::narrowConstantArrayWithCallable($types[$j]);
+						if ($types[$j] instanceof NeverType) {
+							return new NeverType();
+						}
+						continue;
+					}
+
 					continue;
 				}
 
@@ -1819,4 +1841,33 @@ public static function removeTruthy(Type $type): Type
 		return self::remove($type, StaticTypeFactory::truthy());
 	}
 
+	private static function narrowConstantArrayWithCallable(ConstantArrayType $constantArray): Type
+	{
+		$keyTypes = $constantArray->getKeyTypes();
+		$valueTypes = $constantArray->getValueTypes();
+		$newValueTypes = $valueTypes;
+
+		foreach ($keyTypes as $k => $keyType) {
+			if ((new ConstantIntegerType(0))->isSuperTypeOf($keyType)->yes()) {
+				$newValueTypes[$k] = self::intersect($valueTypes[$k], new UnionType([new ClassStringType(), new ObjectWithoutClassType()]));
+				if ($newValueTypes[$k] instanceof NeverType) {
+					return new NeverType();
+				}
+			} elseif ((new ConstantIntegerType(1))->isSuperTypeOf($keyType)->yes()) {
+				$newValueTypes[$k] = self::intersect($valueTypes[$k], new StringType());
+				if ($newValueTypes[$k] instanceof NeverType) {
+					return new NeverType();
+				}
+			}
+		}
+
+		return new ConstantArrayType(
+			$keyTypes,
+			$newValueTypes,
+			$constantArray->getNextAutoIndexes(),
+			$constantArray->getOptionalKeys(),
+			$constantArray->isList(),
+		);
+	}
+
 }

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

@@ -36,8 +36,7 @@ public function testCallableArrayIterableTypes(callable $value): void
 	public function testConstantArrayNarrowing(array $task): void
 	{
 		if (\is_callable($task)) {
-			// ConstantArrayType keeps its shape, callable narrows offset access
-			assertType('list{string, string}&callable(): mixed', $task);
+			assertType('list{class-string, string}&callable(): mixed', $task);
 			assertType('class-string', $task[0]);
 			assertType('string', $task[1]);
 		}
@@ -56,7 +55,7 @@ public function testTypedArrayNarrowing(array $task): void
 	/** @param callable-array $value */
 	public function testCallableArrayPhpDoc(array $value): void
 	{
-		assertType('array&callable(): mixed', $value);
+		assertType('list{class-string|object, string}&callable(): mixed', $value);
 		assertType('class-string|object', $value[0]);
 		assertType('string', $value[1]);
 	}

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

@@ -28,7 +28,7 @@ function testIsArrayOnCallable(callable $value): void {
 
 /** @param callable-array $value */
 function testCallableArrayPhpDoc(array $value): void {
-	assertType('array&callable(): mixed', $value);
+	assertType('list{class-string|object, string}&callable(): mixed', $value);
 	assertType('class-string|object', $value[0]);
 	assertType('string', $value[1]);
 }

tests/PHPStan/Analyser/nsrt/more-types.php

@@ -39,7 +39,7 @@ public function doFoo(
 	): void
 	{
 		assertType('pure-callable(): mixed', $pureCallable);
-		assertType('array&callable(): mixed', $callableArray);
+		assertType('list{class-string|object, string}&callable(): mixed', $callableArray);
 		assertType('resource', $closedResource);
 		assertType('resource', $openResource);
 		assertType('class-string<UnitEnum>', $enumString);