Implement getNamedArgumentsVariants() on UnionTypeMethodReflection and IntersectionTypeMethodReflection to combine parameters by name

[phpstan-bot]

Summary

When calling a method with named arguments on a union type A|B where both classes have the same method with parameters in a different order, PHPStan falsely reported "Unknown parameter $target". This happened because UnionTypeMethodReflection::getNamedArgumentsVariants() returned null, forcing the system to use the positional-combined acceptor from getVariants() which produced compound parameter names like other|target that couldn't be matched by the named argument normalizer.

Changes

• Added ParametersAcceptorSelector::combineAcceptorsByParameterName() — a new public method analogous to combineAcceptors() but groups parameters by name instead of position (src/Reflection/ParametersAcceptorSelector.php)
• Implemented UnionTypeMethodReflection::getNamedArgumentsVariants() using combineAcceptorsByParameterName() (src/Reflection/Type/UnionTypeMethodReflection.php)
• Implemented IntersectionTypeMethodReflection::getNamedArgumentsVariants() using the same approach (src/Reflection/Type/IntersectionTypeMethodReflection.php)
• Modified the early-return optimization in ParametersAcceptorSelector::selectFromArgs() to skip when the acceptor has compound parameter names (from union type positional combining) and named arguments are present, allowing the existing named-arguments flow to handle them correctly
• Added acceptorHasCompoundParameterNames() private helper to detect names containing |

Analogous cases probed

• Static method calls on union types: confirmed fixed — they reuse UnionTypeMethodReflection, so the fix applies automatically. Added test in CallStaticMethodsRuleTest.
• Intersection types: fixed IntersectionTypeMethodReflection::getNamedArgumentsVariants() with the same pattern.
• Constructor calls on union types: not affected — InstantiationRule iterates per-class, doesn't go through UnionTypeMethodReflection.
• Callable calls: not affected — uses its own callable-specific reflection.

Root cause

combineAcceptors() merges parameters by position index, producing compound names like other|target when parameters at the same position have different names across union members. Neither ArgumentsNormalizer::reorderArgs() nor FunctionCallParametersCheck::processArguments() could match a named argument like target: against a parameter named other|target. The fix provides a separate named-arguments-specific variant combined by parameter name.

Test

• tests/PHPStan/Rules/Methods/data/bug-14661.php — regression test for instance method calls on A|B with named arguments in different parameter order. Covers: single named arg, both args in both orders, different parameter types, and three-way union.
• tests/PHPStan/Rules/Methods/data/bug-14661-static.php — analogous test for static method calls on class-string<A>|class-string<B>.
• Both tests expect zero errors (false positive fix).

Fixes phpstan/phpstan#14661

[ondrejmirtes]

I miss some test expected error failures to demonstrate that differentTypes method cannot be called without named arguments.

[phpstan-bot]

Pushed. Added test cases for differentTypes called with wrong named argument types on the A|B union — differentTypes(a: 'hello', b: 1) and differentTypes(b: 1, a: 'hello') both correctly produce errors because $a expects int and $b expects string (consistent across both union members when matched by name). This demonstrates that the combineAcceptorsByParameterName() path correctly enforces parameter types, catching type mismatches that the positional combined acceptor (int|string) cannot.

[ondrejmirtes]

No, I want to test that $obj->differentTypes('hello', 1); is wrong. Without named arguments.

[phpstan-bot]

Pushed. The changes address the reviewer's request by adding per-member checking for positional calls on union type methods where parameter names differ at the same position.

What changed:

• CallMethodsRule: When the combined positional acceptor has compound parameter names (like $a|b) and the call uses only positional arguments, each union member's method is checked individually instead of using the over-permissive combined acceptor. Extracted checkMethodParameters() helper to avoid duplicating the 15 message template strings.

• Test data (bug-14661.php): Added differentTypesPositional(A|B $obj) that calls $obj->differentTypes('hello', 1) and $obj->differentTypes(1, 'hello') without named arguments.

• Test expectations: 4 new expected errors demonstrating that positional calls produce type errors against the union member that doesn't accept the argument order (A for ('hello', 1), B for (1, 'hello')).

[ondrejmirtes]

I don't like this direction, doesn't work well. Keeping open so that someone can pick this up.