Generic variance

src/PhpDoc/PhpDocNodeResolver.php

@@ -22,6 +22,7 @@
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\Generic\TemplateTypeFactory;
 use PHPStan\Type\Generic\TemplateTypeMap;
+use PHPStan\Type\Generic\TemplateTypeVariance;
 use PHPStan\Type\IntegerType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
@@ -263,7 +264,18 @@ private function resolveTemplateTags(PhpDocNode $phpDocNode, NameScope $nameScop
 			foreach ($phpDocNode->getTemplateTagValues($tagName) as $tagValue) {
 				$resolved[$tagValue->name] = new TemplateTag(
 					$tagValue->name,
-					$tagValue->bound !== null ? $this->typeNodeResolver->resolve($tagValue->bound, $nameScope) : new MixedType()
+					$tagValue->bound !== null ? $this->typeNodeResolver->resolve($tagValue->bound, $nameScope) : new MixedType(),
+					TemplateTypeVariance::createInvariant()
+				);
+			}
+		}
+
+		foreach (['@template-covariant', '@psalm-template-covariant', '@phpstan-template-covariant'] as $tagName) {
+			foreach ($phpDocNode->getTemplateTagValues($tagName) as $tagValue) {
+				$resolved[$tagValue->name] = new TemplateTag(
+					$tagValue->name,
+					$tagValue->bound !== null ? $this->typeNodeResolver->resolve($tagValue->bound, $nameScope) : new MixedType(),
+					TemplateTypeVariance::createCovariant()
 				);
 			}
 		}

src/PhpDoc/Tag/TemplateTag.php

@@ -2,6 +2,7 @@
 
 namespace PHPStan\PhpDoc\Tag;
 
+use PHPStan\Type\Generic\TemplateTypeVariance;
 use PHPStan\Type\Type;
 
 class TemplateTag
@@ -13,10 +14,14 @@ class TemplateTag
 	/** @var \PHPStan\Type\Type */
 	private $bound;
 
-	public function __construct(string $name, Type $bound)
+	/** @var TemplateTypeVariance */
+	private $variance;
+
+	public function __construct(string $name, Type $bound, TemplateTypeVariance $variance)
 	{
 		$this->name = $name;
 		$this->bound = $bound;
+		$this->variance = $variance;
 	}
 
 	public function getName(): string
@@ -29,6 +34,11 @@ public function getBound(): Type
 		return $this->bound;
 	}
 
+	public function getVariance(): TemplateTypeVariance
+	{
+		return $this->variance;
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 * @return self
@@ -37,7 +47,8 @@ public static function __set_state(array $properties): self
 	{
 		return new self(
 			$properties['name'],
-			$properties['bound']
+			$properties['bound'],
+			$properties['variance']
 		);
 	}
 

src/Type/Generic/GenericObjectType.php

@@ -13,7 +13,6 @@
 use PHPStan\Type\CompoundType;
 use PHPStan\Type\ErrorType;
 use PHPStan\Type\IntersectionType;
-use PHPStan\Type\MixedType;
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeWithClassName;
@@ -116,17 +115,24 @@ private function isSuperTypeOfInternal(Type $type, bool $acceptsContext): Trinar
 			return TrinaryLogic::createNo();
 		}
 
-		foreach ($this->types as $i => $t) {
+		$classReflection = $this->getClassReflection();
+		if ($classReflection === null) {
+			return $nakedSuperTypeOf;
+		}
+
+		$typeList = $classReflection->typeMapToList($classReflection->getTemplateTypeMap());
+
+		foreach ($typeList as $i => $templateType) {
 			if (!isset($ancestor->types[$i])) {
 				throw new \PHPStan\ShouldNotHappenException();
 			}
-			if (!$t->equals($ancestor->types[$i])) {
-				if ($t instanceof MixedType) {
-					continue;
-				}
-				if ($ancestor->types[$i] instanceof MixedType) {
-					continue;
-				}
+			if (!isset($this->types[$i])) {
+				throw new \PHPStan\ShouldNotHappenException();
+			}
+			if (!$templateType instanceof TemplateType) {
+				throw new \PHPStan\ShouldNotHappenException();
+			}
+			if (!$templateType->isValidVariance($this->types[$i], $ancestor->types[$i])) {
 				return TrinaryLogic::createNo();
 			}
 		}
@@ -218,6 +224,11 @@ public function traverse(callable $cb): Type
 		return $this;
 	}
 
+	public function changeSubtractedType(?Type $subtractedType): Type
+	{
+		return new self($this->getClassName(), $this->types, $subtractedType);
+	}
+
 	/**
 	 * @param mixed[] $properties
 	 * @return Type

src/Type/Generic/TemplateMixedType.php

@@ -25,9 +25,13 @@ final class TemplateMixedType extends MixedType implements TemplateType
 	/** @var TemplateTypeStrategy */
 	private $strategy;
 
+	/** @var TemplateTypeVariance */
+	private $variance;
+
 	public function __construct(
 		TemplateTypeScope $scope,
 		TemplateTypeStrategy $templateTypeStrategy,
+		TemplateTypeVariance $templateTypeVariance,
 		string $name,
 		?Type $subtractedType = null
 	)
@@ -36,6 +40,7 @@ public function __construct(
 
 		$this->scope = $scope;
 		$this->strategy = $templateTypeStrategy;
+		$this->variance = $templateTypeVariance;
 		$this->name = $name;
 	}
 
@@ -143,11 +148,17 @@ public function toArgument(): TemplateType
 		return new self(
 			$this->scope,
 			new TemplateTypeArgumentStrategy(),
+			$this->variance,
 			$this->name,
 			$this->getSubtractedType()
 		);
 	}
 
+	public function isValidVariance(Type $a, Type $b): bool
+	{
+		return $this->variance->isValidVariance($a, $b);
+	}
+
 	public function subtract(Type $type): Type
 	{
 		if ($type instanceof self) {
@@ -160,6 +171,7 @@ public function subtract(Type $type): Type
 		return new self(
 			$this->scope,
 			$this->strategy,
+			$this->variance,
 			$this->name,
 			$type
 		);
@@ -170,6 +182,7 @@ public function getTypeWithoutSubtractedType(): Type
 		return new self(
 			$this->scope,
 			$this->strategy,
+			$this->variance,
 			$this->name,
 			null
 		);
@@ -180,6 +193,7 @@ public function changeSubtractedType(?Type $subtractedType): Type
 		return new self(
 			$this->scope,
 			$this->strategy,
+			$this->variance,
 			$this->name,
 			$subtractedType
 		);
@@ -194,6 +208,7 @@ public static function __set_state(array $properties): Type
 		return new self(
 			$properties['scope'],
 			$properties['strategy'],
+			$properties['variance'],
 			$properties['name'],
 			$properties['subtractedType']
 		);

src/Type/Generic/TemplateObjectType.php

@@ -8,7 +8,6 @@
 use PHPStan\Type\ObjectType;
 use PHPStan\Type\ObjectWithoutClassType;
 use PHPStan\Type\Type;
-use PHPStan\Type\TypeCombinator;
 use PHPStan\Type\TypeUtils;
 use PHPStan\Type\UnionType;
 use PHPStan\Type\VerbosityLevel;
@@ -28,9 +27,13 @@ final class TemplateObjectType extends ObjectType implements TemplateType
 	/** @var ObjectType */
 	private $bound;
 
+	/** @var TemplateTypeVariance */
+	private $variance;
+
 	public function __construct(
 		TemplateTypeScope $scope,
 		TemplateTypeStrategy $templateTypeStrategy,
+		TemplateTypeVariance $templateTypeVariance,
 		string $name,
 		string $class,
 		?Type $subtractedType = null
@@ -40,6 +43,7 @@ public function __construct(
 
 		$this->scope = $scope;
 		$this->strategy = $templateTypeStrategy;
+		$this->variance = $templateTypeVariance;
 		$this->name = $name;
 		$this->bound = new ObjectType($class, $subtractedType);
 	}
@@ -163,43 +167,24 @@ public function toArgument(): TemplateType
 		return new self(
 			$this->scope,
 			new TemplateTypeArgumentStrategy(),
+			TemplateTypeVariance::createInvariant(),
 			$this->name,
 			$this->getClassName(),
 			$this->getSubtractedType()
 		);
 	}
 
-	public function subtract(Type $type): Type
-	{
-		if ($this->getSubtractedType() !== null) {
-			$type = TypeCombinator::union($this->getSubtractedType(), $type);
-		}
-
-		return new self(
-			$this->scope,
-			$this->strategy,
-			$this->name,
-			$this->getClassName(),
-			$type
-		);
-	}
-
-	public function getTypeWithoutSubtractedType(): Type
+	public function isValidVariance(Type $a, Type $b): bool
 	{
-		return new self(
-			$this->scope,
-			$this->strategy,
-			$this->name,
-			$this->getClassName(),
-			null
-		);
+		return $this->variance->isValidVariance($a, $b);
 	}
 
 	public function changeSubtractedType(?Type $subtractedType): Type
 	{
 		return new self(
 			$this->scope,
 			$this->strategy,
+			$this->variance,
 			$this->name,
 			$this->getClassName(),
 			$subtractedType
@@ -215,6 +200,7 @@ public static function __set_state(array $properties): Type
 		return new self(
 			$properties['scope'],
 			$properties['strategy'],
+			$properties['variance'],
 			$properties['name'],
 			$properties['className'],
 			$properties['subtractedType']

src/Type/Generic/TemplateType.php

@@ -18,4 +18,6 @@ public function toArgument(): TemplateType;
 
 	public function isArgument(): bool;
 
+	public function isValidVariance(Type $a, Type $b): bool;
+
 }

src/Type/Generic/TemplateTypeFactory.php

@@ -11,24 +11,24 @@
 final class TemplateTypeFactory
 {
 
-	public static function create(TemplateTypeScope $scope, string $name, ?Type $bound): Type
+	public static function create(TemplateTypeScope $scope, string $name, ?Type $bound, TemplateTypeVariance $variance): Type
 	{
 		$strategy = new TemplateTypeParameterStrategy();
 
 		if ($bound instanceof ObjectType) {
-			return new TemplateObjectType($scope, $strategy, $name, $bound->getClassName());
+			return new TemplateObjectType($scope, $strategy, $variance, $name, $bound->getClassName());
 		}
 
 		if ($bound === null || get_class($bound) === MixedType::class) {
-			return new TemplateMixedType($scope, $strategy, $name);
+			return new TemplateMixedType($scope, $strategy, $variance, $name);
 		}
 
 		return new ErrorType();
 	}
 
 	public static function fromTemplateTag(TemplateTypeScope $scope, TemplateTag $tag): Type
 	{
-		return self::create($scope, $tag->getName(), $tag->getBound());
+		return self::create($scope, $tag->getName(), $tag->getBound(), $tag->getVariance());
 	}
 
 }