1: | <?php declare(strict_types = 1); |
2: | |
3: | namespace PHPStan\Type; |
4: | |
5: | use PHPStan\TrinaryLogic; |
6: | use PHPStan\Type\Accessory\AccessoryArrayListType; |
7: | use PHPStan\Type\Accessory\AccessoryLowercaseStringType; |
8: | use PHPStan\Type\Accessory\AccessoryNonEmptyStringType; |
9: | use PHPStan\Type\Accessory\AccessoryType; |
10: | use PHPStan\Type\Accessory\AccessoryUppercaseStringType; |
11: | use PHPStan\Type\Accessory\HasOffsetType; |
12: | use PHPStan\Type\Accessory\HasOffsetValueType; |
13: | use PHPStan\Type\Accessory\HasPropertyType; |
14: | use PHPStan\Type\Accessory\NonEmptyArrayType; |
15: | use PHPStan\Type\Accessory\OversizedArrayType; |
16: | use PHPStan\Type\Constant\ConstantArrayType; |
17: | use PHPStan\Type\Constant\ConstantArrayTypeBuilder; |
18: | use PHPStan\Type\Constant\ConstantBooleanType; |
19: | use PHPStan\Type\Constant\ConstantFloatType; |
20: | use PHPStan\Type\Constant\ConstantIntegerType; |
21: | use PHPStan\Type\Constant\ConstantStringType; |
22: | use PHPStan\Type\Generic\GenericClassStringType; |
23: | use PHPStan\Type\Generic\TemplateArrayType; |
24: | use PHPStan\Type\Generic\TemplateBenevolentUnionType; |
25: | use PHPStan\Type\Generic\TemplateType; |
26: | use PHPStan\Type\Generic\TemplateTypeFactory; |
27: | use PHPStan\Type\Generic\TemplateUnionType; |
28: | use function array_key_exists; |
29: | use function array_key_first; |
30: | use function array_map; |
31: | use function array_merge; |
32: | use function array_slice; |
33: | use function array_splice; |
34: | use function array_values; |
35: | use function count; |
36: | use function get_class; |
37: | use function is_int; |
38: | use function md5; |
39: | use function sprintf; |
40: | use function usort; |
41: | use const PHP_INT_MAX; |
42: | use const PHP_INT_MIN; |
43: | |
44: | |
45: | |
46: | |
47: | final class TypeCombinator |
48: | { |
49: | |
50: | public static function addNull(Type $type): Type |
51: | { |
52: | $nullType = new NullType(); |
53: | |
54: | if ($nullType->isSuperTypeOf($type)->no()) { |
55: | return self::union($type, $nullType); |
56: | } |
57: | |
58: | return $type; |
59: | } |
60: | |
61: | public static function remove(Type $fromType, Type $typeToRemove): Type |
62: | { |
63: | if ($typeToRemove instanceof UnionType) { |
64: | foreach ($typeToRemove->getTypes() as $unionTypeToRemove) { |
65: | $fromType = self::remove($fromType, $unionTypeToRemove); |
66: | } |
67: | return $fromType; |
68: | } |
69: | |
70: | $isSuperType = $typeToRemove->isSuperTypeOf($fromType); |
71: | if ($isSuperType->yes()) { |
72: | return new NeverType(); |
73: | } |
74: | if ($isSuperType->no()) { |
75: | return $fromType; |
76: | } |
77: | |
78: | if ($typeToRemove instanceof MixedType) { |
79: | $typeToRemoveSubtractedType = $typeToRemove->getSubtractedType(); |
80: | if ($typeToRemoveSubtractedType !== null) { |
81: | return self::intersect($fromType, $typeToRemoveSubtractedType); |
82: | } |
83: | } |
84: | |
85: | $removed = $fromType->tryRemove($typeToRemove); |
86: | if ($removed !== null) { |
87: | return $removed; |
88: | } |
89: | |
90: | $fromFiniteTypes = $fromType->getFiniteTypes(); |
91: | if (count($fromFiniteTypes) > 0) { |
92: | $finiteTypesToRemove = $typeToRemove->getFiniteTypes(); |
93: | if (count($finiteTypesToRemove) === 1) { |
94: | $result = []; |
95: | foreach ($fromFiniteTypes as $finiteType) { |
96: | if ($finiteType->equals($finiteTypesToRemove[0])) { |
97: | continue; |
98: | } |
99: | |
100: | $result[] = $finiteType; |
101: | } |
102: | |
103: | if (count($result) === count($fromFiniteTypes)) { |
104: | return $fromType; |
105: | } |
106: | |
107: | if (count($result) === 0) { |
108: | return new NeverType(); |
109: | } |
110: | |
111: | if (count($result) === 1) { |
112: | return $result[0]; |
113: | } |
114: | |
115: | return new UnionType($result); |
116: | } |
117: | } |
118: | |
119: | return $fromType; |
120: | } |
121: | |
122: | public static function removeNull(Type $type): Type |
123: | { |
124: | if (self::containsNull($type)) { |
125: | return self::remove($type, new NullType()); |
126: | } |
127: | |
128: | return $type; |
129: | } |
130: | |
131: | public static function containsNull(Type $type): bool |
132: | { |
133: | if ($type instanceof UnionType) { |
134: | foreach ($type->getTypes() as $innerType) { |
135: | if ($innerType instanceof NullType) { |
136: | return true; |
137: | } |
138: | } |
139: | |
140: | return false; |
141: | } |
142: | |
143: | return $type instanceof NullType; |
144: | } |
145: | |
146: | public static function union(Type ...$types): Type |
147: | { |
148: | $typesCount = count($types); |
149: | if ($typesCount === 0) { |
150: | return new NeverType(); |
151: | } |
152: | |
153: | $benevolentTypes = []; |
154: | $benevolentUnionObject = null; |
155: | |
156: | for ($i = 0; $i < $typesCount; $i++) { |
157: | if ($types[$i] instanceof BenevolentUnionType) { |
158: | if ($types[$i] instanceof TemplateBenevolentUnionType && $benevolentUnionObject === null) { |
159: | $benevolentUnionObject = $types[$i]; |
160: | } |
161: | $benevolentTypesCount = 0; |
162: | $typesInner = $types[$i]->getTypes(); |
163: | foreach ($typesInner as $benevolentInnerType) { |
164: | $benevolentTypesCount++; |
165: | $benevolentTypes[$benevolentInnerType->describe(VerbosityLevel::value())] = $benevolentInnerType; |
166: | } |
167: | array_splice($types, $i, 1, $typesInner); |
168: | $typesCount += $benevolentTypesCount - 1; |
169: | continue; |
170: | } |
171: | if (!($types[$i] instanceof UnionType)) { |
172: | continue; |
173: | } |
174: | if ($types[$i] instanceof TemplateType) { |
175: | continue; |
176: | } |
177: | |
178: | $typesInner = $types[$i]->getTypes(); |
179: | array_splice($types, $i, 1, $typesInner); |
180: | $typesCount += count($typesInner) - 1; |
181: | } |
182: | |
183: | if ($typesCount === 1) { |
184: | return $types[0]; |
185: | } |
186: | |
187: | $arrayTypes = []; |
188: | $scalarTypes = []; |
189: | $hasGenericScalarTypes = []; |
190: | $enumCaseTypes = []; |
191: | $integerRangeTypes = []; |
192: | for ($i = 0; $i < $typesCount; $i++) { |
193: | if ($types[$i] instanceof ConstantScalarType) { |
194: | $type = $types[$i]; |
195: | $scalarTypes[get_class($type)][md5($type->describe(VerbosityLevel::cache()))] = $type; |
196: | unset($types[$i]); |
197: | continue; |
198: | } |
199: | if ($types[$i] instanceof BooleanType) { |
200: | $hasGenericScalarTypes[ConstantBooleanType::class] = true; |
201: | } |
202: | if ($types[$i] instanceof FloatType) { |
203: | $hasGenericScalarTypes[ConstantFloatType::class] = true; |
204: | } |
205: | if ($types[$i] instanceof IntegerType && !$types[$i] instanceof IntegerRangeType) { |
206: | $hasGenericScalarTypes[ConstantIntegerType::class] = true; |
207: | } |
208: | if ($types[$i] instanceof StringType && !$types[$i] instanceof ClassStringType) { |
209: | $hasGenericScalarTypes[ConstantStringType::class] = true; |
210: | } |
211: | $enumCases = $types[$i]->getEnumCases(); |
212: | if (count($enumCases) === 1) { |
213: | $enumCaseTypes[$types[$i]->describe(VerbosityLevel::cache())] = $types[$i]; |
214: | |
215: | unset($types[$i]); |
216: | continue; |
217: | } |
218: | |
219: | if ($types[$i] instanceof IntegerRangeType) { |
220: | $integerRangeTypes[] = $types[$i]; |
221: | unset($types[$i]); |
222: | |
223: | continue; |
224: | } |
225: | |
226: | if (!$types[$i]->isArray()->yes()) { |
227: | continue; |
228: | } |
229: | |
230: | $arrayTypes[] = $types[$i]; |
231: | unset($types[$i]); |
232: | } |
233: | |
234: | foreach ($scalarTypes as $classType => $scalarTypeItems) { |
235: | $scalarTypes[$classType] = array_values($scalarTypeItems); |
236: | } |
237: | |
238: | $enumCaseTypes = array_values($enumCaseTypes); |
239: | usort( |
240: | $integerRangeTypes, |
241: | static fn (IntegerRangeType $a, IntegerRangeType $b): int => ($a->getMin() ?? PHP_INT_MIN) <=> ($b->getMin() ?? PHP_INT_MIN) |
242: | ?: ($a->getMax() ?? PHP_INT_MAX) <=> ($b->getMax() ?? PHP_INT_MAX) |
243: | ); |
244: | $types = array_merge($types, $integerRangeTypes); |
245: | $types = array_values($types); |
246: | $typesCount = count($types); |
247: | |
248: | foreach ($scalarTypes as $classType => $scalarTypeItems) { |
249: | if (isset($hasGenericScalarTypes[$classType])) { |
250: | unset($scalarTypes[$classType]); |
251: | continue; |
252: | } |
253: | if ($classType === ConstantBooleanType::class && count($scalarTypeItems) === 2) { |
254: | $types[] = new BooleanType(); |
255: | $typesCount++; |
256: | unset($scalarTypes[$classType]); |
257: | continue; |
258: | } |
259: | |
260: | $scalarTypeItemsCount = count($scalarTypeItems); |
261: | for ($i = 0; $i < $typesCount; $i++) { |
262: | for ($j = 0; $j < $scalarTypeItemsCount; $j++) { |
263: | $compareResult = self::compareTypesInUnion($types[$i], $scalarTypeItems[$j]); |
264: | if ($compareResult === null) { |
265: | continue; |
266: | } |
267: | |
268: | [$a, $b] = $compareResult; |
269: | if ($a !== null) { |
270: | $types[$i] = $a; |
271: | array_splice($scalarTypeItems, $j--, 1); |
272: | $scalarTypeItemsCount--; |
273: | continue 1; |
274: | } |
275: | if ($b !== null) { |
276: | $scalarTypeItems[$j] = $b; |
277: | array_splice($types, $i--, 1); |
278: | $typesCount--; |
279: | continue 2; |
280: | } |
281: | } |
282: | } |
283: | |
284: | $scalarTypes[$classType] = $scalarTypeItems; |
285: | } |
286: | |
287: | if (count($types) > 16) { |
288: | $newTypes = []; |
289: | foreach ($types as $type) { |
290: | $newTypes[$type->describe(VerbosityLevel::cache())] = $type; |
291: | } |
292: | $types = array_values($newTypes); |
293: | } |
294: | |
295: | $types = array_merge( |
296: | $types, |
297: | self::processArrayTypes($arrayTypes), |
298: | ); |
299: | $typesCount = count($types); |
300: | |
301: | |
302: | |
303: | for ($i = 0; $i < $typesCount; $i++) { |
304: | for ($j = $i + 1; $j < $typesCount; $j++) { |
305: | $compareResult = self::compareTypesInUnion($types[$i], $types[$j]); |
306: | if ($compareResult === null) { |
307: | continue; |
308: | } |
309: | |
310: | [$a, $b] = $compareResult; |
311: | if ($a !== null) { |
312: | $types[$i] = $a; |
313: | array_splice($types, $j--, 1); |
314: | $typesCount--; |
315: | continue 1; |
316: | } |
317: | if ($b !== null) { |
318: | $types[$j] = $b; |
319: | array_splice($types, $i--, 1); |
320: | $typesCount--; |
321: | continue 2; |
322: | } |
323: | } |
324: | } |
325: | |
326: | $enumCasesCount = count($enumCaseTypes); |
327: | for ($i = 0; $i < $typesCount; $i++) { |
328: | for ($j = 0; $j < $enumCasesCount; $j++) { |
329: | $compareResult = self::compareTypesInUnion($types[$i], $enumCaseTypes[$j]); |
330: | if ($compareResult === null) { |
331: | continue; |
332: | } |
333: | |
334: | [$a, $b] = $compareResult; |
335: | if ($a !== null) { |
336: | $types[$i] = $a; |
337: | array_splice($enumCaseTypes, $j--, 1); |
338: | $enumCasesCount--; |
339: | continue 1; |
340: | } |
341: | if ($b !== null) { |
342: | $enumCaseTypes[$j] = $b; |
343: | array_splice($types, $i--, 1); |
344: | $typesCount--; |
345: | continue 2; |
346: | } |
347: | } |
348: | } |
349: | |
350: | foreach ($enumCaseTypes as $enumCaseType) { |
351: | $types[] = $enumCaseType; |
352: | $typesCount++; |
353: | } |
354: | |
355: | foreach ($scalarTypes as $scalarTypeItems) { |
356: | foreach ($scalarTypeItems as $scalarType) { |
357: | $types[] = $scalarType; |
358: | $typesCount++; |
359: | } |
360: | } |
361: | |
362: | if ($typesCount === 0) { |
363: | return new NeverType(); |
364: | } |
365: | if ($typesCount === 1) { |
366: | return $types[0]; |
367: | } |
368: | |
369: | if ($benevolentTypes !== []) { |
370: | $tempTypes = $types; |
371: | foreach ($tempTypes as $i => $type) { |
372: | if (!isset($benevolentTypes[$type->describe(VerbosityLevel::value())])) { |
373: | break; |
374: | } |
375: | |
376: | unset($tempTypes[$i]); |
377: | } |
378: | |
379: | if ($tempTypes === []) { |
380: | if ($benevolentUnionObject instanceof TemplateBenevolentUnionType) { |
381: | return $benevolentUnionObject->withTypes($types); |
382: | } |
383: | |
384: | return new BenevolentUnionType($types, true); |
385: | } |
386: | } |
387: | |
388: | return new UnionType($types, true); |
389: | } |
390: | |
391: | |
392: | |
393: | |
394: | private static function compareTypesInUnion(Type $a, Type $b): ?array |
395: | { |
396: | if ($a instanceof IntegerRangeType) { |
397: | $type = $a->tryUnion($b); |
398: | if ($type !== null) { |
399: | $a = $type; |
400: | return [$a, null]; |
401: | } |
402: | } |
403: | if ($b instanceof IntegerRangeType) { |
404: | $type = $b->tryUnion($a); |
405: | if ($type !== null) { |
406: | $b = $type; |
407: | return [null, $b]; |
408: | } |
409: | } |
410: | if ($a instanceof IntegerRangeType && $b instanceof IntegerRangeType) { |
411: | return null; |
412: | } |
413: | if ($a instanceof HasOffsetValueType && $b instanceof HasOffsetValueType) { |
414: | if ($a->getOffsetType()->equals($b->getOffsetType())) { |
415: | return [new HasOffsetValueType($a->getOffsetType(), self::union($a->getValueType(), $b->getValueType())), null]; |
416: | } |
417: | } |
418: | if ($a->isConstantArray()->yes() && $b->isConstantArray()->yes()) { |
419: | return null; |
420: | } |
421: | |
422: | |
423: | if ($a instanceof IterableType && $b instanceof IterableType) { |
424: | return [ |
425: | new IterableType( |
426: | self::union($a->getIterableKeyType(), $b->getIterableKeyType()), |
427: | self::union($a->getIterableValueType(), $b->getIterableValueType()), |
428: | ), |
429: | null, |
430: | ]; |
431: | } |
432: | |
433: | if ($a instanceof SubtractableType) { |
434: | $typeWithoutSubtractedTypeA = $a->getTypeWithoutSubtractedType(); |
435: | if ($typeWithoutSubtractedTypeA instanceof MixedType && $b instanceof MixedType) { |
436: | $isSuperType = $typeWithoutSubtractedTypeA->isSuperTypeOfMixed($b); |
437: | } else { |
438: | $isSuperType = $typeWithoutSubtractedTypeA->isSuperTypeOf($b); |
439: | } |
440: | if ($isSuperType->yes()) { |
441: | $a = self::intersectWithSubtractedType($a, $b); |
442: | return [$a, null]; |
443: | } |
444: | } |
445: | |
446: | if ($b instanceof SubtractableType) { |
447: | $typeWithoutSubtractedTypeB = $b->getTypeWithoutSubtractedType(); |
448: | if ($typeWithoutSubtractedTypeB instanceof MixedType && $a instanceof MixedType) { |
449: | $isSuperType = $typeWithoutSubtractedTypeB->isSuperTypeOfMixed($a); |
450: | } else { |
451: | $isSuperType = $typeWithoutSubtractedTypeB->isSuperTypeOf($a); |
452: | } |
453: | if ($isSuperType->yes()) { |
454: | $b = self::intersectWithSubtractedType($b, $a); |
455: | return [null, $b]; |
456: | } |
457: | } |
458: | |
459: | if ($b->isSuperTypeOf($a)->yes()) { |
460: | return [null, $b]; |
461: | } |
462: | |
463: | if ($a->isSuperTypeOf($b)->yes()) { |
464: | return [$a, null]; |
465: | } |
466: | |
467: | if ( |
468: | $a instanceof ConstantStringType |
469: | && $a->getValue() === '' |
470: | && ($b->describe(VerbosityLevel::value()) === 'non-empty-string' |
471: | || $b->describe(VerbosityLevel::value()) === 'non-falsy-string') |
472: | ) { |
473: | return [null, self::intersect( |
474: | new StringType(), |
475: | ...self::getAccessoryCaseStringTypes($b), |
476: | )]; |
477: | } |
478: | |
479: | if ( |
480: | $b instanceof ConstantStringType |
481: | && $b->getValue() === '' |
482: | && ($a->describe(VerbosityLevel::value()) === 'non-empty-string' |
483: | || $a->describe(VerbosityLevel::value()) === 'non-falsy-string') |
484: | ) { |
485: | return [self::intersect( |
486: | new StringType(), |
487: | ...self::getAccessoryCaseStringTypes($a), |
488: | ), null]; |
489: | } |
490: | |
491: | if ( |
492: | $a instanceof ConstantStringType |
493: | && $a->getValue() === '0' |
494: | && $b->describe(VerbosityLevel::value()) === 'non-falsy-string' |
495: | ) { |
496: | return [null, self::intersect( |
497: | new StringType(), |
498: | new AccessoryNonEmptyStringType(), |
499: | ...self::getAccessoryCaseStringTypes($b), |
500: | )]; |
501: | } |
502: | |
503: | if ( |
504: | $b instanceof ConstantStringType |
505: | && $b->getValue() === '0' |
506: | && $a->describe(VerbosityLevel::value()) === 'non-falsy-string' |
507: | ) { |
508: | return [self::intersect( |
509: | new StringType(), |
510: | new AccessoryNonEmptyStringType(), |
511: | ...self::getAccessoryCaseStringTypes($a), |
512: | ), null]; |
513: | } |
514: | |
515: | return null; |
516: | } |
517: | |
518: | |
519: | |
520: | |
521: | private static function getAccessoryCaseStringTypes(Type $type): array |
522: | { |
523: | $accessory = []; |
524: | if ($type->isLowercaseString()->yes()) { |
525: | $accessory[] = new AccessoryLowercaseStringType(); |
526: | } |
527: | if ($type->isUppercaseString()->yes()) { |
528: | $accessory[] = new AccessoryUppercaseStringType(); |
529: | } |
530: | |
531: | return $accessory; |
532: | } |
533: | |
534: | private static function unionWithSubtractedType( |
535: | Type $type, |
536: | ?Type $subtractedType, |
537: | ): Type |
538: | { |
539: | if ($subtractedType === null) { |
540: | return $type; |
541: | } |
542: | |
543: | if ($type instanceof SubtractableType) { |
544: | $subtractedType = $type->getSubtractedType() === null |
545: | ? $subtractedType |
546: | : self::union($type->getSubtractedType(), $subtractedType); |
547: | |
548: | $subtractedType = self::intersect( |
549: | $type->getTypeWithoutSubtractedType(), |
550: | $subtractedType, |
551: | ); |
552: | if ($subtractedType instanceof NeverType) { |
553: | $subtractedType = null; |
554: | } |
555: | |
556: | return $type->changeSubtractedType($subtractedType); |
557: | } |
558: | |
559: | if ($subtractedType->isSuperTypeOf($type)->yes()) { |
560: | return new NeverType(); |
561: | } |
562: | |
563: | return self::remove($type, $subtractedType); |
564: | } |
565: | |
566: | private static function intersectWithSubtractedType( |
567: | SubtractableType $a, |
568: | Type $b, |
569: | ): Type |
570: | { |
571: | if ($a->getSubtractedType() === null) { |
572: | return $a; |
573: | } |
574: | |
575: | if ($b instanceof IntersectionType) { |
576: | $subtractableTypes = []; |
577: | foreach ($b->getTypes() as $innerType) { |
578: | if (!$innerType instanceof SubtractableType) { |
579: | continue; |
580: | } |
581: | |
582: | $subtractableTypes[] = $innerType; |
583: | } |
584: | |
585: | if (count($subtractableTypes) === 0) { |
586: | return $a->getTypeWithoutSubtractedType(); |
587: | } |
588: | |
589: | $subtractedTypes = []; |
590: | foreach ($subtractableTypes as $subtractableType) { |
591: | if ($subtractableType->getSubtractedType() === null) { |
592: | continue; |
593: | } |
594: | |
595: | $subtractedTypes[] = $subtractableType->getSubtractedType(); |
596: | } |
597: | |
598: | if (count($subtractedTypes) === 0) { |
599: | return $a->getTypeWithoutSubtractedType(); |
600: | |
601: | } |
602: | |
603: | $subtractedType = self::union(...$subtractedTypes); |
604: | } else { |
605: | $isBAlreadySubtracted = $a->getSubtractedType()->isSuperTypeOf($b); |
606: | |
607: | if ($isBAlreadySubtracted->no()) { |
608: | return $a; |
609: | } elseif ($isBAlreadySubtracted->yes()) { |
610: | $subtractedType = self::remove($a->getSubtractedType(), $b); |
611: | |
612: | if ($subtractedType instanceof NeverType) { |
613: | $subtractedType = null; |
614: | } |
615: | |
616: | return $a->changeSubtractedType($subtractedType); |
617: | } elseif ($b instanceof SubtractableType) { |
618: | $subtractedType = $b->getSubtractedType(); |
619: | if ($subtractedType === null) { |
620: | return $a->getTypeWithoutSubtractedType(); |
621: | } |
622: | } else { |
623: | $subtractedTypeTmp = self::intersect($a->getTypeWithoutSubtractedType(), $a->getSubtractedType()); |
624: | if ($b->isSuperTypeOf($subtractedTypeTmp)->yes()) { |
625: | return $a->getTypeWithoutSubtractedType(); |
626: | } |
627: | $subtractedType = new MixedType(subtractedType: $b); |
628: | } |
629: | } |
630: | |
631: | $subtractedType = self::intersect( |
632: | $a->getSubtractedType(), |
633: | $subtractedType, |
634: | ); |
635: | if ($subtractedType instanceof NeverType) { |
636: | $subtractedType = null; |
637: | } |
638: | |
639: | return $a->changeSubtractedType($subtractedType); |
640: | } |
641: | |
642: | |
643: | |
644: | |
645: | |
646: | private static function processArrayAccessoryTypes(array $arrayTypes): array |
647: | { |
648: | $isIterableAtLeastOnce = []; |
649: | $accessoryTypes = []; |
650: | foreach ($arrayTypes as $i => $arrayType) { |
651: | $isIterableAtLeastOnce[] = $arrayType->isIterableAtLeastOnce(); |
652: | |
653: | if ($arrayType instanceof IntersectionType) { |
654: | foreach ($arrayType->getTypes() as $innerType) { |
655: | if ($innerType instanceof TemplateType) { |
656: | break; |
657: | } |
658: | if (!($innerType instanceof AccessoryType) && !($innerType instanceof CallableType)) { |
659: | continue; |
660: | } |
661: | if ($innerType instanceof HasOffsetType) { |
662: | $offset = $innerType->getOffsetType(); |
663: | if ($offset instanceof ConstantStringType || $offset instanceof ConstantIntegerType) { |
664: | $innerType = new HasOffsetValueType($offset, $arrayType->getIterableValueType()); |
665: | } |
666: | } |
667: | if ($innerType instanceof HasOffsetValueType) { |
668: | $accessoryTypes[sprintf('hasOffsetValue(%s)', $innerType->getOffsetType()->describe(VerbosityLevel::cache()))][$i] = $innerType; |
669: | continue; |
670: | } |
671: | |
672: | $accessoryTypes[$innerType->describe(VerbosityLevel::cache())][$i] = $innerType; |
673: | } |
674: | } |
675: | |
676: | if (!$arrayType->isConstantArray()->yes()) { |
677: | continue; |
678: | } |
679: | $constantArrays = $arrayType->getConstantArrays(); |
680: | |
681: | foreach ($constantArrays as $constantArray) { |
682: | if ($constantArray->isList()->yes()) { |
683: | $list = new AccessoryArrayListType(); |
684: | $accessoryTypes[$list->describe(VerbosityLevel::cache())][$i] = $list; |
685: | } |
686: | |
687: | if (!$constantArray->isIterableAtLeastOnce()->yes()) { |
688: | continue; |
689: | } |
690: | |
691: | $nonEmpty = new NonEmptyArrayType(); |
692: | $accessoryTypes[$nonEmpty->describe(VerbosityLevel::cache())][$i] = $nonEmpty; |
693: | } |
694: | } |
695: | |
696: | $commonAccessoryTypes = []; |
697: | $arrayTypeCount = count($arrayTypes); |
698: | foreach ($accessoryTypes as $accessoryType) { |
699: | if (count($accessoryType) !== $arrayTypeCount) { |
700: | $firstKey = array_key_first($accessoryType); |
701: | if ($accessoryType[$firstKey] instanceof OversizedArrayType) { |
702: | $commonAccessoryTypes[] = $accessoryType[$firstKey]; |
703: | } |
704: | continue; |
705: | } |
706: | |
707: | if ($accessoryType[0] instanceof HasOffsetValueType) { |
708: | $commonAccessoryTypes[] = self::union(...$accessoryType); |
709: | continue; |
710: | } |
711: | |
712: | $commonAccessoryTypes[] = $accessoryType[0]; |
713: | } |
714: | |
715: | if (TrinaryLogic::createYes()->and(...$isIterableAtLeastOnce)->yes()) { |
716: | $commonAccessoryTypes[] = new NonEmptyArrayType(); |
717: | } |
718: | |
719: | return $commonAccessoryTypes; |
720: | } |
721: | |
722: | |
723: | |
724: | |
725: | |
726: | private static function processArrayTypes(array $arrayTypes): array |
727: | { |
728: | if ($arrayTypes === []) { |
729: | return []; |
730: | } |
731: | |
732: | $accessoryTypes = self::processArrayAccessoryTypes($arrayTypes); |
733: | |
734: | if (count($arrayTypes) === 1) { |
735: | return [ |
736: | self::intersect(...$arrayTypes, ...$accessoryTypes), |
737: | ]; |
738: | } |
739: | |
740: | $keyTypesForGeneralArray = []; |
741: | $valueTypesForGeneralArray = []; |
742: | $generalArrayOccurred = false; |
743: | $constantKeyTypesNumbered = []; |
744: | $filledArrays = 0; |
745: | $overflowed = false; |
746: | |
747: | |
748: | $nextConstantKeyTypeIndex = 1; |
749: | $constantArraysMap = array_map( |
750: | static fn (Type $t) => $t->getConstantArrays(), |
751: | $arrayTypes, |
752: | ); |
753: | |
754: | foreach ($arrayTypes as $arrayIdx => $arrayType) { |
755: | $constantArrays = $constantArraysMap[$arrayIdx]; |
756: | $isConstantArray = $constantArrays !== []; |
757: | if (!$isConstantArray || !$arrayType->isIterableAtLeastOnce()->no()) { |
758: | $filledArrays++; |
759: | } |
760: | |
761: | if ($generalArrayOccurred || !$isConstantArray) { |
762: | foreach ($arrayType->getArrays() as $type) { |
763: | $keyTypesForGeneralArray[] = $type->getIterableKeyType(); |
764: | $valueTypesForGeneralArray[] = $type->getItemType(); |
765: | $generalArrayOccurred = true; |
766: | } |
767: | continue; |
768: | } |
769: | |
770: | $constantArrays = $arrayType->getConstantArrays(); |
771: | foreach ($constantArrays as $constantArray) { |
772: | foreach ($constantArray->getKeyTypes() as $i => $keyType) { |
773: | $keyTypesForGeneralArray[] = $keyType; |
774: | $valueTypesForGeneralArray[] = $constantArray->getValueTypes()[$i]; |
775: | |
776: | $keyTypeValue = $keyType->getValue(); |
777: | if (array_key_exists($keyTypeValue, $constantKeyTypesNumbered)) { |
778: | continue; |
779: | } |
780: | |
781: | $constantKeyTypesNumbered[$keyTypeValue] = $nextConstantKeyTypeIndex; |
782: | $nextConstantKeyTypeIndex *= 2; |
783: | if (!is_int($nextConstantKeyTypeIndex)) { |
784: | $generalArrayOccurred = true; |
785: | $overflowed = true; |
786: | continue 2; |
787: | } |
788: | } |
789: | } |
790: | } |
791: | |
792: | if ($generalArrayOccurred && (!$overflowed || $filledArrays > 1)) { |
793: | $reducedArrayTypes = self::reduceArrays($arrayTypes, false); |
794: | if (count($reducedArrayTypes) === 1) { |
795: | return [self::intersect($reducedArrayTypes[0], ...$accessoryTypes)]; |
796: | } |
797: | $scopes = []; |
798: | $useTemplateArray = true; |
799: | foreach ($arrayTypes as $arrayType) { |
800: | if (!$arrayType instanceof TemplateArrayType) { |
801: | $useTemplateArray = false; |
802: | break; |
803: | } |
804: | |
805: | $scopes[$arrayType->getScope()->describe()] = $arrayType; |
806: | } |
807: | |
808: | $arrayType = new ArrayType( |
809: | self::union(...$keyTypesForGeneralArray), |
810: | self::union(...self::optimizeConstantArrays($valueTypesForGeneralArray)), |
811: | ); |
812: | |
813: | if ($useTemplateArray && count($scopes) === 1) { |
814: | $templateArray = array_values($scopes)[0]; |
815: | $arrayType = new TemplateArrayType( |
816: | $templateArray->getScope(), |
817: | $templateArray->getStrategy(), |
818: | $templateArray->getVariance(), |
819: | $templateArray->getName(), |
820: | $arrayType, |
821: | $templateArray->getDefault(), |
822: | ); |
823: | } |
824: | |
825: | return [ |
826: | self::intersect($arrayType, ...$accessoryTypes), |
827: | ]; |
828: | } |
829: | |
830: | $reducedArrayTypes = self::reduceArrays($arrayTypes, true); |
831: | |
832: | return array_map( |
833: | static fn (Type $arrayType) => self::intersect($arrayType, ...$accessoryTypes), |
834: | self::optimizeConstantArrays($reducedArrayTypes), |
835: | ); |
836: | } |
837: | |
838: | |
839: | |
840: | |
841: | |
842: | private static function optimizeConstantArrays(array $types): array |
843: | { |
844: | $constantArrayValuesCount = self::countConstantArrayValueTypes($types); |
845: | |
846: | if ($constantArrayValuesCount <= ConstantArrayTypeBuilder::ARRAY_COUNT_LIMIT) { |
847: | return $types; |
848: | } |
849: | |
850: | $results = []; |
851: | $eachIsOversized = true; |
852: | foreach ($types as $type) { |
853: | $isOversized = false; |
854: | $result = TypeTraverser::map($type, static function (Type $type, callable $traverse) use (&$isOversized): Type { |
855: | if (!$type instanceof ConstantArrayType) { |
856: | return $traverse($type); |
857: | } |
858: | |
859: | if ($type->isIterableAtLeastOnce()->no()) { |
860: | return $type; |
861: | } |
862: | |
863: | $isOversized = true; |
864: | |
865: | $isList = true; |
866: | $valueTypes = []; |
867: | $keyTypes = []; |
868: | $nextAutoIndex = 0; |
869: | foreach ($type->getKeyTypes() as $i => $innerKeyType) { |
870: | if (!$innerKeyType instanceof ConstantIntegerType) { |
871: | $isList = false; |
872: | } elseif ($innerKeyType->getValue() !== $nextAutoIndex) { |
873: | $isList = false; |
874: | $nextAutoIndex = $innerKeyType->getValue() + 1; |
875: | } else { |
876: | $nextAutoIndex++; |
877: | } |
878: | |
879: | $generalizedKeyType = $innerKeyType->generalize(GeneralizePrecision::moreSpecific()); |
880: | $keyTypes[$generalizedKeyType->describe(VerbosityLevel::precise())] = $generalizedKeyType; |
881: | |
882: | $innerValueType = $type->getValueTypes()[$i]; |
883: | $generalizedValueType = TypeTraverser::map($innerValueType, static function (Type $type) use ($traverse): Type { |
884: | if ($type instanceof ArrayType || $type instanceof ConstantArrayType) { |
885: | return TypeCombinator::intersect($type, new OversizedArrayType()); |
886: | } |
887: | |
888: | if ($type instanceof ConstantScalarType) { |
889: | return $type->generalize(GeneralizePrecision::moreSpecific()); |
890: | } |
891: | |
892: | return $traverse($type); |
893: | }); |
894: | $valueTypes[$generalizedValueType->describe(VerbosityLevel::precise())] = $generalizedValueType; |
895: | } |
896: | |
897: | $keyType = TypeCombinator::union(...array_values($keyTypes)); |
898: | $valueType = TypeCombinator::union(...array_values($valueTypes)); |
899: | |
900: | $arrayType = new ArrayType($keyType, $valueType); |
901: | if ($isList) { |
902: | $arrayType = TypeCombinator::intersect($arrayType, new AccessoryArrayListType()); |
903: | } |
904: | |
905: | return TypeCombinator::intersect($arrayType, new NonEmptyArrayType(), new OversizedArrayType()); |
906: | }); |
907: | |
908: | if (!$isOversized) { |
909: | $eachIsOversized = false; |
910: | } |
911: | |
912: | $results[] = $result; |
913: | } |
914: | |
915: | if ($eachIsOversized) { |
916: | $eachIsList = true; |
917: | $keyTypes = []; |
918: | $valueTypes = []; |
919: | foreach ($results as $result) { |
920: | $keyTypes[] = $result->getIterableKeyType(); |
921: | $valueTypes[] = $result->getLastIterableValueType(); |
922: | if ($result->isList()->yes()) { |
923: | continue; |
924: | } |
925: | $eachIsList = false; |
926: | } |
927: | |
928: | $keyType = self::union(...$keyTypes); |
929: | $valueType = self::union(...$valueTypes); |
930: | |
931: | if ($valueType instanceof UnionType && count($valueType->getTypes()) > ConstantArrayTypeBuilder::ARRAY_COUNT_LIMIT) { |
932: | $valueType = $valueType->generalize(GeneralizePrecision::lessSpecific()); |
933: | } |
934: | |
935: | $arrayType = new ArrayType($keyType, $valueType); |
936: | if ($eachIsList) { |
937: | $arrayType = self::intersect($arrayType, new AccessoryArrayListType()); |
938: | } |
939: | |
940: | return [self::intersect($arrayType, new NonEmptyArrayType(), new OversizedArrayType())]; |
941: | } |
942: | |
943: | return $results; |
944: | } |
945: | |
946: | |
947: | |
948: | |
949: | public static function countConstantArrayValueTypes(array $types): int |
950: | { |
951: | $constantArrayValuesCount = 0; |
952: | foreach ($types as $type) { |
953: | TypeTraverser::map($type, static function (Type $type, callable $traverse) use (&$constantArrayValuesCount): Type { |
954: | if ($type instanceof ConstantArrayType) { |
955: | $constantArrayValuesCount += count($type->getValueTypes()); |
956: | } |
957: | |
958: | return $traverse($type); |
959: | }); |
960: | } |
961: | return $constantArrayValuesCount; |
962: | } |
963: | |
964: | |
965: | |
966: | |
967: | |
968: | private static function reduceArrays(array $constantArrays, bool $preserveTaggedUnions): array |
969: | { |
970: | $newArrays = []; |
971: | $arraysToProcess = []; |
972: | $emptyArray = null; |
973: | foreach ($constantArrays as $constantArray) { |
974: | if (!$constantArray->isConstantArray()->yes()) { |
975: | |
976: | |
977: | if (!$preserveTaggedUnions) { |
978: | return $constantArrays; |
979: | } |
980: | $newArrays[] = $constantArray; |
981: | continue; |
982: | } |
983: | |
984: | if ($constantArray->isIterableAtLeastOnce()->no()) { |
985: | $emptyArray = $constantArray; |
986: | continue; |
987: | } |
988: | |
989: | $arraysToProcess = array_merge($arraysToProcess, $constantArray->getConstantArrays()); |
990: | } |
991: | |
992: | if ($emptyArray !== null) { |
993: | $newArrays[] = $emptyArray; |
994: | } |
995: | |
996: | $arraysToProcessPerKey = []; |
997: | foreach ($arraysToProcess as $i => $arrayToProcess) { |
998: | foreach ($arrayToProcess->getKeyTypes() as $keyType) { |
999: | $arraysToProcessPerKey[$keyType->getValue()][] = $i; |
1000: | } |
1001: | } |
1002: | |
1003: | $eligibleCombinations = []; |
1004: | |
1005: | foreach ($arraysToProcessPerKey as $arrays) { |
1006: | for ($i = 0, $arraysCount = count($arrays); $i < $arraysCount - 1; $i++) { |
1007: | for ($j = $i + 1; $j < $arraysCount; $j++) { |
1008: | $eligibleCombinations[$arrays[$i]][$arrays[$j]] ??= 0; |
1009: | $eligibleCombinations[$arrays[$i]][$arrays[$j]]++; |
1010: | } |
1011: | } |
1012: | } |
1013: | |
1014: | foreach ($eligibleCombinations as $i => $other) { |
1015: | if (!array_key_exists($i, $arraysToProcess)) { |
1016: | continue; |
1017: | } |
1018: | |
1019: | foreach ($other as $j => $overlappingKeysCount) { |
1020: | if (!array_key_exists($j, $arraysToProcess)) { |
1021: | continue; |
1022: | } |
1023: | |
1024: | if ( |
1025: | $preserveTaggedUnions |
1026: | && $overlappingKeysCount === count($arraysToProcess[$i]->getKeyTypes()) |
1027: | && $arraysToProcess[$j]->isKeysSupersetOf($arraysToProcess[$i]) |
1028: | ) { |
1029: | $arraysToProcess[$j] = $arraysToProcess[$j]->mergeWith($arraysToProcess[$i]); |
1030: | unset($arraysToProcess[$i]); |
1031: | continue 2; |
1032: | } |
1033: | |
1034: | if ( |
1035: | $preserveTaggedUnions |
1036: | && $overlappingKeysCount === count($arraysToProcess[$j]->getKeyTypes()) |
1037: | && $arraysToProcess[$i]->isKeysSupersetOf($arraysToProcess[$j]) |
1038: | ) { |
1039: | $arraysToProcess[$i] = $arraysToProcess[$i]->mergeWith($arraysToProcess[$j]); |
1040: | unset($arraysToProcess[$j]); |
1041: | continue 1; |
1042: | } |
1043: | |
1044: | if ( |
1045: | !$preserveTaggedUnions |
1046: | |
1047: | && $overlappingKeysCount === count($arraysToProcess[$i]->getKeyTypes()) |
1048: | && $overlappingKeysCount === count($arraysToProcess[$j]->getKeyTypes()) |
1049: | ) { |
1050: | $arraysToProcess[$j] = $arraysToProcess[$j]->mergeWith($arraysToProcess[$i]); |
1051: | unset($arraysToProcess[$i]); |
1052: | continue 2; |
1053: | } |
1054: | } |
1055: | } |
1056: | |
1057: | return array_merge($newArrays, $arraysToProcess); |
1058: | } |
1059: | |
1060: | public static function intersect(Type ...$types): Type |
1061: | { |
1062: | $types = array_values($types); |
1063: | |
1064: | $typesCount = count($types); |
1065: | if ($typesCount === 0) { |
1066: | return new NeverType(); |
1067: | } |
1068: | if ($typesCount === 1) { |
1069: | return $types[0]; |
1070: | } |
1071: | |
1072: | $sortTypes = static function (Type $a, Type $b): int { |
1073: | if (!$a instanceof UnionType || !$b instanceof UnionType) { |
1074: | return 0; |
1075: | } |
1076: | |
1077: | if ($a instanceof TemplateType) { |
1078: | return -1; |
1079: | } |
1080: | if ($b instanceof TemplateType) { |
1081: | return 1; |
1082: | } |
1083: | |
1084: | if ($a instanceof BenevolentUnionType) { |
1085: | return -1; |
1086: | } |
1087: | if ($b instanceof BenevolentUnionType) { |
1088: | return 1; |
1089: | } |
1090: | |
1091: | return 0; |
1092: | }; |
1093: | usort($types, $sortTypes); |
1094: | |
1095: | foreach ($types as $i => $type) { |
1096: | if (!$type instanceof UnionType) { |
1097: | continue; |
1098: | } |
1099: | |
1100: | $topLevelUnionSubTypes = []; |
1101: | $innerTypes = $type->getTypes(); |
1102: | usort($innerTypes, $sortTypes); |
1103: | $slice1 = array_slice($types, 0, $i); |
1104: | $slice2 = array_slice($types, $i + 1); |
1105: | foreach ($innerTypes as $innerUnionSubType) { |
1106: | $topLevelUnionSubTypes[] = self::intersect( |
1107: | $innerUnionSubType, |
1108: | ...$slice1, |
1109: | ...$slice2, |
1110: | ); |
1111: | } |
1112: | |
1113: | $union = self::union(...$topLevelUnionSubTypes); |
1114: | if ($union instanceof NeverType) { |
1115: | return $union; |
1116: | } |
1117: | |
1118: | if ($type instanceof BenevolentUnionType) { |
1119: | $union = TypeUtils::toBenevolentUnion($union); |
1120: | } |
1121: | |
1122: | if ($type instanceof TemplateUnionType || $type instanceof TemplateBenevolentUnionType) { |
1123: | $union = TemplateTypeFactory::create( |
1124: | $type->getScope(), |
1125: | $type->getName(), |
1126: | $union, |
1127: | $type->getVariance(), |
1128: | $type->getStrategy(), |
1129: | $type->getDefault(), |
1130: | ); |
1131: | } |
1132: | |
1133: | return $union; |
1134: | } |
1135: | $typesCount = count($types); |
1136: | |
1137: | |
1138: | for ($i = 0; $i < $typesCount; $i++) { |
1139: | $type = $types[$i]; |
1140: | |
1141: | if (!($type instanceof IntersectionType)) { |
1142: | continue; |
1143: | } |
1144: | |
1145: | array_splice($types, $i--, 1, $type->getTypes()); |
1146: | $typesCount = count($types); |
1147: | } |
1148: | |
1149: | $hasOffsetValueTypeCount = 0; |
1150: | $newTypes = []; |
1151: | foreach ($types as $type) { |
1152: | if (!$type instanceof HasOffsetValueType) { |
1153: | $newTypes[] = $type; |
1154: | continue; |
1155: | } |
1156: | |
1157: | $hasOffsetValueTypeCount++; |
1158: | } |
1159: | |
1160: | if ($hasOffsetValueTypeCount > 32) { |
1161: | $newTypes[] = new OversizedArrayType(); |
1162: | $types = $newTypes; |
1163: | $typesCount = count($types); |
1164: | } |
1165: | |
1166: | usort($types, static function (Type $a, Type $b): int { |
1167: | |
1168: | if ($a instanceof SubtractableType && $a->getSubtractedType() !== null) { |
1169: | return -1; |
1170: | } |
1171: | if ($b instanceof SubtractableType && $b->getSubtractedType() !== null) { |
1172: | return 1; |
1173: | } |
1174: | |
1175: | if ($a instanceof ConstantArrayType && !$b instanceof ConstantArrayType) { |
1176: | return -1; |
1177: | } |
1178: | if ($b instanceof ConstantArrayType && !$a instanceof ConstantArrayType) { |
1179: | return 1; |
1180: | } |
1181: | |
1182: | return 0; |
1183: | }); |
1184: | |
1185: | |
1186: | |
1187: | |
1188: | |
1189: | |
1190: | |
1191: | |
1192: | |
1193: | for ($i = 0; $i < $typesCount; $i++) { |
1194: | for ($j = $i + 1; $j < $typesCount; $j++) { |
1195: | if ($types[$j] instanceof SubtractableType) { |
1196: | $typeWithoutSubtractedTypeA = $types[$j]->getTypeWithoutSubtractedType(); |
1197: | |
1198: | if ($typeWithoutSubtractedTypeA instanceof MixedType && $types[$i] instanceof MixedType) { |
1199: | $isSuperTypeSubtractableA = $typeWithoutSubtractedTypeA->isSuperTypeOfMixed($types[$i]); |
1200: | } else { |
1201: | $isSuperTypeSubtractableA = $typeWithoutSubtractedTypeA->isSuperTypeOf($types[$i]); |
1202: | } |
1203: | if ($isSuperTypeSubtractableA->yes()) { |
1204: | $types[$i] = self::unionWithSubtractedType($types[$i], $types[$j]->getSubtractedType()); |
1205: | array_splice($types, $j--, 1); |
1206: | $typesCount--; |
1207: | continue 1; |
1208: | } |
1209: | } |
1210: | |
1211: | if ($types[$i] instanceof SubtractableType) { |
1212: | $typeWithoutSubtractedTypeB = $types[$i]->getTypeWithoutSubtractedType(); |
1213: | |
1214: | if ($typeWithoutSubtractedTypeB instanceof MixedType && $types[$j] instanceof MixedType) { |
1215: | $isSuperTypeSubtractableB = $typeWithoutSubtractedTypeB->isSuperTypeOfMixed($types[$j]); |
1216: | } else { |
1217: | $isSuperTypeSubtractableB = $typeWithoutSubtractedTypeB->isSuperTypeOf($types[$j]); |
1218: | } |
1219: | if ($isSuperTypeSubtractableB->yes()) { |
1220: | $types[$j] = self::unionWithSubtractedType($types[$j], $types[$i]->getSubtractedType()); |
1221: | array_splice($types, $i--, 1); |
1222: | $typesCount--; |
1223: | continue 2; |
1224: | } |
1225: | } |
1226: | |
1227: | if ($types[$i] instanceof IntegerRangeType) { |
1228: | $intersectionType = $types[$i]->tryIntersect($types[$j]); |
1229: | if ($intersectionType !== null) { |
1230: | $types[$j] = $intersectionType; |
1231: | array_splice($types, $i--, 1); |
1232: | $typesCount--; |
1233: | continue 2; |
1234: | } |
1235: | } |
1236: | |
1237: | if ($types[$j] instanceof IterableType) { |
1238: | $isSuperTypeA = $types[$j]->isSuperTypeOfMixed($types[$i]); |
1239: | } else { |
1240: | $isSuperTypeA = $types[$j]->isSuperTypeOf($types[$i]); |
1241: | } |
1242: | |
1243: | if ($isSuperTypeA->yes()) { |
1244: | array_splice($types, $j--, 1); |
1245: | $typesCount--; |
1246: | continue; |
1247: | } |
1248: | |
1249: | if ($types[$i] instanceof IterableType) { |
1250: | $isSuperTypeB = $types[$i]->isSuperTypeOfMixed($types[$j]); |
1251: | } else { |
1252: | $isSuperTypeB = $types[$i]->isSuperTypeOf($types[$j]); |
1253: | } |
1254: | |
1255: | if ($isSuperTypeB->maybe()) { |
1256: | if ($types[$i] instanceof ConstantArrayType && $types[$j] instanceof HasOffsetType) { |
1257: | $types[$i] = $types[$i]->makeOffsetRequired($types[$j]->getOffsetType()); |
1258: | array_splice($types, $j--, 1); |
1259: | $typesCount--; |
1260: | continue; |
1261: | } |
1262: | |
1263: | if ($types[$j] instanceof ConstantArrayType && $types[$i] instanceof HasOffsetType) { |
1264: | $types[$j] = $types[$j]->makeOffsetRequired($types[$i]->getOffsetType()); |
1265: | array_splice($types, $i--, 1); |
1266: | $typesCount--; |
1267: | continue 2; |
1268: | } |
1269: | |
1270: | if ( |
1271: | $types[$i] instanceof ConstantArrayType |
1272: | && count($types[$i]->getKeyTypes()) === 1 |
1273: | && $types[$i]->isOptionalKey(0) |
1274: | && $types[$j] instanceof NonEmptyArrayType |
1275: | ) { |
1276: | $types[$i] = $types[$i]->makeOffsetRequired($types[$i]->getKeyTypes()[0]); |
1277: | array_splice($types, $j--, 1); |
1278: | $typesCount--; |
1279: | continue; |
1280: | } |
1281: | |
1282: | if ( |
1283: | $types[$j] instanceof ConstantArrayType |
1284: | && count($types[$j]->getKeyTypes()) === 1 |
1285: | && $types[$j]->isOptionalKey(0) |
1286: | && $types[$i] instanceof NonEmptyArrayType |
1287: | ) { |
1288: | $types[$j] = $types[$j]->makeOffsetRequired($types[$j]->getKeyTypes()[0]); |
1289: | array_splice($types, $i--, 1); |
1290: | $typesCount--; |
1291: | continue 2; |
1292: | } |
1293: | |
1294: | if ($types[$i] instanceof ConstantArrayType && $types[$j] instanceof HasOffsetValueType) { |
1295: | $offsetType = $types[$j]->getOffsetType(); |
1296: | $valueType = $types[$j]->getValueType(); |
1297: | $newValueType = self::intersect($types[$i]->getOffsetValueType($offsetType), $valueType); |
1298: | if ($newValueType instanceof NeverType) { |
1299: | return $newValueType; |
1300: | } |
1301: | $types[$i] = $types[$i]->setOffsetValueType($offsetType, $newValueType); |
1302: | array_splice($types, $j--, 1); |
1303: | $typesCount--; |
1304: | continue; |
1305: | } |
1306: | |
1307: | if ($types[$j] instanceof ConstantArrayType && $types[$i] instanceof HasOffsetValueType) { |
1308: | $offsetType = $types[$i]->getOffsetType(); |
1309: | $valueType = $types[$i]->getValueType(); |
1310: | $newValueType = self::intersect($types[$j]->getOffsetValueType($offsetType), $valueType); |
1311: | if ($newValueType instanceof NeverType) { |
1312: | return $newValueType; |
1313: | } |
1314: | |
1315: | $types[$j] = $types[$j]->setOffsetValueType($offsetType, $newValueType); |
1316: | array_splice($types, $i--, 1); |
1317: | $typesCount--; |
1318: | continue 2; |
1319: | } |
1320: | |
1321: | if ($types[$i] instanceof OversizedArrayType && $types[$j] instanceof HasOffsetValueType) { |
1322: | array_splice($types, $j--, 1); |
1323: | $typesCount--; |
1324: | continue; |
1325: | } |
1326: | |
1327: | if ($types[$j] instanceof OversizedArrayType && $types[$i] instanceof HasOffsetValueType) { |
1328: | array_splice($types, $i--, 1); |
1329: | $typesCount--; |
1330: | continue 2; |
1331: | } |
1332: | |
1333: | if ($types[$i] instanceof ObjectShapeType && $types[$j] instanceof HasPropertyType) { |
1334: | $types[$i] = $types[$i]->makePropertyRequired($types[$j]->getPropertyName()); |
1335: | array_splice($types, $j--, 1); |
1336: | $typesCount--; |
1337: | continue; |
1338: | } |
1339: | |
1340: | if ($types[$j] instanceof ObjectShapeType && $types[$i] instanceof HasPropertyType) { |
1341: | $types[$j] = $types[$j]->makePropertyRequired($types[$i]->getPropertyName()); |
1342: | array_splice($types, $i--, 1); |
1343: | $typesCount--; |
1344: | continue 2; |
1345: | } |
1346: | |
1347: | if ($types[$i] instanceof ConstantArrayType && ($types[$j] instanceof ArrayType || $types[$j] instanceof ConstantArrayType)) { |
1348: | $newArray = ConstantArrayTypeBuilder::createEmpty(); |
1349: | $valueTypes = $types[$i]->getValueTypes(); |
1350: | foreach ($types[$i]->getKeyTypes() as $k => $keyType) { |
1351: | $newArray->setOffsetValueType( |
1352: | self::intersect($keyType, $types[$j]->getIterableKeyType()), |
1353: | self::intersect($valueTypes[$k], $types[$j]->getIterableValueType()), |
1354: | $types[$i]->isOptionalKey($k) && !$types[$j]->hasOffsetValueType($keyType)->yes(), |
1355: | ); |
1356: | } |
1357: | $types[$i] = $newArray->getArray(); |
1358: | array_splice($types, $j--, 1); |
1359: | $typesCount--; |
1360: | continue 2; |
1361: | } |
1362: | |
1363: | if ($types[$j] instanceof ConstantArrayType && ($types[$i] instanceof ArrayType || $types[$i] instanceof ConstantArrayType)) { |
1364: | $newArray = ConstantArrayTypeBuilder::createEmpty(); |
1365: | $valueTypes = $types[$j]->getValueTypes(); |
1366: | foreach ($types[$j]->getKeyTypes() as $k => $keyType) { |
1367: | $newArray->setOffsetValueType( |
1368: | self::intersect($keyType, $types[$i]->getIterableKeyType()), |
1369: | self::intersect($valueTypes[$k], $types[$i]->getIterableValueType()), |
1370: | $types[$j]->isOptionalKey($k) && !$types[$i]->hasOffsetValueType($keyType)->yes(), |
1371: | ); |
1372: | } |
1373: | $types[$j] = $newArray->getArray(); |
1374: | array_splice($types, $i--, 1); |
1375: | $typesCount--; |
1376: | continue 2; |
1377: | } |
1378: | |
1379: | if ( |
1380: | ($types[$i] instanceof ArrayType || $types[$i] instanceof ConstantArrayType || $types[$i] instanceof IterableType) && |
1381: | ($types[$j] instanceof ArrayType || $types[$j] instanceof ConstantArrayType || $types[$j] instanceof IterableType) |
1382: | ) { |
1383: | $keyType = self::intersect($types[$i]->getIterableKeyType(), $types[$j]->getKeyType()); |
1384: | $itemType = self::intersect($types[$i]->getItemType(), $types[$j]->getItemType()); |
1385: | if ($types[$i] instanceof IterableType && $types[$j] instanceof IterableType) { |
1386: | $types[$j] = new IterableType($keyType, $itemType); |
1387: | } else { |
1388: | $types[$j] = new ArrayType($keyType, $itemType); |
1389: | } |
1390: | array_splice($types, $i--, 1); |
1391: | $typesCount--; |
1392: | continue 2; |
1393: | } |
1394: | |
1395: | if ($types[$i] instanceof GenericClassStringType && $types[$j] instanceof GenericClassStringType) { |
1396: | $genericType = self::intersect($types[$i]->getGenericType(), $types[$j]->getGenericType()); |
1397: | $types[$i] = new GenericClassStringType($genericType); |
1398: | array_splice($types, $j--, 1); |
1399: | $typesCount--; |
1400: | continue; |
1401: | } |
1402: | |
1403: | if ( |
1404: | $types[$i] instanceof ArrayType |
1405: | && get_class($types[$i]) === ArrayType::class |
1406: | && $types[$j] instanceof AccessoryArrayListType |
1407: | && !$types[$j]->getIterableKeyType()->isSuperTypeOf($types[$i]->getIterableKeyType())->yes() |
1408: | ) { |
1409: | $keyType = self::intersect($types[$i]->getIterableKeyType(), $types[$j]->getIterableKeyType()); |
1410: | if ($keyType instanceof NeverType) { |
1411: | return $keyType; |
1412: | } |
1413: | $types[$i] = new ArrayType($keyType, $types[$i]->getItemType()); |
1414: | continue; |
1415: | } |
1416: | |
1417: | continue; |
1418: | } |
1419: | |
1420: | if ($isSuperTypeB->yes()) { |
1421: | array_splice($types, $i--, 1); |
1422: | $typesCount--; |
1423: | continue 2; |
1424: | } |
1425: | |
1426: | if ($isSuperTypeA->no()) { |
1427: | return new NeverType(); |
1428: | } |
1429: | } |
1430: | } |
1431: | |
1432: | if ($typesCount === 1) { |
1433: | return $types[0]; |
1434: | } |
1435: | |
1436: | return new IntersectionType($types); |
1437: | } |
1438: | |
1439: | public static function removeFalsey(Type $type): Type |
1440: | { |
1441: | return self::remove($type, StaticTypeFactory::falsey()); |
1442: | } |
1443: | |
1444: | public static function removeTruthy(Type $type): Type |
1445: | { |
1446: | return self::remove($type, StaticTypeFactory::truthy()); |
1447: | } |
1448: | |
1449: | } |
1450: | |