<?php declare(strict_types = 1);

namespace PHPStan\Type;

use ArrayAccess;

use ArrayObject;

use Closure;

use Countable;

use DateTimeInterface;

use Iterator;

use IteratorAggregate;

use PHPStan\Analyser\OutOfClassScope;

use PHPStan\Broker\ClassNotFoundException;

use PHPStan\Php\PhpVersion;

use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;

use PHPStan\PhpDocParser\Ast\Type\TypeNode;

use PHPStan\Reflection\Callables\CallableParametersAcceptor;

use PHPStan\Reflection\Callables\FunctionCallableVariant;

use PHPStan\Reflection\ClassConstantReflection;

use PHPStan\Reflection\ClassMemberAccessAnswerer;

use PHPStan\Reflection\ClassReflection;

use PHPStan\Reflection\Dummy\DummyPropertyReflection;

use PHPStan\Reflection\ExtendedMethodReflection;

use PHPStan\Reflection\ExtendedPropertyReflection;

use PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension;

use PHPStan\Reflection\ReflectionProvider;

use PHPStan\Reflection\ReflectionProviderStaticAccessor;

use PHPStan\Reflection\TrivialParametersAcceptor;

use PHPStan\Reflection\Type\CallbackUnresolvedPropertyPrototypeReflection;

use PHPStan\Reflection\Type\CalledOnTypeUnresolvedMethodPrototypeReflection;

use PHPStan\Reflection\Type\CalledOnTypeUnresolvedPropertyPrototypeReflection;

use PHPStan\Reflection\Type\UnionTypeUnresolvedPropertyPrototypeReflection;

use PHPStan\Reflection\Type\UnresolvedMethodPrototypeReflection;

use PHPStan\Reflection\Type\UnresolvedPropertyPrototypeReflection;

use PHPStan\ShouldNotHappenException;

use PHPStan\TrinaryLogic;

use PHPStan\Type\Accessory\AccessoryLiteralStringType;

use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;

use PHPStan\Type\Accessory\AccessoryNumericStringType;

use PHPStan\Type\Accessory\HasOffsetValueType;

use PHPStan\Type\Constant\ConstantArrayType;

use PHPStan\Type\Constant\ConstantBooleanType;

use PHPStan\Type\Constant\ConstantStringType;

use PHPStan\Type\Enum\EnumCaseObjectType;

use PHPStan\Type\Generic\GenericClassStringType;

use PHPStan\Type\Generic\GenericObjectType;

use PHPStan\Type\Generic\TemplateTypeHelper;

use PHPStan\Type\Traits\MaybeIterableTypeTrait;

use PHPStan\Type\Traits\NonArrayTypeTrait;

use PHPStan\Type\Traits\NonGeneralizableTypeTrait;

use PHPStan\Type\Traits\NonGenericTypeTrait;

use PHPStan\Type\Traits\SubstractableTypeTrait;

use PHPStan\Type\Traits\UndecidedComparisonTypeTrait;

use Stringable;

use Throwable;

use Traversable;

use function array_key_exists;

use function array_map;

use function array_values;

use function count;

use function get_class;

use function implode;

use function in_array;

use function sprintf;

use function strtolower;

/** @api */

class ObjectType implements TypeWithClassName, SubtractableType

{

use MaybeIterableTypeTrait;

use NonArrayTypeTrait;

use NonGenericTypeTrait;

use UndecidedComparisonTypeTrait;

use NonGeneralizableTypeTrait;

use SubstractableTypeTrait;

private const EXTRA_OFFSET_CLASSES = [

'DOMNamedNodeMap', // Only read and existence

'Dom\NamedNodeMap', // Only read and existence

'DOMNodeList', // Only read and existence

'Dom\NodeList', // Only read and existence

'Dom\HTMLCollection', // Only read and existence

'Dom\DtdNamedNodeMap', // Only read and existence

'PDORow', // Only read and existence

'ResourceBundle', // Only read

'FFI\CData', // Very funky and weird

'SimpleXMLElement',

'Threaded',

];

private ?Type $subtractedType;

/** @var array<string, array<string, IsSuperTypeOfResult>> */

private static array $superTypes = [];

private ?self $cachedParent = null;

/** @var self[]|null */

private ?array $cachedInterfaces = null;

/** @var array<string, array<string, array<string, UnresolvedMethodPrototypeReflection>>> */

private static array $methods = [];

/** @var array<string, array<string, array<string, UnresolvedPropertyPrototypeReflection>>> */

private static array $properties = [];

/** @var array<string, array<string, array<string, UnresolvedPropertyPrototypeReflection>>> */

private static array $instanceProperties = [];

/** @var array<string, array<string, array<string, UnresolvedPropertyPrototypeReflection>>> */

private static array $staticProperties = [];

/** @var array<string, array<string, self|null>> */

private static array $ancestors = [];

/** @var array<string, self|null> */

private array $currentAncestors = [];

private ?string $cachedDescription = null;

/**

* The reflection resolved on demand by getClassReflection(), kept apart from the one

* handed to the constructor. The constructor's reflection is part of the type's value

* — it can differ from what the provider would return (an anonymous class is identified

* by its start line, a final-by-keyword override changes subtyping) — and so it belongs

* in the cache key. A lazily fetched one is merely a cache: folding it into the key made

* describe(VerbosityLevel::cache()) depend on whether the fetch had happened yet, which

* made TypeCombinator::union() — which dedupes on that key — depend on cache warmth

* rather than on its arguments' values.

*/

private ?ClassReflection $lazyClassReflection = null;

/** @var array<string, list<EnumCaseObjectType>> */

private static array $enumCases = [];

/** @var array<string, ExtendedMethodReflection> */

private array $methodCache = [];

/** @api */

public function __construct(

private string $className,

?Type $subtractedType = null,

private ?ClassReflection $classReflection = null,

)

{

if ($subtractedType instanceof NeverType) {

$subtractedType = null;

}

$this->subtractedType = $subtractedType;

}

public static function resetCaches(): void

{

self::$superTypes = [];

self::$methods = [];

self::$properties = [];

self::$instanceProperties = [];

self::$staticProperties = [];

self::$ancestors = [];

self::$enumCases = [];

}

public function getClassName(): string

{

return $this->className;

}

public function hasProperty(string $propertyName): TrinaryLogic

{

$classReflection = $this->getClassReflection();

if ($classReflection === null) {

return TrinaryLogic::createMaybe();

}

$classHasProperty = RecursionGuard::run($this, static fn (): bool => $classReflection->hasProperty($propertyName));

if ($classHasProperty === true || $classHasProperty instanceof ErrorType) {

return TrinaryLogic::createYes();

}

if ($classReflection->allowsDynamicProperties()) {

return TrinaryLogic::createMaybe();

}

if (!$classReflection->isFinal()) {

return TrinaryLogic::createMaybe();

}

return TrinaryLogic::createNo();

}

public function getProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection

{

return $this->getUnresolvedPropertyPrototype($propertyName, $scope)->getTransformedProperty();

}

public function getUnresolvedPropertyPrototype(string $propertyName, ClassMemberAccessAnswerer $scope): UnresolvedPropertyPrototypeReflection

{

if (!$scope->isInClass()) {

$canAccessProperty = 'no';

} else {

$canAccessProperty = $scope->getClassReflection()->getName();

}

$description = $this->describeCache();

if (isset(self::$properties[$description][$propertyName][$canAccessProperty])) {

return self::$properties[$description][$propertyName][$canAccessProperty];

}

$nakedClassReflection = $this->getNakedClassReflection();

if ($nakedClassReflection === null) {

throw new ClassNotFoundException($this->className);

}

if ($nakedClassReflection->isEnum()) {

if (

$propertyName === 'name'

|| ($propertyName === 'value' && $nakedClassReflection->isBackedEnum())

) {

$properties = [];

foreach ($this->getEnumCases() as $enumCase) {

$properties[] = $enumCase->getUnresolvedPropertyPrototype($propertyName, $scope);

}

if (count($properties) > 0) {

if (count($properties) === 1) {

return $properties[0];

}

return new UnionTypeUnresolvedPropertyPrototypeReflection($properties);

}

}

}

if (!$nakedClassReflection->hasNativeProperty($propertyName)) {

$nakedClassReflection = $this->getClassReflection();

}

if ($nakedClassReflection === null) {

throw new ClassNotFoundException($this->className);

}

$property = RecursionGuard::run($this, static fn () => $nakedClassReflection->getProperty($propertyName, $scope));

if ($property instanceof ErrorType) {

$property = new DummyPropertyReflection($propertyName);

return new CallbackUnresolvedPropertyPrototypeReflection(

$property,

$property->getDeclaringClass(),

false,

static fn (Type $type): Type => $type,

);

}

$ancestor = $this->getAncestorWithClassName($property->getDeclaringClass()->getName());

$resolvedClassReflection = null;

if ($ancestor !== null && $ancestor->hasProperty($propertyName)->yes()) {

$resolvedClassReflection = $ancestor->getClassReflection();

if ($ancestor !== $this) {

$property = $ancestor->getUnresolvedPropertyPrototype($propertyName, $scope)->getNakedProperty();

}

}

if ($resolvedClassReflection === null) {

$resolvedClassReflection = $property->getDeclaringClass();

}

return self::$properties[$description][$propertyName][$canAccessProperty] = new CalledOnTypeUnresolvedPropertyPrototypeReflection(

$property,

$resolvedClassReflection,

true,

$this,

);

}

public function hasInstanceProperty(string $propertyName): TrinaryLogic

{

$classReflection = $this->getClassReflection();

if ($classReflection === null) {

return TrinaryLogic::createMaybe();

}

$classHasProperty = RecursionGuard::run($this, static fn (): bool => $classReflection->hasInstanceProperty($propertyName));

if ($classHasProperty === true || $classHasProperty instanceof ErrorType) {

return TrinaryLogic::createYes();

}

if ($classReflection->allowsDynamicProperties()) {

return TrinaryLogic::createMaybe();

}

if (!$classReflection->isFinal()) {

return TrinaryLogic::createMaybe();

}

return TrinaryLogic::createNo();

}

public function getInstanceProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection

{

return $this->getUnresolvedInstancePropertyPrototype($propertyName, $scope)->getTransformedProperty();

}

public function getUnresolvedInstancePropertyPrototype(string $propertyName, ClassMemberAccessAnswerer $scope): UnresolvedPropertyPrototypeReflection

{

if (!$scope->isInClass()) {

$canAccessProperty = 'no';

} else {

$canAccessProperty = $scope->getClassReflection()->getName();

}

$description = $this->describeCache();

if (isset(self::$instanceProperties[$description][$propertyName][$canAccessProperty])) {

return self::$instanceProperties[$description][$propertyName][$canAccessProperty];

}

$nakedClassReflection = $this->getNakedClassReflection();

if ($nakedClassReflection === null) {

throw new ClassNotFoundException($this->className);

}

if ($nakedClassReflection->isEnum()) {

if (

$propertyName === 'name'

|| ($propertyName === 'value' && $nakedClassReflection->isBackedEnum())

) {

$properties = [];

foreach ($this->getEnumCases() as $enumCase) {

$properties[] = $enumCase->getUnresolvedInstancePropertyPrototype($propertyName, $scope);

}

if (count($properties) > 0) {

if (count($properties) === 1) {

return $properties[0];

}

return new UnionTypeUnresolvedPropertyPrototypeReflection($properties);

}

}

}

if (!$nakedClassReflection->hasNativeProperty($propertyName)) {

$nakedClassReflection = $this->getClassReflection();

}

if ($nakedClassReflection === null) {

throw new ClassNotFoundException($this->className);

}

$property = RecursionGuard::run($this, static fn () => $nakedClassReflection->getInstanceProperty($propertyName, $scope));

if ($property instanceof ErrorType) {

$property = new DummyPropertyReflection($propertyName);

return new CallbackUnresolvedPropertyPrototypeReflection(

$property,

$property->getDeclaringClass(),

false,

static fn (Type $type): Type => $type,

);

}

$ancestor = $this->getAncestorWithClassName($property->getDeclaringClass()->getName());

$resolvedClassReflection = null;

if ($ancestor !== null && $ancestor->hasInstanceProperty($propertyName)->yes()) {

$resolvedClassReflection = $ancestor->getClassReflection();

if ($ancestor !== $this) {

$property = $ancestor->getUnresolvedInstancePropertyPrototype($propertyName, $scope)->getNakedProperty();

}

}

if ($resolvedClassReflection === null) {

$resolvedClassReflection = $property->getDeclaringClass();

}

return self::$instanceProperties[$description][$propertyName][$canAccessProperty] = new CalledOnTypeUnresolvedPropertyPrototypeReflection(

$property,

$resolvedClassReflection,

true,

$this,

);

}

public function hasStaticProperty(string $propertyName): TrinaryLogic

{

$classReflection = $this->getClassReflection();

if ($classReflection === null) {

return TrinaryLogic::createMaybe();

}

$classHasProperty = RecursionGuard::run($this, static fn (): bool => $classReflection->hasStaticProperty($propertyName));

if ($classHasProperty === true || $classHasProperty instanceof ErrorType) {

return TrinaryLogic::createYes();

}

if (!$classReflection->isFinal()) {

return TrinaryLogic::createMaybe();

}

return TrinaryLogic::createNo();

}

public function getStaticProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection

{

return $this->getUnresolvedStaticPropertyPrototype($propertyName, $scope)->getTransformedProperty();

}

public function getUnresolvedStaticPropertyPrototype(string $propertyName, ClassMemberAccessAnswerer $scope): UnresolvedPropertyPrototypeReflection

{

if (!$scope->isInClass()) {

$canAccessProperty = 'no';

} else {

$canAccessProperty = $scope->getClassReflection()->getName();

}

$description = $this->describeCache();

if (isset(self::$staticProperties[$description][$propertyName][$canAccessProperty])) {

return self::$staticProperties[$description][$propertyName][$canAccessProperty];

}

$nakedClassReflection = $this->getNakedClassReflection();

if ($nakedClassReflection === null) {

throw new ClassNotFoundException($this->className);

}

if (!$nakedClassReflection->hasNativeProperty($propertyName)) {

$nakedClassReflection = $this->getClassReflection();

}

if ($nakedClassReflection === null) {

throw new ClassNotFoundException($this->className);

}

$property = RecursionGuard::run($this, static fn () => $nakedClassReflection->getStaticProperty($propertyName));

if ($property instanceof ErrorType) {

$property = new DummyPropertyReflection($propertyName);

return new CallbackUnresolvedPropertyPrototypeReflection(

$property,

$property->getDeclaringClass(),

false,

static fn (Type $type): Type => $type,

);

}

$ancestor = $this->getAncestorWithClassName($property->getDeclaringClass()->getName());

$resolvedClassReflection = null;

if ($ancestor !== null && $ancestor->hasStaticProperty($propertyName)->yes()) {

$resolvedClassReflection = $ancestor->getClassReflection();

if ($ancestor !== $this) {

$property = $ancestor->getUnresolvedStaticPropertyPrototype($propertyName, $scope)->getNakedProperty();

}

}

if ($resolvedClassReflection === null) {

$resolvedClassReflection = $property->getDeclaringClass();

}

return self::$staticProperties[$description][$propertyName][$canAccessProperty] = new CalledOnTypeUnresolvedPropertyPrototypeReflection(

$property,

$resolvedClassReflection,

true,

$this,

);

}

public function getReferencedClasses(): array

{

if ($this->className === '') {

return [];

}

return [$this->className];

}

public function getObjectClassNames(): array

{

if ($this->className === '') {

return [];

}

return [$this->className];

}

public function getObjectClassReflections(): array

{

$classReflection = $this->getClassReflection();

if ($classReflection === null) {

return [];

}

return [$classReflection];

}

public function accepts(Type $type, bool $strictTypes): AcceptsResult

{

if ($type instanceof StaticType) {

return $this->checkSubclassAcceptability($type->getClassName());

}

if ($type instanceof CompoundType) {

return $type->isAcceptedBy($this, $strictTypes);

}

if ($type instanceof ClosureType) {

return new AcceptsResult($this->isInstanceOf(Closure::class), []);

}

if ($type instanceof ObjectWithoutClassType) {

return AcceptsResult::createMaybe();

}

$thatClassNames = $type->getObjectClassNames();

if (count($thatClassNames) > 1) {

throw new ShouldNotHappenException();

}

if ($thatClassNames === []) {

return AcceptsResult::createNo();

}

return $this->checkSubclassAcceptability($thatClassNames[0]);

}

public function isSuperTypeOf(Type $type): IsSuperTypeOfResult

{

$thatClassNames = $type->getObjectClassNames();

if (!$type instanceof CompoundType && $thatClassNames === [] && !$type instanceof ObjectWithoutClassType) {

return IsSuperTypeOfResult::createNo();

}

$thisDescription = $this->describeCache();

if ($type instanceof self) {

$description = $type->describeCache();

} else {

$description = $type->describe(VerbosityLevel::cache());

}

if (isset(self::$superTypes[$thisDescription][$description])) {

return self::$superTypes[$thisDescription][$description];

}

if ($type instanceof CompoundType) {

return self::$superTypes[$thisDescription][$description] = $type->isSubTypeOf($this);

}

if ($type instanceof ClosureType) {

return self::$superTypes[$thisDescription][$description] = new IsSuperTypeOfResult($this->isInstanceOf(Closure::class), []);

}

if ($type instanceof ObjectWithoutClassType) {

if ($type->getSubtractedType() !== null) {

$isSuperType = $type->getSubtractedType()->isSuperTypeOf($this);

if ($isSuperType->yes()) {

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createNo();

}

}

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createMaybe();

}

$transformResult = static fn (IsSuperTypeOfResult $result) => $result;

if ($this->subtractedType !== null) {

$isSuperType = $this->subtractedType->isSuperTypeOf($type);

if ($isSuperType->yes()) {

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createNo();

}

if ($isSuperType->maybe()) {

$transformResult = static fn (IsSuperTypeOfResult $result) => $result->and(IsSuperTypeOfResult::createMaybe());

}

}

if (

$type instanceof SubtractableType

&& $type->getSubtractedType() !== null

) {

$isSuperType = $type->getSubtractedType()->isSuperTypeOf($this);

if ($isSuperType->yes()) {

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createNo();

}

}

$thisClassName = $this->className;

if (count($thatClassNames) > 1) {

throw new ShouldNotHappenException();

}

$thisClassReflection = $this->getClassReflection();

$thatClassReflections = $type->getObjectClassReflections();

if (count($thatClassReflections) === 1) {

$thatClassReflection = $thatClassReflections[0];

} else {

$thatClassReflection = null;

}

if ($thisClassReflection === null || $thatClassReflection === null) {

if ($thatClassNames[0] === $thisClassName) {

return self::$superTypes[$thisDescription][$description] = $transformResult(IsSuperTypeOfResult::createYes());

}

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createMaybe();

}

if ($thatClassNames[0] === $thisClassName) {

if ($thisClassReflection->getNativeReflection()->isFinal()) {

return self::$superTypes[$thisDescription][$description] = $transformResult(IsSuperTypeOfResult::createYes());

}

if ($thisClassReflection->hasFinalByKeywordOverride()) {

if (!$thatClassReflection->hasFinalByKeywordOverride()) {

return self::$superTypes[$thisDescription][$description] = $transformResult(IsSuperTypeOfResult::createMaybe());

}

}

return self::$superTypes[$thisDescription][$description] = $transformResult(IsSuperTypeOfResult::createYes());

}

if ($thisClassReflection->isTrait() || $thatClassReflection->isTrait()) {

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createNo();

}

if ($thisClassReflection->getName() === $thatClassReflection->getName()) {

return self::$superTypes[$thisDescription][$description] = $transformResult(IsSuperTypeOfResult::createYes());

}

if ($thatClassReflection->isSubclassOfClass($thisClassReflection)) {

return self::$superTypes[$thisDescription][$description] = $transformResult(IsSuperTypeOfResult::createYes());

}

if ($thisClassReflection->isSubclassOfClass($thatClassReflection)) {

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createMaybe();

}

if ($thisClassReflection->isInterface() && !$thatClassReflection->isFinalByKeyword()) {

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createMaybe();

}

if ($thatClassReflection->isInterface() && !$thisClassReflection->isFinalByKeyword()) {

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createMaybe();

}

return self::$superTypes[$thisDescription][$description] = IsSuperTypeOfResult::createNo();

}

public function equals(Type $type): bool

{

if (get_class($type) !== static::class) {

return false;

}

if ($this->className !== $type->className) {

return false;

}

if ($this->subtractedType === null) {

return $type->subtractedType === null;

}

if ($type->subtractedType === null) {

return false;

}

return $this->subtractedType->equals($type->subtractedType);

}

private function checkSubclassAcceptability(string $thatClass): AcceptsResult

{

if ($this->className === $thatClass) {

return AcceptsResult::createYes();

}

$reflectionProvider = ReflectionProviderStaticAccessor::getInstance();

if ($this->getClassReflection() === null || !$reflectionProvider->hasClass($thatClass)) {

return AcceptsResult::createNo();

}

$thisReflection = $this->getClassReflection();

$thatReflection = $reflectionProvider->getClass($thatClass);

if ($thisReflection->getName() === $thatReflection->getName()) {

// class alias

return AcceptsResult::createYes();

}

if ($thisReflection->isInterface() && $thatReflection->isInterface()) {

return AcceptsResult::createFromBoolean(

$thatReflection->implementsInterface($thisReflection->getName()),

);

}

return AcceptsResult::createFromBoolean(

$thatReflection->isSubclassOfClass($thisReflection),

);

}

public function describe(VerbosityLevel $level): string

{

$preciseNameCallback = function (): string {

$reflectionProvider = ReflectionProviderStaticAccessor::getInstance();

if (!$reflectionProvider->hasClass($this->className)) {

return $this->className;

}

return $reflectionProvider->getClassName($this->className);

};

$preciseWithSubtracted = fn (): string => $this->className . $this->describeSubtractedType($this->subtractedType, $level);

return $level->handle(

$preciseNameCallback,

$preciseNameCallback,

$preciseWithSubtracted,

function () use ($preciseWithSubtracted): string {

$reflection = $this->classReflection;

$line = '';

if ($reflection !== null) {

$line .= '-';

$line .= (string) $reflection->getNativeReflection()->getStartLine();

$line .= '-';

}

return $preciseWithSubtracted() . '-' . static::class . '-' . $line . $this->describeAdditionalCacheKey();

},

);

}

protected function describeAdditionalCacheKey(): string

{

return '';

}

private function describeCache(): string

{

if ($this->cachedDescription !== null) {

return $this->cachedDescription;

}

if (static::class !== self::class) {

return $this->cachedDescription = $this->describe(VerbosityLevel::cache());

}

$description = $this->className;

if ($this instanceof GenericObjectType) {

$description .= '<';

$typeDescriptions = [];

foreach ($this->getTypes() as $type) {

$typeDescriptions[] = $type->describe(VerbosityLevel::cache());

}

$description .= '<' . implode(', ', $typeDescriptions) . '>';

}

$description .= $this->describeSubtractedType($this->subtractedType, VerbosityLevel::cache());

$reflection = $this->classReflection;

if ($reflection !== null) {

$description .= '-';

$description .= (string) $reflection->getNativeReflection()->getStartLine();

$description .= '-';

if ($reflection->hasFinalByKeywordOverride()) {

$description .= 'f=' . ($reflection->isFinalByKeyword() ? 't' : 'f');

}

}

return $this->cachedDescription = $description;

}

public function toNumber(): Type

{

if (

$this->isInstanceOf('SimpleXMLElement')->yes()

|| $this->isInstanceOf('GMP')->yes()

) {

return new UnionType([

new FloatType(),

new IntegerType(),

]);

}

return new ErrorType();

}

public function toBitwiseNotType(): Type

{

return new ErrorType();

}

public function toGetClassResultType(): Type

{

return $this->getClassStringType();

}

public function toClassConstantType(ReflectionProvider $reflectionProvider): Type

{

if ($reflectionProvider->hasClass($this->className)) {

$reflection = $reflectionProvider->getClass($this->className);

if ($reflection->isFinalByKeyword()) {

return new ConstantStringType($reflection->getName(), true);

}

}

return new IntersectionType([$this->getClassStringType(), new AccessoryLiteralStringType()]);

}

public function toObjectTypeForInstanceofCheck(): ClassNameToObjectTypeResult

{

return new ClassNameToObjectTypeResult($this, true);

}

public function toObjectTypeForIsACheck(Type $objectOrClassType, bool $allowString, bool $allowSameClass): ClassNameToObjectTypeResult

{

if ($allowString) {

return new ClassNameToObjectTypeResult(

new UnionType([new ObjectWithoutClassType(), new ClassStringType()]),

false,

);

}

return new ClassNameToObjectTypeResult(new ObjectWithoutClassType(), false);

}

public function toAbsoluteNumber(): Type

{

return $this->toNumber()->toAbsoluteNumber();

}

public function toInteger(): Type

{

if (

$this->isInstanceOf('SimpleXMLElement')->yes()

|| $this->isInstanceOf('GMP')->yes()

) {

return new IntegerType();

}

if (in_array($this->getClassName(), ['CurlHandle', 'CurlMultiHandle'], true)) {

return new IntegerType();

}

return new ErrorType();

}

public function toFloat(): Type

{

if (

$this->isInstanceOf('SimpleXMLElement')->yes()

|| $this->isInstanceOf('GMP')->yes()

) {

return new FloatType();

}

return new ErrorType();

}

public function toString(): Type

{

if (

$this->isInstanceOf('BcMath\Number')->yes()

|| $this->isInstanceOf('GMP')->yes()

) {

return new IntersectionType([

new StringType(),

new AccessoryNumericStringType(),

new AccessoryNonEmptyStringType(),

]);

}

$classReflection = $this->getClassReflection();

if ($classReflection === null) {

return new ErrorType();

}

if ($classReflection->hasNativeMethod('__toString')) {

return $this->getMethod('__toString', new OutOfClassScope())->getOnlyVariant()->getReturnType();

}

return new ErrorType();

}

public function toArray(): Type

{

$classReflection = $this->getClassReflection();

if ($classReflection === null) {

return new ArrayType(new MixedType(), new MixedType());

}

$reflectionProvider = ReflectionProviderStaticAccessor::getInstance();

if (

!$classReflection->getNativeReflection()->isUserDefined()

|| $classReflection->is(ArrayObject::class)

|| UniversalObjectCratesClassReflectionExtension::isUniversalObjectCrate(

$reflectionProvider,

$classReflection,

)

) {

return new ArrayType(new MixedType(), new MixedType());

}

$arrayKeys = [];

$arrayValues = [];

$isFinal = $classReflection->isFinal();

do {

foreach ($classReflection->getNativeReflection()->getProperties() as $nativeProperty) {

if ($nativeProperty->isStatic()) {

continue;

}

$declaringClass = $reflectionProvider->getClass($nativeProperty->getDeclaringClass()->getName());

$property = $declaringClass->getNativeProperty($nativeProperty->getName());

$keyName = $nativeProperty->getName();

if ($nativeProperty->isPrivate()) {

$keyName = sprintf(

"\0%s\0%s",

$declaringClass->getName(),

$keyName,

);

} elseif ($nativeProperty->isProtected()) {

$keyName = sprintf(

"\0*\0%s",

$keyName,

);

}

$arrayKeys[] = new ConstantStringType($keyName);

$arrayValues[] = $property->getReadableType();

}

$classReflection = $classReflection->getParentClass();

} while ($classReflection !== null);

if (!$isFinal) {

if (count($arrayKeys) === 0 || count($arrayKeys) > 16) {

return new ArrayType(new MixedType(), new MixedType());

}

$types = [new ArrayType(new MixedType(), new MixedType())];

foreach ($arrayKeys as $i => $arrayKey) {

$types[] = new HasOffsetValueType($arrayKey, $arrayValues[$i]);

}

return new IntersectionType($types);

}

return new ConstantArrayType($arrayKeys, $arrayValues);

}

public function toArrayKey(): Type

{

return new ErrorType();

}

public function toCoercedArgumentType(bool $strictTypes): Type

{

if (!$strictTypes) {

$classReflection = $this->getClassReflection();

if (

$classReflection === null

|| !$classReflection->hasNativeMethod('__toString')

) {

return $this;

}

return TypeCombinator::union($this, $this->toString());

}

return $this;

}

public function toBoolean(): BooleanType

{

if (

$this->isInstanceOf('SimpleXMLElement')->yes()

|| $this->isInstanceOf('BcMath\Number')->yes()

|| $this->isInstanceOf('GMP')->yes()

) {

return new BooleanType();

}

return new ConstantBooleanType(true);

}

public function isObject(): TrinaryLogic

{

return TrinaryLogic::createYes();

}

public function getClassStringType(): Type

{

return new GenericClassStringType($this);

}

public function isEnum(): TrinaryLogic

{

$classReflection = $this->getClassReflection();

if ($classReflection === null) {

return TrinaryLogic::createMaybe();

}

if (

$classReflection->isEnum()

|| $classReflection->is('UnitEnum')