<?php declare(strict_types = 1);

namespace PHPStan\Analyser;

use ArrayAccess;

use Closure;

use Generator;

use Nette\Utils\Strings;

use PhpParser\Node;

use PhpParser\Node\Arg;

use PhpParser\Node\Expr;

use PhpParser\Node\Expr\Array_;

use PhpParser\Node\Expr\BinaryOp;

use PhpParser\Node\Expr\Cast\Bool_;

use PhpParser\Node\Expr\Cast\Double;

use PhpParser\Node\Expr\Cast\Int_;

use PhpParser\Node\Expr\Cast\Object_;

use PhpParser\Node\Expr\Cast\Unset_;

use PhpParser\Node\Expr\ConstFetch;

use PhpParser\Node\Expr\FuncCall;

use PhpParser\Node\Expr\MethodCall;

use PhpParser\Node\Expr\New_;

use PhpParser\Node\Expr\PropertyFetch;

use PhpParser\Node\Expr\Variable;

use PhpParser\Node\Name;

use PhpParser\Node\Name\FullyQualified;

use PhpParser\Node\Scalar\DNumber;

use PhpParser\Node\Scalar\EncapsedStringPart;

use PhpParser\Node\Scalar\LNumber;

use PhpParser\Node\Scalar\String_;

use PhpParser\NodeFinder;

use PHPStan\Node\ExecutionEndNode;

use PHPStan\Node\Expr\GetIterableKeyTypeExpr;

use PHPStan\Node\Expr\GetIterableValueTypeExpr;

use PHPStan\Node\Expr\GetOffsetValueTypeExpr;

use PHPStan\Node\Expr\OriginalPropertyTypeExpr;

use PHPStan\Node\Expr\SetOffsetValueTypeExpr;

use PHPStan\Node\Expr\TypeExpr;

use PHPStan\Node\Printer\ExprPrinter;

use PHPStan\Parser\Parser;

use PHPStan\Parser\ParserErrorsException;

use PHPStan\Php\PhpVersion;

use PHPStan\Reflection\ClassMemberReflection;

use PHPStan\Reflection\ClassReflection;

use PHPStan\Reflection\ConstantReflection;

use PHPStan\Reflection\Dummy\DummyConstructorReflection;

use PHPStan\Reflection\FunctionReflection;

use PHPStan\Reflection\InitializerExprContext;

use PHPStan\Reflection\InitializerExprTypeResolver;

use PHPStan\Reflection\MethodReflection;

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\Reflection\Php\PhpFunctionFromParserNodeReflection;

use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection;

use PHPStan\Reflection\PropertyReflection;

use PHPStan\Reflection\ReflectionProvider;

use PHPStan\Reflection\TrivialParametersAcceptor;

use PHPStan\Rules\Properties\PropertyReflectionFinder;

use PHPStan\ShouldNotHappenException;

use PHPStan\TrinaryLogic;

use PHPStan\Type\Accessory\AccessoryLiteralStringType;

use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;

use PHPStan\Type\ArrayType;

use PHPStan\Type\BooleanType;

use PHPStan\Type\ClosureType;

use PHPStan\Type\Constant\ConstantArrayType;

use PHPStan\Type\Constant\ConstantArrayTypeBuilder;

use PHPStan\Type\Constant\ConstantBooleanType;

use PHPStan\Type\Constant\ConstantFloatType;

use PHPStan\Type\Constant\ConstantIntegerType;

use PHPStan\Type\Constant\ConstantStringType;

use PHPStan\Type\ConstantTypeHelper;

use PHPStan\Type\DynamicReturnTypeExtensionRegistry;

use PHPStan\Type\ErrorType;

use PHPStan\Type\GeneralizePrecision;

use PHPStan\Type\Generic\GenericClassStringType;

use PHPStan\Type\Generic\GenericObjectType;

use PHPStan\Type\Generic\TemplateType;

use PHPStan\Type\Generic\TemplateTypeHelper;

use PHPStan\Type\Generic\TemplateTypeMap;

use PHPStan\Type\GenericTypeVariableResolver;

use PHPStan\Type\IntegerRangeType;

use PHPStan\Type\IntegerType;

use PHPStan\Type\IntersectionType;

use PHPStan\Type\MixedType;

use PHPStan\Type\NeverType;

use PHPStan\Type\NonexistentParentClassType;

use PHPStan\Type\NullType;

use PHPStan\Type\ObjectType;

use PHPStan\Type\ObjectWithoutClassType;

use PHPStan\Type\ParserNodeTypeToPHPStanType;

use PHPStan\Type\StaticType;

use PHPStan\Type\StaticTypeFactory;

use PHPStan\Type\StringType;

use PHPStan\Type\ThisType;

use PHPStan\Type\Type;

use PHPStan\Type\TypeCombinator;

use PHPStan\Type\TypehintHelper;

use PHPStan\Type\TypeTraverser;

use PHPStan\Type\TypeUtils;

use PHPStan\Type\TypeWithClassName;

use PHPStan\Type\UnionType;

use PHPStan\Type\VerbosityLevel;

use PHPStan\Type\VoidType;

use Throwable;

use function abs;

use function array_column;

use function array_filter;

use function array_key_exists;

use function array_keys;

use function array_map;

use function array_pop;

use function count;

use function get_class;

use function in_array;

use function is_string;

use function ltrim;

use function sprintf;

use function str_starts_with;

use function strlen;

use function strtolower;

use function substr;

use function usort;

use const PHP_INT_MAX;

use const PHP_INT_MIN;

class MutatingScope implements Scope

{

/** @var Type[] */

private array $resolvedTypes = [];

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

private array $truthyScopes = [];

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

private array $falseyScopes = [];

private ?string $namespace;

private ?self $scopeOutOfFirstLevelStatement = null;

/**

* @param array<string, Type> $constantTypes

* @param VariableTypeHolder[] $variableTypes

* @param VariableTypeHolder[] $moreSpecificTypes

* @param array<string, ConditionalExpressionHolder[]> $conditionalExpressions

* @param array<string, true> $currentlyAssignedExpressions

* @param array<string, true> $currentlyAllowedUndefinedExpressions

* @param array<string, Type> $nativeExpressionTypes

* @param array<MethodReflection|FunctionReflection> $inFunctionCallsStack

*/

public function __construct(

private ScopeFactory $scopeFactory,

private ReflectionProvider $reflectionProvider,

private InitializerExprTypeResolver $initializerExprTypeResolver,

private DynamicReturnTypeExtensionRegistry $dynamicReturnTypeExtensionRegistry,

private ExprPrinter $exprPrinter,

private TypeSpecifier $typeSpecifier,

private PropertyReflectionFinder $propertyReflectionFinder,

private Parser $parser,

private NodeScopeResolver $nodeScopeResolver,

private ConstantResolver $constantResolver,

private ScopeContext $context,

private PhpVersion $phpVersion,

private bool $declareStrictTypes = false,

private array $constantTypes = [],

private FunctionReflection|MethodReflection|null $function = null,

?string $namespace = null,

private array $variableTypes = [],

private array $moreSpecificTypes = [],

private array $conditionalExpressions = [],

private ?string $inClosureBindScopeClass = null,

private ?ParametersAcceptor $anonymousFunctionReflection = null,

private bool $inFirstLevelStatement = true,

private array $currentlyAssignedExpressions = [],

private array $currentlyAllowedUndefinedExpressions = [],

private array $nativeExpressionTypes = [],

private array $inFunctionCallsStack = [],

private bool $treatPhpDocTypesAsCertain = true,

private bool $afterExtractCall = false,

private ?Scope $parentScope = null,

private bool $explicitMixedInUnknownGenericNew = false,

private bool $explicitMixedForGlobalVariables = false,

)

{

if ($namespace === '') {

$namespace = null;

}

$this->namespace = $namespace;

}

/** @api */

public function getFile(): string

{

return $this->context->getFile();

}

/** @api */

public function getFileDescription(): string

{

if ($this->context->getTraitReflection() === null) {

return $this->getFile();

}

/** @var ClassReflection $classReflection */

$classReflection = $this->context->getClassReflection();

$className = $classReflection->getDisplayName();

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

$className = sprintf('class %s', $className);

}

$traitReflection = $this->context->getTraitReflection();

if ($traitReflection->getFileName() === null) {

throw new ShouldNotHappenException();

}

return sprintf(

'%s (in context of %s)',

$traitReflection->getFileName(),

$className,

);

}

/** @api */

public function isDeclareStrictTypes(): bool

{

return $this->declareStrictTypes;

}

public function enterDeclareStrictTypes(): self

{

return $this->scopeFactory->create(

$this->context,

true,

[],

null,

null,

$this->variableTypes,

);

}

/** @api */

public function isInClass(): bool

{

return $this->context->getClassReflection() !== null;

}

/** @api */

public function isInTrait(): bool

{

return $this->context->getTraitReflection() !== null;

}

/** @api */

public function getClassReflection(): ?ClassReflection

{

return $this->context->getClassReflection();

}

/** @api */

public function getTraitReflection(): ?ClassReflection

{

return $this->context->getTraitReflection();

}

/**

* @api

* @return FunctionReflection|MethodReflection|null

*/

public function getFunction()

{

return $this->function;

}

/** @api */

public function getFunctionName(): ?string

{

return $this->function !== null ? $this->function->getName() : null;

}

/** @api */

public function getNamespace(): ?string

{

return $this->namespace;

}

/** @api */

public function getParentScope(): ?Scope

{

return $this->parentScope;

}

/**

* @return array<string, VariableTypeHolder>

*/

private function getVariableTypes(): array

{

return $this->variableTypes;

}

/** @api */

public function canAnyVariableExist(): bool

{

return ($this->function === null && !$this->isInAnonymousFunction()) || $this->afterExtractCall;

}

public function afterExtractCall(): self

{

return $this->scopeFactory->create(

$this->context,

$this->isDeclareStrictTypes(),

$this->constantTypes,

$this->getFunction(),

$this->getNamespace(),

$this->getVariableTypes(),

$this->moreSpecificTypes,

[],

$this->inClosureBindScopeClass,

$this->anonymousFunctionReflection,

$this->isInFirstLevelStatement(),

$this->currentlyAssignedExpressions,

$this->currentlyAllowedUndefinedExpressions,

$this->nativeExpressionTypes,

$this->inFunctionCallsStack,

true,

$this->parentScope,

);

}

public function afterClearstatcacheCall(): self

{

$moreSpecificTypes = $this->moreSpecificTypes;

foreach (array_keys($moreSpecificTypes) as $exprString) {

// list from https://www.php.net/manual/en/function.clearstatcache.php

// stat(), lstat(), file_exists(), is_writable(), is_readable(), is_executable(), is_file(), is_dir(), is_link(), filectime(), fileatime(), filemtime(), fileinode(), filegroup(), fileowner(), filesize(), filetype(), and fileperms().

foreach ([

'stat',

'lstat',

'file_exists',

'is_writable',

'is_writeable',

'is_readable',

'is_executable',

'is_file',

'is_dir',

'is_link',

'filectime',

'fileatime',

'filemtime',

'fileinode',

'filegroup',

'fileowner',

'filesize',

'filetype',

'fileperms',

] as $functionName) {

if (!str_starts_with((string) $exprString, $functionName . '(') && !str_starts_with((string) $exprString, '\\' . $functionName . '(')) {

continue;

}

unset($moreSpecificTypes[$exprString]);

continue 2;

}

}

return $this->scopeFactory->create(

$this->context,

$this->isDeclareStrictTypes(),

$this->constantTypes,

$this->getFunction(),

$this->getNamespace(),

$this->getVariableTypes(),

$moreSpecificTypes,

$this->conditionalExpressions,

$this->inClosureBindScopeClass,

$this->anonymousFunctionReflection,

$this->isInFirstLevelStatement(),

$this->currentlyAssignedExpressions,

$this->currentlyAllowedUndefinedExpressions,

$this->nativeExpressionTypes,

$this->inFunctionCallsStack,

$this->afterExtractCall,

$this->parentScope,

);

}

public function afterOpenSslCall(string $openSslFunctionName): self

{

$moreSpecificTypes = $this->moreSpecificTypes;

if (in_array($openSslFunctionName, [

'openssl_cipher_iv_length',

'openssl_cms_decrypt',

'openssl_cms_encrypt',

'openssl_cms_read',

'openssl_cms_sign',

'openssl_cms_verify',

'openssl_csr_export_to_file',

'openssl_csr_export',

'openssl_csr_get_public_key',

'openssl_csr_get_subject',

'openssl_csr_new',

'openssl_csr_sign',

'openssl_decrypt',

'openssl_dh_compute_key',

'openssl_digest',

'openssl_encrypt',

'openssl_get_curve_names',

'openssl_get_privatekey',

'openssl_get_publickey',

'openssl_open',

'openssl_pbkdf2',

'openssl_pkcs12_export_to_file',

'openssl_pkcs12_export',

'openssl_pkcs12_read',

'openssl_pkcs7_decrypt',

'openssl_pkcs7_encrypt',

'openssl_pkcs7_read',

'openssl_pkcs7_sign',

'openssl_pkcs7_verify',

'openssl_pkey_derive',

'openssl_pkey_export_to_file',

'openssl_pkey_export',

'openssl_pkey_get_private',

'openssl_pkey_get_public',

'openssl_pkey_new',

'openssl_private_decrypt',

'openssl_private_encrypt',

'openssl_public_decrypt',

'openssl_public_encrypt',

'openssl_random_pseudo_bytes',

'openssl_seal',

'openssl_sign',

'openssl_spki_export_challenge',

'openssl_spki_export',

'openssl_spki_new',

'openssl_spki_verify',

'openssl_verify',

'openssl_x509_checkpurpose',

'openssl_x509_export_to_file',

'openssl_x509_export',

'openssl_x509_fingerprint',

'openssl_x509_read',

'openssl_x509_verify',

], true)) {

unset($moreSpecificTypes['\openssl_error_string()']);

}

return $this->scopeFactory->create(

$this->context,

$this->isDeclareStrictTypes(),

$this->constantTypes,

$this->getFunction(),

$this->getNamespace(),

$this->getVariableTypes(),

$moreSpecificTypes,

$this->conditionalExpressions,

$this->inClosureBindScopeClass,

$this->anonymousFunctionReflection,

$this->isInFirstLevelStatement(),

$this->currentlyAssignedExpressions,

$this->currentlyAllowedUndefinedExpressions,

$this->nativeExpressionTypes,

$this->inFunctionCallsStack,

$this->afterExtractCall,

$this->parentScope,

);

}

/** @api */

public function hasVariableType(string $variableName): TrinaryLogic

{

if ($this->isGlobalVariable($variableName)) {

return TrinaryLogic::createYes();

}

if (!isset($this->variableTypes[$variableName])) {

if ($this->canAnyVariableExist()) {

return TrinaryLogic::createMaybe();

}

return TrinaryLogic::createNo();

}

return $this->variableTypes[$variableName]->getCertainty();

}

/** @api */

public function getVariableType(string $variableName): Type

{

if ($this->isGlobalVariable($variableName)) {

return new ArrayType(new StringType(), new MixedType($this->explicitMixedForGlobalVariables));

}

if ($this->hasVariableType($variableName)->no()) {

throw new UndefinedVariableException($this, $variableName);

}

if (!array_key_exists($variableName, $this->variableTypes)) {

return new MixedType();

}

return $this->variableTypes[$variableName]->getType();

}

/**

* @api

* @return array<int, string>

*/

public function getDefinedVariables(): array

{

$variables = [];

foreach ($this->variableTypes as $variableName => $holder) {

if (!$holder->getCertainty()->yes()) {

continue;

}

$variables[] = $variableName;

}

return $variables;

}

private function isGlobalVariable(string $variableName): bool

{

return in_array($variableName, [

'GLOBALS',

'_SERVER',

'_GET',

'_POST',

'_FILES',

'_COOKIE',

'_SESSION',

'_REQUEST',

'_ENV',

], true);

}

/** @api */

public function hasConstant(Name $name): bool

{

$isCompilerHaltOffset = $name->toString() === '__COMPILER_HALT_OFFSET__';

if ($isCompilerHaltOffset) {

return $this->fileHasCompilerHaltStatementCalls();

}

if ($name->isFullyQualified()) {

if (array_key_exists($name->toCodeString(), $this->constantTypes)) {

return true;

}

}

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

$constantName = new FullyQualified([$this->getNamespace(), $name->toString()]);

if (array_key_exists($constantName->toCodeString(), $this->constantTypes)) {

return true;

}

}

$constantName = new FullyQualified($name->toString());

if (array_key_exists($constantName->toCodeString(), $this->constantTypes)) {

return true;

}

return $this->reflectionProvider->hasConstant($name, $this);

}

private function fileHasCompilerHaltStatementCalls(): bool

{

$nodes = $this->parser->parseFile($this->getFile());

foreach ($nodes as $node) {

if ($node instanceof Node\Stmt\HaltCompiler) {

return true;

}

}

return false;

}

/** @api */

public function isInAnonymousFunction(): bool

{

return $this->anonymousFunctionReflection !== null;

}

/** @api */

public function getAnonymousFunctionReflection(): ?ParametersAcceptor

{

return $this->anonymousFunctionReflection;

}

/** @api */

public function getAnonymousFunctionReturnType(): ?Type

{

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

return null;

}

return $this->anonymousFunctionReflection->getReturnType();

}

/** @api */

public function getType(Expr $node): Type

{

if ($node instanceof GetIterableKeyTypeExpr) {

return $this->getType($node->getExpr())->getIterableKeyType();

}

if ($node instanceof GetIterableValueTypeExpr) {

return $this->getType($node->getExpr())->getIterableValueType();

}

if ($node instanceof GetOffsetValueTypeExpr) {

return $this->getType($node->getVar())->getOffsetValueType($this->getType($node->getDim()));

}

if ($node instanceof SetOffsetValueTypeExpr) {

return $this->getType($node->getVar())->setOffsetValueType(

$node->getDim() !== null ? $this->getType($node->getDim()) : null,

$this->getType($node->getValue()),

);

}

if ($node instanceof TypeExpr) {

return $node->getExprType();

}

if ($node instanceof OriginalPropertyTypeExpr) {

$propertyReflection = $this->propertyReflectionFinder->findPropertyReflectionFromNode($node->getPropertyFetch(), $this);

if ($propertyReflection === null) {

return new ErrorType();

}

return $propertyReflection->getReadableType();

}

$key = $this->getNodeKey($node);

if (!array_key_exists($key, $this->resolvedTypes)) {

$this->resolvedTypes[$key] = TypeUtils::resolveLateResolvableTypes($this->resolveType($node));

}

return $this->resolvedTypes[$key];

}

private function getNodeKey(Expr $node): string

{

return $this->exprPrinter->printExpr($node);

}

private function resolveType(Expr $node): Type

{

if ($node instanceof Expr\Exit_ || $node instanceof Expr\Throw_) {

return new NeverType(true);

}

$exprString = $this->getNodeKey($node);

if (isset($this->moreSpecificTypes[$exprString]) && $this->moreSpecificTypes[$exprString]->getCertainty()->yes()) {

return $this->moreSpecificTypes[$exprString]->getType();

}

if ($node instanceof Expr\BinaryOp\Smaller) {

return $this->getType($node->left)->isSmallerThan($this->getType($node->right))->toBooleanType();

}

if ($node instanceof Expr\BinaryOp\SmallerOrEqual) {

return $this->getType($node->left)->isSmallerThanOrEqual($this->getType($node->right))->toBooleanType();

}

if ($node instanceof Expr\BinaryOp\Greater) {

return $this->getType($node->right)->isSmallerThan($this->getType($node->left))->toBooleanType();

}

if ($node instanceof Expr\BinaryOp\GreaterOrEqual) {

return $this->getType($node->right)->isSmallerThanOrEqual($this->getType($node->left))->toBooleanType();

}

if ($node instanceof Expr\BinaryOp\Equal) {

if (

$node->left instanceof Variable

&& is_string($node->left->name)

&& $node->right instanceof Variable

&& is_string($node->right->name)

&& $node->left->name === $node->right->name

) {

return new ConstantBooleanType(true);

}

$leftType = $this->getType($node->left);

$rightType = $this->getType($node->right);

return $this->initializerExprTypeResolver->resolveEqualType($leftType, $rightType);

}

if ($node instanceof Expr\BinaryOp\NotEqual) {

return $this->getType(new Expr\BooleanNot(new BinaryOp\Equal($node->left, $node->right)));

}

if ($node instanceof Expr\Empty_) {

$result = $this->issetCheck($node->expr, static function (Type $type): ?bool {

$isNull = (new NullType())->isSuperTypeOf($type);

$isFalsey = (new ConstantBooleanType(false))->isSuperTypeOf($type->toBoolean());

if ($isNull->maybe()) {

return null;

}

if ($isFalsey->maybe()) {

return null;

}

if ($isNull->yes()) {

if ($isFalsey->yes()) {

return false;

}

if ($isFalsey->no()) {

return true;

}

return false;

}

return !$isFalsey->yes();

});

if ($result === null) {

return new BooleanType();

}

return new ConstantBooleanType(!$result);

}

if ($node instanceof Node\Expr\BooleanNot) {

if ($this->treatPhpDocTypesAsCertain) {

$exprBooleanType = $this->getType($node->expr)->toBoolean();

} else {

$exprBooleanType = $this->getNativeType($node->expr)->toBoolean();

}

if ($exprBooleanType instanceof ConstantBooleanType) {

return new ConstantBooleanType(!$exprBooleanType->getValue());

}

return new BooleanType();

}

if ($node instanceof Node\Expr\BitwiseNot) {

return $this->initializerExprTypeResolver->getBitwiseNotType($node->expr, fn (Expr $expr): Type => $this->getType($expr));

}

if (

$node instanceof Node\Expr\BinaryOp\BooleanAnd

|| $node instanceof Node\Expr\BinaryOp\LogicalAnd

) {

if ($this->treatPhpDocTypesAsCertain) {

$leftBooleanType = $this->getType($node->left)->toBoolean();

} else {

$leftBooleanType = $this->getNativeType($node->left)->toBoolean();

}

if (

$leftBooleanType instanceof ConstantBooleanType

&& !$leftBooleanType->getValue()

) {

return new ConstantBooleanType(false);

}

if ($this->treatPhpDocTypesAsCertain) {

$rightBooleanType = $this->filterByTruthyValue($node->left)->getType($node->right)->toBoolean();

} else {

$rightBooleanType = $this->promoteNativeTypes()->filterByTruthyValue($node->left)->getType($node->right)->toBoolean();

}

if (

$rightBooleanType instanceof ConstantBooleanType

&& !$rightBooleanType->getValue()

) {

return new ConstantBooleanType(false);

}

if (

$leftBooleanType instanceof ConstantBooleanType

&& $leftBooleanType->getValue()

&& $rightBooleanType instanceof ConstantBooleanType

&& $rightBooleanType->getValue()

) {

return new ConstantBooleanType(true);

}

return new BooleanType();

}

if (

$node instanceof Node\Expr\BinaryOp\BooleanOr

|| $node instanceof Node\Expr\BinaryOp\LogicalOr

) {

if ($this->treatPhpDocTypesAsCertain) {

$leftBooleanType = $this->getType($node->left)->toBoolean();

} else {

$leftBooleanType = $this->getNativeType($node->left)->toBoolean();

}

if (

$leftBooleanType instanceof ConstantBooleanType

&& $leftBooleanType->getValue()

) {

return new ConstantBooleanType(true);

}

if ($this->treatPhpDocTypesAsCertain) {

$rightBooleanType = $this->filterByFalseyValue($node->left)->getType($node->right)->toBoolean();

} else {

$rightBooleanType = $this->promoteNativeTypes()->filterByFalseyValue($node->left)->getType($node->right)->toBoolean();

}

if (

$rightBooleanType instanceof ConstantBooleanType

&& $rightBooleanType->getValue()

) {

return new ConstantBooleanType(true);

}

if (

$leftBooleanType instanceof ConstantBooleanType

&& !$leftBooleanType->getValue()

&& $rightBooleanType instanceof ConstantBooleanType

&& !$rightBooleanType->getValue()

) {

return new ConstantBooleanType(false);

}

return new BooleanType();

}

if ($node instanceof Node\Expr\BinaryOp\LogicalXor) {

if ($this->treatPhpDocTypesAsCertain) {

$leftBooleanType = $this->getType($node->left)->toBoolean();

$rightBooleanType = $this->getType($node->right)->toBoolean();

} else {

$leftBooleanType = $this->getNativeType($node->left)->toBoolean();

$rightBooleanType = $this->getNativeType($node->right)->toBoolean();

}

if (

$leftBooleanType instanceof ConstantBooleanType

&& $rightBooleanType instanceof ConstantBooleanType

) {

return new ConstantBooleanType(

$leftBooleanType->getValue() xor $rightBooleanType->getValue(),

);

}

return new BooleanType();

}

if ($node instanceof Expr\BinaryOp\Identical) {

if (

$node->left instanceof Variable

&& is_string($node->left->name)

&& $node->right instanceof Variable

&& is_string($node->right->name)

&& $node->left->name === $node->right->name

) {

return new ConstantBooleanType(true);

}

if ($this->treatPhpDocTypesAsCertain) {

$leftType = $this->getType($node->left);

$rightType = $this->getType($node->right);

} else {

$leftType = $this->getNativeType($node->left);

$rightType = $this->getNativeType($node->right);

}

if (

(

$node->left instanceof Node\Expr\PropertyFetch

|| $node->left instanceof Node\Expr\StaticPropertyFetch

)

&& $rightType instanceof NullType

&& !$this->hasPropertyNativeType($node->left)

) {

return new BooleanType();

}

if (

(

$node->right instanceof Node\Expr\PropertyFetch

|| $node->right instanceof Node\Expr\StaticPropertyFetch

)

&& $leftType instanceof NullType

&& !$this->hasPropertyNativeType($node->right)

) {

return new BooleanType();

}

return $this->initializerExprTypeResolver->resolveIdenticalType($leftType, $rightType);

}

if ($node instanceof Expr\BinaryOp\NotIdentical) {

return $this->getType(new Expr\BooleanNot(new BinaryOp\Identical($node->left, $node->right)));

}

if ($node instanceof Expr\Instanceof_) {

if ($this->treatPhpDocTypesAsCertain) {

$expressionType = $this->getType($node->expr);

} else {

$expressionType = $this->getNativeType($node->expr);

}

if (

$this->isInTrait()

&& TypeUtils::findThisType($expressionType) !== null

) {

return new BooleanType();

}

if ($expressionType instanceof NeverType) {

return new ConstantBooleanType(false);

}

$uncertainty = false;

if ($node->class instanceof Node\Name) {

$unresolvedClassName = $node->class->toString();

if (

strtolower($unresolvedClassName) === 'static'

&& $this->isInClass()

) {

$classType = new StaticType($this->getClassReflection());

} else {

$className = $this->resolveName($node->class);

$classType = new ObjectType($className);

}

} else {

$classType = $this->getType($node->class);

$classType = TypeTraverser::map($classType, static function (Type $type, callable $traverse) use (&$uncertainty): Type {

if ($type instanceof UnionType || $type instanceof IntersectionType) {

return $traverse($type);

}

if ($type instanceof TypeWithClassName) {

$uncertainty = true;

return $type;

}

if ($type instanceof GenericClassStringType) {

$uncertainty = true;

return $type->getGenericType();

}

if ($type instanceof ConstantStringType) {

return new ObjectType($type->getValue());

}

return new MixedType();

});

}

if ($classType->isSuperTypeOf(new MixedType())->yes()) {

return new BooleanType();

}

$isSuperType = $classType->isSuperTypeOf($expressionType);

if ($isSuperType->no()) {

return new ConstantBooleanType(false);

} elseif ($isSuperType->yes() && !$uncertainty) {

return new ConstantBooleanType(true);

}

return new BooleanType();

}

if ($node instanceof Node\Expr\UnaryPlus) {

return $this->getType($node->expr)->toNumber();

}

if ($node instanceof Expr\ErrorSuppress

|| $node instanceof Expr\Assign

) {

return $this->getType($node->expr);

}

if ($node instanceof Node\Expr\UnaryMinus) {

return $this->initializerExprTypeResolver->getUnaryMinusType($node->expr, fn (Expr $expr): Type => $this->getType($expr));

}

if ($node instanceof Expr\BinaryOp\Concat) {

return $this->initializerExprTypeResolver->getConcatType($node->left, $node->right, fn (Expr $expr): Type => $this->getType($expr));

}

if ($node instanceof Expr\AssignOp\Concat) {

return $this->initializerExprTypeResolver->getConcatType($node->var, $node->expr, fn (Expr $expr): Type => $this->getType($expr));

}

if ($node instanceof BinaryOp\BitwiseAnd) {

return $this->initializerExprTypeResolver->getBitwiseAndType($node->left, $node->right, fn (Expr $expr): Type => $this->getType($expr));

}

if ($node instanceof Expr\AssignOp\BitwiseAnd) {

return $this->initializerExprTypeResolver->getBitwiseAndType($node->var, $node->expr, fn (Expr $expr): Type => $this->getType($expr));

}

if ($node instanceof BinaryOp\BitwiseOr) {

return $this->initializerExprTypeResolver->getBitwiseOrType($node->left, $node->right, fn (Expr $expr): Type => $this->getType($expr));

}

if ($node instanceof Expr\AssignOp\BitwiseOr) {

return $this->initializerExprTypeResolver->getBitwiseOrType($node->var, $node->expr, fn (Expr $expr): Type => $this->getType($expr));