Split TemplateType::isSubTypeOf() and TemplateType::isAcceptedBy()

src/Type/Generic/TemplateTypeArgumentStrategy.php

@@ -25,8 +25,14 @@ public function accepts(TemplateType $left, Type $right, bool $strictTypes): Tri
 			return TrinaryLogic::createNo();
 		}
 
-		return $left->isSuperTypeOf($right)
-			->or(TrinaryLogic::createFromBoolean($right->equals(new MixedType())));
+		if ($right instanceof TemplateType) {
+			$accepts = $right->isAcceptedBy($left, $strictTypes);
+		} else {
+			$accepts = $left->getBound()->accepts($right, $strictTypes)
+				->and(TrinaryLogic::createMaybe());
+		}
+
+		return $accepts->or(TrinaryLogic::createFromBoolean($right->equals(new MixedType())));
 	}
 
 	public function isArgument(): bool

src/Type/Generic/TemplateTypeTrait.php

@@ -112,7 +112,27 @@ public function equals(Type $type): bool
 
 	public function isAcceptedBy(Type $acceptingType, bool $strictTypes): TrinaryLogic
 	{
-		return $this->isSubTypeOf($acceptingType);
+		/** @var Type $bound */
+		$bound = $this->getBound();
+		if (
+			!$acceptingType instanceof $bound
+			&& !$this instanceof $acceptingType
+			&& !$acceptingType instanceof TemplateType
+			&& ($acceptingType instanceof UnionType || $acceptingType instanceof IntersectionType)
+		) {
+			return $acceptingType->accepts($this, $strictTypes);
+		}
+
+		if (!$acceptingType instanceof TemplateType) {
+			return $acceptingType->accepts($this->getBound(), $strictTypes);
+		}
+
+		if ($this->getScope()->equals($acceptingType->getScope()) && $this->getName() === $acceptingType->getName()) {
+			return $acceptingType->getBound()->accepts($this->getBound(), $strictTypes);
+		}
+
+		return $acceptingType->getBound()->accepts($this->getBound(), $strictTypes)
+			->and(TrinaryLogic::createMaybe());
 	}
 
 	public function accepts(Type $type, bool $strictTypes): TrinaryLogic

src/Type/UnionType.php

@@ -92,7 +92,7 @@ public function accepts(Type $type, bool $strictTypes): TrinaryLogic
 			return TrinaryLogic::createYes();
 		}
 
-		if ($type instanceof CompoundType && !$type instanceof CallableType && !$type instanceof TemplateUnionType) {
+		if ($type instanceof CompoundType && !$type instanceof CallableType && !$type instanceof TemplateType) {
 			return $type->isAcceptedBy($this, $strictTypes);
 		}
 

tests/PHPStan/Rules/Methods/ReturnTypeRuleTest.php

@@ -16,9 +16,11 @@ class ReturnTypeRuleTest extends RuleTestCase
 
 	private bool $checkExplicitMixed = false;
 
+	private bool $checkUnionTypes = true;
+
 	protected function getRule(): Rule
 	{
-		return new ReturnTypeRule(new FunctionReturnTypeCheck(new RuleLevelHelper($this->createReflectionProvider(), true, false, true, $this->checkExplicitMixed)));
+		return new ReturnTypeRule(new FunctionReturnTypeCheck(new RuleLevelHelper($this->createReflectionProvider(), true, false, $this->checkUnionTypes, $this->checkExplicitMixed)));
 	}
 
 	public function testReturnTypeRule(): void
@@ -586,4 +588,19 @@ public function testBug6438(): void
 		$this->analyse([__DIR__ . '/data/bug-6438.php'], []);
 	}
 
+	public function testBug6589(): void
+	{
+		$this->checkUnionTypes = false;
+		$this->analyse([__DIR__ . '/data/bug-6589.php'], [
+			[
+				'Method Bug6589\HelloWorldTemplated::getField() should return TField of Bug6589\Field2 but returns Bug6589\Field.',
+				17,
+			],
+			[
+				'Method Bug6589\HelloWorldSimple::getField() should return Bug6589\Field2 but returns Bug6589\Field.',
+				31,
+			],
+		]);
+	}
+
 }

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

@@ -0,0 +1,33 @@
+<?php declare(strict_types = 1);
+
+namespace Bug6589;
+
+class Field {}
+
+class Field2 extends Field {}
+
+/**
+ * @template TField of Field2
+ */
+class HelloWorldTemplated
+{
+	/** @return TField */
+	public function getField()
+	{
+		return new Field();
+	}
+
+	/** @return TField */
+	public function getField2()
+	{
+		return new Field2();
+	}
+}
+
+class HelloWorldSimple
+{
+    public function getField(string $name): Field2
+    {
+        return new Field();
+    }
+}

tests/PHPStan/Type/ObjectTypeTest.php

@@ -412,7 +412,7 @@ public function dataAccepts(): array
 					new ObjectType(DateTimeInterface::class),
 					TemplateTypeVariance::createInvariant(),
 				),
-				TrinaryLogic::createMaybe(),
+				TrinaryLogic::createNo(),
 			],
 		];
 	}

tests/PHPStan/Type/TemplateTypeTest.php

@@ -5,6 +5,7 @@
 use DateTime;
 use DateTimeInterface;
 use Exception;
+use Iterator;
 use PHPStan\Testing\PHPStanTestCase;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Generic\TemplateType;
@@ -14,6 +15,7 @@
 use PHPStan\Type\Generic\TemplateTypeVariance;
 use stdClass;
 use Throwable;
+use Traversable;
 use function array_map;
 use function assert;
 use function sprintf;
@@ -85,6 +87,12 @@ public function dataAccepts(): array
 				TrinaryLogic::createYes(),
 				TrinaryLogic::createYes(),
 			],
+			'does not accept ObjectType that is a super type of bound' => [
+				$templateType('T', new ObjectType(Iterator::class)),
+				new ObjectType(Traversable::class),
+				TrinaryLogic::createNo(),
+				TrinaryLogic::createNo(),
+			],
 		];
 	}
 

tests/PHPStan/Type/UnionTypeTest.php

@@ -919,7 +919,7 @@ public function dataAccepts(): array
 				),
 				TrinaryLogic::createYes(),
 			],
-			'maybe accepts template-of-union sub type of a union member' => [
+			'accepts template-of-union sub type of a union member' => [
 				new UnionType([
 					TemplateTypeFactory::create(
 						TemplateTypeScope::createWithClass('Foo'),
@@ -941,6 +941,30 @@ public function dataAccepts(): array
 					]),
 					TemplateTypeVariance::createInvariant(),
 				),
+				TrinaryLogic::createYes(),
+			],
+			'maybe accepts template-of-union sub type of a union member (argument)' => [
+				new UnionType([
+					TemplateTypeFactory::create(
+						TemplateTypeScope::createWithClass('Foo'),
+						'T',
+						new UnionType([
+							new IntegerType(),
+							new FloatType(),
+						]),
+						TemplateTypeVariance::createInvariant(),
+					)->toArgument(),
+					new NullType(),
+				]),
+				TemplateTypeFactory::create(
+					TemplateTypeScope::createWithClass('Bar'),
+					'T',
+					new UnionType([
+						new IntegerType(),
+						new FloatType(),
+					]),
+					TemplateTypeVariance::createInvariant(),
+				),
 				TrinaryLogic::createMaybe(),
 			],
 			'accepts template-of-string equal to a union member' => [
@@ -961,7 +985,7 @@ public function dataAccepts(): array
 				),
 				TrinaryLogic::createYes(),
 			],
-			'maybe accepts template-of-string sub type of a union member' => [
+			'accepts template-of-string sub type of a union member' => [
 				new UnionType([
 					TemplateTypeFactory::create(
 						TemplateTypeScope::createWithClass('Foo'),
@@ -979,6 +1003,24 @@ public function dataAccepts(): array
 				),
 				TrinaryLogic::createMaybe(),
 			],
+			'maybe accepts template-of-string sub type of a union member (argument)' => [
+				new UnionType([
+					TemplateTypeFactory::create(
+						TemplateTypeScope::createWithClass('Foo'),
+						'T',
+						new StringType(),
+						TemplateTypeVariance::createInvariant(),
+					)->toArgument(),
+					new NullType(),
+				]),
+				TemplateTypeFactory::create(
+					TemplateTypeScope::createWithClass('Bar'),
+					'T',
+					new StringType(),
+					TemplateTypeVariance::createInvariant(),
+				),
+				TrinaryLogic::createMaybe(),
+			],
 			'accepts template-of-union containing a union member' => [
 				new UnionType([
 					new IntegerType(),