GenericObjectType.php

<?php declare(strict_types = 1);

namespace PHPStan\Type\Generic;

use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
use PHPStan\PhpDocParser\Ast\Type\TypeNode;
use PHPStan\Reflection\ClassMemberAccessAnswerer;
use PHPStan\Reflection\ClassReflection;
use PHPStan\Reflection\ExtendedMethodReflection;
use PHPStan\Reflection\ExtendedPropertyReflection;
use PHPStan\Reflection\ReflectionProviderStaticAccessor;
use PHPStan\Reflection\Type\UnresolvedMethodPrototypeReflection;
use PHPStan\Reflection\Type\UnresolvedPropertyPrototypeReflection;
use PHPStan\ShouldNotHappenException;
use PHPStan\TrinaryLogic;
use PHPStan\Type\AcceptsResult;
use PHPStan\Type\CompoundType;
use PHPStan\Type\ErrorType;
use PHPStan\Type\InstanceofDeprecated;
use PHPStan\Type\IntersectionType;
use PHPStan\Type\IsSuperTypeOfResult;
use PHPStan\Type\ObjectType;
use PHPStan\Type\RecursionGuard;
use PHPStan\Type\Type;
use PHPStan\Type\TypeWithClassName;
use PHPStan\Type\UnionType;
use PHPStan\Type\VerbosityLevel;
use function array_map;
use function count;
use function implode;
use function sprintf;

/** @api */
#[InstanceofDeprecated]
class GenericObjectType extends ObjectType
{

	/**
	 * @api
	 * @param array<int, Type> $types
	 * @param array<int, TemplateTypeVariance> $variances
	 */
	public function __construct(
		string $mainType,
		private array $types,
		?Type $subtractedType = null,
		private ?ClassReflection $classReflection = null,
		private array $variances = [],
	)
	{
		parent::__construct($mainType, $subtractedType, $classReflection);
	}

	public function describe(VerbosityLevel $level): string
	{
		return sprintf(
			'%s<%s>',
			parent::describe($level),
			implode(', ', array_map(
				static fn (Type $type, ?TemplateTypeVariance $variance = null): string => TypeProjectionHelper::describe($type, $variance, $level),
				$this->types,
				$this->variances,
			)),
		);
	}

	public function equals(Type $type): bool
	{
		if (!$type instanceof self) {
			return false;
		}

		if (!parent::equals($type)) {
			return false;
		}

		if (count($this->types) !== count($type->types)) {
			return false;
		}

		foreach ($this->types as $i => $genericType) {
			$otherGenericType = $type->types[$i];
			if (!$genericType->equals($otherGenericType)) {
				return false;
			}

			$variance = $this->variances[$i] ?? TemplateTypeVariance::createInvariant();
			$otherVariance = $type->variances[$i] ?? TemplateTypeVariance::createInvariant();
			if (!$variance->equals($otherVariance)) {
				return false;
			}
		}

		return true;
	}

	public function getReferencedClasses(): array
	{
		$classes = parent::getReferencedClasses();
		foreach ($this->types as $type) {
			$referencedClasses = RecursionGuard::runOnObjectIdentity($type, static fn () => $type->getReferencedClasses());
			if ($referencedClasses instanceof ErrorType) {
				continue;
			}
			foreach ($referencedClasses as $referencedClass) {
				$classes[] = $referencedClass;
			}
		}

		return $classes;
	}

	/** @return array<int, Type> */
	public function getTypes(): array
	{
		return $this->types;
	}

	/** @return array<int, TemplateTypeVariance> */
	public function getVariances(): array
	{
		return $this->variances;
	}

	public function accepts(Type $type, bool $strictTypes): AcceptsResult
	{
		if ($type instanceof CompoundType) {
			return $type->isAcceptedBy($this, $strictTypes);
		}

		return $this->isSuperTypeOfInternal($type, true)->toAcceptsResult();
	}

	public function isSuperTypeOf(Type $type): IsSuperTypeOfResult
	{
		if ($type instanceof CompoundType) {
			return $type->isSubTypeOf($this);
		}

		return $this->isSuperTypeOfInternal($type, false);
	}

	private function isSuperTypeOfInternal(Type $type, bool $acceptsContext): IsSuperTypeOfResult
	{
		$nakedSuperTypeOf = parent::isSuperTypeOf($type);
		if ($nakedSuperTypeOf->no()) {
			return $nakedSuperTypeOf;
		}

		if (!$type instanceof ObjectType) {
			return $nakedSuperTypeOf;
		}

		$ancestor = $type->getAncestorWithClassName($this->getClassName());
		if ($ancestor === null) {
			return $nakedSuperTypeOf;
		}
		if (!$ancestor instanceof self) {
			if ($acceptsContext) {
				return $nakedSuperTypeOf;
			}

			return $nakedSuperTypeOf->and(IsSuperTypeOfResult::createMaybe());
		}

		if (count($this->types) !== count($ancestor->types)) {
			return IsSuperTypeOfResult::createNo();
		}

		$classReflection = $this->getClassReflection();
		if ($classReflection === null) {
			return $nakedSuperTypeOf;
		}

		// Type arguments of a class name written without them are resolved to the
		// template bounds, so a `mixed` there means "not parameterized" and stays
		// compatible with any other type argument. When the other side is explicitly
		// parameterized, `mixed` is a type argument like any other and the variance
		// has to be evaluated strictly - otherwise `Foo<mixed>` and `Foo<int>` would
		// be supertypes of each other and TypeCombinator::union() would discard one
		// of them depending on their order.
		$strictVariance = !$acceptsContext && $type instanceof self;

		$typeList = $classReflection->typeMapToList($classReflection->getTemplateTypeMap());
		$results = [];
		foreach ($typeList as $i => $templateType) {
			if (!isset($ancestor->types[$i])) {
				continue;
			}
			if (!isset($this->types[$i])) {
				continue;
			}
			if ($templateType instanceof ErrorType) {
				continue;
			}
			if (!$templateType instanceof TemplateType) {
				throw new ShouldNotHappenException();
			}

			$thisVariance = $this->variances[$i] ?? TemplateTypeVariance::createInvariant();
			$ancestorVariance = $ancestor->variances[$i] ?? TemplateTypeVariance::createInvariant();
			if (!$thisVariance->invariant()) {
				$results[] = $thisVariance->isValidVariance($templateType, $this->types[$i], $ancestor->types[$i], $strictVariance);
			} else {
				$varianceResult = $templateType->isValidVariance($this->types[$i], $ancestor->types[$i], $strictVariance);

				// Invariance means `Foo<Cat>` is not assignable to `Foo<Animal>`, it does not
				// mean the two are disjoint - the same object can satisfy both claims. Saying
				// "no" outside of the accepts context would let TypeCombinator::intersect()
				// and dead code detection conclude that narrowing `Foo<Animal>` down to
				// `Foo<Cat>` is impossible. Assignability is still answered with "no", so
				// variance keeps being enforced on arguments and return types.
				if (
					!$acceptsContext
					&& $templateType->getVariance()->invariant()
					&& $varianceResult->no()
					&& !$this->types[$i]->isSuperTypeOf($ancestor->types[$i])->no()
				) {
					$varianceResult = new IsSuperTypeOfResult(
						TrinaryLogic::createMaybe(),
						$varianceResult->reasons,
						$varianceResult->lazyReasons,
					);
				}

				$results[] = $varianceResult;
			}

			$results[] = IsSuperTypeOfResult::createFromBoolean($thisVariance->validPosition($ancestorVariance));
		}

		if (count($results) === 0) {
			return $nakedSuperTypeOf;
		}

		$result = IsSuperTypeOfResult::createYes();
		foreach ($results as $innerResult) {
			$result = $result->and($innerResult);
		}

		return $result;
	}

	public function getClassReflection(): ?ClassReflection
	{
		if ($this->classReflection !== null) {
			return $this->classReflection;
		}

		$reflectionProvider = ReflectionProviderStaticAccessor::getInstance();
		if (!$reflectionProvider->hasClass($this->getClassName())) {
			return null;
		}

		return $this->classReflection = $reflectionProvider->getClass($this->getClassName())
			->withTypes($this->types)
			->withVariances($this->variances);
	}

	public function getProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection
	{
		return $this->getUnresolvedPropertyPrototype($propertyName, $scope)->getTransformedProperty();
	}

	public function getUnresolvedPropertyPrototype(string $propertyName, ClassMemberAccessAnswerer $scope): UnresolvedPropertyPrototypeReflection
	{
		$prototype = parent::getUnresolvedPropertyPrototype($propertyName, $scope);

		return $prototype->doNotResolveTemplateTypeMapToBounds();
	}

	public function getInstanceProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection
	{
		return $this->getUnresolvedInstancePropertyPrototype($propertyName, $scope)->getTransformedProperty();
	}

	public function getUnresolvedInstancePropertyPrototype(string $propertyName, ClassMemberAccessAnswerer $scope): UnresolvedPropertyPrototypeReflection
	{
		$prototype = parent::getUnresolvedInstancePropertyPrototype($propertyName, $scope);

		return $prototype->doNotResolveTemplateTypeMapToBounds();
	}

	public function getStaticProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection
	{
		return $this->getUnresolvedStaticPropertyPrototype($propertyName, $scope)->getTransformedProperty();
	}

	public function getUnresolvedStaticPropertyPrototype(string $propertyName, ClassMemberAccessAnswerer $scope): UnresolvedPropertyPrototypeReflection
	{
		$prototype = parent::getUnresolvedStaticPropertyPrototype($propertyName, $scope);

		return $prototype->doNotResolveTemplateTypeMapToBounds();
	}

	public function getMethod(string $methodName, ClassMemberAccessAnswerer $scope): ExtendedMethodReflection
	{
		return $this->getUnresolvedMethodPrototype($methodName, $scope)->getTransformedMethod();
	}

	public function getUnresolvedMethodPrototype(string $methodName, ClassMemberAccessAnswerer $scope): UnresolvedMethodPrototypeReflection
	{
		$prototype = parent::getUnresolvedMethodPrototype($methodName, $scope);

		return $prototype->doNotResolveTemplateTypeMapToBounds();
	}

	public function inferTemplateTypes(Type $receivedType): TemplateTypeMap
	{
		if ($receivedType instanceof UnionType || $receivedType instanceof IntersectionType) {
			return $receivedType->inferTemplateTypesOn($this);
		}

		if (!$receivedType instanceof TypeWithClassName) {
			return TemplateTypeMap::createEmpty();
		}

		$ancestor = $receivedType->getAncestorWithClassName($this->getClassName());

		if ($ancestor === null) {
			return TemplateTypeMap::createEmpty();
		}
		$ancestorClassReflection = $ancestor->getClassReflection();
		if ($ancestorClassReflection === null) {
			return TemplateTypeMap::createEmpty();
		}

		$otherTypes = $ancestorClassReflection->typeMapToList($ancestorClassReflection->getActiveTemplateTypeMap());
		$typeMap = TemplateTypeMap::createEmpty();

		foreach ($this->getTypes() as $i => $type) {
			$other = $otherTypes[$i] ?? new ErrorType();
			$typeMap = $typeMap->union($type->inferTemplateTypes($other));
		}

		return $typeMap;
	}

	public function getReferencedTemplateTypes(TemplateTypeVariance $positionVariance): array
	{
		$classReflection = $this->getClassReflection();
		if ($classReflection !== null) {
			$typeList = $classReflection->typeMapToList($classReflection->getTemplateTypeMap());
		} else {
			$typeList = [];
		}

		$references = [];

		foreach ($this->types as $i => $type) {
			$effectiveVariance = $this->variances[$i] ?? TemplateTypeVariance::createInvariant();
			if ($effectiveVariance->invariant() && isset($typeList[$i]) && $typeList[$i] instanceof TemplateType) {
				$effectiveVariance = $typeList[$i]->getVariance();
			}

			$variance = $positionVariance->compose($effectiveVariance);
			foreach ($type->getReferencedTemplateTypes($variance) as $reference) {
				$references[] = $reference;
			}
		}

		return $references;
	}

	public function traverse(callable $cb): Type
	{
		$subtractedType = $this->getSubtractedType() !== null ? $cb($this->getSubtractedType()) : null;

		$typesChanged = false;
		$types = [];
		foreach ($this->types as $type) {
			$newType = $cb($type);
			$types[] = $newType;
			if ($newType === $type) {
				continue;
			}

			$typesChanged = true;
		}

		if ($subtractedType !== $this->getSubtractedType() || $typesChanged) {
			return $this->recreate($this->getClassName(), $types, $subtractedType, $this->variances);
		}

		return $this;
	}

	public function traverseSimultaneously(Type $right, callable $cb): Type
	{
		if (!$right instanceof TypeWithClassName) {
			return $this;
		}

		$ancestor = $right->getAncestorWithClassName($this->getClassName());
		if (!$ancestor instanceof self) {
			return $this;
		}

		if (count($this->types) !== count($ancestor->types)) {
			return $this;
		}

		$typesChanged = false;
		$types = [];
		foreach ($this->types as $i => $leftType) {
			$rightType = $ancestor->types[$i];
			$newType = $cb($leftType, $rightType);
			$types[] = $newType;
			if ($newType === $leftType) {
				continue;
			}

			$typesChanged = true;
		}

		if ($typesChanged) {
			return $this->recreate($this->getClassName(), $types, null);
		}

		return $this;
	}

	/**
	 * @param Type[] $types
	 * @param TemplateTypeVariance[] $variances
	 */
	protected function recreate(string $className, array $types, ?Type $subtractedType, array $variances = []): self
	{
		return new self(
			$className,
			$types,
			$subtractedType,
			null,
			$variances,
		);
	}

	/**
	 * @param TemplateTypeVariance[] $variances
	 */
	public function changeVariances(array $variances): self
	{
		return $this->recreate($this->getClassName(), $this->getTypes(), $this->getSubtractedType(), $variances);
	}

	public function withoutFinalByKeywordOverride(): Type
	{
		if ($this->classReflection === null || !$this->classReflection->hasFinalByKeywordOverride()) {
			return $this;
		}

		return new self(
			$this->getClassName(),
			$this->types,
			$this->getSubtractedType(),
			$this->classReflection->withoutFinalByKeywordOverride(),
			$this->variances,
		);
	}

	public function changeSubtractedType(?Type $subtractedType): Type
	{
		$result = parent::changeSubtractedType($subtractedType);

		// Parent handles sealed type exhaustiveness (returning NeverType when all
		// allowed subtypes are subtracted, or a single remaining subtype).
		if (!$result instanceof ObjectType || $result->getClassName() !== $this->getClassName()) {
			return $result;
		}

		return new self($this->getClassName(), $this->types, $subtractedType, null, $this->variances);
	}

	public function toPhpDocNode(): TypeNode
	{
		/** @var IdentifierTypeNode $parent */
		$parent = parent::toPhpDocNode();
		return new GenericTypeNode(
			$parent,
			array_map(static fn (Type $type) => $type->toPhpDocNode(), $this->types),
			array_map(static fn (TemplateTypeVariance $variance) => $variance->toPhpDocNodeVariance(), $this->variances),
		);
	}

	public function hasTemplateOrLateResolvableType(): bool
	{
		foreach ($this->types as $type) {
			if (!$type->hasTemplateOrLateResolvableType()) {
				continue;
			}

			return true;
		}

		if ($this->getSubtractedType() === null) {
			return false;
		}

		return $this->getSubtractedType()->hasTemplateOrLateResolvableType();
	}

}