Use intersection method resolution for getCallableParametersAcceptors()

Instead of collecting and merging callable acceptors from individual
types (which is union-like behavior), leverage IntersectionType's own
__invoke method resolution via IntersectionTypeMethodReflection. This
properly intersects return types when multiple types define __invoke.

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

Author: phpstan-bot

src/Type/IntersectionType.php

@@ -14,8 +14,10 @@
 use PHPStan\Reflection\ExtendedPropertyReflection;
 use PHPStan\Reflection\InitializerExprTypeResolver;
 use PHPStan\Reflection\MissingConstantFromReflectionException;
+use PHPStan\Reflection\Callables\FunctionCallableVariant;
 use PHPStan\Reflection\MissingMethodFromReflectionException;
 use PHPStan\Reflection\MissingPropertyFromReflectionException;
+use PHPStan\Reflection\TrivialParametersAcceptor;
 use PHPStan\Reflection\Type\IntersectionTypeUnresolvedMethodPrototypeReflection;
 use PHPStan\Reflection\Type\IntersectionTypeUnresolvedPropertyPrototypeReflection;
 use PHPStan\Reflection\Type\UnresolvedMethodPrototypeReflection;
@@ -45,7 +47,6 @@
 use function array_filter;
 use function array_intersect_key;
 use function array_map;
-use function array_merge;
 use function array_shift;
 use function array_unique;
 use function array_values;
@@ -1124,28 +1125,21 @@ public function isCallable(): TrinaryLogic
 
 	public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope): array
 	{
-		$yesAcceptors = [];
-		$maybeAcceptors = [];
-
-		foreach ($this->types as $type) {
-			$isCallable = $type->isCallable();
-			if ($isCallable->no()) {
-				continue;
-			}
-
-			if ($isCallable->yes()) {
-				$yesAcceptors[] = $type->getCallableParametersAcceptors($scope);
-			} else {
-				$maybeAcceptors[] = $type->getCallableParametersAcceptors($scope);
-			}
+		if ($this->hasMethod('__invoke')->yes()) {
+			$method = $this->getMethod('__invoke', $scope);
+			return FunctionCallableVariant::createFromVariants($method, $method->getVariants());
 		}
 
-		if (count($yesAcceptors) > 0) {
-			return array_merge(...$yesAcceptors);
+		if ($this->isCallable()->yes()) {
+			foreach ($this->types as $type) {
+				if ($type->isCallable()->yes()) {
+					return $type->getCallableParametersAcceptors($scope);
+				}
+			}
 		}
 
-		if (count($maybeAcceptors) > 0) {
-			return array_merge(...$maybeAcceptors);
+		if ($this->isCallable()->maybe()) {
+			return [new TrivialParametersAcceptor()];
 		}
 
 		throw new ShouldNotHappenException();

tests/PHPStan/Analyser/nsrt/bug-14362.php

@@ -41,6 +41,11 @@ interface E
 
 }
 
+interface F
+{
+	public function __invoke(B $b): string;
+}
+
 class G {
 	public static function u(): A&B&E {
 		return new class() implements A, B, E {
@@ -58,6 +63,12 @@ public static function u(): B&E {
 	}
 }
 
+class I {
+	public static function u(): A&F {
+		throw new \Exception();
+	}
+}
+
 function doBar() : void {
 	assertType('Closure(Bug14362\B): int', C::u()(...));
 	assertType('Closure(Bug14362\B): int', D::u()(...));
@@ -67,6 +78,9 @@ function doBar() : void {
 
 	// Intersection with only maybe-callable types (neither has __invoke)
 	assertType('Closure', H::u()(...));
+
+	// Intersection with two yes-callable types (both have __invoke) - return types are intersected
+	assertType('Closure(Bug14362\B): never', I::u()(...));
 }
 
 function doFoo(string $c):void {