Fix phpstan/phpstan#14249: Propagate @phpstan-assert-* annotations to First-class callables (Closures) and string callables

[phpstan-bot]

Summary

When a function with @phpstan-assert-if-true (or similar assertion annotations) was converted to a first-class callable (fn(...)) or used as a string callable ('fn_name'), the assertion metadata was lost. This meant type narrowing did not work when calling the function through a variable.

Changes

• Added Assertions property to ClosureType (src/Type/ClosureType.php) with a constructor parameter and getter, preserving assertions through traverse() and traverseSimultaneously()
• Modified InitializerExprTypeResolver::createFirstClassCallable() (src/Reflection/InitializerExprTypeResolver.php) to pass the function/method's assertions to the created ClosureType
• Added specifyTypesFromCallableCall() method and a new branch in TypeSpecifier::specifyTypesInCondition() (src/Analyser/TypeSpecifier.php) to handle FuncCall nodes where the callee is a variable — it checks for ClosureType with assertions (first-class callables) and ConstantStringType callables (string callables), then applies assertions using the existing specifyTypesFromAsserts mechanism

Root cause

The TypeSpecifier only handled assertion propagation for direct function calls (FuncCall with a Name node). When a function was used as a first-class callable (is_positive_int(...)), it was converted to a ClosureType that did not carry assertion metadata. Similarly, string callables ('is_positive_int') were not resolved back to their function reflection for assertion processing. The fix adds assertion storage to ClosureType and extends TypeSpecifier to resolve assertions from both callable forms.

Test

Added tests/PHPStan/Analyser/nsrt/bug-14249.php — an NSRT test that verifies @phpstan-assert-if-true positive-int $value correctly narrows the type to int<1, max> when the function is called directly, through a first-class callable variable, and through a string callable variable.

Fixes phpstan/phpstan#14249

[ondrejmirtes]

Stupid fix, should be a a new getAssertions method on CallableParametersAcceptor.

[staabm]

revert the fix and implement a new getAssertions method on CallableParametersAcceptor instead

[ondrejmirtes]

In case it doesn't notice, you need to rebase the branch

[phpstan-bot]

Done. Here's a summary of the changes:

Added getAsserts(): Assertions to the CallableParametersAcceptor interface (as requested by the reviewer), instead of relying on instanceof ClosureType checks in TypeSpecifier.

Files changed:

1. CallableParametersAcceptor.php - Added getAsserts(): Assertions method to the interface
2. ClosureType.php - Already had getAsserts(), no change needed (implements the interface method)
3. FunctionCallableVariant.php - Delegates to $this->function->getAsserts() (the underlying function/method reflection)
4. InaccessibleMethod.php - Returns Assertions::createEmpty()
5. ExtendedCallableFunctionVariant.php - Added optional $assertions constructor param + getter
6. TrivialParametersAcceptor.php - Returns Assertions::createEmpty()
7. CallableType.php - Returns Assertions::createEmpty()
8. ResolvedFunctionVariantWithCallable.php - Added optional $assertions constructor param + getter
9. ParametersAcceptorSelector.php - Passes $acceptor->getAsserts() when wrapping a CallableParametersAcceptor
10. GenericParametersAcceptorResolver.php - Passes assertions through to ResolvedFunctionVariantWithCallable
11. TypeSpecifier.php - Removed instanceof ClosureType check, now uses $variant->getAsserts() on any CallableParametersAcceptor; removed unused ClosureType import

[staabm]

template type resolving does not work yet for first class callable functions. see the newly added failling test case.

fix it

[phpstan-bot]

Done. Here's what I fixed:

Problem: Template type resolving wasn't working for first-class callable ($f1 = assertIfTemplated(...)) and string callable ($f2 = 'Bug14249\assertIfTemplated') assertions. The specifyTypesFromCallableCall method was using the raw CallableParametersAcceptor directly from getCallableParametersAcceptors(), which had unresolved template types.

Fix: Changed specifyTypesFromCallableCall to pass the callable variants through ParametersAcceptorSelector::selectFromArgs() with the actual call arguments. This triggers GenericParametersAcceptorResolver::resolve() which infers template types from arguments (e.g., T => true when called with true), matching the same pattern used for direct function calls at line 537.

The resolved acceptor's getResolvedTemplateTypeMap() then correctly contains the inferred types, so TemplateTypeHelper::resolveTemplateTypes() can resolve conditional assertions like (T is true ? true : false).

[staabm]

phpstan/phpunit test-failures will be fixed with phpstan/phpstan-phpunit#287 (unrelated to this PR).

I think this one here is good to go

[ondrejmirtes]

Thank you!

[phpstan-bot]

I processed this review but have nothing to report.