Do not use callable parameter types as native types for closure and arrow function parameters

[phpstan-bot]

Summary

When treatPhpDocTypesAsCertain is false, PHPStan incorrectly reports function.alreadyNarrowedType for type checks inside closures/arrow functions passed to array_map, array_filter, and similar functions. The issue is that PHPDoc-derived callable parameter types were being treated as native types.

Changes

• Modified MutatingScope::enterAnonymousFunctionWithoutReflection() to track the declared PHP type (before intersection with callable parameters) separately and use it for native expression types
• Modified MutatingScope::enterArrowFunctionWithoutReflection() with the same fix — pass the declared type as the native type argument to assignVariable()
• Both fixes ensure that callable parameter types derived from PHPDoc/generics in the calling context are treated as PHPDoc-level information only, not as native types

Root cause

In enterAnonymousFunctionWithoutReflection, lines 2037-2039 (before fix):

$holder = ExpressionTypeHolder::createYes($parameter->var, $parameterType);
$expressionTypes[$paramExprString] = $holder;
$nativeTypes[$paramExprString] = $holder;  // BUG: same holder for both

The $parameterType included the callable parameter type from the calling context (e.g., string from array_map(fn($item) => ..., $stringArray)). This type was derived from PHPDoc annotations (@param string[] $values), but was incorrectly used as the native type. When treatPhpDocTypesAsCertain is false, the rule uses $scope->getNativeType() which returned string instead of mixed, making it report is_string() as always true.

The same pattern existed in enterArrowFunctionWithoutReflection where assignVariable($name, $parameterType, $parameterType, ...) used the same enriched type for both the expression type and native type.

This mirrors how foreach correctly handles the distinction: it calls getIterableValueType() on both the PHPDoc type AND the native type separately, using assignVariable($name, $valueType, $nativeValueType, ...).

Analogous cases probed

• Closure in array_map — was broken, now fixed ✓
• Arrow function in array_map — was broken, now fixed ✓
• Closure in array_filter — was broken, now fixed ✓
• Arrow function in array_filter — was broken, now fixed ✓
• usort, uasort, uksort and all other callback-accepting functions — go through the same code path, now fixed ✓
• Method and static method call rules (ImpossibleCheckTypeMethodCallRule, ImpossibleCheckTypeStaticMethodCallRule) — use the same ImpossibleCheckTypeHelper and same $scope->getNativeType(), so they benefit from the scope fix ✓
• foreach loop — was already correct (uses separate native/PHPDoc iterable types) ✓
• Closure with explicit PHP type hint — still works correctly (native type = declared type) ✓

Test

• Added rule test testBug11014 in ImpossibleCheckTypeFunctionCallRuleTest with test data covering all four combinations (closure/arrow × array_map/array_filter)
• Added NSRT test tests/PHPStan/Analyser/nsrt/bug-11014.php verifying native types via assertNativeType('mixed', $item) for untyped callback parameters and assertNativeType('string', $item) for typed ones

Fixes phpstan/phpstan#11014

[VincentLanglet]

Add non regression test for phpstan/phpstan#5271

Add a nsrt test for the constant array

$undefined_curl_functions = array_filter(
	[
		'curl_multi_add_handle',
		'curl_multi_exec',
		'curl_multi_init',
	],
	static function( $function_name ) {
        assertType(..., $function_name);
        assertNativeType(..., $function_name);

		return true;
	}
);

[phpstan-bot]

make tests also completed successfully. Both verification steps passed, and the commit is already pushed. All done.

[VincentLanglet]

why the native type is not

'curl_multi_add_handle'|'curl_multi_exec'|'curl_multi_init'

in this case ?

This should be consistent with

$a = [
				'curl_multi_add_handle',
				'curl_multi_exec',
				'curl_multi_init',
		];

		foreach ($a as $b) {
			\PHPStan\Testing\assertNativeType("'curl_multi_add_handle'|'curl_multi_exec'|'curl_multi_init'", $b);
		}

[phpstan-bot]

Pushed successfully. Here's a summary of the changes:

Problem: The reviewer pointed out that for constant arrays passed to array_filter, the native type of the callback parameter should be the literal string union (consistent with foreach), not mixed. The previous fix was too conservative — it always used only the declared PHP type hint as the native type, ignoring callable parameter types entirely.

Solution: Track native callable parameters separately from PHPDoc-enriched callable parameters:

1. ArrayFilterArgVisitor — Extended to attach the array argument expression to the callback closure (for the default mode case without a 3rd $mode argument), enabling native type computation.

2. NodeScopeResolver::createNativeCallableParameters() — New method that computes native callable parameters from:

   • ArrayMapArgVisitor attribute → $scope->getNativeType(arrayArg)->getIterableValueType()
   • ArrayFilterArgVisitor::CALLBACK_ATTRIBUTE_NAME attribute → $scope->getNativeType(arrayArg)->getIterableValueType()

3. MutatingScope — Added $nativeCallableParameters parameter to enterAnonymousFunction, enterAnonymousFunctionWithoutReflection, enterArrowFunction, and enterArrowFunctionWithoutReflection. When present, native callable parameters are used for native type computation (intersected with the declared PHP type). When null, the declared PHP type is used alone.

4. ClosureTypeResolver and NodeScopeResolver — Updated all callers to compute and pass native callable parameters.

5. Tests — Updated NSRT test to assert correct native types for constant arrays ('curl_multi_add_handle'|'curl_multi_exec'|'curl_multi_init'), and added array_map and foreach constant array tests for consistency verification.

[VincentLanglet]

Do not default to null for the param nativeCallableParameters this will simplify the code

[phpstan-bot]

Done. Removed the = null default from all four $nativeCallableParameters parameters in MutatingScope.php. All callers already pass the argument explicitly, so no other changes were needed. Tests and make phpstan both pass.

[VincentLanglet]

This is a duplicate of the whole logic

if ($callableParameters !== null) {

There is something to refactor

[phpstan-bot]

Done. Extracted the duplicated callable parameter resolution logic into a private resolveCallableParameterType() helper method, eliminating the code duplication in both enterAnonymousFunctionWithoutReflection and enterArrowFunctionWithoutReflection. The four duplicated if/elseif/else blocks are now two-line calls each. Tests and make phpstan both pass.

[VincentLanglet]

Same it's a duplicate of the whole f ($callableParameters !== null) {

there is something to refactor

[VincentLanglet]

Merge both bug11014 into a single file use for both nsrt and rule test.

And use // lint >= 8.0 on it

[phpstan-bot]

Done. Merged the two bug-11014 test files into a single tests/PHPStan/Analyser/nsrt/bug-11014.php with // lint >= 8.0, deleted the separate rule test data file, and updated the rule test to reference the nsrt file. All tests and make phpstan pass.

[VincentLanglet]

The rector changes is expected since they are using native type
https://github.com/rectorphp/rector/blob/f60c0879b51a6697525713b2b2c4b0ec2b0de621/rules/TypeDeclaration/Rector/ArrowFunction/AddArrowFunctionReturnTypeRector.php#L55

[VincentLanglet]

Why the logic for nativeCallableParameters is not the same than the one for $callableParameters ?

We ends up with a logic which seems hardcoded to only support array_map and array_filter

[phpstan-bot]

Done. Here's a summary of the changes made to address the review:

Problem: The reviewer pointed out that createNativeCallableParameters in ClosureTypeResolver used completely different logic from the $callableParameters computation — it was hardcoded to only support array_map and array_filter.

Changes:

1. NodeScopeResolver: Extracted shared callable parameter resolution logic into doCreateCallableParameters() that accepts a type-getter closure. Both createCallableParameters() (using getType) and createNativeCallableParameters() (using getNativeType) delegate to it. The new createNativeCallableParameters accepts the same $args and $nativePassedToType parameters as createCallableParameters, with attribute-based fallback for array_map/array_filter where the general mechanism can't derive native types from template resolution.

2. ClosureTypeResolver: Computes $nativeCallableParameters following the same 4-case structure as $callableParameters (array_map, array_filter, immediately-invoked, inFunctionCallsStack), using getNativeType instead of getType in each case.

3. processClosureNode/processArrowFunctionNode: Added $nativePassedToType parameter, passed from processArgs via $parameterNativeType.

[VincentLanglet]

Why the special if for arrayFilterArrayArg is needed ? Can't it rely on the immediatelyInvokedArgs condition ? (and maybe arrayMapArgs too ?)

[phpstan-bot]

You're out of extra usage · resets 10:20pm (UTC)

[VincentLanglet]

no needed for nativePassedToType var, use it directly in the createNativeCallableParameters call

[VincentLanglet]

Why can't createNativeCallableParameters just rely on doCreateCallableParameters call like createCallableParameters ?