1: | <?php declare(strict_types = 1); |
2: | |
3: | namespace PHPStan\Type\Constant; |
4: | |
5: | use Nette\Utils\Strings; |
6: | use PHPStan\Analyser\OutOfClassScope; |
7: | use PHPStan\Internal\CombinationsHelper; |
8: | use PHPStan\Php\PhpVersion; |
9: | use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprIntegerNode; |
10: | use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprStringNode; |
11: | use PHPStan\PhpDocParser\Ast\Type\ArrayShapeItemNode; |
12: | use PHPStan\PhpDocParser\Ast\Type\ArrayShapeNode; |
13: | use PHPStan\PhpDocParser\Ast\Type\ConstTypeNode; |
14: | use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode; |
15: | use PHPStan\PhpDocParser\Ast\Type\TypeNode; |
16: | use PHPStan\Reflection\Callables\FunctionCallableVariant; |
17: | use PHPStan\Reflection\ClassMemberAccessAnswerer; |
18: | use PHPStan\Reflection\InaccessibleMethod; |
19: | use PHPStan\Reflection\InitializerExprTypeResolver; |
20: | use PHPStan\Reflection\PhpVersionStaticAccessor; |
21: | use PHPStan\Reflection\TrivialParametersAcceptor; |
22: | use PHPStan\ShouldNotHappenException; |
23: | use PHPStan\TrinaryLogic; |
24: | use PHPStan\Type\AcceptsResult; |
25: | use PHPStan\Type\Accessory\AccessoryArrayListType; |
26: | use PHPStan\Type\Accessory\HasOffsetType; |
27: | use PHPStan\Type\Accessory\HasOffsetValueType; |
28: | use PHPStan\Type\Accessory\NonEmptyArrayType; |
29: | use PHPStan\Type\ArrayType; |
30: | use PHPStan\Type\BooleanType; |
31: | use PHPStan\Type\CompoundType; |
32: | use PHPStan\Type\ConstantScalarType; |
33: | use PHPStan\Type\ErrorType; |
34: | use PHPStan\Type\GeneralizePrecision; |
35: | use PHPStan\Type\Generic\TemplateTypeMap; |
36: | use PHPStan\Type\Generic\TemplateTypeVariance; |
37: | use PHPStan\Type\IntegerRangeType; |
38: | use PHPStan\Type\IntersectionType; |
39: | use PHPStan\Type\IsSuperTypeOfResult; |
40: | use PHPStan\Type\MixedType; |
41: | use PHPStan\Type\NeverType; |
42: | use PHPStan\Type\NullType; |
43: | use PHPStan\Type\Traits\ArrayTypeTrait; |
44: | use PHPStan\Type\Traits\NonObjectTypeTrait; |
45: | use PHPStan\Type\Traits\UndecidedComparisonTypeTrait; |
46: | use PHPStan\Type\Type; |
47: | use PHPStan\Type\TypeCombinator; |
48: | use PHPStan\Type\UnionType; |
49: | use PHPStan\Type\VerbosityLevel; |
50: | use function array_keys; |
51: | use function array_map; |
52: | use function array_merge; |
53: | use function array_pop; |
54: | use function array_push; |
55: | use function array_slice; |
56: | use function array_unique; |
57: | use function array_values; |
58: | use function assert; |
59: | use function count; |
60: | use function implode; |
61: | use function in_array; |
62: | use function is_string; |
63: | use function min; |
64: | use function pow; |
65: | use function range; |
66: | use function sort; |
67: | use function sprintf; |
68: | use function str_contains; |
69: | |
70: | |
71: | |
72: | |
73: | class ConstantArrayType implements Type |
74: | { |
75: | |
76: | use ArrayTypeTrait { |
77: | chunkArray as traitChunkArray; |
78: | } |
79: | use NonObjectTypeTrait; |
80: | use UndecidedComparisonTypeTrait; |
81: | |
82: | private const DESCRIBE_LIMIT = 8; |
83: | private const CHUNK_FINITE_TYPES_LIMIT = 5; |
84: | |
85: | private TrinaryLogic $isList; |
86: | |
87: | |
88: | private ?array $allArrays = null; |
89: | |
90: | private ?Type $iterableKeyType = null; |
91: | |
92: | private ?Type $iterableValueType = null; |
93: | |
94: | |
95: | |
96: | |
97: | |
98: | |
99: | |
100: | |
101: | public function __construct( |
102: | private array $keyTypes, |
103: | private array $valueTypes, |
104: | private array $nextAutoIndexes = [0], |
105: | private array $optionalKeys = [], |
106: | ?TrinaryLogic $isList = null, |
107: | ) |
108: | { |
109: | assert(count($keyTypes) === count($valueTypes)); |
110: | |
111: | $keyTypesCount = count($this->keyTypes); |
112: | if ($keyTypesCount === 0) { |
113: | $isList = TrinaryLogic::createYes(); |
114: | } |
115: | |
116: | if ($isList === null) { |
117: | $isList = TrinaryLogic::createNo(); |
118: | } |
119: | $this->isList = $isList; |
120: | } |
121: | |
122: | public function getConstantArrays(): array |
123: | { |
124: | return [$this]; |
125: | } |
126: | |
127: | public function getReferencedClasses(): array |
128: | { |
129: | $referencedClasses = []; |
130: | foreach ($this->getKeyTypes() as $keyType) { |
131: | foreach ($keyType->getReferencedClasses() as $referencedClass) { |
132: | $referencedClasses[] = $referencedClass; |
133: | } |
134: | } |
135: | |
136: | foreach ($this->getValueTypes() as $valueType) { |
137: | foreach ($valueType->getReferencedClasses() as $referencedClass) { |
138: | $referencedClasses[] = $referencedClass; |
139: | } |
140: | } |
141: | |
142: | return $referencedClasses; |
143: | } |
144: | |
145: | public function getIterableKeyType(): Type |
146: | { |
147: | if ($this->iterableKeyType !== null) { |
148: | return $this->iterableKeyType; |
149: | } |
150: | |
151: | $keyTypesCount = count($this->keyTypes); |
152: | if ($keyTypesCount === 0) { |
153: | $keyType = new NeverType(true); |
154: | } elseif ($keyTypesCount === 1) { |
155: | $keyType = $this->keyTypes[0]; |
156: | } else { |
157: | $keyType = new UnionType($this->keyTypes); |
158: | } |
159: | |
160: | return $this->iterableKeyType = $keyType; |
161: | } |
162: | |
163: | public function getIterableValueType(): Type |
164: | { |
165: | if ($this->iterableValueType !== null) { |
166: | return $this->iterableValueType; |
167: | } |
168: | |
169: | return $this->iterableValueType = count($this->valueTypes) > 0 ? TypeCombinator::union(...$this->valueTypes) : new NeverType(true); |
170: | } |
171: | |
172: | public function getKeyType(): Type |
173: | { |
174: | return $this->getIterableKeyType(); |
175: | } |
176: | |
177: | public function getItemType(): Type |
178: | { |
179: | return $this->getIterableValueType(); |
180: | } |
181: | |
182: | public function isConstantValue(): TrinaryLogic |
183: | { |
184: | return TrinaryLogic::createYes(); |
185: | } |
186: | |
187: | |
188: | |
189: | |
190: | public function getNextAutoIndexes(): array |
191: | { |
192: | return $this->nextAutoIndexes; |
193: | } |
194: | |
195: | |
196: | |
197: | |
198: | public function getOptionalKeys(): array |
199: | { |
200: | return $this->optionalKeys; |
201: | } |
202: | |
203: | |
204: | |
205: | |
206: | public function getAllArrays(): array |
207: | { |
208: | if ($this->allArrays !== null) { |
209: | return $this->allArrays; |
210: | } |
211: | |
212: | if (count($this->optionalKeys) <= 10) { |
213: | $optionalKeysCombinations = $this->powerSet($this->optionalKeys); |
214: | } else { |
215: | $optionalKeysCombinations = [ |
216: | [], |
217: | $this->optionalKeys, |
218: | ]; |
219: | } |
220: | |
221: | $requiredKeys = []; |
222: | foreach (array_keys($this->keyTypes) as $i) { |
223: | if (in_array($i, $this->optionalKeys, true)) { |
224: | continue; |
225: | } |
226: | $requiredKeys[] = $i; |
227: | } |
228: | |
229: | $arrays = []; |
230: | foreach ($optionalKeysCombinations as $combination) { |
231: | $keys = array_merge($requiredKeys, $combination); |
232: | sort($keys); |
233: | |
234: | if ($this->isList->yes() && array_keys($keys) !== $keys) { |
235: | continue; |
236: | } |
237: | |
238: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
239: | foreach ($keys as $i) { |
240: | $builder->setOffsetValueType($this->keyTypes[$i], $this->valueTypes[$i]); |
241: | } |
242: | |
243: | $array = $builder->getArray(); |
244: | if (!$array instanceof self) { |
245: | throw new ShouldNotHappenException(); |
246: | } |
247: | |
248: | $arrays[] = $array; |
249: | } |
250: | |
251: | return $this->allArrays = $arrays; |
252: | } |
253: | |
254: | |
255: | |
256: | |
257: | |
258: | |
259: | private function powerSet(array $in): array |
260: | { |
261: | $count = count($in); |
262: | $members = pow(2, $count); |
263: | $return = []; |
264: | for ($i = 0; $i < $members; $i++) { |
265: | $b = sprintf('%0' . $count . 'b', $i); |
266: | $out = []; |
267: | for ($j = 0; $j < $count; $j++) { |
268: | if ($b[$j] !== '1') { |
269: | continue; |
270: | } |
271: | |
272: | $out[] = $in[$j]; |
273: | } |
274: | $return[] = $out; |
275: | } |
276: | |
277: | return $return; |
278: | } |
279: | |
280: | |
281: | |
282: | |
283: | public function getKeyTypes(): array |
284: | { |
285: | return $this->keyTypes; |
286: | } |
287: | |
288: | |
289: | |
290: | |
291: | public function getValueTypes(): array |
292: | { |
293: | return $this->valueTypes; |
294: | } |
295: | |
296: | public function isOptionalKey(int $i): bool |
297: | { |
298: | return in_array($i, $this->optionalKeys, true); |
299: | } |
300: | |
301: | public function accepts(Type $type, bool $strictTypes): AcceptsResult |
302: | { |
303: | if ($type instanceof CompoundType && !$type instanceof IntersectionType) { |
304: | return $type->isAcceptedBy($this, $strictTypes); |
305: | } |
306: | |
307: | if ($type instanceof self && count($this->keyTypes) === 0) { |
308: | return AcceptsResult::createFromBoolean(count($type->keyTypes) === 0); |
309: | } |
310: | |
311: | $result = AcceptsResult::createYes(); |
312: | foreach ($this->keyTypes as $i => $keyType) { |
313: | $valueType = $this->valueTypes[$i]; |
314: | $hasOffsetValueType = $type->hasOffsetValueType($keyType); |
315: | $hasOffset = new AcceptsResult( |
316: | $hasOffsetValueType, |
317: | $hasOffsetValueType->yes() || !$type->isConstantArray()->yes() ? [] : [sprintf('Array %s have offset %s.', $hasOffsetValueType->no() ? 'does not' : 'might not', $keyType->describe(VerbosityLevel::value()))], |
318: | ); |
319: | if ($hasOffset->no()) { |
320: | if ($this->isOptionalKey($i)) { |
321: | continue; |
322: | } |
323: | return $hasOffset; |
324: | } |
325: | if ($hasOffset->maybe() && $this->isOptionalKey($i)) { |
326: | $hasOffset = AcceptsResult::createYes(); |
327: | } |
328: | |
329: | $result = $result->and($hasOffset); |
330: | $otherValueType = $type->getOffsetValueType($keyType); |
331: | $verbosity = VerbosityLevel::getRecommendedLevelByType($valueType, $otherValueType); |
332: | $acceptsValue = $valueType->accepts($otherValueType, $strictTypes)->decorateReasons( |
333: | static fn (string $reason) => sprintf( |
334: | 'Offset %s (%s) does not accept type %s: %s', |
335: | $keyType->describe(VerbosityLevel::precise()), |
336: | $valueType->describe($verbosity), |
337: | $otherValueType->describe($verbosity), |
338: | $reason, |
339: | ), |
340: | ); |
341: | if (!$acceptsValue->yes() && count($acceptsValue->reasons) === 0 && $type->isConstantArray()->yes()) { |
342: | $acceptsValue = new AcceptsResult($acceptsValue->result, [ |
343: | sprintf( |
344: | 'Offset %s (%s) does not accept type %s.', |
345: | $keyType->describe(VerbosityLevel::precise()), |
346: | $valueType->describe($verbosity), |
347: | $otherValueType->describe($verbosity), |
348: | ), |
349: | ]); |
350: | } |
351: | if ($acceptsValue->no()) { |
352: | return $acceptsValue; |
353: | } |
354: | $result = $result->and($acceptsValue); |
355: | } |
356: | |
357: | $result = $result->and(new AcceptsResult($type->isArray(), [])); |
358: | if ($type->isOversizedArray()->yes()) { |
359: | if (!$result->no()) { |
360: | return AcceptsResult::createYes(); |
361: | } |
362: | } |
363: | |
364: | return $result; |
365: | } |
366: | |
367: | public function isSuperTypeOf(Type $type): IsSuperTypeOfResult |
368: | { |
369: | if ($type instanceof self) { |
370: | if (count($this->keyTypes) === 0) { |
371: | return new IsSuperTypeOfResult($type->isIterableAtLeastOnce()->negate(), []); |
372: | } |
373: | |
374: | $results = []; |
375: | foreach ($this->keyTypes as $i => $keyType) { |
376: | $hasOffset = $type->hasOffsetValueType($keyType); |
377: | if ($hasOffset->no()) { |
378: | if (!$this->isOptionalKey($i)) { |
379: | return IsSuperTypeOfResult::createNo(); |
380: | } |
381: | |
382: | $results[] = IsSuperTypeOfResult::createYes(); |
383: | continue; |
384: | } elseif ($hasOffset->maybe() && !$this->isOptionalKey($i)) { |
385: | $results[] = IsSuperTypeOfResult::createMaybe(); |
386: | } |
387: | |
388: | $isValueSuperType = $this->valueTypes[$i]->isSuperTypeOf($type->getOffsetValueType($keyType)); |
389: | if ($isValueSuperType->no()) { |
390: | return $isValueSuperType->decorateReasons(static fn (string $reason) => sprintf('Offset %s: %s', $keyType->describe(VerbosityLevel::value()), $reason)); |
391: | } |
392: | $results[] = $isValueSuperType; |
393: | } |
394: | |
395: | return IsSuperTypeOfResult::createYes()->and(...$results); |
396: | } |
397: | |
398: | if ($type instanceof ArrayType) { |
399: | $result = IsSuperTypeOfResult::createMaybe(); |
400: | if (count($this->keyTypes) === 0) { |
401: | return $result; |
402: | } |
403: | |
404: | $isKeySuperType = $this->getKeyType()->isSuperTypeOf($type->getKeyType()); |
405: | if ($isKeySuperType->no()) { |
406: | return $isKeySuperType; |
407: | } |
408: | |
409: | return $result->and($isKeySuperType, $this->getItemType()->isSuperTypeOf($type->getItemType())); |
410: | } |
411: | |
412: | if ($type instanceof CompoundType) { |
413: | return $type->isSubTypeOf($this); |
414: | } |
415: | |
416: | return IsSuperTypeOfResult::createNo(); |
417: | } |
418: | |
419: | public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType |
420: | { |
421: | if ($type->isInteger()->yes()) { |
422: | return new ConstantBooleanType(false); |
423: | } |
424: | |
425: | if ($this->isIterableAtLeastOnce()->no()) { |
426: | if ($type->isIterableAtLeastOnce()->yes()) { |
427: | return new ConstantBooleanType(false); |
428: | } |
429: | |
430: | $constantScalarValues = $type->getConstantScalarValues(); |
431: | if (count($constantScalarValues) > 0) { |
432: | $results = []; |
433: | foreach ($constantScalarValues as $constantScalarValue) { |
434: | |
435: | $results[] = TrinaryLogic::createFromBoolean($constantScalarValue == []); |
436: | } |
437: | |
438: | return TrinaryLogic::extremeIdentity(...$results)->toBooleanType(); |
439: | } |
440: | } |
441: | |
442: | return new BooleanType(); |
443: | } |
444: | |
445: | public function equals(Type $type): bool |
446: | { |
447: | if (!$type instanceof self) { |
448: | return false; |
449: | } |
450: | |
451: | if (count($this->keyTypes) !== count($type->keyTypes)) { |
452: | return false; |
453: | } |
454: | |
455: | foreach ($this->keyTypes as $i => $keyType) { |
456: | $valueType = $this->valueTypes[$i]; |
457: | if (!$valueType->equals($type->valueTypes[$i])) { |
458: | return false; |
459: | } |
460: | if (!$keyType->equals($type->keyTypes[$i])) { |
461: | return false; |
462: | } |
463: | } |
464: | |
465: | if ($this->optionalKeys !== $type->optionalKeys) { |
466: | return false; |
467: | } |
468: | |
469: | return true; |
470: | } |
471: | |
472: | public function isCallable(): TrinaryLogic |
473: | { |
474: | $typeAndMethods = $this->findTypeAndMethodNames(); |
475: | if ($typeAndMethods === []) { |
476: | return TrinaryLogic::createNo(); |
477: | } |
478: | |
479: | $results = array_map( |
480: | static fn (ConstantArrayTypeAndMethod $typeAndMethod): TrinaryLogic => $typeAndMethod->getCertainty(), |
481: | $typeAndMethods, |
482: | ); |
483: | |
484: | return TrinaryLogic::createYes()->and(...$results); |
485: | } |
486: | |
487: | public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope): array |
488: | { |
489: | $typeAndMethodNames = $this->findTypeAndMethodNames(); |
490: | if ($typeAndMethodNames === []) { |
491: | throw new ShouldNotHappenException(); |
492: | } |
493: | |
494: | $acceptors = []; |
495: | foreach ($typeAndMethodNames as $typeAndMethodName) { |
496: | if ($typeAndMethodName->isUnknown() || !$typeAndMethodName->getCertainty()->yes()) { |
497: | $acceptors[] = new TrivialParametersAcceptor(); |
498: | continue; |
499: | } |
500: | |
501: | $method = $typeAndMethodName->getType() |
502: | ->getMethod($typeAndMethodName->getMethod(), $scope); |
503: | |
504: | if (!$scope->canCallMethod($method)) { |
505: | $acceptors[] = new InaccessibleMethod($method); |
506: | continue; |
507: | } |
508: | |
509: | array_push($acceptors, ...FunctionCallableVariant::createFromVariants($method, $method->getVariants())); |
510: | } |
511: | |
512: | return $acceptors; |
513: | } |
514: | |
515: | |
516: | public function findTypeAndMethodNames(): array |
517: | { |
518: | if (count($this->keyTypes) !== 2) { |
519: | return []; |
520: | } |
521: | |
522: | $classOrObject = null; |
523: | $method = null; |
524: | foreach ($this->keyTypes as $i => $keyType) { |
525: | if ($keyType->isSuperTypeOf(new ConstantIntegerType(0))->yes()) { |
526: | $classOrObject = $this->valueTypes[$i]; |
527: | continue; |
528: | } |
529: | |
530: | if (!$keyType->isSuperTypeOf(new ConstantIntegerType(1))->yes()) { |
531: | continue; |
532: | } |
533: | |
534: | $method = $this->valueTypes[$i]; |
535: | } |
536: | |
537: | if ($classOrObject === null || $method === null) { |
538: | return []; |
539: | } |
540: | |
541: | $callableArray = [$classOrObject, $method]; |
542: | |
543: | [$classOrObject, $methods] = $callableArray; |
544: | if (count($methods->getConstantStrings()) === 0) { |
545: | return [ConstantArrayTypeAndMethod::createUnknown()]; |
546: | } |
547: | |
548: | $type = $classOrObject->getObjectTypeOrClassStringObjectType(); |
549: | if (!$type->isObject()->yes()) { |
550: | return [ConstantArrayTypeAndMethod::createUnknown()]; |
551: | } |
552: | |
553: | $typeAndMethods = []; |
554: | $phpVersion = PhpVersionStaticAccessor::getInstance(); |
555: | foreach ($methods->getConstantStrings() as $methodName) { |
556: | $has = $type->hasMethod($methodName->getValue()); |
557: | if ($has->no()) { |
558: | continue; |
559: | } |
560: | |
561: | if ( |
562: | $has->yes() |
563: | && !$phpVersion->supportsCallableInstanceMethods() |
564: | ) { |
565: | $methodReflection = $type->getMethod($methodName->getValue(), new OutOfClassScope()); |
566: | if ($classOrObject->isString()->yes() && !$methodReflection->isStatic()) { |
567: | continue; |
568: | } |
569: | } |
570: | |
571: | if ($this->isOptionalKey(0) || $this->isOptionalKey(1)) { |
572: | $has = $has->and(TrinaryLogic::createMaybe()); |
573: | } |
574: | |
575: | $typeAndMethods[] = ConstantArrayTypeAndMethod::createConcrete($type, $methodName->getValue(), $has); |
576: | } |
577: | |
578: | return $typeAndMethods; |
579: | } |
580: | |
581: | public function hasOffsetValueType(Type $offsetType): TrinaryLogic |
582: | { |
583: | $offsetArrayKeyType = $offsetType->toArrayKey(); |
584: | |
585: | return $this->recursiveHasOffsetValueType($offsetArrayKeyType); |
586: | } |
587: | |
588: | private function recursiveHasOffsetValueType(Type $offsetType): TrinaryLogic |
589: | { |
590: | if ($offsetType instanceof UnionType) { |
591: | $results = []; |
592: | foreach ($offsetType->getTypes() as $innerType) { |
593: | $results[] = $this->recursiveHasOffsetValueType($innerType); |
594: | } |
595: | |
596: | return TrinaryLogic::extremeIdentity(...$results); |
597: | } |
598: | if ($offsetType instanceof IntegerRangeType) { |
599: | $finiteTypes = $offsetType->getFiniteTypes(); |
600: | if ($finiteTypes !== []) { |
601: | $results = []; |
602: | foreach ($finiteTypes as $innerType) { |
603: | $results[] = $this->recursiveHasOffsetValueType($innerType); |
604: | } |
605: | |
606: | return TrinaryLogic::extremeIdentity(...$results); |
607: | } |
608: | } |
609: | |
610: | $result = TrinaryLogic::createNo(); |
611: | foreach ($this->keyTypes as $i => $keyType) { |
612: | if ( |
613: | $keyType instanceof ConstantIntegerType |
614: | && !$offsetType->isString()->no() |
615: | && $offsetType->isConstantScalarValue()->no() |
616: | ) { |
617: | return TrinaryLogic::createMaybe(); |
618: | } |
619: | |
620: | $has = $keyType->isSuperTypeOf($offsetType); |
621: | if ($has->yes()) { |
622: | if ($this->isOptionalKey($i)) { |
623: | return TrinaryLogic::createMaybe(); |
624: | } |
625: | return TrinaryLogic::createYes(); |
626: | } |
627: | if (!$has->maybe()) { |
628: | continue; |
629: | } |
630: | |
631: | $result = TrinaryLogic::createMaybe(); |
632: | } |
633: | |
634: | return $result; |
635: | } |
636: | |
637: | public function getOffsetValueType(Type $offsetType): Type |
638: | { |
639: | if (count($this->keyTypes) === 0) { |
640: | return new ErrorType(); |
641: | } |
642: | |
643: | $offsetType = $offsetType->toArrayKey(); |
644: | $matchingValueTypes = []; |
645: | $all = true; |
646: | $maybeAll = true; |
647: | foreach ($this->keyTypes as $i => $keyType) { |
648: | if ($keyType->isSuperTypeOf($offsetType)->no()) { |
649: | $all = false; |
650: | |
651: | if ( |
652: | $keyType instanceof ConstantIntegerType |
653: | && !$offsetType->isString()->no() |
654: | && $offsetType->isConstantScalarValue()->no() |
655: | ) { |
656: | continue; |
657: | } |
658: | $maybeAll = false; |
659: | continue; |
660: | } |
661: | |
662: | $matchingValueTypes[] = $this->valueTypes[$i]; |
663: | } |
664: | |
665: | if ($all) { |
666: | return $this->getIterableValueType(); |
667: | } |
668: | |
669: | if (count($matchingValueTypes) > 0) { |
670: | $type = TypeCombinator::union(...$matchingValueTypes); |
671: | if ($type instanceof ErrorType) { |
672: | return new MixedType(); |
673: | } |
674: | |
675: | return $type; |
676: | } |
677: | |
678: | if ($maybeAll) { |
679: | return $this->getIterableValueType(); |
680: | } |
681: | |
682: | return new ErrorType(); |
683: | } |
684: | |
685: | public function setOffsetValueType(?Type $offsetType, Type $valueType, bool $unionValues = true): Type |
686: | { |
687: | $builder = ConstantArrayTypeBuilder::createFromConstantArray($this); |
688: | $builder->setOffsetValueType($offsetType, $valueType); |
689: | |
690: | return $builder->getArray(); |
691: | } |
692: | |
693: | public function setExistingOffsetValueType(Type $offsetType, Type $valueType): Type |
694: | { |
695: | $offsetType = $offsetType->toArrayKey(); |
696: | $builder = ConstantArrayTypeBuilder::createFromConstantArray($this); |
697: | foreach ($this->keyTypes as $keyType) { |
698: | if ($offsetType->isSuperTypeOf($keyType)->no()) { |
699: | continue; |
700: | } |
701: | |
702: | $builder->setOffsetValueType($keyType, $valueType); |
703: | } |
704: | |
705: | return $builder->getArray(); |
706: | } |
707: | |
708: | public function unsetOffset(Type $offsetType): Type |
709: | { |
710: | $offsetType = $offsetType->toArrayKey(); |
711: | if ($offsetType instanceof ConstantIntegerType || $offsetType instanceof ConstantStringType) { |
712: | foreach ($this->keyTypes as $i => $keyType) { |
713: | if ($keyType->getValue() !== $offsetType->getValue()) { |
714: | continue; |
715: | } |
716: | |
717: | $keyTypes = $this->keyTypes; |
718: | unset($keyTypes[$i]); |
719: | $valueTypes = $this->valueTypes; |
720: | unset($valueTypes[$i]); |
721: | |
722: | $newKeyTypes = []; |
723: | $newValueTypes = []; |
724: | $newOptionalKeys = []; |
725: | |
726: | $k = 0; |
727: | foreach ($keyTypes as $j => $newKeyType) { |
728: | $newKeyTypes[] = $newKeyType; |
729: | $newValueTypes[] = $valueTypes[$j]; |
730: | if (in_array($j, $this->optionalKeys, true)) { |
731: | $newOptionalKeys[] = $k; |
732: | } |
733: | $k++; |
734: | } |
735: | |
736: | return new self($newKeyTypes, $newValueTypes, $this->nextAutoIndexes, $newOptionalKeys, TrinaryLogic::createNo()); |
737: | } |
738: | |
739: | return $this; |
740: | } |
741: | |
742: | $constantScalars = $offsetType->getConstantScalarTypes(); |
743: | if (count($constantScalars) > 0) { |
744: | $optionalKeys = $this->optionalKeys; |
745: | |
746: | foreach ($constantScalars as $constantScalar) { |
747: | $constantScalar = $constantScalar->toArrayKey(); |
748: | if (!$constantScalar instanceof ConstantIntegerType && !$constantScalar instanceof ConstantStringType) { |
749: | continue; |
750: | } |
751: | |
752: | foreach ($this->keyTypes as $i => $keyType) { |
753: | if ($keyType->getValue() !== $constantScalar->getValue()) { |
754: | continue; |
755: | } |
756: | |
757: | if (in_array($i, $optionalKeys, true)) { |
758: | continue 2; |
759: | } |
760: | |
761: | $optionalKeys[] = $i; |
762: | } |
763: | } |
764: | |
765: | return new self($this->keyTypes, $this->valueTypes, $this->nextAutoIndexes, $optionalKeys, TrinaryLogic::createNo()); |
766: | } |
767: | |
768: | $optionalKeys = $this->optionalKeys; |
769: | $isList = $this->isList; |
770: | foreach ($this->keyTypes as $i => $keyType) { |
771: | if (!$offsetType->isSuperTypeOf($keyType)->yes()) { |
772: | continue; |
773: | } |
774: | $optionalKeys[] = $i; |
775: | $isList = TrinaryLogic::createNo(); |
776: | } |
777: | $optionalKeys = array_values(array_unique($optionalKeys)); |
778: | |
779: | return new self($this->keyTypes, $this->valueTypes, $this->nextAutoIndexes, $optionalKeys, $isList); |
780: | } |
781: | |
782: | public function chunkArray(Type $lengthType, TrinaryLogic $preserveKeys): Type |
783: | { |
784: | $biggerOne = IntegerRangeType::fromInterval(1, null); |
785: | $finiteTypes = $lengthType->getFiniteTypes(); |
786: | if ($biggerOne->isSuperTypeOf($lengthType)->yes() && count($finiteTypes) < self::CHUNK_FINITE_TYPES_LIMIT) { |
787: | $results = []; |
788: | foreach ($finiteTypes as $finiteType) { |
789: | if (!$finiteType instanceof ConstantIntegerType || $finiteType->getValue() < 1) { |
790: | return $this->traitChunkArray($lengthType, $preserveKeys); |
791: | } |
792: | |
793: | $length = $finiteType->getValue(); |
794: | |
795: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
796: | |
797: | $keyTypesCount = count($this->keyTypes); |
798: | for ($i = 0; $i < $keyTypesCount; $i += $length) { |
799: | $chunk = $this->sliceArray(new ConstantIntegerType($i), new ConstantIntegerType($length), TrinaryLogic::createYes()); |
800: | $builder->setOffsetValueType(null, $preserveKeys->yes() ? $chunk : $chunk->getValuesArray()); |
801: | } |
802: | |
803: | $results[] = $builder->getArray(); |
804: | } |
805: | |
806: | return TypeCombinator::union(...$results); |
807: | } |
808: | |
809: | return $this->traitChunkArray($lengthType, $preserveKeys); |
810: | } |
811: | |
812: | public function fillKeysArray(Type $valueType): Type |
813: | { |
814: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
815: | |
816: | foreach ($this->valueTypes as $i => $keyType) { |
817: | if ($keyType->isInteger()->no()) { |
818: | $stringKeyType = $keyType->toString(); |
819: | if ($stringKeyType instanceof ErrorType) { |
820: | return $stringKeyType; |
821: | } |
822: | |
823: | $builder->setOffsetValueType($stringKeyType, $valueType, $this->isOptionalKey($i)); |
824: | } else { |
825: | $builder->setOffsetValueType($keyType, $valueType, $this->isOptionalKey($i)); |
826: | } |
827: | } |
828: | |
829: | return $builder->getArray(); |
830: | } |
831: | |
832: | public function flipArray(): Type |
833: | { |
834: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
835: | |
836: | foreach ($this->keyTypes as $i => $keyType) { |
837: | $valueType = $this->valueTypes[$i]; |
838: | $builder->setOffsetValueType( |
839: | $valueType->toArrayKey(), |
840: | $keyType, |
841: | $this->isOptionalKey($i), |
842: | ); |
843: | } |
844: | |
845: | return $builder->getArray(); |
846: | } |
847: | |
848: | public function intersectKeyArray(Type $otherArraysType): Type |
849: | { |
850: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
851: | |
852: | foreach ($this->keyTypes as $i => $keyType) { |
853: | $valueType = $this->valueTypes[$i]; |
854: | $has = $otherArraysType->hasOffsetValueType($keyType); |
855: | if ($has->no()) { |
856: | continue; |
857: | } |
858: | $builder->setOffsetValueType($keyType, $valueType, $this->isOptionalKey($i) || !$has->yes()); |
859: | } |
860: | |
861: | return $builder->getArray(); |
862: | } |
863: | |
864: | public function popArray(): Type |
865: | { |
866: | return $this->removeLastElements(1); |
867: | } |
868: | |
869: | public function reverseArray(TrinaryLogic $preserveKeys): Type |
870: | { |
871: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
872: | |
873: | for ($i = count($this->keyTypes) - 1; $i >= 0; $i--) { |
874: | $offsetType = $preserveKeys->yes() || $this->keyTypes[$i]->isInteger()->no() |
875: | ? $this->keyTypes[$i] |
876: | : null; |
877: | $builder->setOffsetValueType($offsetType, $this->valueTypes[$i], $this->isOptionalKey($i)); |
878: | } |
879: | |
880: | return $builder->getArray(); |
881: | } |
882: | |
883: | public function searchArray(Type $needleType): Type |
884: | { |
885: | $matches = []; |
886: | $hasIdenticalValue = false; |
887: | |
888: | foreach ($this->valueTypes as $index => $valueType) { |
889: | $isNeedleSuperType = $valueType->isSuperTypeOf($needleType); |
890: | if ($isNeedleSuperType->no()) { |
891: | continue; |
892: | } |
893: | |
894: | if ($needleType instanceof ConstantScalarType && $valueType instanceof ConstantScalarType |
895: | && $needleType->getValue() === $valueType->getValue() |
896: | && !$this->isOptionalKey($index) |
897: | ) { |
898: | $hasIdenticalValue = true; |
899: | } |
900: | |
901: | $matches[] = $this->keyTypes[$index]; |
902: | } |
903: | |
904: | if (count($matches) > 0) { |
905: | if ($hasIdenticalValue) { |
906: | return TypeCombinator::union(...$matches); |
907: | } |
908: | |
909: | return TypeCombinator::union(new ConstantBooleanType(false), ...$matches); |
910: | } |
911: | |
912: | return new ConstantBooleanType(false); |
913: | } |
914: | |
915: | public function shiftArray(): Type |
916: | { |
917: | return $this->removeFirstElements(1); |
918: | } |
919: | |
920: | public function shuffleArray(): Type |
921: | { |
922: | $builder = ConstantArrayTypeBuilder::createFromConstantArray($this->getValuesArray()); |
923: | $builder->degradeToGeneralArray(); |
924: | |
925: | return $builder->getArray(); |
926: | } |
927: | |
928: | public function sliceArray(Type $offsetType, Type $lengthType, TrinaryLogic $preserveKeys): Type |
929: | { |
930: | $keyTypesCount = count($this->keyTypes); |
931: | if ($keyTypesCount === 0) { |
932: | return $this; |
933: | } |
934: | |
935: | $offset = $offsetType instanceof ConstantIntegerType ? $offsetType->getValue() : null; |
936: | |
937: | if ($lengthType instanceof ConstantIntegerType) { |
938: | $length = $lengthType->getValue(); |
939: | } elseif ($lengthType->isNull()->yes()) { |
940: | $length = $keyTypesCount; |
941: | } else { |
942: | $length = null; |
943: | } |
944: | |
945: | if ($offset === null || $length === null) { |
946: | $builder = ConstantArrayTypeBuilder::createFromConstantArray($this); |
947: | $builder->degradeToGeneralArray(); |
948: | |
949: | return $builder->getArray() |
950: | ->sliceArray($offsetType, $lengthType, $preserveKeys); |
951: | } |
952: | |
953: | if ($keyTypesCount + $offset <= 0) { |
954: | |
955: | $offset = 0; |
956: | } |
957: | |
958: | if ($keyTypesCount + $length <= 0) { |
959: | |
960: | $length = 0; |
961: | } |
962: | |
963: | if ($length === 0 || ($offset < 0 && $length < 0 && $offset - $length >= 0)) { |
964: | |
965: | return new self([], []); |
966: | } |
967: | |
968: | if ($length < 0) { |
969: | |
970: | return $this->removeLastElements($length * -1) |
971: | ->sliceArray($offsetType, new NullType(), $preserveKeys); |
972: | } |
973: | |
974: | if ($offset < 0) { |
975: | |
976: | |
977: | |
978: | |
979: | |
980: | |
981: | |
982: | |
983: | |
984: | |
985: | |
986: | |
987: | |
988: | $offset *= -1; |
989: | $reversedLength = min($length, $offset); |
990: | $reversedOffset = $offset - $reversedLength; |
991: | return $this->reverseArray(TrinaryLogic::createYes()) |
992: | ->sliceArray(new ConstantIntegerType($reversedOffset), new ConstantIntegerType($reversedLength), $preserveKeys) |
993: | ->reverseArray(TrinaryLogic::createYes()); |
994: | } |
995: | |
996: | if ($offset > 0) { |
997: | return $this->removeFirstElements($offset, false) |
998: | ->sliceArray(new ConstantIntegerType(0), $lengthType, $preserveKeys); |
999: | } |
1000: | |
1001: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
1002: | |
1003: | $nonOptionalElementsCount = 0; |
1004: | $hasOptional = false; |
1005: | for ($i = 0; $nonOptionalElementsCount < $length && $i < $keyTypesCount; $i++) { |
1006: | $isOptional = $this->isOptionalKey($i); |
1007: | if (!$isOptional) { |
1008: | $nonOptionalElementsCount++; |
1009: | } else { |
1010: | $hasOptional = true; |
1011: | } |
1012: | |
1013: | $isLastElement = $nonOptionalElementsCount >= $length || $i + 1 >= $keyTypesCount; |
1014: | if ($isLastElement && $length < $keyTypesCount && $hasOptional) { |
1015: | |
1016: | |
1017: | |
1018: | $isOptional = true; |
1019: | } |
1020: | |
1021: | $offsetType = $preserveKeys->yes() || $this->keyTypes[$i]->isInteger()->no() |
1022: | ? $this->keyTypes[$i] |
1023: | : null; |
1024: | |
1025: | $builder->setOffsetValueType($offsetType, $this->valueTypes[$i], $isOptional); |
1026: | } |
1027: | |
1028: | return $builder->getArray(); |
1029: | } |
1030: | |
1031: | public function isIterableAtLeastOnce(): TrinaryLogic |
1032: | { |
1033: | $keysCount = count($this->keyTypes); |
1034: | if ($keysCount === 0) { |
1035: | return TrinaryLogic::createNo(); |
1036: | } |
1037: | |
1038: | $optionalKeysCount = count($this->optionalKeys); |
1039: | if ($optionalKeysCount < $keysCount) { |
1040: | return TrinaryLogic::createYes(); |
1041: | } |
1042: | |
1043: | return TrinaryLogic::createMaybe(); |
1044: | } |
1045: | |
1046: | public function getArraySize(): Type |
1047: | { |
1048: | $optionalKeysCount = count($this->optionalKeys); |
1049: | $totalKeysCount = count($this->getKeyTypes()); |
1050: | if ($optionalKeysCount === 0) { |
1051: | return new ConstantIntegerType($totalKeysCount); |
1052: | } |
1053: | |
1054: | return IntegerRangeType::fromInterval($totalKeysCount - $optionalKeysCount, $totalKeysCount); |
1055: | } |
1056: | |
1057: | public function getFirstIterableKeyType(): Type |
1058: | { |
1059: | $keyTypes = []; |
1060: | foreach ($this->keyTypes as $i => $keyType) { |
1061: | $keyTypes[] = $keyType; |
1062: | if (!$this->isOptionalKey($i)) { |
1063: | break; |
1064: | } |
1065: | } |
1066: | |
1067: | return TypeCombinator::union(...$keyTypes); |
1068: | } |
1069: | |
1070: | public function getLastIterableKeyType(): Type |
1071: | { |
1072: | $keyTypes = []; |
1073: | for ($i = count($this->keyTypes) - 1; $i >= 0; $i--) { |
1074: | $keyTypes[] = $this->keyTypes[$i]; |
1075: | if (!$this->isOptionalKey($i)) { |
1076: | break; |
1077: | } |
1078: | } |
1079: | |
1080: | return TypeCombinator::union(...$keyTypes); |
1081: | } |
1082: | |
1083: | public function getFirstIterableValueType(): Type |
1084: | { |
1085: | $valueTypes = []; |
1086: | foreach ($this->valueTypes as $i => $valueType) { |
1087: | $valueTypes[] = $valueType; |
1088: | if (!$this->isOptionalKey($i)) { |
1089: | break; |
1090: | } |
1091: | } |
1092: | |
1093: | return TypeCombinator::union(...$valueTypes); |
1094: | } |
1095: | |
1096: | public function getLastIterableValueType(): Type |
1097: | { |
1098: | $valueTypes = []; |
1099: | for ($i = count($this->keyTypes) - 1; $i >= 0; $i--) { |
1100: | $valueTypes[] = $this->valueTypes[$i]; |
1101: | if (!$this->isOptionalKey($i)) { |
1102: | break; |
1103: | } |
1104: | } |
1105: | |
1106: | return TypeCombinator::union(...$valueTypes); |
1107: | } |
1108: | |
1109: | public function isConstantArray(): TrinaryLogic |
1110: | { |
1111: | return TrinaryLogic::createYes(); |
1112: | } |
1113: | |
1114: | public function isList(): TrinaryLogic |
1115: | { |
1116: | return $this->isList; |
1117: | } |
1118: | |
1119: | |
1120: | private function removeLastElements(int $length): self |
1121: | { |
1122: | $keyTypesCount = count($this->keyTypes); |
1123: | if ($keyTypesCount === 0) { |
1124: | return $this; |
1125: | } |
1126: | |
1127: | $keyTypes = $this->keyTypes; |
1128: | $valueTypes = $this->valueTypes; |
1129: | $optionalKeys = $this->optionalKeys; |
1130: | $nextAutoindexes = $this->nextAutoIndexes; |
1131: | |
1132: | $optionalKeysRemoved = 0; |
1133: | $newLength = $keyTypesCount - $length; |
1134: | for ($i = $keyTypesCount - 1; $i >= 0; $i--) { |
1135: | $isOptional = $this->isOptionalKey($i); |
1136: | |
1137: | if ($i >= $newLength) { |
1138: | if ($isOptional) { |
1139: | $optionalKeysRemoved++; |
1140: | foreach ($optionalKeys as $key => $value) { |
1141: | if ($value === $i) { |
1142: | unset($optionalKeys[$key]); |
1143: | break; |
1144: | } |
1145: | } |
1146: | } |
1147: | |
1148: | $removedKeyType = array_pop($keyTypes); |
1149: | array_pop($valueTypes); |
1150: | $nextAutoindexes = $removedKeyType instanceof ConstantIntegerType |
1151: | ? [$removedKeyType->getValue()] |
1152: | : $this->nextAutoIndexes; |
1153: | continue; |
1154: | } |
1155: | |
1156: | if ($isOptional || $optionalKeysRemoved <= 0) { |
1157: | continue; |
1158: | } |
1159: | |
1160: | $optionalKeys[] = $i; |
1161: | $optionalKeysRemoved--; |
1162: | } |
1163: | |
1164: | return new self( |
1165: | $keyTypes, |
1166: | $valueTypes, |
1167: | $nextAutoindexes, |
1168: | array_values($optionalKeys), |
1169: | $this->isList, |
1170: | ); |
1171: | } |
1172: | |
1173: | |
1174: | private function removeFirstElements(int $length, bool $reindex = true): Type |
1175: | { |
1176: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
1177: | |
1178: | $optionalKeysIgnored = 0; |
1179: | foreach ($this->keyTypes as $i => $keyType) { |
1180: | $isOptional = $this->isOptionalKey($i); |
1181: | if ($i <= $length - 1) { |
1182: | if ($isOptional) { |
1183: | $optionalKeysIgnored++; |
1184: | } |
1185: | continue; |
1186: | } |
1187: | |
1188: | if (!$isOptional && $optionalKeysIgnored > 0) { |
1189: | $isOptional = true; |
1190: | $optionalKeysIgnored--; |
1191: | } |
1192: | |
1193: | $valueType = $this->valueTypes[$i]; |
1194: | if ($reindex && $keyType instanceof ConstantIntegerType) { |
1195: | $keyType = null; |
1196: | } |
1197: | |
1198: | $builder->setOffsetValueType($keyType, $valueType, $isOptional); |
1199: | } |
1200: | |
1201: | return $builder->getArray(); |
1202: | } |
1203: | |
1204: | public function toBoolean(): BooleanType |
1205: | { |
1206: | return $this->getArraySize()->toBoolean(); |
1207: | } |
1208: | |
1209: | public function toInteger(): Type |
1210: | { |
1211: | return $this->toBoolean()->toInteger(); |
1212: | } |
1213: | |
1214: | public function toFloat(): Type |
1215: | { |
1216: | return $this->toBoolean()->toFloat(); |
1217: | } |
1218: | |
1219: | public function generalize(GeneralizePrecision $precision): Type |
1220: | { |
1221: | if (count($this->keyTypes) === 0) { |
1222: | return $this; |
1223: | } |
1224: | |
1225: | if ($precision->isTemplateArgument()) { |
1226: | return $this->traverse(static fn (Type $type) => $type->generalize($precision)); |
1227: | } |
1228: | |
1229: | $arrayType = new ArrayType( |
1230: | $this->getIterableKeyType()->generalize($precision), |
1231: | $this->getIterableValueType()->generalize($precision), |
1232: | ); |
1233: | |
1234: | $keyTypesCount = count($this->keyTypes); |
1235: | $optionalKeysCount = count($this->optionalKeys); |
1236: | |
1237: | $accessoryTypes = []; |
1238: | if ($precision->isMoreSpecific() && ($keyTypesCount - $optionalKeysCount) < 32) { |
1239: | foreach ($this->keyTypes as $i => $keyType) { |
1240: | if ($this->isOptionalKey($i)) { |
1241: | continue; |
1242: | } |
1243: | |
1244: | $accessoryTypes[] = new HasOffsetValueType($keyType, $this->valueTypes[$i]->generalize($precision)); |
1245: | } |
1246: | } elseif ($keyTypesCount > $optionalKeysCount) { |
1247: | $accessoryTypes[] = new NonEmptyArrayType(); |
1248: | } |
1249: | |
1250: | if ($this->isList()->yes()) { |
1251: | $arrayType = TypeCombinator::intersect($arrayType, new AccessoryArrayListType()); |
1252: | } |
1253: | |
1254: | if (count($accessoryTypes) > 0) { |
1255: | return TypeCombinator::intersect($arrayType, ...$accessoryTypes); |
1256: | } |
1257: | |
1258: | return $arrayType; |
1259: | } |
1260: | |
1261: | public function generalizeValues(): self |
1262: | { |
1263: | $valueTypes = []; |
1264: | foreach ($this->valueTypes as $valueType) { |
1265: | $valueTypes[] = $valueType->generalize(GeneralizePrecision::lessSpecific()); |
1266: | } |
1267: | |
1268: | return new self($this->keyTypes, $valueTypes, $this->nextAutoIndexes, $this->optionalKeys, $this->isList); |
1269: | } |
1270: | |
1271: | public function getKeysArray(): self |
1272: | { |
1273: | return $this->getKeysOrValuesArray($this->keyTypes); |
1274: | } |
1275: | |
1276: | public function getValuesArray(): self |
1277: | { |
1278: | return $this->getKeysOrValuesArray($this->valueTypes); |
1279: | } |
1280: | |
1281: | |
1282: | |
1283: | |
1284: | private function getKeysOrValuesArray(array $types): self |
1285: | { |
1286: | $count = count($types); |
1287: | $autoIndexes = range($count - count($this->optionalKeys), $count); |
1288: | assert($autoIndexes !== []); |
1289: | |
1290: | if ($this->isList->yes()) { |
1291: | |
1292: | $keyTypes = array_map( |
1293: | static fn (int $i): ConstantIntegerType => new ConstantIntegerType($i), |
1294: | array_keys($types), |
1295: | ); |
1296: | return new self($keyTypes, $types, $autoIndexes, $this->optionalKeys, TrinaryLogic::createYes()); |
1297: | } |
1298: | |
1299: | $keyTypes = []; |
1300: | $valueTypes = []; |
1301: | $optionalKeys = []; |
1302: | $maxIndex = 0; |
1303: | |
1304: | foreach ($types as $i => $type) { |
1305: | $keyTypes[] = new ConstantIntegerType($i); |
1306: | |
1307: | if ($this->isOptionalKey($maxIndex)) { |
1308: | |
1309: | do { |
1310: | $maxIndex++; |
1311: | } while ($maxIndex < $count && $this->isOptionalKey($maxIndex)); |
1312: | } |
1313: | |
1314: | if ($i === $maxIndex) { |
1315: | $valueTypes[] = $type; |
1316: | } else { |
1317: | $valueTypes[] = TypeCombinator::union(...array_slice($types, $i, $maxIndex - $i + 1)); |
1318: | if ($maxIndex >= $count) { |
1319: | $optionalKeys[] = $i; |
1320: | } |
1321: | } |
1322: | $maxIndex++; |
1323: | } |
1324: | |
1325: | return new self($keyTypes, $valueTypes, $autoIndexes, $optionalKeys, TrinaryLogic::createYes()); |
1326: | } |
1327: | |
1328: | public function describe(VerbosityLevel $level): string |
1329: | { |
1330: | $describeValue = function (bool $truncate) use ($level): string { |
1331: | $items = []; |
1332: | $values = []; |
1333: | $exportValuesOnly = true; |
1334: | foreach ($this->keyTypes as $i => $keyType) { |
1335: | $valueType = $this->valueTypes[$i]; |
1336: | if ($keyType->getValue() !== $i) { |
1337: | $exportValuesOnly = false; |
1338: | } |
1339: | |
1340: | $isOptional = $this->isOptionalKey($i); |
1341: | if ($isOptional) { |
1342: | $exportValuesOnly = false; |
1343: | } |
1344: | |
1345: | $keyDescription = $keyType->getValue(); |
1346: | if (is_string($keyDescription)) { |
1347: | if (str_contains($keyDescription, '"')) { |
1348: | $keyDescription = sprintf('\'%s\'', $keyDescription); |
1349: | } elseif (str_contains($keyDescription, '\'')) { |
1350: | $keyDescription = sprintf('"%s"', $keyDescription); |
1351: | } |
1352: | } |
1353: | |
1354: | $valueTypeDescription = $valueType->describe($level); |
1355: | $items[] = sprintf('%s%s: %s', $keyDescription, $isOptional ? '?' : '', $valueTypeDescription); |
1356: | $values[] = $valueTypeDescription; |
1357: | } |
1358: | |
1359: | $append = ''; |
1360: | if ($truncate && count($items) > self::DESCRIBE_LIMIT) { |
1361: | $items = array_slice($items, 0, self::DESCRIBE_LIMIT); |
1362: | $values = array_slice($values, 0, self::DESCRIBE_LIMIT); |
1363: | $append = ', ...'; |
1364: | } |
1365: | |
1366: | return sprintf( |
1367: | 'array{%s%s}', |
1368: | implode(', ', $exportValuesOnly ? $values : $items), |
1369: | $append, |
1370: | ); |
1371: | }; |
1372: | return $level->handle( |
1373: | fn (): string => $this->isIterableAtLeastOnce()->no() ? 'array' : sprintf('array<%s, %s>', $this->getIterableKeyType()->describe($level), $this->getIterableValueType()->describe($level)), |
1374: | static fn (): string => $describeValue(true), |
1375: | static fn (): string => $describeValue(false), |
1376: | ); |
1377: | } |
1378: | |
1379: | public function inferTemplateTypes(Type $receivedType): TemplateTypeMap |
1380: | { |
1381: | if ($receivedType instanceof UnionType || $receivedType instanceof IntersectionType) { |
1382: | return $receivedType->inferTemplateTypesOn($this); |
1383: | } |
1384: | |
1385: | if ($receivedType instanceof self) { |
1386: | $typeMap = TemplateTypeMap::createEmpty(); |
1387: | foreach ($this->keyTypes as $i => $keyType) { |
1388: | $valueType = $this->valueTypes[$i]; |
1389: | if ($receivedType->hasOffsetValueType($keyType)->no()) { |
1390: | continue; |
1391: | } |
1392: | $receivedValueType = $receivedType->getOffsetValueType($keyType); |
1393: | $typeMap = $typeMap->union($valueType->inferTemplateTypes($receivedValueType)); |
1394: | } |
1395: | |
1396: | return $typeMap; |
1397: | } |
1398: | |
1399: | if ($receivedType->isArray()->yes()) { |
1400: | $keyTypeMap = $this->getIterableKeyType()->inferTemplateTypes($receivedType->getIterableKeyType()); |
1401: | $itemTypeMap = $this->getIterableValueType()->inferTemplateTypes($receivedType->getIterableValueType()); |
1402: | |
1403: | return $keyTypeMap->union($itemTypeMap); |
1404: | } |
1405: | |
1406: | return TemplateTypeMap::createEmpty(); |
1407: | } |
1408: | |
1409: | public function getReferencedTemplateTypes(TemplateTypeVariance $positionVariance): array |
1410: | { |
1411: | $variance = $positionVariance->compose(TemplateTypeVariance::createCovariant()); |
1412: | $references = []; |
1413: | |
1414: | foreach ($this->keyTypes as $type) { |
1415: | foreach ($type->getReferencedTemplateTypes($variance) as $reference) { |
1416: | $references[] = $reference; |
1417: | } |
1418: | } |
1419: | |
1420: | foreach ($this->valueTypes as $type) { |
1421: | foreach ($type->getReferencedTemplateTypes($variance) as $reference) { |
1422: | $references[] = $reference; |
1423: | } |
1424: | } |
1425: | |
1426: | return $references; |
1427: | } |
1428: | |
1429: | public function tryRemove(Type $typeToRemove): ?Type |
1430: | { |
1431: | if ($typeToRemove->isConstantArray()->yes() && $typeToRemove->isIterableAtLeastOnce()->no()) { |
1432: | return TypeCombinator::intersect($this, new NonEmptyArrayType()); |
1433: | } |
1434: | |
1435: | if ($typeToRemove instanceof NonEmptyArrayType) { |
1436: | return new ConstantArrayType([], []); |
1437: | } |
1438: | |
1439: | if ($typeToRemove instanceof HasOffsetType) { |
1440: | return $this->unsetOffset($typeToRemove->getOffsetType()); |
1441: | } |
1442: | |
1443: | if ($typeToRemove instanceof HasOffsetValueType) { |
1444: | return $this->unsetOffset($typeToRemove->getOffsetType()); |
1445: | } |
1446: | |
1447: | return null; |
1448: | } |
1449: | |
1450: | public function traverse(callable $cb): Type |
1451: | { |
1452: | $valueTypes = []; |
1453: | |
1454: | $stillOriginal = true; |
1455: | foreach ($this->valueTypes as $valueType) { |
1456: | $transformedValueType = $cb($valueType); |
1457: | if ($transformedValueType !== $valueType) { |
1458: | $stillOriginal = false; |
1459: | } |
1460: | |
1461: | $valueTypes[] = $transformedValueType; |
1462: | } |
1463: | |
1464: | if ($stillOriginal) { |
1465: | return $this; |
1466: | } |
1467: | |
1468: | return new self($this->keyTypes, $valueTypes, $this->nextAutoIndexes, $this->optionalKeys, $this->isList); |
1469: | } |
1470: | |
1471: | public function traverseSimultaneously(Type $right, callable $cb): Type |
1472: | { |
1473: | if (!$right->isArray()->yes()) { |
1474: | return $this; |
1475: | } |
1476: | |
1477: | $valueTypes = []; |
1478: | |
1479: | $stillOriginal = true; |
1480: | foreach ($this->valueTypes as $i => $valueType) { |
1481: | $keyType = $this->keyTypes[$i]; |
1482: | $transformedValueType = $cb($valueType, $right->getOffsetValueType($keyType)); |
1483: | if ($transformedValueType !== $valueType) { |
1484: | $stillOriginal = false; |
1485: | } |
1486: | |
1487: | $valueTypes[] = $transformedValueType; |
1488: | } |
1489: | |
1490: | if ($stillOriginal) { |
1491: | return $this; |
1492: | } |
1493: | |
1494: | return new self($this->keyTypes, $valueTypes, $this->nextAutoIndexes, $this->optionalKeys, $this->isList); |
1495: | } |
1496: | |
1497: | public function isKeysSupersetOf(self $otherArray): bool |
1498: | { |
1499: | $keyTypesCount = count($this->keyTypes); |
1500: | $otherKeyTypesCount = count($otherArray->keyTypes); |
1501: | |
1502: | if ($keyTypesCount < $otherKeyTypesCount) { |
1503: | return false; |
1504: | } |
1505: | |
1506: | if ($otherKeyTypesCount === 0) { |
1507: | return $keyTypesCount === 0; |
1508: | } |
1509: | |
1510: | $failOnDifferentValueType = $keyTypesCount !== $otherKeyTypesCount || $keyTypesCount < 2; |
1511: | |
1512: | $keyTypes = $this->keyTypes; |
1513: | |
1514: | foreach ($otherArray->keyTypes as $j => $keyType) { |
1515: | $i = self::findKeyIndex($keyType, $keyTypes); |
1516: | if ($i === null) { |
1517: | return false; |
1518: | } |
1519: | |
1520: | unset($keyTypes[$i]); |
1521: | |
1522: | $valueType = $this->valueTypes[$i]; |
1523: | $otherValueType = $otherArray->valueTypes[$j]; |
1524: | if (!$otherValueType->isSuperTypeOf($valueType)->no()) { |
1525: | continue; |
1526: | } |
1527: | |
1528: | if ($failOnDifferentValueType) { |
1529: | return false; |
1530: | } |
1531: | $failOnDifferentValueType = true; |
1532: | } |
1533: | |
1534: | $requiredKeyCount = 0; |
1535: | foreach (array_keys($keyTypes) as $i) { |
1536: | if ($this->isOptionalKey($i)) { |
1537: | continue; |
1538: | } |
1539: | |
1540: | $requiredKeyCount++; |
1541: | if ($requiredKeyCount > 1) { |
1542: | return false; |
1543: | } |
1544: | } |
1545: | |
1546: | return true; |
1547: | } |
1548: | |
1549: | public function mergeWith(self $otherArray): self |
1550: | { |
1551: | |
1552: | $valueTypes = $this->valueTypes; |
1553: | $optionalKeys = $this->optionalKeys; |
1554: | foreach ($this->keyTypes as $i => $keyType) { |
1555: | $otherIndex = $otherArray->getKeyIndex($keyType); |
1556: | if ($otherIndex === null) { |
1557: | $optionalKeys[] = $i; |
1558: | continue; |
1559: | } |
1560: | if ($otherArray->isOptionalKey($otherIndex)) { |
1561: | $optionalKeys[] = $i; |
1562: | } |
1563: | $otherValueType = $otherArray->valueTypes[$otherIndex]; |
1564: | $valueTypes[$i] = TypeCombinator::union($valueTypes[$i], $otherValueType); |
1565: | } |
1566: | |
1567: | $optionalKeys = array_values(array_unique($optionalKeys)); |
1568: | |
1569: | $nextAutoIndexes = array_values(array_unique(array_merge($this->nextAutoIndexes, $otherArray->nextAutoIndexes))); |
1570: | sort($nextAutoIndexes); |
1571: | |
1572: | return new self($this->keyTypes, $valueTypes, $nextAutoIndexes, $optionalKeys, $this->isList->and($otherArray->isList)); |
1573: | } |
1574: | |
1575: | |
1576: | |
1577: | |
1578: | private function getKeyIndex($otherKeyType): ?int |
1579: | { |
1580: | return self::findKeyIndex($otherKeyType, $this->keyTypes); |
1581: | } |
1582: | |
1583: | |
1584: | |
1585: | |
1586: | |
1587: | private static function findKeyIndex($otherKeyType, array $keyTypes): ?int |
1588: | { |
1589: | foreach ($keyTypes as $i => $keyType) { |
1590: | if ($keyType->equals($otherKeyType)) { |
1591: | return $i; |
1592: | } |
1593: | } |
1594: | |
1595: | return null; |
1596: | } |
1597: | |
1598: | public function makeOffsetRequired(Type $offsetType): self |
1599: | { |
1600: | $offsetType = $offsetType->toArrayKey(); |
1601: | $optionalKeys = $this->optionalKeys; |
1602: | foreach ($this->keyTypes as $i => $keyType) { |
1603: | if (!$keyType->equals($offsetType)) { |
1604: | continue; |
1605: | } |
1606: | |
1607: | foreach ($optionalKeys as $j => $key) { |
1608: | if ($i === $key) { |
1609: | unset($optionalKeys[$j]); |
1610: | return new self($this->keyTypes, $this->valueTypes, $this->nextAutoIndexes, array_values($optionalKeys), $this->isList); |
1611: | } |
1612: | } |
1613: | |
1614: | break; |
1615: | } |
1616: | |
1617: | return $this; |
1618: | } |
1619: | |
1620: | public function toPhpDocNode(): TypeNode |
1621: | { |
1622: | $items = []; |
1623: | $values = []; |
1624: | $exportValuesOnly = true; |
1625: | foreach ($this->keyTypes as $i => $keyType) { |
1626: | if ($keyType->getValue() !== $i) { |
1627: | $exportValuesOnly = false; |
1628: | } |
1629: | $keyPhpDocNode = $keyType->toPhpDocNode(); |
1630: | if (!$keyPhpDocNode instanceof ConstTypeNode) { |
1631: | continue; |
1632: | } |
1633: | $valueType = $this->valueTypes[$i]; |
1634: | |
1635: | |
1636: | $keyNode = $keyPhpDocNode->constExpr; |
1637: | if ($keyNode instanceof ConstExprStringNode) { |
1638: | $value = $keyNode->value; |
1639: | if (self::isValidIdentifier($value)) { |
1640: | $keyNode = new IdentifierTypeNode($value); |
1641: | } |
1642: | } |
1643: | |
1644: | $isOptional = $this->isOptionalKey($i); |
1645: | if ($isOptional) { |
1646: | $exportValuesOnly = false; |
1647: | } |
1648: | $items[] = new ArrayShapeItemNode( |
1649: | $keyNode, |
1650: | $isOptional, |
1651: | $valueType->toPhpDocNode(), |
1652: | ); |
1653: | $values[] = new ArrayShapeItemNode( |
1654: | null, |
1655: | $isOptional, |
1656: | $valueType->toPhpDocNode(), |
1657: | ); |
1658: | } |
1659: | |
1660: | return ArrayShapeNode::createSealed($exportValuesOnly ? $values : $items); |
1661: | } |
1662: | |
1663: | public static function isValidIdentifier(string $value): bool |
1664: | { |
1665: | $result = Strings::match($value, '~^(?:[\\\\]?+[a-z_\\x80-\\xFF][0-9a-z_\\x80-\\xFF-]*+)++$~si'); |
1666: | |
1667: | return $result !== null; |
1668: | } |
1669: | |
1670: | public function getFiniteTypes(): array |
1671: | { |
1672: | $arraysArraysForCombinations = []; |
1673: | $count = 0; |
1674: | foreach ($this->getAllArrays() as $array) { |
1675: | $values = $array->getValueTypes(); |
1676: | $arraysForCombinations = []; |
1677: | $combinationCount = 1; |
1678: | foreach ($values as $valueType) { |
1679: | $finiteTypes = $valueType->getFiniteTypes(); |
1680: | if ($finiteTypes === []) { |
1681: | return []; |
1682: | } |
1683: | $arraysForCombinations[] = $finiteTypes; |
1684: | $combinationCount *= count($finiteTypes); |
1685: | } |
1686: | $arraysArraysForCombinations[] = $arraysForCombinations; |
1687: | $count += $combinationCount; |
1688: | } |
1689: | |
1690: | if ($count > InitializerExprTypeResolver::CALCULATE_SCALARS_LIMIT) { |
1691: | return []; |
1692: | } |
1693: | |
1694: | $finiteTypes = []; |
1695: | foreach ($arraysArraysForCombinations as $arraysForCombinations) { |
1696: | $combinations = CombinationsHelper::combinations($arraysForCombinations); |
1697: | foreach ($combinations as $combination) { |
1698: | $builder = ConstantArrayTypeBuilder::createEmpty(); |
1699: | foreach ($combination as $i => $v) { |
1700: | $builder->setOffsetValueType($this->keyTypes[$i], $v); |
1701: | } |
1702: | $finiteTypes[] = $builder->getArray(); |
1703: | } |
1704: | } |
1705: | |
1706: | return $finiteTypes; |
1707: | } |
1708: | |
1709: | } |
1710: | |