Check each union member individually for positional calls with different parameter names

When calling a method on a union type where parameters at the same position
have different names (e.g., A::foo(int $a, string $b) vs B::foo(string $b, int $a)),
the combined positional acceptor produces compound names like $a|$b with union
types int|string that accept too broadly. This adds per-member checking in
CallMethodsRule for positional-only calls when compound parameter names are
detected, so type errors against individual union members are reported.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: phpstan-bot

src/Rules/Methods/CallMethodsRule.php

@@ -9,11 +9,13 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\RegisteredRule;
 use PHPStan\Internal\SprintfHelper;
+use PHPStan\Reflection\ExtendedMethodReflection;
 use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Rules\FunctionCallParametersCheck;
 use PHPStan\Rules\IdentifierRuleError;
 use PHPStan\Rules\Rule;
 use function array_merge;
+use function str_contains;
 
 /**
  * @implements Rule<Node\Expr\MethodCall>
@@ -69,16 +71,51 @@ private function processSingleMethodCall(Scope $scope, MethodCall $node, string
 			return $errors;
 		}
 
+		$args = $node->getArgs();
+		$selectedAcceptor = ParametersAcceptorSelector::selectFromArgs(
+			$scope,
+			$args,
+			$methodReflection->getVariants(),
+			$methodReflection->getNamedArgumentsVariants(),
+		);
+
+		if ($this->shouldCheckPerUnionMember($selectedAcceptor, $args)) {
+			$callerType = $scope->getType($node->var);
+			foreach ($callerType->getObjectClassReflections() as $classReflection) {
+				if (!$classReflection->hasMethod($methodName)) {
+					continue;
+				}
+				$memberMethod = $classReflection->getMethod($methodName, $scope);
+				$memberAcceptor = ParametersAcceptorSelector::selectFromArgs(
+					$scope,
+					$args,
+					$memberMethod->getVariants(),
+					$memberMethod->getNamedArgumentsVariants(),
+				);
+				$errors = array_merge($errors, $this->checkMethodParameters($memberAcceptor, $scope, $node, $memberMethod));
+			}
+		} else {
+			$errors = array_merge($errors, $this->checkMethodParameters($selectedAcceptor, $scope, $node, $methodReflection));
+		}
+
+		return $errors;
+	}
+
+	/**
+	 * @return list<IdentifierRuleError>
+	 */
+	private function checkMethodParameters(
+		\PHPStan\Reflection\ParametersAcceptor $acceptor,
+		Scope $scope,
+		MethodCall $node,
+		ExtendedMethodReflection $methodReflection,
+	): array
+	{
 		$declaringClass = $methodReflection->getDeclaringClass();
 		$messagesMethodName = SprintfHelper::escapeFormatString($declaringClass->getDisplayName() . '::' . $methodReflection->getName() . '()');
 
-		return array_merge($errors, $this->parametersCheck->check(
-			ParametersAcceptorSelector::selectFromArgs(
-				$scope,
-				$node->getArgs(),
-				$methodReflection->getVariants(),
-				$methodReflection->getNamedArgumentsVariants(),
-			),
+		return $this->parametersCheck->check(
+			$acceptor,
 			$scope,
 			$declaringClass->isBuiltin(),
 			$node,
@@ -99,7 +136,33 @@ private function processSingleMethodCall(Scope $scope, MethodCall $node, string
 			'Return type of call to method ' . $messagesMethodName . ' contains unresolvable type.',
 			'%s of method ' . $messagesMethodName . ' contains unresolvable type.',
 			'Method ' . $messagesMethodName . ' invoked with %s, but it\'s not allowed because of @no-named-arguments.',
-		));
+		);
+	}
+
+	/**
+	 * @param Node\Arg[] $args
+	 */
+	private function shouldCheckPerUnionMember(\PHPStan\Reflection\ParametersAcceptor $acceptor, array $args): bool
+	{
+		$hasCompoundName = false;
+		foreach ($acceptor->getParameters() as $parameter) {
+			if (str_contains($parameter->getName(), '|')) {
+				$hasCompoundName = true;
+				break;
+			}
+		}
+
+		if (!$hasCompoundName) {
+			return false;
+		}
+
+		foreach ($args as $arg) {
+			if ($arg->name !== null) {
+				return false;
+			}
+		}
+
+		return true;
 	}
 
 }

tests/PHPStan/Rules/Methods/CallMethodsRuleTest.php

@@ -4129,6 +4129,22 @@ public function testBug14661(): void
 				'Parameter $b of method Bug14661\A::differentTypes() expects string, int given.',
 				77,
 			],
+			[
+				'Parameter #1 $a of method Bug14661\A::differentTypes() expects int, string given.',
+				82,
+			],
+			[
+				'Parameter #2 $b of method Bug14661\A::differentTypes() expects string, int given.',
+				82,
+			],
+			[
+				'Parameter #1 $b of method Bug14661\B::differentTypes() expects string, int given.',
+				83,
+			],
+			[
+				'Parameter #2 $a of method Bug14661\B::differentTypes() expects int, string given.',
+				83,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/Methods/data/bug-14661.php

@@ -77,6 +77,12 @@ function differentTypesErrors(A|B $obj): void
     $obj->differentTypes(b: 1, a: 'hello');
 }
 
+function differentTypesPositional(A|B $obj): void
+{
+    $obj->differentTypes('hello', 1);
+    $obj->differentTypes(1, 'hello');
+}
+
 function threeWayUnion(A|B|C $obj): void
 {
     $obj->mixedOrder(target: 'value');