<?php declare(strict_types = 1);

namespace PHPStan\Reflection;

use Closure;

use Nette\Utils\Strings;

use PhpParser\Node\Arg;

use PhpParser\Node\ComplexType;

use PhpParser\Node\Expr;

use PhpParser\Node\Expr\BinaryOp;

use PhpParser\Node\Expr\Cast\Array_;

use PhpParser\Node\Expr\Cast\Bool_;

use PhpParser\Node\Expr\Cast\Double;

use PhpParser\Node\Expr\Cast\Object_;

use PhpParser\Node\Expr\ClassConstFetch;

use PhpParser\Node\Expr\ConstFetch;

use PhpParser\Node\Expr\FuncCall;

use PhpParser\Node\Expr\New_;

use PhpParser\Node\Expr\PropertyFetch;

use PhpParser\Node\Expr\Variable;

use PhpParser\Node\Identifier;

use PhpParser\Node\Name;

use PhpParser\Node\Param;

use PhpParser\Node\Scalar\Float_;

use PhpParser\Node\Scalar\Int_;

use PhpParser\Node\Scalar\MagicConst;

use PhpParser\Node\Scalar\MagicConst\Dir;

use PhpParser\Node\Scalar\MagicConst\File;

use PhpParser\Node\Scalar\MagicConst\Line;

use PhpParser\Node\Scalar\String_;

use PHPStan\Analyser\ConstantResolver;

use PHPStan\Analyser\OutOfClassScope;

use PHPStan\DependencyInjection\AutowiredParameter;

use PHPStan\DependencyInjection\AutowiredService;

use PHPStan\Node\Expr\TypeExpr;

use PHPStan\Php\PhpVersion;

use PHPStan\PhpDoc\Tag\TemplateTag;

use PHPStan\Reflection\Callables\CallableParametersAcceptor;

use PHPStan\Reflection\Callables\SimpleImpurePoint;

use PHPStan\Reflection\Callables\SimpleThrowPoint;

use PHPStan\Reflection\Native\NativeParameterReflection;

use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider;

use PHPStan\ShouldNotHappenException;

use PHPStan\TrinaryLogic;

use PHPStan\Type\Accessory\AccessoryArrayListType;

use PHPStan\Type\Accessory\AccessoryLiteralStringType;

use PHPStan\Type\Accessory\AccessoryLowercaseStringType;

use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;

use PHPStan\Type\Accessory\AccessoryNonFalsyStringType;

use PHPStan\Type\Accessory\AccessoryNumericStringType;

use PHPStan\Type\Accessory\AccessoryUppercaseStringType;

use PHPStan\Type\Accessory\HasOffsetValueType;

use PHPStan\Type\Accessory\NonEmptyArrayType;

use PHPStan\Type\ArrayType;

use PHPStan\Type\BenevolentUnionType;

use PHPStan\Type\BooleanType;

use PHPStan\Type\CallableAssertionsHelper;

use PHPStan\Type\ClassStringType;

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\Constant\OversizedArrayBuilder;

use PHPStan\Type\ConstantScalarType;

use PHPStan\Type\ConstantTypeHelper;

use PHPStan\Type\Enum\EnumCaseObjectType;

use PHPStan\Type\ErrorType;

use PHPStan\Type\FloatType;

use PHPStan\Type\GeneralizePrecision;

use PHPStan\Type\Generic\GenericClassStringType;

use PHPStan\Type\Generic\TemplateType;

use PHPStan\Type\Generic\TemplateTypeMap;

use PHPStan\Type\Generic\TemplateTypeVarianceMap;

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\ObjectShapeType;

use PHPStan\Type\ObjectType;

use PHPStan\Type\ObjectWithoutClassType;

use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry;

use PHPStan\Type\ParserNodeTypeToPHPStanType;

use PHPStan\Type\StaticType;

use PHPStan\Type\StringType;

use PHPStan\Type\ThisType;

use PHPStan\Type\Type;

use PHPStan\Type\TypeCombinator;

use PHPStan\Type\TypehintHelper;

use PHPStan\Type\TypeResult;

use PHPStan\Type\TypeUtils;

use PHPStan\Type\TypeWithClassName;

use PHPStan\Type\UnaryOperatorTypeSpecifyingExtensionRegistry;

use PHPStan\Type\UnionType;

use stdClass;

use Throwable;

use function array_key_exists;

use function array_keys;

use function array_map;

use function array_merge;

use function array_values;

use function assert;

use function ceil;

use function count;

use function dirname;

use function floor;

use function in_array;

use function intval;

use function is_finite;

use function is_float;

use function is_int;

use function is_numeric;

use function is_string;

use function max;

use function min;

use function sprintf;

use function str_starts_with;

use function strtolower;

use const INF;

#[AutowiredService]

final class InitializerExprTypeResolver

{

public const CALCULATE_SCALARS_LIMIT = 128;

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

private array $currentlyResolvingClassConstant = [];

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

private array $classConstantValueTypeCache = [];

public function __construct(

private ConstantResolver $constantResolver,

private ReflectionProviderProvider $reflectionProviderProvider,

private PhpVersion $phpVersion,

private OperatorTypeSpecifyingExtensionRegistry $operatorTypeSpecifyingExtensionRegistry,

private UnaryOperatorTypeSpecifyingExtensionRegistry $unaryOperatorTypeSpecifyingExtensionRegistry,

private OversizedArrayBuilder $oversizedArrayBuilder,

#[AutowiredParameter]

private bool $usePathConstantsAsConstantString,

)

{

}

/** @api */

public function getType(Expr $expr, InitializerExprContext $context): Type

{

if ($expr instanceof TypeExpr) {

return $expr->getExprType();

}

if ($expr instanceof Int_) {

return new ConstantIntegerType($expr->value);

}

if ($expr instanceof Float_) {

return new ConstantFloatType($expr->value);

}

if ($expr instanceof String_) {

return new ConstantStringType($expr->value);

}

if ($expr instanceof ConstFetch) {

$constName = (string) $expr->name;

$loweredConstName = strtolower($constName);

if ($loweredConstName === 'true') {

return new ConstantBooleanType(true);

} elseif ($loweredConstName === 'false') {

return new ConstantBooleanType(false);

} elseif ($loweredConstName === 'null') {

return new NullType();

}

$constant = $this->constantResolver->resolveConstant($expr->name, $context);

if ($constant !== null) {

return $constant;

}

return new ErrorType();

}

if ($expr instanceof File) {

$file = $context->getFile();

if ($file === null) {

return new StringType();

}

$stringType = new ConstantStringType($file);

return $this->usePathConstantsAsConstantString ? $stringType : $stringType->generalize(GeneralizePrecision::moreSpecific());

}

if ($expr instanceof Dir) {

$file = $context->getFile();

if ($file === null) {

return new StringType();

}

$stringType = new ConstantStringType(dirname($file));

return $this->usePathConstantsAsConstantString ? $stringType : $stringType->generalize(GeneralizePrecision::moreSpecific());

}

if ($expr instanceof Line) {

return new ConstantIntegerType($expr->getStartLine());

}

if ($expr instanceof Expr\New_) {

if ($expr->class instanceof Name) {

return new ObjectType((string) $expr->class);

}

return new ObjectWithoutClassType();

}

if ($expr instanceof Expr\Array_) {

return $this->getArrayType($expr, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\Cast) {

return $this->getCastType($expr, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\CallLike && $expr->isFirstClassCallable()) {

return $this->getFirstClassCallableType($expr, $context, false);

}

if ($expr instanceof Expr\Closure && $expr->static) {

$parameters = [];

$isVariadic = false;

$firstOptionalParameterIndex = null;

foreach ($expr->params as $i => $param) {

$isOptionalCandidate = $param->default !== null || $param->variadic;

if ($isOptionalCandidate) {

if ($firstOptionalParameterIndex === null) {

$firstOptionalParameterIndex = $i;

}

} else {

$firstOptionalParameterIndex = null;

}

}

foreach ($expr->params as $i => $param) {

if ($param->variadic) {

$isVariadic = true;

}

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

throw new ShouldNotHappenException();

}

$parameters[] = new NativeParameterReflection(

$param->var->name,

$firstOptionalParameterIndex !== null && $i >= $firstOptionalParameterIndex,

$this->getFunctionType($param->type, $this->isParameterValueNullable($param), false, $context),

$param->byRef

? PassedByReference::createCreatesNewVariable()

: PassedByReference::createNo(),

$param->variadic,

$param->default !== null ? $this->getType($param->default, $context) : null,

);

}

$returnType = new MixedType(false);

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

$returnType = $this->getFunctionType($expr->returnType, false, false, $context);

}

return new ClosureType(

$parameters,

$returnType,

$isVariadic,

TemplateTypeMap::createEmpty(),

TemplateTypeMap::createEmpty(),

TemplateTypeVarianceMap::createEmpty(),

acceptsNamedArguments: TrinaryLogic::createYes(),

isStatic: TrinaryLogic::createYes(),

);

}

if ($expr instanceof Expr\ArrayDimFetch && $expr->dim !== null) {

$var = $this->getType($expr->var, $context);

$dim = $this->getType($expr->dim, $context);

return $var->getOffsetValueType($dim);

}

if ($expr instanceof ClassConstFetch && $expr->name instanceof Identifier) {

return $this->getClassConstFetchType($expr->class, $expr->name->toString(), $context->getClassName(), fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\UnaryPlus) {

return $this->getUnaryPlusType($expr->expr, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\UnaryMinus) {

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

}

if ($expr instanceof Expr\BinaryOp\Coalesce) {

$leftType = $this->getType($expr->left, $context);

$rightType = $this->getType($expr->right, $context);

return TypeCombinator::union(TypeCombinator::removeNull($leftType), $rightType);

}

if ($expr instanceof Expr\Ternary) {

$elseType = $this->getType($expr->else, $context);

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

$condType = $this->getType($expr->cond, $context);

return TypeCombinator::union(

TypeCombinator::removeFalsey($condType),

$elseType,

);

}

$ifType = $this->getType($expr->if, $context);

return TypeCombinator::union(

TypeCombinator::removeFalsey($ifType),

$elseType,

);

}

if ($expr instanceof Expr\FuncCall && $expr->name instanceof Name && $expr->name->toLowerString() === 'constant') {

$firstArg = $expr->args[0] ?? null;

if ($firstArg instanceof Arg && $firstArg->value instanceof String_) {

$constant = $this->constantResolver->resolvePredefinedConstant($firstArg->value->value);

if ($constant !== null) {

return $constant;

}

}

}

if ($expr instanceof Expr\BooleanNot) {

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

if ($exprBooleanType instanceof ConstantBooleanType) {

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

}

return new BooleanType();

}

if ($expr instanceof Expr\BitwiseNot) {

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

}

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

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

}

if ($expr instanceof Expr\BinaryOp\BitwiseAnd) {

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

}

if ($expr instanceof Expr\BinaryOp\BitwiseOr) {

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

}

if ($expr instanceof Expr\BinaryOp\BitwiseXor) {

return $this->getBitwiseXorType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\BinaryOp\Spaceship) {

return $this->getSpaceshipType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if (

$expr instanceof Expr\BinaryOp\BooleanAnd

|| $expr instanceof Expr\BinaryOp\LogicalAnd

|| $expr instanceof Expr\BinaryOp\BooleanOr

|| $expr instanceof Expr\BinaryOp\LogicalOr

) {

return new BooleanType();

}

if ($expr instanceof Expr\BinaryOp\Div) {

return $this->getDivType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\BinaryOp\Mod) {

return $this->getModType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\BinaryOp\Plus) {

return $this->getPlusType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\BinaryOp\Minus) {

return $this->getMinusType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\BinaryOp\Mul) {

return $this->getMulType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\BinaryOp\Pow) {

return $this->getPowType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\BinaryOp\ShiftLeft) {

return $this->getShiftLeftType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof Expr\BinaryOp\ShiftRight) {

return $this->getShiftRightType($expr->left, $expr->right, fn (Expr $expr): Type => $this->getType($expr, $context));

}

if ($expr instanceof BinaryOp\Identical) {

return $this->resolveIdenticalType(

$this->getType($expr->left, $context),

$this->getType($expr->right, $context),

)->type;

}

if ($expr instanceof BinaryOp\NotIdentical) {

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

}

if ($expr instanceof BinaryOp\Equal) {

return $this->resolveEqualType(

$this->getType($expr->left, $context),

$this->getType($expr->right, $context),

)->type;

}

if ($expr instanceof BinaryOp\NotEqual) {

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

}

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

return $this->getType($expr->left, $context)->isSmallerThan($this->getType($expr->right, $context), $this->phpVersion)->toBooleanType();

}

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

return $this->getType($expr->left, $context)->isSmallerThanOrEqual($this->getType($expr->right, $context), $this->phpVersion)->toBooleanType();

}

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

return $this->getType($expr->right, $context)->isSmallerThan($this->getType($expr->left, $context), $this->phpVersion)->toBooleanType();

}

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

return $this->getType($expr->right, $context)->isSmallerThanOrEqual($this->getType($expr->left, $context), $this->phpVersion)->toBooleanType();

}

if ($expr instanceof Expr\BinaryOp\LogicalXor) {

$leftBooleanType = $this->getType($expr->left, $context)->toBoolean();

$rightBooleanType = $this->getType($expr->right, $context)->toBoolean();

if (

$leftBooleanType instanceof ConstantBooleanType

&& $rightBooleanType instanceof ConstantBooleanType

) {

return new ConstantBooleanType(

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

);

}

return new BooleanType();

}

if ($expr instanceof MagicConst\Class_) {

if ($context->getTraitName() !== null) {

return new IntersectionType([

new ClassStringType(),

new AccessoryLiteralStringType(),

]);

}

if ($context->getClassName() === null) {

return new ConstantStringType('');

}

return new ConstantStringType($context->getClassName(), true);

}

if ($expr instanceof MagicConst\Namespace_) {

if ($context->getTraitName() !== null) {

return new IntersectionType([

new StringType(),

new AccessoryLiteralStringType(),

]);

}

return new ConstantStringType($context->getNamespace() ?? '');

}

if ($expr instanceof MagicConst\Method) {

return new ConstantStringType($context->getMethod() ?? '');

}

if ($expr instanceof MagicConst\Function_) {

return new ConstantStringType($context->getFunction() ?? '');

}

if ($expr instanceof MagicConst\Trait_) {

if ($context->getTraitName() === null) {

return new ConstantStringType('');

}

return new ConstantStringType($context->getTraitName(), true);

}

if ($expr instanceof MagicConst\Property) {

$contextProperty = $context->getProperty();

if ($contextProperty === null) {

return new ConstantStringType('');

}

return new ConstantStringType($contextProperty);

}

if ($expr instanceof PropertyFetch && $expr->name instanceof Identifier) {

$fetchedOnType = $this->getType($expr->var, $context);

if (!$fetchedOnType->hasInstanceProperty($expr->name->name)->yes()) {

return new ErrorType();

}

return $fetchedOnType->getInstanceProperty($expr->name->name, new OutOfClassScope())->getReadableType();

}

return new MixedType();

}

/**

* @param callable(Expr): Type $getTypeCallback

*/

public function getConcatType(Expr $left, Expr $right, callable $getTypeCallback): Type

{

$leftType = $getTypeCallback($left);

$rightType = $getTypeCallback($right);

return $this->resolveConcatType($leftType, $rightType);

}

public function resolveConcatType(Type $left, Type $right): Type

{

$leftStringType = $left->toString();

$rightStringType = $right->toString();

if (TypeCombinator::union(

$leftStringType,

$rightStringType,

) instanceof ErrorType) {

return new ErrorType();

}

if ($leftStringType instanceof ConstantStringType && $leftStringType->getValue() === '') {

return $rightStringType;

}

if ($rightStringType instanceof ConstantStringType && $rightStringType->getValue() === '') {

return $leftStringType;

}

if ($leftStringType instanceof ConstantStringType && $rightStringType instanceof ConstantStringType) {

return $leftStringType->append($rightStringType);

}

$leftConstantStrings = $leftStringType->getConstantStrings();

$rightConstantStrings = $rightStringType->getConstantStrings();

$combinedConstantStringsCount = count($leftConstantStrings) * count($rightConstantStrings);

// we limit the number of union-types for performance reasons

if ($combinedConstantStringsCount > 0 && $combinedConstantStringsCount <= self::CALCULATE_SCALARS_LIMIT) {

$strings = [];

foreach ($leftConstantStrings as $leftConstantString) {

if ($leftConstantString->getValue() === '') {

$strings = array_merge($strings, $rightConstantStrings);

continue;

}

foreach ($rightConstantStrings as $rightConstantString) {

if ($rightConstantString->getValue() === '') {

$strings[] = $leftConstantString;

continue;

}

$strings[] = $leftConstantString->append($rightConstantString);

}

}

if (count($strings) > 0) {

return TypeCombinator::union(...$strings);

}

}

$accessoryTypes = [];

if ($leftStringType->isNonEmptyString()->and($rightStringType->isNonEmptyString())->yes()) {

$accessoryTypes[] = new AccessoryNonFalsyStringType();

} elseif ($leftStringType->isNonFalsyString()->or($rightStringType->isNonFalsyString())->yes()) {

$accessoryTypes[] = new AccessoryNonFalsyStringType();

} elseif ($leftStringType->isNonEmptyString()->or($rightStringType->isNonEmptyString())->yes()) {

$accessoryTypes[] = new AccessoryNonEmptyStringType();

}

if ($leftStringType->isLiteralString()->and($rightStringType->isLiteralString())->yes()) {

$accessoryTypes[] = new AccessoryLiteralStringType();

}

if ($leftStringType->isLowercaseString()->and($rightStringType->isLowercaseString())->yes()) {

$accessoryTypes[] = new AccessoryLowercaseStringType();

}

if ($leftStringType->isUppercaseString()->and($rightStringType->isUppercaseString())->yes()) {

$accessoryTypes[] = new AccessoryUppercaseStringType();

}

$leftNumericStringNonEmpty = TypeCombinator::remove($leftStringType, new ConstantStringType(''));

if ($leftNumericStringNonEmpty->isNumericString()->yes()) {

$validationCallback = $left->isInteger()->yes()

? static fn (string $value): bool => !str_starts_with($value, '-')

: static fn (string $value): bool => Strings::match($value, '#^\d+$#') !== null;

$allRightConstantsZeroOrMore = false;

foreach ($rightConstantStrings as $rightConstantString) {

if ($rightConstantString->getValue() === '') {

continue;

}

if (

!is_numeric($rightConstantString->getValue())

|| !$validationCallback($rightConstantString->getValue())

) {

$allRightConstantsZeroOrMore = false;

break;

}

$allRightConstantsZeroOrMore = true;

}

$zeroOrMoreInteger = IntegerRangeType::fromInterval(0, null);

$nonNegativeRight = $allRightConstantsZeroOrMore || $zeroOrMoreInteger->isSuperTypeOf($right)->yes();

if ($nonNegativeRight) {

$accessoryTypes[] = new AccessoryNumericStringType();

}

}

if (count($accessoryTypes) > 0) {

$accessoryTypes[] = new StringType();

return new IntersectionType($accessoryTypes);

}

return new StringType();

}

/**

* @param callable(Expr): Type $getTypeCallback

*/

public function getArrayType(Expr\Array_ $expr, callable $getTypeCallback): Type

{

if (count($expr->items) > ConstantArrayTypeBuilder::ARRAY_COUNT_LIMIT) {

return $this->oversizedArrayBuilder->build($expr, $getTypeCallback);

}

$arrayBuilder = ConstantArrayTypeBuilder::createEmpty();

$isList = null;

$hasOffsetValueTypes = [];

foreach ($expr->items as $arrayItem) {

$valueType = $getTypeCallback($arrayItem->value);

if ($arrayItem->unpack) {

$constantArrays = $valueType->getConstantArrays();

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

$constantArrayType = $constantArrays[0];

$hasStringKey = false;

if ($this->phpVersion->supportsArrayUnpackingWithStringKeys()) {

foreach ($constantArrayType->getKeyTypes() as $keyType) {

if ($keyType->isString()->yes()) {

$hasStringKey = true;

break;

}

}

}

foreach ($constantArrayType->getValueTypes() as $i => $innerValueType) {

if ($hasStringKey) {

$arrayBuilder->setOffsetValueType($constantArrayType->getKeyTypes()[$i], $innerValueType, $constantArrayType->isOptionalKey($i));

if (!$constantArrayType->isOptionalKey($i)) {

$hasOffsetValueTypes[$constantArrayType->getKeyTypes()[$i]->getValue()] = new HasOffsetValueType($constantArrayType->getKeyTypes()[$i], $innerValueType);

}

} else {

$arrayBuilder->setOffsetValueType(null, $innerValueType, $constantArrayType->isOptionalKey($i));

}

}

} else {

$arrayBuilder->degradeToGeneralArray();

if ($this->phpVersion->supportsArrayUnpackingWithStringKeys() && !$valueType->getIterableKeyType()->isString()->no()) {

$isList = false;

$offsetType = $valueType->getIterableKeyType();

foreach ($hasOffsetValueTypes as $key => $hasOffsetValueType) {

if (!$offsetType->isSuperTypeOf($hasOffsetValueType->getOffsetType())->yes()) {

continue;

}

unset($hasOffsetValueTypes[$key]);

}

} else {

$isList ??= $arrayBuilder->isList();

$offsetType = new IntegerType();

}

$arrayBuilder->setOffsetValueType($offsetType, $valueType->getIterableValueType(), !$valueType->isIterableAtLeastOnce()->yes());

}

} else {

$arrayBuilder->setOffsetValueType(

$arrayItem->key !== null ? $getTypeCallback($arrayItem->key) : null,

$valueType,

);

}

}

$arrayType = $arrayBuilder->getArray();

if ($isList === true) {

$arrayType = TypeCombinator::intersect($arrayType, new AccessoryArrayListType());

}

if (count($hasOffsetValueTypes) > 0 && !$arrayType->isConstantArray()->yes()) {

$arrayType = TypeCombinator::intersect($arrayType, ...array_values($hasOffsetValueTypes));

}

return $arrayType;

}

/**

* @param callable(Expr): Type $getTypeCallback

*/

public function getCastType(Expr\Cast $expr, callable $getTypeCallback): Type

{

if ($expr instanceof \PhpParser\Node\Expr\Cast\Int_) {

return $getTypeCallback($expr->expr)->toInteger();

}

if ($expr instanceof Bool_) {

return $getTypeCallback($expr->expr)->toBoolean();

}

if ($expr instanceof Double) {

return $getTypeCallback($expr->expr)->toFloat();

}

if ($expr instanceof \PhpParser\Node\Expr\Cast\String_) {

return $getTypeCallback($expr->expr)->toString();

}

if ($expr instanceof Array_) {

return $getTypeCallback($expr->expr)->toArray();

}

if ($expr instanceof Object_) {

return $this->getCastObjectType($getTypeCallback($expr->expr));

}

return new MixedType();

}

public function getCastObjectType(Type $exprType): Type

{

$castToObject = static function (Type $type): Type {

$constantArrays = $type->getConstantArrays();

if (count($constantArrays) > 0) {

$objects = [];

foreach ($constantArrays as $constantArray) {

$properties = [];

$optionalProperties = [];

foreach ($constantArray->getKeyTypes() as $i => $keyType) {

$valueType = $constantArray->getValueTypes()[$i];

$optional = $constantArray->isOptionalKey($i);

if ($optional) {

$optionalProperties[] = $keyType->getValue();

}

$properties[$keyType->getValue()] = $valueType;

}

$objects[] = new IntersectionType([new ObjectShapeType($properties, $optionalProperties), new ObjectType(stdClass::class)]);

}

return TypeCombinator::union(...$objects);

}

if ($type->isObject()->yes()) {

return $type;

}

return new ObjectType('stdClass');

};

if ($exprType instanceof UnionType) {

return TypeCombinator::union(...array_map($castToObject, $exprType->getTypes()));

}

return $castToObject($exprType);

}

/**

* @param Name|Identifier|ComplexType|null $type

*/

public function getFunctionType($type, bool $isNullable, bool $isVariadic, InitializerExprContext $context): Type

{

if ($isNullable) {

return TypeCombinator::addNull(

$this->getFunctionType($type, false, $isVariadic, $context),

);

}

if ($isVariadic) {

if ($this->phpVersion->supportsNamedArguments()) {

return new ArrayType(new UnionType([IntegerRangeType::createAllGreaterThanOrEqualTo(0), new StringType()]), $this->getFunctionType(

$type,

false,

false,

$context,

));

}

return new IntersectionType([new ArrayType(IntegerRangeType::createAllGreaterThanOrEqualTo(0), $this->getFunctionType(

$type,

false,

false,

$context,

)), new AccessoryArrayListType()]);

}

if ($type instanceof Name) {

$className = (string) $type;

$lowercasedClassName = strtolower($className);

if ($lowercasedClassName === 'parent') {

$classReflection = null;

if ($context->getClassName() !== null && $this->getReflectionProvider()->hasClass($context->getClassName())) {

$classReflection = $this->getReflectionProvider()->getClass($context->getClassName());

}

if ($classReflection !== null && $classReflection->getParentClass() !== null) {

return new ObjectType($classReflection->getParentClass()->getName());

}

return new NonexistentParentClassType();

}

}

$classReflection = null;

if ($context->getClassName() !== null && $this->getReflectionProvider()->hasClass($context->getClassName())) {

$classReflection = $this->getReflectionProvider()->getClass($context->getClassName());

}

return ParserNodeTypeToPHPStanType::resolve($type, $classReflection);

}

private function isParameterValueNullable(Param $parameter): bool

{

if ($parameter->default instanceof ConstFetch) {

return strtolower((string) $parameter->default->name) === 'null';

}

return false;

}

public function getFirstClassCallableType(Expr\CallLike $expr, InitializerExprContext $context, bool $nativeTypesPromoted): Type

{

if ($expr instanceof FuncCall) {

if ($expr->name instanceof Name) {

if ($this->getReflectionProvider()->hasFunction($expr->name, $context)) {

$function = $this->getReflectionProvider()->getFunction($expr->name, $context);

return $this->createFirstClassCallable(

$function,

$function->getVariants(),

$nativeTypesPromoted,

);

}

return new ObjectType(Closure::class);

}

}

if ($expr instanceof Expr\StaticCall) {

if (!$expr->class instanceof Name) {

return new ObjectType(Closure::class);

}

if (!$expr->name instanceof Identifier) {

return new ObjectType(Closure::class);

}

$classReflection = null;

if ($context->getClassName() !== null && $this->getReflectionProvider()->hasClass($context->getClassName())) {

$classReflection = $this->getReflectionProvider()->getClass($context->getClassName());

}

$classType = $this->resolveTypeByName($expr->class, $classReflection);

$methodName = $expr->name->toString();

if (!$classType->hasMethod($methodName)->yes()) {

return new ObjectType(Closure::class);

}

$method = $classType->getMethod($methodName, new OutOfClassScope());

$classType = $this->resolveTypeByNameWithLateStaticBinding($expr->class, $classType, $method);

if (!$classType->hasMethod($methodName)->yes()) {

return new ObjectType(Closure::class);

}

$method = $classType->getMethod($methodName, new OutOfClassScope());

return $this->createFirstClassCallable(

$method,

$method->getVariants(),

$nativeTypesPromoted,

);

}

if ($expr instanceof New_) {

return new ErrorType();

}

throw new ShouldNotHappenException();

}

/**

* @param ParametersAcceptor[] $variants

*/

public function createFirstClassCallable(

FunctionReflection|ExtendedMethodReflection|null $function,

array $variants,

bool $nativeTypesPromoted,

): Type

{

$closureTypes = [];

foreach ($variants as $variant) {

$returnType = $variant->getReturnType();

if ($variant instanceof ExtendedParametersAcceptor) {

$returnType = $nativeTypesPromoted ? $variant->getNativeReturnType() : $returnType;

}

$templateTags = [];

foreach ($variant->getTemplateTypeMap()->getTypes() as $templateType) {

if (!$templateType instanceof TemplateType) {

continue;

}

$templateTags[$templateType->getName()] = new TemplateTag(

$templateType->getName(),

$templateType->getBound(),

$templateType->getDefault(),

$templateType->getVariance(),

);

}

$throwPoints = [];

$impurePoints = [];

$acceptsNamedArguments = TrinaryLogic::createYes();

$mustUseReturnValue = TrinaryLogic::createMaybe();

$isStaticClosure = TrinaryLogic::createMaybe();

if ($variant instanceof CallableParametersAcceptor) {

$throwPoints = $variant->getThrowPoints();

$impurePoints = $variant->getImpurePoints();

$acceptsNamedArguments = $variant->acceptsNamedArguments();

$mustUseReturnValue = $variant->mustUseReturnValue();

$isStaticClosure = $variant->isStaticClosure();

} elseif ($function !== null) {

$returnTypeForThrow = $variant->getReturnType();

$throwType = $function->getThrowType();

if ($throwType === null) {

if ($returnTypeForThrow instanceof NeverType && $returnTypeForThrow->isExplicit()) {

$throwType = new ObjectType(Throwable::class);

}

}

if ($throwType !== null) {

if (!$throwType->isVoid()->yes()) {

$throwPoints[] = SimpleThrowPoint::createExplicit($throwType, true);

}

} else {

if (!(new ObjectType(Throwable::class))->isSuperTypeOf($returnTypeForThrow)->yes()) {

$throwPoints[] = SimpleThrowPoint::createImplicit();

}

}

$impurePoint = SimpleImpurePoint::createFromVariant($function, $variant);

if ($impurePoint !== null) {

$impurePoints[] = $impurePoint;

}

$acceptsNamedArguments = $function->acceptsNamedArguments();

$mustUseReturnValue = $function->mustUseReturnValue();

}

$parameters = $variant->getParameters();

if ($function !== null) {

$assertions = $function->getAsserts();

} elseif ($variant instanceof CallableParametersAcceptor) {

$assertions = $variant->getAsserts();

} else {

$assertions = Assertions::createEmpty();

}

// a conditional return type referencing the function's own parameter,

// like @return ($value is int ? true : false) on is_int(),

// also becomes a type predicate of the resulting Closure

$assertions = CallableAssertionsHelper::withConditionalReturnPredicate($assertions, $variant);

$closureTypes[] = new ClosureType(

$parameters,

$returnType,

$variant->isVariadic(),

$variant->getTemplateTypeMap(),

$variant->getResolvedTemplateTypeMap(),

$variant instanceof ExtendedParametersAcceptor ? $variant->getCallSiteVarianceMap() : TemplateTypeVarianceMap::createEmpty(),

$templateTags,

$throwPoints,

$impurePoints,

acceptsNamedArguments: $acceptsNamedArguments,

mustUseReturnValue: $mustUseReturnValue,

assertions: $assertions,

isStatic: $isStaticClosure,

);

}

return TypeCombinator::union(...$closureTypes);

}