{

private const LOOP_SCOPE_ITERATIONS = 3;

private const GENERALIZE_AFTER_ITERATION = 1;

/** @var bool[] filePath(string) => bool(true) */

private array $analysedFiles = [];

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

private array $earlyTerminatingMethodNames;

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

private array $calledMethodStack = [];

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

private array $calledMethodResults = [];

/**

public function __construct(

private readonly ReflectionProvider $reflectionProvider,

private readonly InitializerExprTypeResolver $initializerExprTypeResolver,

private readonly Reflector $reflector,

private readonly ClassReflectionExtensionRegistryProvider $classReflectionExtensionRegistryProvider,

private readonly ParameterOutTypeExtensionProvider $parameterOutTypeExtensionProvider,

private readonly Parser $parser,

private readonly FileTypeMapper $fileTypeMapper,

private readonly StubPhpDocProvider $stubPhpDocProvider,

private readonly PhpVersion $phpVersion,

private readonly SignatureMapProvider $signatureMapProvider,

private readonly PhpDocInheritanceResolver $phpDocInheritanceResolver,

private readonly FileHelper $fileHelper,

private readonly TypeSpecifier $typeSpecifier,

private readonly DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider,

private readonly ReadWritePropertiesExtensionProvider $readWritePropertiesExtensionProvider,

private readonly ParameterClosureTypeExtensionProvider $parameterClosureTypeExtensionProvider,

private readonly ScopeFactory $scopeFactory,

private readonly bool $polluteScopeWithLoopInitialAssignments,

private readonly bool $polluteScopeWithAlwaysIterableForeach,

private readonly array $earlyTerminatingMethodCalls,

private readonly array $earlyTerminatingFunctionCalls,

private readonly array $universalObjectCratesClasses,

private readonly bool $implicitThrows,

private readonly bool $treatPhpDocTypesAsCertain,

private readonly bool $detectDeadTypeInMultiCatch,

private readonly bool $paramOutType,

private readonly bool $preciseMissingReturn,

)

{

$earlyTerminatingMethodNames = [];

foreach ($this->earlyTerminatingMethodCalls as $methodNames) {

foreach ($methodNames as $methodName) {

$earlyTerminatingMethodNames[strtolower($methodName)] = true;

}

}

$this->earlyTerminatingMethodNames = $earlyTerminatingMethodNames;

}

/**

public function setAnalysedFiles(array $files): void

{

$this->analysedFiles = array_fill_keys($files, true);

}

/**

public function processNodes(

array $nodes,

MutatingScope $scope,

callable $nodeCallback,

): void

{

$alreadyTerminated = false;

foreach ($nodes as $i => $node) {

if (

!$node instanceof Node\Stmt

|| ($alreadyTerminated && !($node instanceof Node\Stmt\Function_ || $node instanceof Node\Stmt\ClassLike))

) {

continue;

}

$statementResult = $this->processStmtNode($node, $scope, $nodeCallback, StatementContext::createTopLevel());

$scope = $statementResult->getScope();

if ($alreadyTerminated || !$statementResult->isAlwaysTerminating()) {

continue;

}

$alreadyTerminated = true;

$nextStmt = $this->getFirstUnreachableNode(array_slice($nodes, $i + 1), true);

if (!$nextStmt instanceof Node\Stmt) {

continue;

}

$nodeCallback(new UnreachableStatementNode($nextStmt), $scope);

}

}

/**

public function processStmtNodes(

Node $parentNode,

array $stmts,

MutatingScope $scope,

callable $nodeCallback,

?StatementContext $context = null,

): StatementResult

{

if ($context === null) {

$context = StatementContext::createTopLevel();

}

$exitPoints = [];

$throwPoints = [];

$impurePoints = [];

$alreadyTerminated = false;

$hasYield = false;

$stmtCount = count($stmts);

$shouldCheckLastStatement = $parentNode instanceof Node\Stmt\Function_

|| $parentNode instanceof Node\Stmt\ClassMethod

|| $parentNode instanceof Expr\Closure;

foreach ($stmts as $i => $stmt) {

if ($alreadyTerminated && !($stmt instanceof Node\Stmt\Function_ || $stmt instanceof Node\Stmt\ClassLike)) {

continue;

}

$isLast = $i === $stmtCount - 1;

$statementResult = $this->processStmtNode(

$stmt,

$scope,

$nodeCallback,

$context,

);

$scope = $statementResult->getScope();

$hasYield = $hasYield || $statementResult->hasYield();

if ($shouldCheckLastStatement && $isLast) {

/** @var Node\Stmt\Function_|Node\Stmt\ClassMethod|Expr\Closure $parentNode */

$parentNode = $parentNode;

$endStatements = $statementResult->getEndStatements();

if ($this->preciseMissingReturn && count($endStatements) > 0) {

foreach ($endStatements as $endStatement) {

$endStatementResult = $endStatement->getResult();

$nodeCallback(new ExecutionEndNode(

$endStatement->getStatement(),

new StatementResult(

$endStatementResult->getScope(),

$hasYield,

$endStatementResult->isAlwaysTerminating(),

$endStatementResult->getExitPoints(),

$endStatementResult->getThrowPoints(),

$endStatementResult->getImpurePoints(),

),

$parentNode->returnType !== null,

), $endStatementResult->getScope());

}

} else {

$nodeCallback(new ExecutionEndNode(

$stmt,

new StatementResult(

$scope,

$hasYield,

$statementResult->isAlwaysTerminating(),

$statementResult->getExitPoints(),

$statementResult->getThrowPoints(),

$statementResult->getImpurePoints(),

),

$parentNode->returnType !== null,

), $scope);

}

}

$exitPoints = array_merge($exitPoints, $statementResult->getExitPoints());

$throwPoints = array_merge($throwPoints, $statementResult->getThrowPoints());

$impurePoints = array_merge($impurePoints, $statementResult->getImpurePoints());

if ($alreadyTerminated || !$statementResult->isAlwaysTerminating()) {

continue;

}

$alreadyTerminated = true;

$nextStmt = $this->getFirstUnreachableNode(array_slice($stmts, $i + 1), $parentNode instanceof Node\Stmt\Namespace_);

if ($nextStmt === null) {

continue;

}

$nodeCallback(new UnreachableStatementNode($nextStmt), $scope);

}

$statementResult = new StatementResult($scope, $hasYield, $alreadyTerminated, $exitPoints, $throwPoints, $impurePoints);

if ($stmtCount === 0 && $shouldCheckLastStatement) {

/** @var Node\Stmt\Function_|Node\Stmt\ClassMethod|Expr\Closure $parentNode */

$parentNode = $parentNode;

$returnTypeNode = $parentNode->returnType;

if ($parentNode instanceof Expr\Closure) {

$parentNode = new Node\Stmt\Expression($parentNode, $parentNode->getAttributes());

}

$nodeCallback(new ExecutionEndNode(

$parentNode,

$statementResult,

$returnTypeNode !== null,

), $scope);

}

return $statementResult;

}

/**

private function processStmtNode(

Node\Stmt $stmt,

MutatingScope $scope,

callable $nodeCallback,

StatementContext $context,

): StatementResult

{

if (

!$stmt instanceof Static_

&& !$stmt instanceof Foreach_

&& !$stmt instanceof Node\Stmt\Global_

&& !$stmt instanceof Node\Stmt\Property

&& !$stmt instanceof Node\Stmt\PropertyProperty

&& !$stmt instanceof Node\Stmt\ClassConst

&& !$stmt instanceof Node\Stmt\Const_

) {

$scope = $this->processStmtVarAnnotation($scope, $stmt, null, $nodeCallback);

}

if ($stmt instanceof Node\Stmt\ClassMethod) {

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

throw new ShouldNotHappenException();

}

if (

$scope->isInTrait()

&& $scope->getClassReflection()->hasNativeMethod($stmt->name->toString())

) {

$methodReflection = $scope->getClassReflection()->getNativeMethod($stmt->name->toString());

if ($methodReflection instanceof NativeMethodReflection) {

return new StatementResult($scope, false, false, [], [], []);

}

if ($methodReflection instanceof PhpMethodReflection) {

$declaringTrait = $methodReflection->getDeclaringTrait();

if ($declaringTrait === null || $declaringTrait->getName() !== $scope->getTraitReflection()->getName()) {

return new StatementResult($scope, false, false, [], [], []);

}

}

}

}

$stmtScope = $scope;

if ($stmt instanceof Throw_ || $stmt instanceof Return_) {

$stmtScope = $this->processStmtVarAnnotation($scope, $stmt, $stmt->expr, $nodeCallback);

}

$nodeCallback($stmt, $stmtScope);

$overridingThrowPoints = $this->getOverridingThrowPoints($stmt, $scope);

if ($stmt instanceof Node\Stmt\Declare_) {

$hasYield = false;

$throwPoints = [];

$impurePoints = [];

$alwaysTerminating = false;

$exitPoints = [];

foreach ($stmt->declares as $declare) {

$nodeCallback($declare, $scope);

$nodeCallback($declare->value, $scope);

if (

$declare->key->name !== 'strict_types'

|| !($declare->value instanceof Node\Scalar\LNumber)

|| $declare->value->value !== 1

) {

continue;

}

$scope = $scope->enterDeclareStrictTypes();

}

if ($stmt->stmts !== null) {

$result = $this->processStmtNodes($stmt, $stmt->stmts, $scope, $nodeCallback, $context);

$scope = $result->getScope();

$hasYield = $result->hasYield();

$throwPoints = $result->getThrowPoints();

$impurePoints = $result->getImpurePoints();

$alwaysTerminating = $result->isAlwaysTerminating();

$exitPoints = $result->getExitPoints();

}

return new StatementResult($scope, $hasYield, $alwaysTerminating, $exitPoints, $throwPoints, $impurePoints);

} elseif ($stmt instanceof Node\Stmt\Function_) {

$hasYield = false;

$throwPoints = [];

$impurePoints = [];

$this->processAttributeGroups($stmt, $stmt->attrGroups, $scope, $nodeCallback);

[$templateTypeMap, $phpDocParameterTypes, $phpDocImmediatelyInvokedCallableParameters, $phpDocClosureThisTypeParameters, $phpDocReturnType, $phpDocThrowType, $deprecatedDescription, $isDeprecated, $isInternal, $isFinal, $isPure, $acceptsNamedArguments, , $phpDocComment, $asserts,, $phpDocParameterOutTypes] = $this->getPhpDocs($scope, $stmt);

foreach ($stmt->params as $param) {

$this->processParamNode($stmt, $param, $scope, $nodeCallback);

}

if ($stmt->returnType !== null) {

$nodeCallback($stmt->returnType, $scope);

}

$functionScope = $scope->enterFunction(

$stmt,

$templateTypeMap,

$phpDocParameterTypes,

$phpDocReturnType,

$phpDocThrowType,

$deprecatedDescription,

$isDeprecated,

$isInternal,

$isFinal,

$isPure,

$acceptsNamedArguments,

$asserts,

$phpDocComment,

$phpDocParameterOutTypes,

$phpDocImmediatelyInvokedCallableParameters,

$phpDocClosureThisTypeParameters,

);

$functionReflection = $functionScope->getFunction();

if (!$functionReflection instanceof PhpFunctionFromParserNodeReflection) {

throw new ShouldNotHappenException();

}

$nodeCallback(new InFunctionNode($functionReflection, $stmt), $functionScope);

$gatheredReturnStatements = [];

$gatheredYieldStatements = [];

$executionEnds = [];

$functionImpurePoints = [];

$statementResult = $this->processStmtNodes($stmt, $stmt->stmts, $functionScope, static function (Node $node, Scope $scope) use ($nodeCallback, $functionScope, &$gatheredReturnStatements, &$gatheredYieldStatements, &$executionEnds, &$functionImpurePoints): void {

$nodeCallback($node, $scope);

if ($scope->getFunction() !== $functionScope->getFunction()) {

return;

}

if ($scope->isInAnonymousFunction()) {

return;

}

if ($node instanceof PropertyAssignNode) {

$functionImpurePoints[] = new ImpurePoint(

$scope,

$node,

'propertyAssign',

'property assignment',

true,

);

return;

}

if ($node instanceof ExecutionEndNode) {

$executionEnds[] = $node;

return;

}

if ($node instanceof Expr\Yield_ || $node instanceof Expr\YieldFrom) {

$gatheredYieldStatements[] = $node;

}

if (!$node instanceof Return_) {

return;

}

$gatheredReturnStatements[] = new ReturnStatement($scope, $node);

}, StatementContext::createTopLevel());

$nodeCallback(new FunctionReturnStatementsNode(

$stmt,

$gatheredReturnStatements,

$gatheredYieldStatements,

$statementResult,

$executionEnds,

array_merge($statementResult->getImpurePoints(), $functionImpurePoints),

$functionReflection,

), $functionScope);

} elseif ($stmt instanceof Node\Stmt\ClassMethod) {

$hasYield = false;

$throwPoints = [];

$impurePoints = [];

$this->processAttributeGroups($stmt, $stmt->attrGroups, $scope, $nodeCallback);

[$templateTypeMap, $phpDocParameterTypes, $phpDocImmediatelyInvokedCallableParameters, $phpDocClosureThisTypeParameters, $phpDocReturnType, $phpDocThrowType, $deprecatedDescription, $isDeprecated, $isInternal, $isFinal, $isPure, $acceptsNamedArguments, , $phpDocComment, $asserts, $selfOutType, $phpDocParameterOutTypes] = $this->getPhpDocs($scope, $stmt);

foreach ($stmt->params as $param) {

$this->processParamNode($stmt, $param, $scope, $nodeCallback);

}

if ($stmt->returnType !== null) {

$nodeCallback($stmt->returnType, $scope);

}

$methodScope = $scope->enterClassMethod(

$stmt,

$templateTypeMap,

$phpDocParameterTypes,

$phpDocReturnType,

$phpDocThrowType,

$deprecatedDescription,

$isDeprecated,

$isInternal,

$isFinal,

$isPure,

$acceptsNamedArguments,

$asserts,

$selfOutType,

$phpDocComment,

$phpDocParameterOutTypes,

$phpDocImmediatelyInvokedCallableParameters,

$phpDocClosureThisTypeParameters,

);

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

throw new ShouldNotHappenException();

}

$isFromTrait = $stmt->getAttribute('originalTraitMethodName') === '__construct';

if ($isFromTrait || $stmt->name->toLowerString() === '__construct') {

foreach ($stmt->params as $param) {

if ($param->flags === 0) {

continue;

}

if (!$param->var instanceof Variable || !is_string($param->var->name)) {

throw new ShouldNotHappenException();

}

$phpDoc = null;

if ($param->getDocComment() !== null) {

$phpDoc = $param->getDocComment()->getText();

}

$nodeCallback(new ClassPropertyNode(

$param->var->name,

$param->flags,

$param->type,

null,

$phpDoc,

$phpDocParameterTypes[$param->var->name] ?? null,

true,

$isFromTrait,

$param,

false,

$scope->isInTrait(),

$scope->getClassReflection()->isReadOnly(),

false,

$scope->getClassReflection(),

), $methodScope);

$methodScope = $methodScope->assignExpression(new PropertyInitializationExpr($param->var->name), new MixedType(), new MixedType());

}

}

if ($stmt->getAttribute('virtual', false) === false) {

$methodReflection = $methodScope->getFunction();

if (!$methodReflection instanceof PhpMethodFromParserNodeReflection) {

throw new ShouldNotHappenException();

}

$nodeCallback(new InClassMethodNode($scope->getClassReflection(), $methodReflection, $stmt), $methodScope);

}

if ($stmt->stmts !== null) {

$gatheredReturnStatements = [];

$gatheredYieldStatements = [];

$executionEnds = [];

$methodImpurePoints = [];

$statementResult = $this->processStmtNodes($stmt, $stmt->stmts, $methodScope, static function (Node $node, Scope $scope) use ($nodeCallback, $methodScope, &$gatheredReturnStatements, &$gatheredYieldStatements, &$executionEnds, &$methodImpurePoints): void {

$nodeCallback($node, $scope);

if ($scope->getFunction() !== $methodScope->getFunction()) {

return;

}

if ($scope->isInAnonymousFunction()) {

return;

}

if ($node instanceof PropertyAssignNode) {

if (

$node->getPropertyFetch() instanceof Expr\PropertyFetch

&& $scope->getFunction() instanceof PhpMethodFromParserNodeReflection

&& $scope->getFunction()->getDeclaringClass()->hasConstructor()

&& $scope->getFunction()->getDeclaringClass()->getConstructor()->getName() === $scope->getFunction()->getName()

&& TypeUtils::findThisType($scope->getType($node->getPropertyFetch()->var)) !== null

) {

return;

}

$methodImpurePoints[] = new ImpurePoint(

$scope,

$node,

'propertyAssign',

'property assignment',

true,

);

return;

}

if ($node instanceof ExecutionEndNode) {

$executionEnds[] = $node;

return;

}

if ($node instanceof Expr\Yield_ || $node instanceof Expr\YieldFrom) {

$gatheredYieldStatements[] = $node;

}

if (!$node instanceof Return_) {

return;

}

$gatheredReturnStatements[] = new ReturnStatement($scope, $node);

}, StatementContext::createTopLevel());

$classReflection = $scope->getClassReflection();

$methodReflection = $methodScope->getFunction();

if (!$methodReflection instanceof ExtendedMethodReflection) {

throw new ShouldNotHappenException();

}

$nodeCallback(new MethodReturnStatementsNode(

$stmt,

$gatheredReturnStatements,

$gatheredYieldStatements,

$statementResult,

$executionEnds,

array_merge($statementResult->getImpurePoints(), $methodImpurePoints),

$classReflection,

$methodReflection,

), $methodScope);

}

} elseif ($stmt instanceof Echo_) {

$hasYield = false;

$throwPoints = [];

foreach ($stmt->exprs as $echoExpr) {

$result = $this->processExprNode($stmt, $echoExpr, $scope, $nodeCallback, ExpressionContext::createDeep());

$throwPoints = array_merge($throwPoints, $result->getThrowPoints());

$scope = $result->getScope();

$hasYield = $hasYield || $result->hasYield();

}

$throwPoints = $overridingThrowPoints ?? $throwPoints;

$impurePoints = [

new ImpurePoint($scope, $stmt, 'echo', 'echo', true),

];

} elseif ($stmt instanceof Return_) {

if ($stmt->expr !== null) {

$result = $this->processExprNode($stmt, $stmt->expr, $scope, $nodeCallback, ExpressionContext::createDeep());

$throwPoints = $result->getThrowPoints();

$impurePoints = $result->getImpurePoints();

$scope = $result->getScope();

$hasYield = $result->hasYield();

} else {

$hasYield = false;

$throwPoints = [];

$impurePoints = [];

}

return new StatementResult($scope, $hasYield, true, [

new StatementExitPoint($stmt, $scope),

], $overridingThrowPoints ?? $throwPoints, $impurePoints);

} elseif ($stmt instanceof Continue_ || $stmt instanceof Break_) {

if ($stmt->num !== null) {

$result = $this->processExprNode($stmt, $stmt->num, $scope, $nodeCallback, ExpressionContext::createDeep());

$scope = $result->getScope();

$hasYield = $result->hasYield();

$throwPoints = $result->getThrowPoints();

$impurePoints = $result->getImpurePoints();

} else {

$hasYield = false;

$throwPoints = [];

$impurePoints = [];

}

return new StatementResult($scope, $hasYield, true, [

new StatementExitPoint($stmt, $scope),

], $overridingThrowPoints ?? $throwPoints, $impurePoints);

} elseif ($stmt instanceof Node\Stmt\Expression) {

$earlyTerminationExpr = $this->findEarlyTerminatingExpr($stmt->expr, $scope);

$hasAssign = false;

$currentScope = $scope;

$result = $this->processExprNode($stmt, $stmt->expr, $scope, static function (Node $node, Scope $scope) use ($nodeCallback, $currentScope, &$hasAssign): void {

$nodeCallback($node, $scope);

if ($scope->getAnonymousFunctionReflection() !== $currentScope->getAnonymousFunctionReflection()) {

return;

}

if ($scope->getFunction() !== $currentScope->getFunction()) {

return;

}

if (!$node instanceof VariableAssignNode && !$node instanceof PropertyAssignNode) {

return;

}

$hasAssign = true;

}, ExpressionContext::createTopLevel());

$throwPoints = array_filter($result->getThrowPoints(), static fn ($throwPoint) => $throwPoint->isExplicit());

if (

count($result->getImpurePoints()) === 0

&& count($throwPoints) === 0

&& !$stmt->expr instanceof Expr\PostInc

&& !$stmt->expr instanceof Expr\PreInc

&& !$stmt->expr instanceof Expr\PostDec

&& !$stmt->expr instanceof Expr\PreDec

) {

$nodeCallback(new NoopExpressionNode($stmt->expr, $hasAssign), $scope);

}

$scope = $result->getScope();

$scope = $scope->filterBySpecifiedTypes($this->typeSpecifier->specifyTypesInCondition(

$scope,

$stmt->expr,

TypeSpecifierContext::createNull(),

));

$hasYield = $result->hasYield();

$throwPoints = $result->getThrowPoints();

$impurePoints = $result->getImpurePoints();

if ($earlyTerminationExpr !== null) {

return new StatementResult($scope, $hasYield, true, [

new StatementExitPoint($stmt, $scope),

], $overridingThrowPoints ?? $throwPoints, $impurePoints);

}

return new StatementResult($scope, $hasYield, false, [], $overridingThrowPoints ?? $throwPoints, $impurePoints);

} elseif ($stmt instanceof Node\Stmt\Namespace_) {

if ($stmt->name !== null) {

$scope = $scope->enterNamespace($stmt->name->toString());

}

$scope = $this->processStmtNodes($stmt, $stmt->stmts, $scope, $nodeCallback, $context)->getScope();

$hasYield = false;

$throwPoints = [];

$impurePoints = [];

} elseif ($stmt instanceof Node\Stmt\Trait_) {

return new StatementResult($scope, false, false, [], [], []);

} elseif ($stmt instanceof Node\Stmt\ClassLike) {

$hasYield = false;

$throwPoints = [];

$impurePoints = [];

if (isset($stmt->namespacedName)) {

$classReflection = $this->getCurrentClassReflection($stmt, $stmt->namespacedName->toString(), $scope);

$classScope = $scope->enterClass($classReflection);

$nodeCallback(new InClassNode($stmt, $classReflection), $classScope);

} elseif ($stmt instanceof Class_) {

if ($stmt->name === null) {

throw new ShouldNotHappenException();

}

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

$classReflection = $this->reflectionProvider->getClass($stmt->name->toString());

} else {

$classReflection = $this->reflectionProvider->getAnonymousClassReflection($stmt, $scope);

}

$classScope = $scope->enterClass($classReflection);

$nodeCallback(new InClassNode($stmt, $classReflection), $classScope);

} else {

throw new ShouldNotHappenException();

}

$classStatementsGatherer = new ClassStatementsGatherer($classReflection, $nodeCallback);

$this->processAttributeGroups($stmt, $stmt->attrGroups, $classScope, $classStatementsGatherer);

$this->processStmtNodes($stmt, $stmt->stmts, $classScope, $classStatementsGatherer, $context);

$nodeCallback(new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensionProvider, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls(), $classStatementsGatherer->getReturnStatementsNodes(), $classReflection), $classScope);

$nodeCallback(new ClassMethodsNode($stmt, $classStatementsGatherer->getMethods(), $classStatementsGatherer->getMethodCalls(), $classReflection), $classScope);

$nodeCallback(new ClassConstantsNode($stmt, $classStatementsGatherer->getConstants(), $classStatementsGatherer->getConstantFetches(), $classReflection), $classScope);

$classReflection->evictPrivateSymbols();

$this->calledMethodResults = [];

} elseif ($stmt instanceof Node\Stmt\Property) {

$hasYield = false;

$throwPoints = [];

$impurePoints = [];

$this->processAttributeGroups($stmt, $stmt->attrGroups, $scope, $nodeCallback);

foreach ($stmt->props as $prop) {

$nodeCallback($prop, $scope);

if ($prop->default !== null) {

$this->processExprNode($stmt, $prop->default, $scope, $nodeCallback, ExpressionContext::createDeep());

}

[,,,,,,,,,,,,$isReadOnly, $docComment, ,,,$varTags, $isAllowedPrivateMutation] = $this->getPhpDocs($scope, $stmt);

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

throw new ShouldNotHappenException();

}

$propertyName = $prop->name->toString();

$phpDocType = null;

if (isset($varTags[0]) && count($varTags) === 1) {

$phpDocType = $varTags[0]->getType();

} elseif (isset($varTags[$propertyName])) {

$phpDocType = $varTags[$propertyName]->getType();

}

$nodeCallback(

new ClassPropertyNode(

$propertyName,

$stmt->flags,

$stmt->type,

$prop->default,

$docComment,

$phpDocType,

false,

false,

$prop,

$isReadOnly,

$scope->isInTrait(),

$scope->getClassReflection()->isReadOnly(),

$isAllowedPrivateMutation,

$scope->getClassReflection(),

),

$scope,

);

}

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

$nodeCallback($stmt->type, $scope);

}

} elseif ($stmt instanceof Throw_) {

$result = $this->processExprNode($stmt, $stmt->expr, $scope, $nodeCallback, ExpressionContext::createDeep());

$throwPoints = $result->getThrowPoints();

$throwPoints[] = ThrowPoint::createExplicit($result->getScope(), $scope->getType($stmt->expr), $stmt, false);

$impurePoints = $result->getImpurePoints();

return new StatementResult($result->getScope(), $result->hasYield(), true, [

new StatementExitPoint($stmt, $scope),

], $throwPoints, $impurePoints);

} elseif ($stmt instanceof If_) {

$conditionType = ($this->treatPhpDocTypesAsCertain ? $scope->getType($stmt->cond) : $scope->getNativeType($stmt->cond))->toBoolean();

$ifAlwaysTrue = $conditionType->isTrue()->yes();

$condResult = $this->processExprNode($stmt, $stmt->cond, $scope, $nodeCallback, ExpressionContext::createDeep());

$exitPoints = [];

$throwPoints = $overridingThrowPoints ?? $condResult->getThrowPoints();

$impurePoints = $condResult->getImpurePoints();

$endStatements = [];

$finalScope = null;

$alwaysTerminating = true;

$hasYield = $condResult->hasYield();

$branchScopeStatementResult = $this->processStmtNodes($stmt, $stmt->stmts, $condResult->getTruthyScope(), $nodeCallback, $context);

if (!$conditionType instanceof ConstantBooleanType || $conditionType->getValue()) {

$exitPoints = $branchScopeStatementResult->getExitPoints();

$throwPoints = array_merge($throwPoints, $branchScopeStatementResult->getThrowPoints());

$impurePoints = array_merge($impurePoints, $branchScopeStatementResult->getImpurePoints());

$branchScope = $branchScopeStatementResult->getScope();

$finalScope = $branchScopeStatementResult->isAlwaysTerminating() ? null : $branchScope;

$alwaysTerminating = $branchScopeStatementResult->isAlwaysTerminating();

if (count($branchScopeStatementResult->getEndStatements()) > 0) {

$endStatements = array_merge($endStatements, $branchScopeStatementResult->getEndStatements());

} elseif (count($stmt->stmts) > 0) {

$endStatements[] = new EndStatementResult($stmt->stmts[count($stmt->stmts) - 1], $branchScopeStatementResult);

} else {

$endStatements[] = new EndStatementResult($stmt, $branchScopeStatementResult);

}

$hasYield = $branchScopeStatementResult->hasYield() || $hasYield;

}

$scope = $condResult->getFalseyScope();

$lastElseIfConditionIsTrue = false;

$condScope = $scope;

foreach ($stmt->elseifs as $elseif) {

$nodeCallback($elseif, $scope);