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
Fixes phpstan/phpstan#5271

[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]

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]

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]

Tests are failing

1) PHPStan\Analyser\NodeScopeResolverTest::testFile@tests\PHPStan\Analyser\nsrt\bug-11014.php with data ('D:\a\phpstan-src\phpstan-src\...14.php')
Failed assertions in D:\a\phpstan-src\phpstan-src\tests\PHPStan\Analyser\nsrt\bug-11014.php:

Line 84:
Expected: 'curl_multi_add_handle'|'curl_multi_exec'|'curl_multi_init'
Actual:   mixed

Line 96:
Expected: 'curl_multi_add_handle'|'curl_multi_exec'|'curl_multi_init'
Actual:   mixed

Why the native type is not correct for constantArray which are nativeType

[phpstan-bot]

Pushed. Here's a summary of what was done:

Problem: For constant arrays passed to array_map/array_filter, the native type of callback parameters was mixed instead of the literal string union. The callback parameter's native PHP type is just callable, which doesn't carry the resolved template types.

Fix (3 files):

1. ArrayFilterArgVisitor — Added CALLBACK_ATTRIBUTE_NAME that tags the callback's value with the array expression (matching how ArrayMapArgVisitor tags callbacks for array_map). Only applies when there's no explicit $mode argument (default filter-by-value mode).

2. NodeScopeResolver — Added createNativeCallableParametersFromArrayArgs() helper that checks for ArrayMapArgVisitor and ArrayFilterArgVisitor::CALLBACK_ATTRIBUTE_NAME attributes on the closure expression. When present, it computes native callable parameters from $scope->getNativeType(arrayArg)->getIterableValueType() instead of from the bare callable type. Used in both processClosureNode and processArrowFunctionNode.

3. ClosureTypeResolver — Combined ArrayMapArgVisitor and ArrayFilterArgVisitor::CALLBACK_ATTRIBUTE_NAME into a single check, so array_filter callbacks use the same code path as array_map for both PHPDoc and native callable parameter computation.

[VincentLanglet]

Don't look for a specific fix for array_map/array_filter but more for a general fix.

You say that the callback parameter's native PHP type is just callable which loses this information but the type is correctly understood. So we maybe need to update the native PHP type too in these case.

[VincentLanglet]

Don't look for a specific fix for array_map/array_filter but more for a general fix.

You say that "the callback parameter's
native PHP type is just callable which loses this information" but the type is correctly understood. So we maybe need to update the native PHP type too in these case.

[phpstan-bot]

Pushed. Here's a summary of what was changed to address the review:

Problem: The previous approach special-cased array_map and array_filter in NodeScopeResolver (via createNativeCallableParametersFromArrayArgs()) and ClosureTypeResolver (via ArrayFilterArgVisitor::CALLBACK_ATTRIBUTE_NAME). The reviewer wanted a general fix instead.

Root cause: ParametersAcceptorSelector::selectFromArgs() already computes concrete callable types for callback parameters of array_map, array_filter, array_walk, and array_find. But it used NativeParameterReflection + FunctionVariant, which lose native type information when GenericParametersAcceptorResolver::resolve() wraps them (native types default to MixedType).

Fix: In selectFromArgs(), use ExtendedDummyParameter (which carries separate native types) + ExtendedFunctionVariant (which preserves them through resolution). Native callable types are computed using $scope->getNativeType() alongside the existing $scope->getType() calls. This makes $matchedParameter->getNativeType() return the correctly resolved native callable type, so the general createNativeCallableParameters() path works for all callback-accepting functions.

Removed:

• NodeScopeResolver::createNativeCallableParametersFromArrayArgs() (special-case method)
• ArrayFilterArgVisitor::CALLBACK_ATTRIBUTE_NAME (no longer needed)
• Array_map/filter-specific imports from NodeScopeResolver and ClosureTypeResolver

All tests pass (make tests: 12056 tests, 0 failures) and make phpstan reports no errors.

[VincentLanglet]

I feel like createExtendedParameter and createModifiedAcceptor are unclear method name

[phpstan-bot]

Renamed the two methods in ParametersAcceptorSelector.php:

• createExtendedParameter → parameterWithOverriddenType (creates a parameter with overridden type and native type, preserving other attributes)
• createModifiedAcceptor → acceptorWithReplacedParameters (creates a new acceptor with replaced parameters)

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

[VincentLanglet]

parameterWithOverriddenType and acceptorWithReplacedParameters are not yet good names.

There is already wrapAcceptor and wrapParameter ; we could build a similar name.
What about overrideParameterType and overrideAcceptorParameters ?

Also parameterWithOverriddenType could use wrapParameter and I wonder if acceptorWithReplacedParameters shouldn't use wrapAcceptor...

[phpstan-bot]

Pushed. Here's what was done:

• Renamed parameterWithOverriddenType → overrideParameterType and acceptorWithReplacedParameters → overrideAcceptorParameters (consistent with wrapParameter/wrapAcceptor naming convention)
• Refactored overrideParameterType to use wrapParameter internally — this eliminates the repeated instanceof ExtendedParameterReflection checks by delegating to wrapParameter first, then reading outType/closureThisType/attributes from the already-wrapped result
• Updated all 4 call sites of each method
• All 12056 tests pass, make phpstan reports no errors

[VincentLanglet]

Add non regression for phpstan/phpstan#5271

[phpstan-bot]

Pushed. Added a non-regression test for issue #5271 in two places:

• tests/PHPStan/Analyser/nsrt/bug-5271.php — NSRT test with assertType/assertNativeType verifying that array_filter callback parameters from PHPDoc-typed arrays have mixed as native type (not the PHPDoc type). Tests both closure and arrow function variants.
• tests/PHPStan/Rules/Classes/ImpossibleInstanceOfRuleTest.php — Rule test testBug5271() with treatPhpDocTypesAsCertain = false confirming the instanceof check inside array_filter does not report as always true.

[VincentLanglet]

instead of a nsrt test bug-5271 should have a rule test checking that https://phpstan.org/r/37cebac0-0a30-4164-b79d-31d4a7798bdb

/**
	 * @param BannerPatternLayer[]             $patterns
	 *
	 * @phpstan-param list<BannerPatternLayer> $patterns
	 * @return $this
	 */
	public function setPatterns(array $patterns) : self{
		$checked = array_filter($patterns, fn($v) => $v instanceof BannerPatternLayer);
		if(count($checked) !== count($patterns)){
			throw new \TypeError("Deque must only contain " . BannerPatternLayer::class . " objects");
		}
		$this->patterns = $checked;
		return $this;
	}

Does not report

Instanceof between BannerPatternLayer and BannerPatternLayer will always evaluate to true.

[phpstan-bot]

Updated the bug-5271 test to use the actual playground reproducer from the issue — the setPatterns method with array_filter + instanceof check, matching https://phpstan.org/r/37cebac0-0a30-4164-b79d-31d4a7798bdb. The rule test (testBug5271 with treatPhpDocTypesAsCertain = false) confirms no false positive is reported. All 12058 tests pass and make phpstan is clean.