Narrow array&callable intersection to list{class-string|object, string} by phpstan-bot · Pull Request #5563 · phpstan/phpstan-src

phpstan-bot · 2026-04-28T22:21:25Z

Summary

When is_callable() narrows an array to array&callable, the resulting type was too permissive — it didn't reflect that callable arrays in PHP are always [class-string|object, string] (a class/object and method name pair).

This PR adds narrowing logic in TypeCombinator::intersect() so that when a plain ArrayType is intersected with CallableType, it's replaced with a ConstantArrayType representing list{class-string|object, string}. This ensures:

The narrowed type displays as list{class-string|object, string}&callable(): mixed
Iterating over it yields 0|1 keys and object|string values
Passing it to a method expecting array<int> correctly reports a type error
Typed arrays (e.g. array<string>) are narrowed with intersection against the callable shape

Changes

src/Type/TypeCombinator.php: Added narrowing logic in intersect() for ArrayType + CallableType combinations
tests/PHPStan/Analyser/nsrt/bug-14549.php: New regression test covering plain array, typed array, constant array, and callable-array PHPDoc narrowing
tests/PHPStan/Rules/Methods/data/bug-14549.php: New rule test data verifying parameter type error is reported
tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php: Added testBug14549()
tests/PHPStan/Analyser/nsrt/bug-3842.php: Updated assertion to match new narrowed type
tests/PHPStan/Analyser/nsrt/bug-12393.php and bug-12393b.php: Updated callable-to-array-property assertion (array → array<mixed>)
phpstan-baseline.neon: Updated instanceof counts for ArrayType and CallableType

Test plan

make tests passes (11942 tests)
make phpstan passes (no errors)
make cs-fix passes (no violations)
make name-collision has a pre-existing failure unrelated to this change

When TypeCombinator::intersect() combines an ArrayType with a CallableType, replace the plain ArrayType with a ConstantArrayType representing array{class-string|object, string}. This reflects the fact that callable arrays in PHP are always two-element lists with a class-string or object at index 0 and a method name string at index 1. This fixes the issue where array&callable was too wide, causing: - Iteration over the intersection to yield mixed keys/values - Parameter type checking to accept array&callable where array<int> is expected Fixes phpstan/phpstan#14549

VincentLanglet

This PR should be able to remove the special behavior added in the InterdectionType hasOffsetValue and getOffsetvalue

VincentLanglet · 2026-04-28T22:42:28Z

+	{
+		if (\is_callable($task)) {
+			// ConstantArrayType keeps its shape, callable narrows offset access
+			assertType('list{string, string}&callable(): mixed', $task);


This should be narrowed to list{class-string, string}&callabld

All changes have been pushed. Here's a summary of what was done to address the review:

Added ConstantArrayType + CallableType narrowing in TypeCombinator::intersect() — When a ConstantArrayType (e.g. array{string, string}) is intersected with CallableType, the value types at offsets 0 and 1 are now narrowed (offset 0 intersected with class-string|object, offset 1 with string). This means array{string, string}&callable now becomes list{class-string, string}&callable.

Updated callable-array PHPDoc resolution in TypeNodeResolver to use TypeCombinator::intersect() instead of directly constructing an IntersectionType. This makes callable-array resolve to list{class-string|object, string}&callable(): mixed instead of the un-narrowed array&callable(): mixed.

Removed the special hasOffsetValueType/getOffsetValueType callable logic from IntersectionType — This is no longer needed since the narrowing now happens at the TypeCombinator level, producing a properly-typed ConstantArrayType upfront.

Updated test assertions in bug-14549.php, bug-3842.php, and more-types.php to match the new narrowed types.

All tests (11942) pass and make phpstan reports no errors.

VincentLanglet · 2026-04-28T22:43:14Z

+	/** @param callable-array $value */
+	public function testCallableArrayPhpDoc(array $value): void
+	{
+		assertType('array&callable(): mixed', $value);


This should be narrowed.

Callable-array parsing could be improved

…ecial 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>

…callable Instead of narrowing keys 0 and 1 independently, first verify both are present — a valid callable array requires both elements. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

phpstan-bot · 2026-04-29T04:56:30Z

Pushed. The fix changes narrowConstantArrayWithCallable to first locate both offset 0 and offset 1 in the array, and only narrow their value types if both are present. This addresses staabm's concern — a callable array requires both elements, so narrowing one in isolation without the other doesn't make sense.

staabm · 2026-04-29T04:56:55Z

+		$valueTypes = $constantArray->getValueTypes();
+		$newValueTypes = $valueTypes;
+
+		foreach ($keyTypes as $k => $keyType) {


we might want to immediately return NeverType when we have less than 2 key-types, so we don't create new ConstantArrayType for "too small/empty" constant arrays

Done. The change adds an early NeverType return in narrowConstantArrayWithCallable when the constant array has fewer than 2 keys or doesn't contain both offsets 0 and 1 — avoiding unnecessary ConstantArrayType construction for arrays that can't be callable. All tests pass and phpstan reports no errors.

When `narrowConstantArrayWithCallable` receives a ConstantArrayType with fewer than 2 keys, or without both offsets 0 and 1, return NeverType immediately instead of constructing an unchanged ConstantArrayType. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

staabm · 2026-04-29T05:12:00Z

+						$types[$i] = new ConstantArrayType(
+							[new ConstantIntegerType(0), new ConstantIntegerType(1)],
+							[$offset0ValueType, $offset1ValueType],
+							[2],


do we really know at this point that $types[$i] did not have more offsets than 0/1?

Pushed. Here's what was done to address staabm's review:

The concern: For the ArrayType + CallableType narrowing, does the code correctly account for all type information when replacing an ArrayType with a 2-element ConstantArrayType?

The answer: A plain ArrayType doesn't have specific offsets (that's ConstantArrayType), but it does carry a key type. Since callable arrays always require integer keys 0 and 1, the original code wasn't checking whether the key type was compatible with integers. For example, array<string, mixed> & callable should be never because string keys are incompatible with the integer keys a callable array requires.

Changes:

Extracted narrowArrayTypeWithCallable() — moved the inline narrowing logic into a dedicated method (mirroring narrowConstantArrayWithCallable) for clarity

Added key type check — verifies $arrayType->getKeyType()->isSuperTypeOf(new IntegerType()) before narrowing; returns NeverType if the key type can't include integers

Added test — array<string, mixed> + is_callable() now correctly resolves to *NEVER*

All 11,942 tests pass and make phpstan reports no errors.

ondrejmirtes · 2026-04-29T05:18:57Z

Hey, this is a huge diff trying to fix a simple error. I'd just fix it in MissingTypehintCheck. "Do not report missing iterable value type if the type is a callable and an array."

A plain ArrayType carries a key type (e.g. array<string, mixed> has StringType keys). Since callable arrays always require integer keys 0 and 1, verify the key type is compatible with integers before narrowing. Extract the inline logic into narrowArrayTypeWithCallable for clarity. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

VincentLanglet reviewed Apr 28, 2026

View reviewed changes

staabm approved these changes Apr 29, 2026

View reviewed changes

Require both offsets 0 and 1 before narrowing ConstantArrayType with …

fa7b3c6

…callable Instead of narrowing keys 0 and 1 independently, first verify both are present — a valid callable array requires both elements. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

staabm reviewed Apr 29, 2026

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Narrow array&callable intersection to list{class-string|object, string}#5563

Narrow array&callable intersection to list{class-string|object, string}#5563
phpstan-bot wants to merge 5 commits intophpstan:2.1.xfrom
phpstan-bot:create-pull-request/patch-rrmiaik

phpstan-bot commented Apr 28, 2026

Uh oh!

VincentLanglet left a comment

Uh oh!

VincentLanglet Apr 28, 2026

Uh oh!

phpstan-bot Apr 28, 2026

Uh oh!

VincentLanglet Apr 28, 2026

Uh oh!

phpstan-bot commented Apr 29, 2026

Uh oh!

staabm Apr 29, 2026

Uh oh!

phpstan-bot Apr 29, 2026

Uh oh!

staabm Apr 29, 2026

Uh oh!

phpstan-bot Apr 29, 2026

Uh oh!

ondrejmirtes commented Apr 29, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

Conversation

phpstan-bot commented Apr 28, 2026

Summary

Changes

Test plan

Uh oh!

VincentLanglet left a comment

Choose a reason for hiding this comment

Uh oh!

VincentLanglet Apr 28, 2026

Choose a reason for hiding this comment

Uh oh!

phpstan-bot Apr 28, 2026

Choose a reason for hiding this comment

Uh oh!

VincentLanglet Apr 28, 2026

Choose a reason for hiding this comment

Uh oh!

phpstan-bot commented Apr 29, 2026

Uh oh!

staabm Apr 29, 2026

Choose a reason for hiding this comment

Uh oh!

phpstan-bot Apr 29, 2026

Choose a reason for hiding this comment

Uh oh!

staabm Apr 29, 2026

Choose a reason for hiding this comment

Uh oh!

phpstan-bot Apr 29, 2026

Choose a reason for hiding this comment

Uh oh!

ondrejmirtes commented Apr 29, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants