CallableType.php

<?php declare(strict_types = 1);

namespace PHPStan\Type;

use Closure;
use PhpParser\Node\Identifier;
use PHPStan\Analyser\OutOfClassScope;
use PHPStan\Php\PhpVersion;
use PHPStan\PhpDoc\Tag\TemplateTag;
use PHPStan\PhpDocParser\Ast\PhpDoc\TemplateTagValueNode;
use PHPStan\PhpDocParser\Ast\Type\CallableTypeNode;
use PHPStan\PhpDocParser\Ast\Type\CallableTypeParameterNode;
use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
use PHPStan\PhpDocParser\Ast\Type\TypeNode;
use PHPStan\Reflection\Assertions;
use PHPStan\Reflection\Callables\CallableParametersAcceptor;
use PHPStan\Reflection\Callables\SimpleImpurePoint;
use PHPStan\Reflection\Callables\SimpleThrowPoint;
use PHPStan\Reflection\ClassMemberAccessAnswerer;
use PHPStan\Reflection\ExtendedParameterReflection;
use PHPStan\Reflection\Native\NativeParameterReflection;
use PHPStan\Reflection\ParameterReflection;
use PHPStan\Reflection\ParametersAcceptor;
use PHPStan\Reflection\ParametersAcceptorSelector;
use PHPStan\Reflection\PassedByReference;
use PHPStan\Reflection\Php\DummyParameter;
use PHPStan\ShouldNotHappenException;
use PHPStan\TrinaryLogic;
use PHPStan\Turbo\ShadowedByTurboExtension;
use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
use PHPStan\Type\Enum\EnumCaseObjectType;
use PHPStan\Type\Generic\TemplateType;
use PHPStan\Type\Generic\TemplateTypeHelper;
use PHPStan\Type\Generic\TemplateTypeMap;
use PHPStan\Type\Generic\TemplateTypeVariance;
use PHPStan\Type\Generic\TemplateTypeVarianceMap;
use PHPStan\Type\Traits\MaybeArrayTypeTrait;
use PHPStan\Type\Traits\MaybeIterableTypeTrait;
use PHPStan\Type\Traits\MaybeObjectTypeTrait;
use PHPStan\Type\Traits\MaybeOffsetAccessibleTypeTrait;
use PHPStan\Type\Traits\NonGeneralizableTypeTrait;
use PHPStan\Type\Traits\NonRemoveableTypeTrait;
use PHPStan\Type\Traits\TruthyBooleanTypeTrait;
use PHPStan\Type\Traits\UndecidedComparisonCompoundTypeTrait;
use function array_key_exists;
use function array_map;
use function array_merge;
use function count;

/** @api */
#[InstanceofDeprecated(insteadUse: 'Type::isCallable() and Type::getCallableParametersAcceptors()')]
#[ShadowedByTurboExtension(implementation: __DIR__ . '/../../turbo-ext/src/CallableType.cpp')]
class CallableType implements CompoundType, CallableParametersAcceptor
{

	use MaybeArrayTypeTrait;
	use MaybeIterableTypeTrait;
	use MaybeObjectTypeTrait;
	use MaybeOffsetAccessibleTypeTrait;
	use TruthyBooleanTypeTrait;
	use UndecidedComparisonCompoundTypeTrait;
	use NonRemoveableTypeTrait;
	use NonGeneralizableTypeTrait;

	/** @var list<ParameterReflection> */
	private array $parameters;

	private Type $returnType;

	private bool $isCommonCallable;

	private TemplateTypeMap $templateTypeMap;

	private TemplateTypeMap $resolvedTemplateTypeMap;

	private TrinaryLogic $isPure;

	private Assertions $assertions;

	/**
	 * @api
	 * @param list<ParameterReflection>|null $parameters
	 * @param array<non-empty-string, TemplateTag> $templateTags
	 */
	public function __construct(
		?array $parameters = null,
		?Type $returnType = null,
		private bool $variadic = true,
		?TemplateTypeMap $templateTypeMap = null,
		?TemplateTypeMap $resolvedTemplateTypeMap = null,
		private array $templateTags = [],
		?TrinaryLogic $isPure = null,
		?Assertions $assertions = null,
	)
	{
		$this->parameters = $parameters ?? [];
		$this->returnType = $returnType ?? new MixedType();
		$this->isCommonCallable = $parameters === null && $returnType === null;
		$this->templateTypeMap = $templateTypeMap ?? TemplateTypeMap::createEmpty();
		$this->resolvedTemplateTypeMap = $resolvedTemplateTypeMap ?? TemplateTypeMap::createEmpty();
		$this->isPure = $isPure ?? TrinaryLogic::createMaybe();
		$this->assertions = $assertions ?? Assertions::createEmpty();
	}

	/**
	 * @return array<non-empty-string, TemplateTag>
	 */
	public function getTemplateTags(): array
	{
		return $this->templateTags;
	}

	public function isPure(): TrinaryLogic
	{
		return $this->isPure;
	}

	public function getReferencedClasses(): array
	{
		$classes = [];
		foreach ($this->parameters as $parameter) {
			$classes = array_merge($classes, $parameter->getType()->getReferencedClasses());
		}
		foreach ($this->assertions->getAll() as $assertTag) {
			$classes = array_merge($classes, $assertTag->getType()->getReferencedClasses());
		}

		return array_merge($classes, $this->returnType->getReferencedClasses());
	}

	public function getObjectClassNames(): array
	{
		return [];
	}

	public function getObjectClassReflections(): array
	{
		return [];
	}

	public function getConstantStrings(): array
	{
		return [];
	}

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

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

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

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

	private function isSuperTypeOfInternal(Type $type, bool $treatMixedAsAny, bool $strictTypes = true): IsSuperTypeOfResult
	{
		$isCallable = IsSuperTypeOfResult::createFromTrinaryLogic($type->isCallable());
		if ($isCallable->no()) {
			return $isCallable;
		}

		static $scope;
		if ($scope === null) {
			$scope = new OutOfClassScope();
		}

		if ($this->isCommonCallable) {
			if ($this->isPure()->yes()) {
				$typePure = TrinaryLogic::createYes();
				foreach ($type->getCallableParametersAcceptors($scope) as $variant) {
					$typePure = $typePure->and($variant->isPure());
				}

				return $isCallable->and(IsSuperTypeOfResult::createFromTrinaryLogic($typePure));
			}

			return $isCallable;
		}

		$parameterTypes = array_map(static fn ($parameter) => $parameter->getType(), $this->getParameters());

		$variantsResult = null;
		foreach ($type->getCallableParametersAcceptors($scope) as $variant) {
			$variant = ParametersAcceptorSelector::selectFromTypes($parameterTypes, [$variant], false);
			if (!$variant instanceof CallableParametersAcceptor) {
				return IsSuperTypeOfResult::createNo([]);
			}
			$isSuperType = CallableTypeHelper::isParametersAcceptorSuperTypeOf($this, $variant, $treatMixedAsAny, $strictTypes);
			if ($variantsResult === null) {
				$variantsResult = $isSuperType;
			} else {
				$variantsResult = $variantsResult->or($isSuperType);
			}
		}

		if ($variantsResult === null) {
			throw new ShouldNotHappenException();
		}

		return $isCallable->and($variantsResult);
	}

	public function isSubTypeOf(Type $otherType): IsSuperTypeOfResult
	{
		if ($otherType instanceof IntersectionType || $otherType instanceof UnionType) {
			return $otherType->isSuperTypeOf($this);
		}

		return IsSuperTypeOfResult::createFromTrinaryLogic(
			$otherType->isCallable()->and($otherType instanceof self ? TrinaryLogic::createYes() : TrinaryLogic::createMaybe()),
		);
	}

	public function isAcceptedBy(Type $acceptingType, bool $strictTypes): AcceptsResult
	{
		return $this->isSubTypeOf($acceptingType)->toAcceptsResult();
	}

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

		if ($this->isCommonCallable) {
			if (!$type->isCommonCallable) {
				return false;
			}
		} elseif ($type->isCommonCallable) {
			return false;
		}

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

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

		if (!$this->returnType->equals($type->returnType)) {
			return false;
		}

		if (!CallableAssertionsHelper::assertionsEqual($this->assertions, $type->assertions)) {
			return false;
		}

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

		foreach ($this->parameters as $i => $parameter) {
			$otherParameter = $type->parameters[$i];
			if ($parameter->isOptional() !== $otherParameter->isOptional()) {
				return false;
			}
			if (!$parameter->passedByReference()->equals($otherParameter->passedByReference())) {
				return false;
			}
			if ($parameter->isVariadic() !== $otherParameter->isVariadic()) {
				return false;
			}
			if (!$parameter->getType()->equals($otherParameter->getType())) {
				return false;
			}
			if ($parameter->getDefaultValue() !== null) {
				if ($otherParameter->getDefaultValue() === null) {
					return false;
				}

				return $parameter->getDefaultValue()->equals($otherParameter->getDefaultValue());
			} elseif ($otherParameter->getDefaultValue() !== null) {
				return false;
			}
		}

		foreach ([[$this->templateTypeMap, $type->templateTypeMap], [$this->resolvedTemplateTypeMap, $type->resolvedTemplateTypeMap]] as [$templateTypeMap, $otherTemplateTypeMap]) {
			if ($templateTypeMap->count() !== $otherTemplateTypeMap->count()) {
				return false;
			}

			foreach ($templateTypeMap->getTypes() as $typeName => $templateType) {
				$otherTemplateType = $otherTemplateTypeMap->getType($typeName);
				if ($otherTemplateType === null) {
					return false;
				}

				if (!$templateType->equals($otherTemplateType)) {
					return false;
				}
			}
		}

		foreach ($this->templateTags as $tagName => $tag) {
			if (!array_key_exists($tagName, $type->templateTags)) {
				return false;
			}

			$otherTag = $type->templateTags[$tagName];
			if ($tag->getName() !== $otherTag->getName()) {
				return false;
			}

			if (!$tag->getBound()->equals($otherTag->getBound())) {
				return false;
			}
			if (!$tag->getVariance()->equals($otherTag->getVariance())) {
				return false;
			}
			if ($tag->getDefault() !== null) {
				if ($otherTag->getDefault() === null) {
					return false;
				}

				return $tag->getDefault()->equals($otherTag->getDefault());
			} elseif ($otherTag->getDefault() !== null) {
				return false;
			}
		}

		return true;
	}

	public function describe(VerbosityLevel $level): string
	{
		return $level->handle(
			static fn (): string => 'callable',
			function (): string {
				$assertedParameterNames = [];
				foreach ($this->assertions->getAll() as $assertTag) {
					$assertedParameterNames[$assertTag->getParameter()->getParameterName()] = true;
				}
				$selfWithoutParameterNames = new self(
					array_map(static fn (ParameterReflection $p): ParameterReflection => new DummyParameter(
						array_key_exists('$' . $p->getName(), $assertedParameterNames) ? $p->getName() : '',
						$p->getType(),
						optional: $p->isOptional() && !$p->isVariadic(),
						passedByReference: PassedByReference::createNo(),
						variadic: $p->isVariadic(),
						defaultValue: $p->getDefaultValue(),
					), $this->parameters),
					$this->returnType,
					$this->variadic,
					$this->templateTypeMap,
					$this->resolvedTemplateTypeMap,
					$this->templateTags,
					$this->isPure,
					$this->assertions,
				);

				return TypeNodeDescriber::describe($selfWithoutParameterNames->toPhpDocNode());
			},
		);
	}

	public function isCallable(): TrinaryLogic
	{
		return TrinaryLogic::createYes();
	}

	public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope): array
	{
		return [$this];
	}

	public function getThrowPoints(): array
	{
		return [
			SimpleThrowPoint::createImplicit(),
		];
	}

	public function getImpurePoints(): array
	{
		$pure = $this->isPure();
		if ($pure->yes()) {
			return [];
		}

		return [
			new SimpleImpurePoint(
				'functionCall',
				'call to a callable',
				$pure->no(),
			),
		];
	}

	public function getInvalidateExpressions(): array
	{
		return [];
	}

	public function getUsedVariables(): array
	{
		return [];
	}

	public function acceptsNamedArguments(): TrinaryLogic
	{
		return TrinaryLogic::createYes();
	}

	public function mustUseReturnValue(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function getAsserts(): Assertions
	{
		return $this->assertions;
	}

	public function isStaticClosure(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function toNumber(): Type
	{
		return new ErrorType();
	}

	public function toBitwiseNotType(): Type
	{
		return new ErrorType();
	}

	public function toAbsoluteNumber(): Type
	{
		return new ErrorType();
	}

	public function toString(): Type
	{
		return new ErrorType();
	}

	public function toInteger(): Type
	{
		return new ErrorType();
	}

	public function toFloat(): Type
	{
		return new ErrorType();
	}

	public function toArray(): Type
	{
		return new ArrayType(new MixedType(), new MixedType());
	}

	public function toArrayKey(): Type
	{
		return new ErrorType();
	}

	public function toCoercedArgumentType(bool $strictTypes): Type
	{
		return TypeCombinator::union(
			$this,
			new IntersectionType([new StringType(), new AccessoryNonEmptyStringType()]),
			new ArrayType(new MixedType(true), new MixedType(true)),
			new ObjectType(Closure::class),
		);
	}

	public function getTemplateTypeMap(): TemplateTypeMap
	{
		return $this->templateTypeMap;
	}

	public function getResolvedTemplateTypeMap(): TemplateTypeMap
	{
		return $this->resolvedTemplateTypeMap;
	}

	public function getCallSiteVarianceMap(): TemplateTypeVarianceMap
	{
		return TemplateTypeVarianceMap::createEmpty();
	}

	/**
	 * @return list<ParameterReflection>
	 */
	public function getParameters(): array
	{
		return $this->parameters;
	}

	public function isVariadic(): bool
	{
		return $this->variadic;
	}

	public function getReturnType(): Type
	{
		return $this->returnType;
	}

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

		if (! $receivedType->isCallable()->yes()) {
			return TemplateTypeMap::createEmpty();
		}

		$parametersAcceptors = $receivedType->getCallableParametersAcceptors(new OutOfClassScope());

		$typeMap = TemplateTypeMap::createEmpty();

		foreach ($parametersAcceptors as $parametersAcceptor) {
			$typeMap = $typeMap->union($this->inferTemplateTypesOnParametersAcceptor($parametersAcceptor));
		}

		return $typeMap;
	}

	private function inferTemplateTypesOnParametersAcceptor(ParametersAcceptor $parametersAcceptor): TemplateTypeMap
	{
		$parameterTypes = array_map(static fn ($parameter) => $parameter->getType(), $this->getParameters());
		$parametersAcceptor = ParametersAcceptorSelector::selectFromTypes($parameterTypes, [$parametersAcceptor], false);
		$args = $parametersAcceptor->getParameters();
		$returnType = $parametersAcceptor->getReturnType();

		$typeMap = TemplateTypeMap::createEmpty();
		foreach ($this->getParameters() as $i => $param) {
			$paramType = $param->getType();
			if (isset($args[$i])) {
				$argType = $args[$i]->getType();
			} elseif ($paramType instanceof TemplateType) {
				$argType = TemplateTypeHelper::resolveToBounds($paramType);
			} else {
				$argType = new NeverType();
			}

			$typeMap = $typeMap->union($paramType->inferTemplateTypes($argType)->convertToLowerBoundTypes());
		}

		$typeMap = $typeMap->union(CallableAssertionsHelper::inferTemplateTypesOnAsserts($this, $parametersAcceptor));

		return $typeMap->union($this->getReturnType()->inferTemplateTypes($returnType));
	}

	public function getReferencedTemplateTypes(TemplateTypeVariance $positionVariance): array
	{
		$references = $this->getReturnType()->getReferencedTemplateTypes(
			$positionVariance->compose(TemplateTypeVariance::createCovariant()),
		);

		foreach ($this->assertions->getAll() as $assertTag) {
			foreach ($assertTag->getType()->getReferencedTemplateTypes($positionVariance->compose(TemplateTypeVariance::createCovariant())) as $reference) {
				$references[] = $reference;
			}
		}

		$paramVariance = $positionVariance->compose(TemplateTypeVariance::createContravariant());

		foreach ($this->getParameters() as $param) {
			foreach ($param->getType()->getReferencedTemplateTypes($paramVariance) as $reference) {
				$references[] = $reference;
			}
		}

		return $references;
	}

	public function traverse(callable $cb): Type
	{
		if ($this->isCommonCallable) {
			return $this;
		}

		$parameters = array_map(static function (ParameterReflection $param) use ($cb): NativeParameterReflection {
			$defaultValue = $param->getDefaultValue();
			return new NativeParameterReflection(
				$param->getName(),
				$param->isOptional(),
				$cb($param->getType()),
				$param->passedByReference(),
				$param->isVariadic(),
				$defaultValue !== null ? $cb($defaultValue) : null,
			);
		}, $this->getParameters());

		return new self(
			$parameters,
			$cb($this->getReturnType()),
			$this->isVariadic(),
			$this->templateTypeMap,
			$this->resolvedTemplateTypeMap,
			$this->templateTags,
			$this->isPure,
			$this->assertions->mapTypes($cb),
		);
	}

	public function traverseSimultaneously(Type $right, callable $cb): Type
	{
		if ($this->isCommonCallable) {
			return $this;
		}

		if (!$right->isCallable()->yes()) {
			return $this;
		}

		$rightAcceptors = $right->getCallableParametersAcceptors(new OutOfClassScope());
		if (count($rightAcceptors) !== 1) {
			return $this;
		}

		$rightParameters = $rightAcceptors[0]->getParameters();
		if (count($this->getParameters()) !== count($rightParameters)) {
			return $this;
		}

		$parameters = [];
		foreach ($this->getParameters() as $i => $leftParam) {
			$rightParam = $rightParameters[$i];
			$leftDefaultValue = $leftParam->getDefaultValue();
			$rightDefaultValue = $rightParam->getDefaultValue();
			$defaultValue = $leftDefaultValue;
			if ($leftDefaultValue !== null && $rightDefaultValue !== null) {
				$defaultValue = $cb($leftDefaultValue, $rightDefaultValue);
			}
			$parameters[] = new NativeParameterReflection(
				$leftParam->getName(),
				$leftParam->isOptional(),
				$cb($leftParam->getType(), $rightParam->getType()),
				$leftParam->passedByReference(),
				$leftParam->isVariadic(),
				$defaultValue,
			);
		}

		return new self(
			$parameters,
			$cb($this->getReturnType(), $rightAcceptors[0]->getReturnType()),
			$this->isVariadic(),
			$this->templateTypeMap,
			$this->resolvedTemplateTypeMap,
			$this->templateTags,
			$this->isPure,
			$this->assertions,
		);
	}

	public function isOversizedArray(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isNull(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isConstantValue(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isConstantScalarValue(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function getConstantScalarTypes(): array
	{
		return [];
	}

	public function getConstantScalarValues(): array
	{
		return [];
	}

	public function isTrue(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isFalse(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isBoolean(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isFloat(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isInteger(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isString(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function isNumericString(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isDecimalIntegerString(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isNonEmptyString(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function isNonFalsyString(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function isLiteralString(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function isLowercaseString(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function isClassString(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function isUppercaseString(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function getClassStringObjectType(): Type
	{
		return new ObjectWithoutClassType();
	}

	public function getObjectTypeOrClassStringObjectType(): Type
	{
		return new ObjectWithoutClassType();
	}

	public function isVoid(): TrinaryLogic
	{
		return TrinaryLogic::createNo();
	}

	public function isScalar(): TrinaryLogic
	{
		return TrinaryLogic::createMaybe();
	}

	public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType
	{
		return new BooleanType();
	}

	public function getEnumCases(): array
	{
		return [];
	}

	public function getEnumCaseObject(): ?EnumCaseObjectType
	{
		return null;
	}

	public function isCommonCallable(): bool
	{
		return $this->isCommonCallable;
	}

	public function exponentiate(Type $exponent): Type
	{
		return new ErrorType();
	}

	public function getFiniteTypes(): array
	{
		return [];
	}

	public function toPhpDocNode(): TypeNode
	{
		if ($this->isCommonCallable) {
			return new IdentifierTypeNode($this->isPure()->yes() ? 'pure-callable' : 'callable');
		}

		$parameters = [];
		foreach ($this->parameters as $parameter) {
			$parameters[] = new CallableTypeParameterNode(
				$parameter->getType()->toPhpDocNode(),
				!$parameter->passedByReference()->no(),
				$parameter->isVariadic(),
				$parameter->getName() === '' ? '' : '$' . $parameter->getName(),
				$parameter->isOptional(),
			);
		}

		$templateTags = [];
		foreach ($this->templateTags as $templateName => $templateTag) {
			$templateTags[] = new TemplateTagValueNode(
				$templateName,
				$templateTag->getBound()->toPhpDocNode(),
				'',
			);
		}

		$returnTypeNode = CallableAssertionsHelper::toConditionalReturnTypeNode($this->assertions, $this->parameters, $this->returnType)
			?? $this->returnType->toPhpDocNode();

		return new CallableTypeNode(
			new IdentifierTypeNode($this->isPure->yes() ? 'pure-callable' : 'callable'),
			$parameters,
			$returnTypeNode,
			$templateTags,
		);
	}

	public function toNativePhpTypeNode(NativeTypePosition $position)
	{
		return $position->isCallableAllowed() ? new Identifier('callable') : null;
	}

	public function hasTemplateOrLateResolvableType(): bool
	{
		foreach ($this->parameters as $parameter) {
			if ($parameter->getType()->hasTemplateOrLateResolvableType()) {
				return true;
			}

			if (!$parameter instanceof ExtendedParameterReflection) {
				continue;
			}

			if ($parameter->getOutType() !== null && $parameter->getOutType()->hasTemplateOrLateResolvableType()) {
				return true;
			}
			if ($parameter->getClosureThisType() !== null && $parameter->getClosureThisType()->hasTemplateOrLateResolvableType()) {
				return true;
			}
		}

		foreach ($this->assertions->getAll() as $assertTag) {
			if ($assertTag->getType()->hasTemplateOrLateResolvableType()) {
				return true;
			}
		}

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

}