<?php declare(strict_types = 1);

namespace PHPStan\Type;

use PHPStan\TrinaryLogic;

use PHPStan\Turbo\ReferencedByTurboExtension;

use PHPStan\Turbo\TurboExtensionEnabler;

use PHPStan\Type\Accessory\AccessoryArrayListType;

use PHPStan\Type\Accessory\AccessoryDecimalIntegerStringType;

use PHPStan\Type\Accessory\AccessoryLowercaseStringType;

use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;

use PHPStan\Type\Accessory\AccessoryNonFalsyStringType;

use PHPStan\Type\Accessory\AccessoryType;

use PHPStan\Type\Accessory\AccessoryUppercaseStringType;

use PHPStan\Type\Accessory\HasOffsetType;

use PHPStan\Type\Accessory\HasOffsetValueType;

use PHPStan\Type\Accessory\HasPropertyType;

use PHPStan\Type\Accessory\NonEmptyArrayType;

use PHPStan\Type\Accessory\OversizedArrayType;

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\Generic\GenericClassStringType;

use PHPStan\Type\Generic\TemplateArrayType;

use PHPStan\Type\Generic\TemplateBenevolentUnionType;

use PHPStan\Type\Generic\TemplateMixedType;

use PHPStan\Type\Generic\TemplateType;

use PHPStan\Type\Generic\TemplateTypeFactory;

use PHPStan\Type\Generic\TemplateUnionType;

use function array_fill;

use function array_filter;

use function array_key_exists;

use function array_key_first;

use function array_keys;

use function array_merge;

use function array_slice;

use function array_splice;

use function array_values;

use function count;

use function get_class;

use function implode;

use function in_array;

use function is_bool;

use function is_int;

use function is_string;

use function sprintf;

use function usort;

use const PHP_INT_MAX;

use const PHP_INT_MIN;

/**

* @api

*/

#[ReferencedByTurboExtension(key: 'typeCombinator')]

final class TypeCombinator

{

/**

* Turned on by TurboExtensionEnabler when the native extension is active, so that

* union(), intersect() and remove() route through the memoizing TypeCombinatorCache.

* Without the extension the operations run exactly as they always have — the flag

* costs a property read, and nothing else changes.

*/

private static ?bool $cacheEnabled = null;

/**

* Memoization hands back shared Type instances, and a Type lazily resolves a

* ClassReflection belonging to the container that created it — so the cache must

* not outlive its container.

*/

public static function clearCache(): void

{

if ((self::$cacheEnabled ??= TurboExtensionEnabler::isTypeCombinatorCacheEnabled()) === false) {

return;

}

TypeCombinatorCache::clearCache();

}

public static function addNull(Type $type): Type

{

$nullType = new NullType();

if ($nullType->isSuperTypeOf($type)->no()) {

return self::union($type, $nullType);

}

return $type;

}

public static function remove(Type $fromType, Type $typeToRemove): Type

{

if (self::$cacheEnabled ??= TurboExtensionEnabler::isTypeCombinatorCacheEnabled()) {

return TypeCombinatorCache::remove($fromType, $typeToRemove);

}

return self::doRemove($fromType, $typeToRemove);

}

/** @internal Delegated to from TypeCombinatorCache, which the native extension shadows to memoize it. */

public static function doRemove(Type $fromType, Type $typeToRemove): Type

{

if ($typeToRemove instanceof UnionType) {

foreach ($typeToRemove->getTypes() as $unionTypeToRemove) {

$fromType = self::remove($fromType, $unionTypeToRemove);

}

return $fromType;

}

$isSuperType = $typeToRemove->isSuperTypeOf($fromType);

if ($isSuperType->yes()) {

return new NeverType();

}

if ($isSuperType->no()) {

return $fromType;

}

if ($typeToRemove instanceof MixedType) {

$typeToRemoveSubtractedType = $typeToRemove->getSubtractedType();

if ($typeToRemoveSubtractedType !== null) {

return self::intersect($fromType, $typeToRemoveSubtractedType);

}

}

$removed = $fromType->tryRemove($typeToRemove);

if ($removed !== null) {

return $removed;

}

$fromFiniteTypes = $fromType->getFiniteTypes();

if (count($fromFiniteTypes) > 0) {

$finiteTypesToRemove = $typeToRemove->getFiniteTypes();

if (count($finiteTypesToRemove) > 0) {

$result = [];

foreach ($fromFiniteTypes as $finiteType) {

foreach ($finiteTypesToRemove as $finiteTypeToRemove) {

if ($finiteType->equals($finiteTypeToRemove)) {

continue 2;

}

}

$result[] = $finiteType;

}

if (count($result) === count($fromFiniteTypes)) {

return $fromType;

}

if (count($result) === 0) {

return new NeverType();

}

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

return $result[0];

}

return new UnionType($result);

}

}

return $fromType;

}

public static function removeNull(Type $type): Type

{

if (self::containsNull($type)) {

return self::remove($type, new NullType());

}

return $type;

}

public static function containsNull(Type $type): bool

{

if ($type instanceof UnionType) {

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

if ($innerType instanceof NullType) {

return true;

}

}

return false;

}

return $type instanceof NullType;

}

public static function union(Type ...$types): Type

{

if (self::$cacheEnabled ??= TurboExtensionEnabler::isTypeCombinatorCacheEnabled()) {

return TypeCombinatorCache::union(...$types);

}

return self::doUnion(...$types);

}

/** @internal Delegated to from TypeCombinatorCache, which the native extension shadows to memoize it. */

public static function doUnion(Type ...$types): Type

{

$typesCount = count($types);

if ($typesCount === 0) {

return new NeverType();

}

// Fast path for single non-union type

if ($typesCount === 1) {

$singleType = $types[0];

if (!$singleType instanceof UnionType && !$singleType->isArray()->yes()) {

return $singleType;

}

}

// Fast path for common 2-type cases

if ($typesCount === 2) {

$a = $types[0];

$b = $types[1];

// union(never, X) = X and union(X, never) = X

if ($a instanceof NeverType && !$a->isExplicit()) {

return $b;

}

if ($b instanceof NeverType && !$b->isExplicit()) {

return $a;

}

// union(mixed, X) = mixed (non-explicit, non-template, no subtracted)

if ($a instanceof MixedType && !$a->isExplicitMixed() && !$a instanceof TemplateMixedType && $a->getSubtractedType() === null) {

return $a;

}

if ($b instanceof MixedType && !$b->isExplicitMixed() && !$b instanceof TemplateMixedType && $b->getSubtractedType() === null) {

return $b;

}

// union(X, X) = X (same object identity)

if ($a === $b) {

return $a;

}

}

$alreadyNormalized = [];

$alreadyNormalizedCounter = 0;

$benevolentTypes = [];

$benevolentUnionObject = null;

$neverCount = 0;

// transform A | (B | C) to A | B | C

for ($i = 0; $i < $typesCount; $i++) {

if (

$types[$i] instanceof MixedType

&& !$types[$i]->isExplicitMixed()

&& !$types[$i] instanceof TemplateMixedType

&& $types[$i]->getSubtractedType() === null

) {

return $types[$i];

}

if ($types[$i] instanceof NeverType && !$types[$i]->isExplicit()) {

$neverCount++;

continue;

}

if ($types[$i] instanceof BenevolentUnionType) {

if ($types[$i] instanceof TemplateBenevolentUnionType && $benevolentUnionObject === null) {

$benevolentUnionObject = $types[$i];

}

$benevolentTypesCount = 0;

$typesInner = $types[$i]->getTypes();

foreach ($typesInner as $benevolentInnerType) {

$benevolentTypesCount++;

$benevolentTypes[$benevolentInnerType->describe(VerbosityLevel::value())] = $benevolentInnerType;

}

array_splice($types, $i, 1, $typesInner);

$typesCount += $benevolentTypesCount - 1;

continue;

}

if (!($types[$i] instanceof UnionType)) {

continue;

}

if ($types[$i] instanceof TemplateType) {

continue;

}

$typesInner = $types[$i]->getTypes();

$alreadyNormalized[$alreadyNormalizedCounter] = $typesInner;

$alreadyNormalizedCounter++;

array_splice($types, $i, 1, $typesInner);

$typesCount += count($typesInner) - 1;

}

// Bulk-remove implicit NeverTypes (skipped during the loop above)

if ($neverCount > 0) {

if ($neverCount === $typesCount) {

return new NeverType();

}

$filtered = [];

for ($i = 0; $i < $typesCount; $i++) {

if ($types[$i] instanceof NeverType && !$types[$i]->isExplicit()) {

continue;

}

$filtered[] = $types[$i];

}

$types = $filtered;

$typesCount = count($types);

if ($typesCount === 0) {

return new NeverType();

}

if ($typesCount === 1 && !$types[0]->isArray()->yes()) {

return $types[0];

}

if ($typesCount === 2) {

return self::union($types[0], $types[1]);

}

}

if ($typesCount === 0) {

return new NeverType();

}

if ($typesCount === 1 && !$types[0]->isArray()->yes()) {

return $types[0];

}

$arrayTypes = [];

$scalarTypes = [];

$hasGenericScalarTypes = [];

$enumCaseTypes = [];

$integerRangeTypes = [];

for ($i = 0; $i < $typesCount; $i++) {

if ($types[$i]->isConstantScalarValue()->yes()) {

$type = $types[$i];

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

unset($types[$i]);

continue;

}

if ($types[$i]->isBoolean()->yes()) {

$hasGenericScalarTypes[ConstantBooleanType::class] = true;

} elseif ($types[$i]->isFloat()->yes()) {

$hasGenericScalarTypes[ConstantFloatType::class] = true;

} elseif ($types[$i]->isInteger()->yes() && !$types[$i] instanceof IntegerRangeType) {

$hasGenericScalarTypes[ConstantIntegerType::class] = true;

} elseif ($types[$i]->isString()->yes() && $types[$i]->isClassString()->no() && TypeUtils::getAccessoryTypes($types[$i]) === []) {

$hasGenericScalarTypes[ConstantStringType::class] = true;

} else {

$enumCase = $types[$i]->getEnumCaseObject();

if ($enumCase !== null) {

$enumCaseTypes[$types[$i]->describe(VerbosityLevel::cache())] = $types[$i];

unset($types[$i]);

continue;

}

}

if ($types[$i] instanceof IntegerRangeType) {

$integerRangeTypes[] = $types[$i];

unset($types[$i]);

continue;

}

if (!$types[$i]->isArray()->yes()) {

continue;

}

$arrayTypes[] = $types[$i];

unset($types[$i]);

}

$enumCaseTypes = array_values($enumCaseTypes);

usort(

$integerRangeTypes,

static fn (IntegerRangeType $a, IntegerRangeType $b): int => ($a->getMin() ?? PHP_INT_MIN) <=> ($b->getMin() ?? PHP_INT_MIN)

?: ($a->getMax() ?? PHP_INT_MAX) <=> ($b->getMax() ?? PHP_INT_MAX),

);

$types = array_merge($types, $integerRangeTypes);

$types = array_values($types);

$typesCount = count($types);

foreach ($scalarTypes as $classType => $scalarTypeItems) {

if (isset($hasGenericScalarTypes[$classType])) {

unset($scalarTypes[$classType]);

continue;

}

if ($classType === ConstantBooleanType::class && count($scalarTypeItems) === 2) {

$types[] = new BooleanType();

$typesCount++;

unset($scalarTypes[$classType]);

continue;

}

$scalarTypeItems = array_values($scalarTypeItems);

$scalarTypeItemsCount = count($scalarTypeItems);

for ($i = 0; $i < $typesCount; $i++) {

for ($j = 0; $j < $scalarTypeItemsCount; $j++) {

$compareResult = self::compareTypesInUnion($types[$i], $scalarTypeItems[$j]);

if ($compareResult === null) {

continue;

}

[$a, $b] = $compareResult;

if ($a !== null) {

$types[$i] = $a;

array_splice($scalarTypeItems, $j, 1);

$scalarTypeItemsCount--;

$j = -1;

continue 1;

}

if ($b !== null) {

$scalarTypeItems[$j] = $b;

array_splice($types, $i--, 1);

$typesCount--;

continue 2;

}

}

}

$scalarTypes[$classType] = $scalarTypeItems;

}

if (count($types) > 16) {

$newTypes = [];

foreach ($types as $type) {

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

}

$types = array_values($newTypes);

}

$types = array_merge(

$types,

self::processArrayTypes($arrayTypes),

);

$typesCount = count($types);

// transform A | A to A

// transform A | never to A

for ($i = 0; $i < $typesCount; $i++) {

for ($j = $i + 1; $j < $typesCount; $j++) {

if (self::isAlreadyNormalized($alreadyNormalized, $types[$i], $types[$j])) {

continue;

}

$compareResult = self::compareTypesInUnion($types[$i], $types[$j]);

if ($compareResult === null) {

continue;

}

[$a, $b] = $compareResult;

if ($a !== null) {

$types[$i] = $a;

array_splice($types, $j--, 1);

$typesCount--;

continue 1;

}

if ($b !== null) {

$types[$j] = $b;

array_splice($types, $i--, 1);

$typesCount--;

continue 2;

}

}

}

$enumCasesCount = count($enumCaseTypes);

for ($i = 0; $i < $typesCount; $i++) {

for ($j = 0; $j < $enumCasesCount; $j++) {

$compareResult = self::compareTypesInUnion($types[$i], $enumCaseTypes[$j]);

if ($compareResult === null) {

continue;

}

[$a, $b] = $compareResult;

if ($a !== null) {

$types[$i] = $a;

array_splice($enumCaseTypes, $j--, 1);

$enumCasesCount--;

continue 1;

}

if ($b !== null) {

$enumCaseTypes[$j] = $b;

array_splice($types, $i--, 1);

$typesCount--;

continue 2;

}

}

}

foreach ($enumCaseTypes as $enumCaseType) {

$types[] = $enumCaseType;

$typesCount++;

}

foreach ($scalarTypes as $scalarTypeItems) {

foreach ($scalarTypeItems as $scalarType) {

$types[] = $scalarType;

$typesCount++;

}

}

if ($typesCount === 0) {

return new NeverType();

}

if ($typesCount === 1) {

return $types[0];

}

if ($benevolentTypes !== []) {

$tempTypes = $types;

foreach ($tempTypes as $i => $type) {

if (!isset($benevolentTypes[$type->describe(VerbosityLevel::value())])) {

break;

}

unset($tempTypes[$i]);

}

if ($tempTypes === []) {

if ($benevolentUnionObject instanceof TemplateBenevolentUnionType) {

return $benevolentUnionObject->withTypes(array_values($types));

}

return new BenevolentUnionType(array_values($types), true);

}

}

return new UnionType(array_values($types), true);

}

/**

* @param array<int, Type[]> $alreadyNormalized

*/

private static function isAlreadyNormalized(array $alreadyNormalized, Type $a, Type $b): bool

{

foreach ($alreadyNormalized as $normalizedTypes) {

foreach ($normalizedTypes as $i => $normalizedType) {

if ($normalizedType !== $a) {

continue;

}

foreach ($normalizedTypes as $j => $anotherNormalizedType) {

if ($i === $j) {

continue;

}

if ($anotherNormalizedType === $b) {

return true;

}

}

}

}

return false;

}

/**

* @return array{Type, null}|array{null, Type}|null

*/

private static function compareTypesInUnion(Type $a, Type $b): ?array

{

if ($a instanceof IntegerRangeType) {

$type = $a->tryUnion($b);

if ($type !== null) {

$a = $type;

return [$a, null];

}

}

if ($b instanceof IntegerRangeType) {

$type = $b->tryUnion($a);

if ($type !== null) {

$b = $type;

return [null, $b];

}

}

if ($a instanceof IntegerRangeType && $b instanceof IntegerRangeType) {

return null;

}

if ($a instanceof HasOffsetValueType && $b instanceof HasOffsetValueType) {

if ($a->getOffsetType()->equals($b->getOffsetType())) {

return [new HasOffsetValueType($a->getOffsetType(), self::union($a->getValueType(), $b->getValueType())), null];

}

}

if ($a instanceof IntersectionType && $b instanceof IntersectionType) {

$merged = self::mergeIntersectionsForUnion($a, $b);

if ($merged !== null) {

return [$merged, null];

}

}

if ($a->isConstantArray()->yes() && $b->isConstantArray()->yes()) {

return null;

}

// simplify string[] | int[] to (string|int)[]

if ($a instanceof IterableType && $b instanceof IterableType) {

return [

new IterableType(

self::union($a->getIterableKeyType(), $b->getIterableKeyType()),

self::union($a->getIterableValueType(), $b->getIterableValueType()),

),

null,

];

}

if ($a instanceof SubtractableType) {

$typeWithoutSubtractedTypeA = $a->getTypeWithoutSubtractedType();

if ($typeWithoutSubtractedTypeA instanceof MixedType && $b instanceof MixedType) {

$isSuperType = $typeWithoutSubtractedTypeA->isSuperTypeOfMixed($b);

} else {

$isSuperType = $typeWithoutSubtractedTypeA->isSuperTypeOf($b);

}

if ($isSuperType->yes()) {

$a = self::intersectWithSubtractedType($a, $b);

return [$a, null];

}

}

if ($b instanceof SubtractableType) {

$typeWithoutSubtractedTypeB = $b->getTypeWithoutSubtractedType();

if ($typeWithoutSubtractedTypeB instanceof MixedType && $a instanceof MixedType) {

$isSuperType = $typeWithoutSubtractedTypeB->isSuperTypeOfMixed($a);

} else {

$isSuperType = $typeWithoutSubtractedTypeB->isSuperTypeOf($a);

}

if ($isSuperType->yes()) {

$b = self::intersectWithSubtractedType($b, $a);

return [null, $b];

}

}

if ($b->isSuperTypeOf($a)->yes()) {

return [null, $b];

}

if ($a->isSuperTypeOf($b)->yes()) {

return [$a, null];

}

if (

$a instanceof ConstantStringType

) {

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

$description = $b->describe(VerbosityLevel::value());

if (in_array($description, ['non-empty-string', 'non-falsy-string'], true)) {

return [null, self::intersect(

new StringType(),

...self::getAccessoryCaseStringTypes($b),

)];

}

}

if ($a->getValue() === '0') {

$nonEmpty = self::downgradeNonFalsyStringToNonEmpty($b);

if ($nonEmpty !== null) {

return [null, $nonEmpty];

}

}

}

if (

$b instanceof ConstantStringType

) {

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

$description = $a->describe(VerbosityLevel::value());

if (in_array($description, ['non-empty-string', 'non-falsy-string'], true)) {

return [self::intersect(

new StringType(),

...self::getAccessoryCaseStringTypes($a),

), null];

}

}

if ($b->getValue() === '0') {

$nonEmpty = self::downgradeNonFalsyStringToNonEmpty($a);

if ($nonEmpty !== null) {

return [$nonEmpty, null];

}

}

}

// numeric-string | non-decimal-int-string → string (preserving common accessories)

// Works because decimal-int-string ⊂ numeric-string, so together they cover all strings

if ($a->isString()->yes() && $b->isString()->yes()) {

$decimalIntString = new IntersectionType([new StringType(), new AccessoryDecimalIntegerStringType()]);

if ($b->isDecimalIntegerString()->no()) {

$bBase = self::removeDecimalIntStringAccessory($b);

if ($bBase->isSuperTypeOf($a)->yes() && $a->isSuperTypeOf($decimalIntString)->yes()) {

return [null, $bBase];

}

}

if ($a->isDecimalIntegerString()->no()) {

$aBase = self::removeDecimalIntStringAccessory($a);

if ($aBase->isSuperTypeOf($b)->yes() && $b->isSuperTypeOf($decimalIntString)->yes()) {

return [$aBase, null];

}

}

}

return null;

}

/**

* @return list<Type>

*/

private static function getAccessoryCaseStringTypes(Type $type): array

{

$accessory = [];

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

$accessory[] = new AccessoryLowercaseStringType();

}

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

$accessory[] = new AccessoryUppercaseStringType();

}

return $accessory;

}

/**

* Turns a non-falsy-string type into its non-empty-string counterpart by

* downgrading the non-falsy accessory while preserving every other accessory

* (numeric-string, decimal-int-string, lowercase-string, …). Used to simplify

* `'0' | non-falsy-string-X` back to `non-empty-string-X`, since `"0"` is the

* only value that separates the two. Returns null when $type is not a

* non-constant non-falsy-string built from an intersection.

*/

private static function downgradeNonFalsyStringToNonEmpty(Type $type): ?Type

{

if (!$type instanceof IntersectionType || $type->isNonFalsyString()->no()) {

return null;

}

$newTypes = [];

$found = false;

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

if ($innerType instanceof AccessoryNonFalsyStringType) {

$found = true;

continue;

}

$newTypes[] = $innerType;

}

if (!$found) {

return null;

}

$withoutNonFalsy = self::intersect(...$newTypes);

if ($withoutNonFalsy->isNonEmptyString()->yes()) {

return $withoutNonFalsy;

}

return self::intersect($withoutNonFalsy, new AccessoryNonEmptyStringType());

}

private static function removeDecimalIntStringAccessory(Type $type): Type

{

if (!$type instanceof IntersectionType) {

return $type;

}

return self::intersect(...array_filter(

$type->getTypes(),

static fn (Type $t): bool => !$t instanceof AccessoryDecimalIntegerStringType,

));

}

private static function unionWithSubtractedType(

Type $type,

?Type $subtractedType,

): Type

{

if ($subtractedType === null) {

return $type;

}

if ($subtractedType instanceof SubtractableType) {

$withoutSubtracted = $subtractedType->getTypeWithoutSubtractedType();

if ($withoutSubtracted->isSuperTypeOf($type)->yes()) {

$subtractedSubtractedType = $subtractedType->getSubtractedType();

if ($subtractedSubtractedType === null) {

return new NeverType();

}

return self::intersect($type, $subtractedSubtractedType);

}

}

if ($type instanceof SubtractableType) {

$subtractedType = $type->getSubtractedType() === null

? $subtractedType

: self::union($type->getSubtractedType(), $subtractedType);

$subtractedType = self::intersect(

$type->getTypeWithoutSubtractedType(),

$subtractedType,

);

if ($subtractedType instanceof NeverType) {

$subtractedType = null;

}

return $type->changeSubtractedType($subtractedType);

}

if ($subtractedType->isSuperTypeOf($type)->yes()) {

return new NeverType();

}

return self::remove($type, $subtractedType);

}

private static function intersectWithSubtractedType(

SubtractableType $a,

Type $b,

): Type

{

if ($a->getSubtractedType() === null || $b instanceof NeverType) {

return $a;

}

if ($b instanceof IntersectionType) {

$subtractableTypes = [];

foreach ($b->getTypes() as $innerType) {

if (!$innerType instanceof SubtractableType) {

continue;

}

$subtractableTypes[] = $innerType;

}

if (count($subtractableTypes) === 0) {

return $a->getTypeWithoutSubtractedType();

}

$subtractedTypes = [];

foreach ($subtractableTypes as $subtractableType) {

if ($subtractableType->getSubtractedType() === null) {

continue;

}

$subtractedTypes[] = $subtractableType->getSubtractedType();

}

if (count($subtractedTypes) === 0) {

return $a->getTypeWithoutSubtractedType();

}

$subtractedType = self::union(...$subtractedTypes);

} else {

$isBAlreadySubtracted = $a->getSubtractedType()->isSuperTypeOf($b);

if ($isBAlreadySubtracted->no()) {

return $a;

} elseif ($isBAlreadySubtracted->yes()) {

$subtractedType = self::remove($a->getSubtractedType(), $b);

if (

$subtractedType instanceof NeverType

|| !$subtractedType->isSuperTypeOf($b)->no()

) {

$subtractedType = null;

}

return $a->changeSubtractedType($subtractedType);

} elseif ($b instanceof SubtractableType) {

$subtractedType = $b->getSubtractedType();

if ($subtractedType === null) {

return $a->getTypeWithoutSubtractedType();

}

} else {

$subtractedTypeTmp = self::intersect($a->getTypeWithoutSubtractedType(), $a->getSubtractedType());

if ($b->isSuperTypeOf($subtractedTypeTmp)->yes()) {

return $a->getTypeWithoutSubtractedType();

}

$subtractedType = new MixedType(subtractedType: $b);

}

}

$subtractedType = self::intersect(

$a->getSubtractedType(),

$subtractedType,

);

if ($subtractedType instanceof NeverType) {

$subtractedType = null;

}

return $a->changeSubtractedType($subtractedType);

}

/**

* @param Type[] $arrayTypes

* @return list<Type>

*/

private static function processArrayAccessoryTypes(array $arrayTypes): array

{

$isIterableAtLeastOnce = [];

$accessoryTypes = [];

foreach ($arrayTypes as $i => $arrayType) {

$isIterableAtLeastOnce[] = $arrayType->isIterableAtLeastOnce();

if ($arrayType instanceof IntersectionType) {

foreach ($arrayType->getTypes() as $innerType) {

if ($innerType instanceof TemplateType) {

break;

}

if (!($innerType instanceof AccessoryType) && !($innerType instanceof CallableType)) {

continue;

}

if ($innerType instanceof HasOffsetType) {

$innerType = new HasOffsetValueType($innerType->getOffsetType(), $arrayType->getIterableValueType());

}

if ($innerType instanceof HasOffsetValueType) {

$accessoryTypes[sprintf('hasOffsetValue(%s)', $innerType->getOffsetType()->describe(VerbosityLevel::cache()))][$i] = $innerType;

continue;

}

$accessoryTypes[$innerType->describe(VerbosityLevel::cache())][$i] = $innerType;

}

}

if (!$arrayType->isConstantArray()->yes()) {

continue;

}

$constantArrays = $arrayType->getConstantArrays();

foreach ($constantArrays as $constantArray) {

if ($constantArray->isList()->yes()) {

$list = new AccessoryArrayListType();

$accessoryTypes[$list->describe(VerbosityLevel::cache())][$i] = $list;

}

if (!$constantArray->isIterableAtLeastOnce()->yes()) {

continue;

}

$nonEmpty = new NonEmptyArrayType();

$accessoryTypes[$nonEmpty->describe(VerbosityLevel::cache())][$i] = $nonEmpty;

}

}

$commonAccessoryTypes = [];

$arrayTypeCount = count($arrayTypes);

foreach ($accessoryTypes as $accessoryType) {

if (count($accessoryType) !== $arrayTypeCount) {

$firstKey = array_key_first($accessoryType);

if ($accessoryType[$firstKey] instanceof OversizedArrayType) {

$commonAccessoryTypes[] = $accessoryType[$firstKey];

}

continue;

}

if ($accessoryType[0] instanceof HasOffsetValueType) {

$commonAccessoryTypes[] = self::union(...$accessoryType);

continue;

}

$commonAccessoryTypes[] = $accessoryType[0];

}

if (TrinaryLogic::createYes()->and(...$isIterableAtLeastOnce)->yes()) {

$commonAccessoryTypes[] = new NonEmptyArrayType();

}

return $commonAccessoryTypes;

}

/**

* @param list<Type> $arrayTypes

* @return Type[]

*/

private static function processArrayTypes(array $arrayTypes): array

{

if ($arrayTypes === []) {

return [];

}

$accessoryTypes = self::processArrayAccessoryTypes($arrayTypes);

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

return [

self::intersect(...$arrayTypes, ...$accessoryTypes),

];

}

$keyTypesForGeneralArray = [];

$valueTypesForGeneralArray = [];

$generalArrayOccurred = false;

$constantKeyTypesNumbered = [];

$filledArrays = 0;

$overflowed = false;

/** @var int|float $nextConstantKeyTypeIndex */

$nextConstantKeyTypeIndex = 1;

foreach ($arrayTypes as $arrayType) {

$constantArrays = $arrayType->getConstantArrays();

$isConstantArray = $constantArrays !== [];

if (!$isConstantArray || !$arrayType->isIterableAtLeastOnce()->no()) {

$filledArrays++;

}

if (!$isConstantArray) {