Fix subtype check for identical late-resolvable conditional types (bug #10942)

src/Type/Traits/LateResolvableTypeTrait.php

@@ -18,6 +18,7 @@
 use PHPStan\Type\LateResolvableType;
 use PHPStan\Type\NeverType;
 use PHPStan\Type\Type;
+use PHPStan\Type\UnionType;
 
 trait LateResolvableTypeTrait
 {
@@ -65,6 +66,18 @@ private function isSuperTypeOfDefault(Type $type): IsSuperTypeOfResult
 			return IsSuperTypeOfResult::createYes();
 		}
 
+		if ($this->equals($type)) {
+			return IsSuperTypeOfResult::createYes();
+		}
+
+		if ($type instanceof UnionType) {
+			foreach ($type->getTypes() as $innerType) {
+				if ($this->equals($innerType)) {
+					return IsSuperTypeOfResult::createYes();
+				}
+			}
+		}
+
 		if ($type instanceof LateResolvableType) {
 			$type = $type->resolve();
 		}
@@ -570,6 +583,18 @@ public function tryRemove(Type $typeToRemove): ?Type
 
 	public function isSubTypeOf(Type $otherType): IsSuperTypeOfResult
 	{
+		if ($this->equals($otherType)) {
+			return IsSuperTypeOfResult::createYes();
+		}
+
+		if ($otherType instanceof UnionType) {
+			foreach ($otherType->getTypes() as $innerType) {
+				if ($this->equals($innerType)) {
+					return IsSuperTypeOfResult::createYes();
+				}
+			}
+		}
+
 		$result = $this->resolve();
 
 		if ($result instanceof CompoundType) {

tests/PHPStan/Rules/Methods/MethodSignatureRuleTest.php

@@ -550,6 +550,13 @@ public function testBug10488(): void
 		$this->analyse([__DIR__ . '/data/bug-10488.php'], []);
 	}
 
+	public function testBug10942(): void
+	{
+		$this->reportMaybes = true;
+		$this->reportStatic = true;
+		$this->analyse([__DIR__ . '/data/bug-10942.php'], []);
+	}
+
 	#[RequiresPhp('>= 8.0')]
 	public function testBug12073(): void
 	{

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

@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace Bug10942;
+
+class A
+{
+
+	/**
+	 * @param string|($operator is 'in' ? int : never) $sqlRight
+	 */
+	protected function _renderConditionBinary(string $operator, string $sqlLeft, $sqlRight): string
+	{
+		return 'x';
+	}
+
+}
+
+class B extends A
+{
+
+	#[\Override]
+	protected function _renderConditionBinary(string $operator, string $sqlLeft, $sqlRight): string
+	{
+		return 'y';
+	}
+
+}

tests/PHPStan/Type/LateResolvableTypeTraitTest.php

@@ -0,0 +1,78 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Type;
+
+use PHPStan\Type\Constant\ConstantStringType;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\NeverType;
+use PHPStan\Type\StringType;
+use PHPStan\Type\Type;
+use PHPStan\Type\ConditionalTypeForParameter;
+use PHPStan\Type\UnionType;
+use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+class LateResolvableTypeTraitTest extends TestCase
+{
+	public static function dataIsSuperTypeOf(): array
+	{
+		return self::provideCases();
+	}
+
+	public static function dataIsSubTypeOf(): array
+	{
+		return self::provideCases();
+	}
+
+	private static function createConditional(
+		string $parameterName = '$operator',
+		string $targetLiteral = 'in',
+		?Type $ifType = null,
+		?Type $elseType = null,
+		bool $negated = false,
+	): ConditionalTypeForParameter
+	{
+		return new ConditionalTypeForParameter(
+			$parameterName,
+			new ConstantStringType($targetLiteral),
+			$ifType ?? new IntegerType(),
+			$elseType ?? new NeverType(),
+			$negated,
+		);
+	}
+
+	/**
+	 * @return list<array{Type, Type, TrinaryLogic}>
+	 */
+	private static function provideCases(): array
+	{
+		return [
+			'conditional vs same conditional' => [
+				self::createConditional(),
+				self::createConditional(),
+				TrinaryLogic::createYes(),
+			],
+			'conditional vs union containing it' => [
+				self::createConditional(),
+				new UnionType([new StringType(), self::createConditional()]),
+				TrinaryLogic::createYes(),
+			],
+		];
+	}
+
+	#[DataProvider('dataIsSuperTypeOf')]
+	public function testIsSuperTypeOf(Type $left, Type $right, TrinaryLogic $expected): void
+	{
+		$actual = $left->isSuperTypeOf($right);
+		$this->assertSame($expected->describe(), $actual->describe());
+	}
+
+	#[DataProvider('dataIsSubTypeOf')]
+	public function testIsSubTypeOf(Type $left, Type $right, TrinaryLogic $expected): void
+	{
+		$actual = $left->isSubTypeOf($right);
+		$this->assertSame($expected->describe(), $actual->describe());
+	}
+
+}