Fix phpstan/phpstan#14362: Intersection loses __invoke() return type

src/Reflection/ParametersAcceptorSelector.php

@@ -674,7 +674,7 @@
 				$winningAcceptors[] = $acceptableAcceptor;
 				$winningCertainty = $isSuperType;
 			} else {
 				$comparison = $winningCertainty->compareTo($isSuperType);
 				if ($comparison === $isSuperType) {
 					$winningAcceptors = [$acceptableAcceptor];
 					$winningCertainty = $isSuperType;
@@ -693,8 +693,10 @@
 
 	/**
 	 * @param ParametersAcceptor[] $acceptors
+	 *
+	 * @return ($acceptors is array<CallableParametersAcceptor> ? CallableParametersAcceptor : ExtendedParametersAcceptor)
 	 */
 	public static function combineAcceptors(array $acceptors): ExtendedParametersAcceptor
 	{
 		if (count($acceptors) === 0) {
 			throw new ShouldNotHappenException(

src/Type/IntersectionType.php

@@ -2,6 +2,7 @@
 
 namespace PHPStan\Type;
 
+use PHPStan\Internal\CombinationsHelper;
 use PHPStan\Php\PhpVersion;
 use PHPStan\PhpDocParser\Ast\Type\ArrayShapeNode;
 use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
@@ -16,7 +17,7 @@
 use PHPStan\Reflection\MissingConstantFromReflectionException;
 use PHPStan\Reflection\MissingMethodFromReflectionException;
 use PHPStan\Reflection\MissingPropertyFromReflectionException;
-use PHPStan\Reflection\TrivialParametersAcceptor;
+use PHPStan\Reflection\ParametersAcceptorSelector;
 use PHPStan\Reflection\Type\IntersectionTypeUnresolvedMethodPrototypeReflection;
 use PHPStan\Reflection\Type\IntersectionTypeUnresolvedPropertyPrototypeReflection;
 use PHPStan\Reflection\Type\UnresolvedMethodPrototypeReflection;
@@ -1124,16 +1125,42 @@
 
 	public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope): array
 	{
-		if ($this->isCallable()->no()) {
+		$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 (count($yesAcceptors) > 0) {
+			$acceptors = $yesAcceptors;
+		} elseif (count($maybeAcceptors) > 0) {
+			$acceptors = $maybeAcceptors;
+		} else {
 			throw new ShouldNotHappenException();
 		}
 
-		return [new TrivialParametersAcceptor()];
+		$result = [];
+		$combinations = CombinationsHelper::combinations($acceptors);
+		foreach ($combinations as $combination) {
+			$result[] = ParametersAcceptorSelector::combineAcceptors($combination);
+		}
+
+		return $result;
 	}
 
 	public function isCloneable(): TrinaryLogic
 	{
 		return $this->intersectResults(static fn (Type $type): TrinaryLogic => $type->isCloneable());
 	}
 
 	public function isSmallerThan(Type $otherType, PhpVersion $phpVersion): TrinaryLogic

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

@@ -0,0 +1,84 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace Bug14362;
+
+use function PHPStan\Testing\assertType;
+
+interface A
+{
+	public function __invoke(B $b): int;
+}
+
+interface B
+{
+
+}
+
+class C {
+	public static function u(): A&B {
+		return new class() implements A, B {
+			public function __invoke(B $b): int {
+				return 1;
+			}
+		};
+	}
+}
+
+class D {
+	public static function u(): A {
+		return new class() implements A {
+			public function __invoke(B $b): int {
+				return 1;
+			}
+		};
+	}
+}
+
+interface E
+{
+	public function __invoke(B $b, bool $option = true): int;
+}
+
+interface F
+{
+
+}
+
+class G {
+	public static function u(): A&E {
+		return new class() implements A, E {
+			public function __invoke(B $b, bool $option = true): int {
+				return 1;
+			}
+		};
+	}
+}
+
+class H {
+	public static function u(): B&F {
+		return new class() implements B, F {
+		};
+	}
+}
+
+function doBar() : void {
+	assertType('Closure(Bug14362\B): int', C::u()(...));
+	assertType('Closure(Bug14362\B): int', D::u()(...));
+
+	// Intersection with two yes-callable compatible
+	assertType('Closure(Bug14362\B, bool=): int', G::u()(...));
+
+	// Intersection with only maybe-callable types (neither has __invoke)
+	assertType('Closure', H::u()(...));
+}
+
+function doFoo(string $c):void {
+	if (is_callable($c)) {
+		$a = $c;
+	} else {
+		$a = C::u()(...);
+	}
+	assertType('callable-string|(Closure(Bug14362\B): int)', $a);
+}