Ask isCallable() of callable-like arrays and strings only where the answer is consumed

[phpstan-bot]

Summary

A two-item array such as ['BigContainer', 'arbitrary_ident'] looks like a callable. Asking its type isCallable() makes PHPStan locate and reflect BigContainer to see whether it has an arbitrary_ident method. PHPStan asked this in several places even when nothing used the array as a callable, for example a private class constant used only in in_array(). With a large generated class (a compiled DI container), this made single-file analysis use hundreds of MB.

This change asks isCallable() only where the answer is used. On the issue's reproducer (a class with 25,000 methods), analysing the file drops from 288 MB to 34.5 MB (30.5 MB with the turbo extension). The file with the reversed item order, which never matched a class, uses 52.5 MB.

Changes

• src/Analyser/ExprHandler/ArrayHandler.php: the array literal's type callback asked isCallable() of every two-item array and only then checked whether a narrowed is_callable($array) expression was in scope. The cheap scope lookup now runs first, and isCallable() is asked only when that narrowing exists.
• src/Analyser/ArgumentsHandler.php: isCallable() was asked of every argument, including arrays and strings passed to plain array/string parameters like in_array()'s haystack. It is now asked only when the result is used:
  • the callback is called immediately (callCallbackImmediately()), or
  • callback-expression invalidation applies and the argument can be an object. Only closures carry invalidate expressions or used variables; the acceptors of callable arrays and strings return [] for both.
• src/Dependency/DependencyResolver.php: the Array_ branch (dependencies on the return types of callable arrays) is skipped for class-level initializers: class constants, property defaults and enum case values. Nothing calls these where they are declared.
• src/Reflection/GenericParametersAcceptorResolver.php (analogous case): inferPredicateTemplateTypes() asked every argument of every generic function isCallable() before checking whether the parameter is a callable with asserts. The order is now reversed. This also covered 'Class::method' string arguments.
• turbo-ext/src/ArrayHandler.cpp, turbo-ext/src/ArgumentsHandler.cpp: the same changes ported to the native mirrors. A follow-up make bump-turbo commit is needed once this commit has its final SHA.
• Probed and left unchanged, because they ask isCallable() only of values that are actually used as callables: UnusedPrivateMethodRule, SimpleImpurePoint, FuncCallHandler, ArgumentsNormalizer, TypeSpecifier, CallCallablesRule, FunctionCallableRule.
• Still reflected on purpose: a callable-like array assigned to a variable inside a function body. The dependency resolver keeps testing it because the variable may be called later.

Root cause

ConstantArrayType::isCallable() and ConstantStringType::isCallable() have to reflect the named class to answer. Several analyser paths asked this unconditionally, "just in case", before checking whether the answer would matter. The pattern: an expensive type query ordered before a cheap check that usually makes it unnecessary. Affected locations:

• ArrayHandler's type callback
• ArgumentsHandler::processArgs()
• DependencyResolver::collectNodeDependencies()
• GenericParametersAcceptorResolver::inferPredicateTemplateTypes()

Test

tests/PHPStan/Analyser/Bug15292Test.php registers a methods class reflection extension that records every hasMethod() question. It asserts:

• testCallableLikeValuesAreNotReflected (data/bug-15292.php): the class named in a callable-like class constant, a property default, an enum constant, and a 'Class::method' string argument to in_array() is never asked about. Without the fix, four method lookups are recorded. Each of the three changed analyser/dependency files is needed on its own; reverting any one brings back some of them.
• testCallableLikeGenericArgumentsAreNotReflected (data/bug-15292-generic.php): the same for arguments to a generic function. It fails without the GenericParametersAcceptorResolver change.
• testCallableIsReflected (data/bug-15292-callable.php): a positive control. An array passed to usort() is still reflected as a callable.

Also verified:

• make tests passes with and without the turbo extension loaded.
• turbo-ext/tests/walk-trace.php produces identical traces.
• smoke.php, side-by-side.php and signature-parity.php pass.
• make phpstan passes.
• make name-collision fails, but on an existing file it cannot parse (tests/PHPStan/Build/data/final-class-rule-pipe.php); it fails the same way on the base branch.

Fixes phpstan/phpstan#15292

🤖 Generated with Claude Code