Make ParametersAcceptorSelector::selectSingle() return union-ed conditional types

src/Reflection/ParametersAcceptorSelector.php

@@ -17,6 +17,7 @@
 use PHPStan\Type\NullType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypeUtils;
 use PHPStan\Type\UnionType;
 use function array_key_last;
 use function array_slice;
@@ -32,7 +33,7 @@ class ParametersAcceptorSelector
 	/**
 	 * @template T of ParametersAcceptor
 	 * @param T[] $parametersAcceptors
-	 * @return T
+	 * @return T|SingleParametersAcceptor
 	 */
 	public static function selectSingle(
 		array $parametersAcceptors,
@@ -48,7 +49,12 @@ public static function selectSingle(
 			throw new ShouldNotHappenException('Multiple variants - use selectFromArgs() instead.');
 		}
 
-		return $parametersAcceptors[0];
+		$parametersAcceptor = $parametersAcceptors[0];
+		if (TypeUtils::containsConditional($parametersAcceptor->getReturnType())) {
+			return new SingleParametersAcceptor($parametersAcceptor);
+		}
+
+		return $parametersAcceptor;
 	}
 
 	/**

src/Reflection/SingleParametersAcceptor.php

@@ -0,0 +1,58 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Reflection;
+
+use PHPStan\Type\ConditionalType;
+use PHPStan\Type\ConditionalTypeForParameter;
+use PHPStan\Type\Generic\TemplateTypeMap;
+use PHPStan\Type\Type;
+use PHPStan\Type\TypeTraverser;
+
+class SingleParametersAcceptor implements ParametersAcceptor
+{
+
+	private ?Type $returnType = null;
+
+	public function __construct(private ParametersAcceptor $acceptor)
+	{
+	}
+
+	public function getTemplateTypeMap(): TemplateTypeMap
+	{
+		return $this->acceptor->getTemplateTypeMap();
+	}
+
+	public function getResolvedTemplateTypeMap(): TemplateTypeMap
+	{
+		return $this->acceptor->getResolvedTemplateTypeMap();
+	}
+
+	/**
+	 * @return array<int, ParameterReflection>
+	 */
+	public function getParameters(): array
+	{
+		return $this->acceptor->getParameters();
+	}
+
+	public function isVariadic(): bool
+	{
+		return $this->acceptor->isVariadic();
+	}
+
+	public function getReturnType(): Type
+	{
+		if ($this->returnType === null) {
+			return $this->returnType = TypeTraverser::map($this->acceptor->getReturnType(), static function (Type $type, callable $traverse) {
+				while ($type instanceof ConditionalType || $type instanceof ConditionalTypeForParameter) {
+					$type = $type->getResult();
+				}
+
+				return $traverse($type);
+			});
+		}
+
+		return $this->returnType;
+	}
+
+}

src/Type/ConditionalType.php

@@ -91,7 +91,7 @@ private function resolve(): Type
 		}
 
 		if ($this->isResolved()) {
-			return TypeCombinator::union($this->if, $this->else);
+			return $this->getResult();
 		}
 
 		return $this;

src/Type/Traits/ConditionalTypeTrait.php

@@ -288,7 +288,7 @@ public function isGreaterThanOrEqual(Type $otherType): TrinaryLogic
 		return $otherType->isSmallerThanOrEqual($result);
 	}
 
-	private function getResult(): Type
+	public function getResult(): Type
 	{
 		if ($this->result === null) {
 			return $this->result = TypeCombinator::union($this->if, $this->else);

src/Type/TypeUtils.php

@@ -328,4 +328,22 @@ public static function containsCallable(Type $type): bool
 		return false;
 	}
 
+	public static function containsConditional(Type $type): bool
+	{
+		if ($type instanceof ConditionalType || $type instanceof ConditionalTypeForParameter) {
+			return true;
+		}
+
+		$contains = false;
+		TypeTraverser::map($type, static function (Type $type, callable $traverse) use (&$contains): Type {
+			if ($type instanceof ConditionalType || $type instanceof ConditionalTypeForParameter) {
+				$contains = true;
+			}
+
+			return !$contains ? $traverse($type) : $type;
+		});
+
+		return $contains;
+	}
+
 }

tests/PHPStan/Analyser/AnalyserIntegrationTest.php

@@ -622,7 +622,7 @@ public function testBug6896(): void
 		}
 
 		$errors = $this->runAnalyse(__DIR__ . '/data/bug-6896.php');
-		$this->assertCount(4, $errors);
+		$this->assertCount(2, $errors);
 	}
 
 	public function testBug6940(): void

tests/PHPStan/Analyser/DynamicReturnTypeExtensionTypeInferenceTest.php

@@ -11,6 +11,7 @@ public function dataAsserts(): iterable
 	{
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/dynamic-method-return-types.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/dynamic-method-return-compound-types.php');
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/dynamic-method-return-getsingle-conditional.php');
 	}
 
 	/**

tests/PHPStan/Analyser/data/TestDynamicReturnTypeExtensions.php

@@ -189,3 +189,23 @@ public function getTypeFromMethodCall(MethodReflection $methodReflection, Method
 	}
 
 }
+
+
+class ConditionalGetSingle implements DynamicMethodReturnTypeExtension {
+
+	public function getClass(): string
+	{
+		return \DynamicMethodReturnGetSingleConditional\Foo::class;
+	}
+
+	public function isMethodSupported(MethodReflection $methodReflection): bool
+	{
+		return $methodReflection->getName() === 'get';
+	}
+
+	public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): Type
+	{
+		return ParametersAcceptorSelector::selectSingle($methodReflection->getVariants())->getReturnType();
+	}
+
+}

tests/PHPStan/Analyser/data/dynamic-method-return-getsingle-conditional.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace DynamicMethodReturnGetSingleConditional;
+
+use function PHPStan\Testing\assertType;
+
+abstract class Foo
+{
+	/**
+	 * @return ($input is 1 ? true : false)
+	 */
+	abstract public function get(int $input): mixed;
+
+	public function doFoo(): void
+	{
+		assertType('bool', $this->get(0));
+		assertType('bool', $this->get(1));
+		assertType('bool', $this->get(2));
+	}
+}

tests/PHPStan/Analyser/dynamic-return-type.neon

@@ -27,3 +27,7 @@ services:
 		class: PHPStan\Tests\FooGetSelf
 		tags:
 			- phpstan.broker.dynamicMethodReturnTypeExtension
+	-
+		class: PHPStan\Tests\ConditionalGetSingle
+		tags:
+			- phpstan.broker.dynamicMethodReturnTypeExtension