File src/Type/IterableType.php

1:	<?php declare(strict_types = 1);
2:
3:	namespace PHPStan\Type;
4:
5:	use PHPStan\Php\PhpVersion;
6:	use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
7:	use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
8:	use PHPStan\PhpDocParser\Ast\Type\TypeNode;
9:	use PHPStan\TrinaryLogic;
10:	use PHPStan\Type\Generic\GenericObjectType;
11:	use PHPStan\Type\Generic\TemplateMixedType;
12:	use PHPStan\Type\Generic\TemplateTypeMap;
13:	use PHPStan\Type\Generic\TemplateTypeVariance;
14:	use PHPStan\Type\Traits\MaybeArrayTypeTrait;
15:	use PHPStan\Type\Traits\MaybeCallableTypeTrait;
16:	use PHPStan\Type\Traits\MaybeObjectTypeTrait;
17:	use PHPStan\Type\Traits\MaybeOffsetAccessibleTypeTrait;
18:	use PHPStan\Type\Traits\NonGeneralizableTypeTrait;
19:	use PHPStan\Type\Traits\UndecidedBooleanTypeTrait;
20:	use PHPStan\Type\Traits\UndecidedComparisonCompoundTypeTrait;
21:	use Traversable;
22:	use function array_merge;
23:	use function sprintf;
24:
25:	/** @api */
26:	class IterableType implements CompoundType
27:	{
28:
29:	use MaybeArrayTypeTrait;
30:	use MaybeCallableTypeTrait;
31:	use MaybeObjectTypeTrait;
32:	use MaybeOffsetAccessibleTypeTrait;
33:	use UndecidedBooleanTypeTrait;
34:	use UndecidedComparisonCompoundTypeTrait;
35:	use NonGeneralizableTypeTrait;
36:
37:	/** @api */
38:	public function __construct(
39:	private Type $keyType,
40:	private Type $itemType,
41:	)
42:	{
43:	}
44:
45:	public function getKeyType(): Type
46:	{
47:	return $this->keyType;
48:	}
49:
50:	public function getItemType(): Type
51:	{
52:	return $this->itemType;
53:	}
54:
55:	public function getReferencedClasses(): array
56:	{
57:	return array_merge(
58:	$this->keyType->getReferencedClasses(),
59:	$this->getItemType()->getReferencedClasses(),
60:	);
61:	}
62:
63:	public function getObjectClassNames(): array
64:	{
65:	return [];
66:	}
67:
68:	public function getObjectClassReflections(): array
69:	{
70:	return [];
71:	}
72:
73:	public function getConstantStrings(): array
74:	{
75:	return [];
76:	}
77:
78:	public function accepts(Type $type, bool $strictTypes): AcceptsResult
79:	{
80:	if ($type->isConstantArray()->yes() && $type->isIterableAtLeastOnce()->no()) {
81:	return AcceptsResult::createYes();
82:	}
83:	if ($type->isIterable()->yes()) {
84:	return $this->getIterableValueType()->accepts($type->getIterableValueType(), $strictTypes)
85:	->and($this->getIterableKeyType()->accepts($type->getIterableKeyType(), $strictTypes));
86:	}
87:
88:	if ($type instanceof CompoundType) {
89:	return $type->isAcceptedBy($this, $strictTypes);
90:	}
91:
92:	return AcceptsResult::createNo();
93:	}
94:
95:	public function isSuperTypeOf(Type $type): IsSuperTypeOfResult
96:	{
97:	if ($type instanceof CompoundType) {
98:	return $type->isSubTypeOf($this);
99:	}
100:
101:	return (new IsSuperTypeOfResult($type->isIterable(), []))
102:	->and($this->getIterableValueType()->isSuperTypeOf($type->getIterableValueType()))
103:	->and($this->getIterableKeyType()->isSuperTypeOf($type->getIterableKeyType()));
104:	}
105:
106:	public function isSuperTypeOfMixed(Type $type): IsSuperTypeOfResult
107:	{
108:	return (new IsSuperTypeOfResult($type->isIterable(), []))
109:	->and($this->isNestedTypeSuperTypeOf($this->getIterableValueType(), $type->getIterableValueType()))
110:	->and($this->isNestedTypeSuperTypeOf($this->getIterableKeyType(), $type->getIterableKeyType()));
111:	}
112:
113:	private function isNestedTypeSuperTypeOf(Type $a, Type $b): IsSuperTypeOfResult
114:	{
115:	if (!$a instanceof MixedType \|\| !$b instanceof MixedType) {
116:	return $a->isSuperTypeOf($b);
117:	}
118:
119:	if ($a instanceof TemplateMixedType \|\| $b instanceof TemplateMixedType) {
120:	return $a->isSuperTypeOf($b);
121:	}
122:
123:	if ($a->isExplicitMixed()) {
124:	if ($b->isExplicitMixed()) {
125:	return IsSuperTypeOfResult::createYes();
126:	}
127:
128:	return IsSuperTypeOfResult::createMaybe();
129:	}
130:
131:	return IsSuperTypeOfResult::createYes();
132:	}
133:
134:	public function isSubTypeOf(Type $otherType): IsSuperTypeOfResult
135:	{
136:	if ($otherType instanceof IntersectionType \|\| $otherType instanceof UnionType) {
137:	return $otherType->isSuperTypeOf(new UnionType([
138:	new ArrayType($this->keyType, $this->itemType),
139:	new IntersectionType([
140:	new ObjectType(Traversable::class),
141:	$this,
142:	]),
143:	]));
144:	}
145:
146:	if ($otherType instanceof self) {
147:	$limit = IsSuperTypeOfResult::createYes();
148:	} else {
149:	$limit = IsSuperTypeOfResult::createMaybe();
150:	}
151:
152:	if ($otherType->isConstantArray()->yes() && $otherType->isIterableAtLeastOnce()->no()) {
153:	return IsSuperTypeOfResult::createMaybe();
154:	}
155:
156:	return $limit->and(
157:	new IsSuperTypeOfResult($otherType->isIterable(), []),
158:	$otherType->getIterableValueType()->isSuperTypeOf($this->itemType),
159:	$otherType->getIterableKeyType()->isSuperTypeOf($this->keyType),
160:	);
161:	}
162:
163:	public function isAcceptedBy(Type $acceptingType, bool $strictTypes): AcceptsResult
164:	{
165:	return $this->isSubTypeOf($acceptingType)->toAcceptsResult();
166:	}
167:
168:	public function equals(Type $type): bool
169:	{
170:	if (!$type instanceof self) {
171:	return false;
172:	}
173:
174:	return $this->keyType->equals($type->keyType)
175:	&& $this->itemType->equals($type->itemType);
176:	}
177:
178:	public function describe(VerbosityLevel $level): string
179:	{
180:	$isMixedKeyType = $this->keyType instanceof MixedType && $this->keyType->describe(VerbosityLevel::precise()) === 'mixed';
181:	$isMixedItemType = $this->itemType instanceof MixedType && $this->itemType->describe(VerbosityLevel::precise()) === 'mixed';
182:	if ($isMixedKeyType) {
183:	if ($isMixedItemType) {
184:	return 'iterable';
185:	}
186:
187:	return sprintf('iterable<%s>', $this->itemType->describe($level));
188:	}
189:
190:	return sprintf('iterable<%s, %s>', $this->keyType->describe($level), $this->itemType->describe($level));
191:	}
192:
193:	public function hasOffsetValueType(Type $offsetType): TrinaryLogic
194:	{
195:	if ($this->getIterableKeyType()->isSuperTypeOf($offsetType)->no()) {
196:	return TrinaryLogic::createNo();
197:	}
198:
199:	return TrinaryLogic::createMaybe();
200:	}
201:
202:	public function toNumber(): Type
203:	{
204:	return new ErrorType();
205:	}
206:
207:	public function toAbsoluteNumber(): Type
208:	{
209:	return new ErrorType();
210:	}
211:
212:	public function toString(): Type
213:	{
214:	return new ErrorType();
215:	}
216:
217:	public function toInteger(): Type
218:	{
219:	return new ErrorType();
220:	}
221:
222:	public function toFloat(): Type
223:	{
224:	return new ErrorType();
225:	}
226:
227:	public function toArray(): Type
228:	{
229:	return new ArrayType($this->keyType, $this->getItemType());
230:	}
231:
232:	public function toArrayKey(): Type
233:	{
234:	return new ErrorType();
235:	}
236:
237:	public function isOffsetAccessLegal(): TrinaryLogic
238:	{
239:	return TrinaryLogic::createMaybe();
240:	}
241:
242:	public function isIterable(): TrinaryLogic
243:	{
244:	return TrinaryLogic::createYes();
245:	}
246:
247:	public function isIterableAtLeastOnce(): TrinaryLogic
248:	{
249:	return TrinaryLogic::createMaybe();
250:	}
251:
252:	public function getArraySize(): Type
253:	{
254:	return IntegerRangeType::fromInterval(0, null);
255:	}
256:
257:	public function getIterableKeyType(): Type
258:	{
259:	return $this->keyType;
260:	}
261:
262:	public function getFirstIterableKeyType(): Type
263:	{
264:	return $this->keyType;
265:	}
266:
267:	public function getLastIterableKeyType(): Type
268:	{
269:	return $this->keyType;
270:	}
271:
272:	public function getIterableValueType(): Type
273:	{
274:	return $this->getItemType();
275:	}
276:
277:	public function getFirstIterableValueType(): Type
278:	{
279:	return $this->getItemType();
280:	}
281:
282:	public function getLastIterableValueType(): Type
283:	{
284:	return $this->getItemType();
285:	}
286:
287:	public function isNull(): TrinaryLogic
288:	{
289:	return TrinaryLogic::createNo();
290:	}
291:
292:	public function isConstantValue(): TrinaryLogic
293:	{
294:	return TrinaryLogic::createNo();
295:	}
296:
297:	public function isConstantScalarValue(): TrinaryLogic
298:	{
299:	return TrinaryLogic::createNo();
300:	}
301:
302:	public function getConstantScalarTypes(): array
303:	{
304:	return [];
305:	}
306:
307:	public function getConstantScalarValues(): array
308:	{
309:	return [];
310:	}
311:
312:	public function isTrue(): TrinaryLogic
313:	{
314:	return TrinaryLogic::createNo();
315:	}
316:
317:	public function isFalse(): TrinaryLogic
318:	{
319:	return TrinaryLogic::createNo();
320:	}
321:
322:	public function isBoolean(): TrinaryLogic
323:	{
324:	return TrinaryLogic::createNo();
325:	}
326:
327:	public function isFloat(): TrinaryLogic
328:	{
329:	return TrinaryLogic::createNo();
330:	}
331:
332:	public function isInteger(): TrinaryLogic
333:	{
334:	return TrinaryLogic::createNo();
335:	}
336:
337:	public function isString(): TrinaryLogic
338:	{
339:	return TrinaryLogic::createNo();
340:	}
341:
342:	public function isNumericString(): TrinaryLogic
343:	{
344:	return TrinaryLogic::createNo();
345:	}
346:
347:	public function isNonEmptyString(): TrinaryLogic
348:	{
349:	return TrinaryLogic::createNo();
350:	}
351:
352:	public function isNonFalsyString(): TrinaryLogic
353:	{
354:	return TrinaryLogic::createNo();
355:	}
356:
357:	public function isLiteralString(): TrinaryLogic
358:	{
359:	return TrinaryLogic::createNo();
360:	}
361:
362:	public function isLowercaseString(): TrinaryLogic
363:	{
364:	return TrinaryLogic::createNo();
365:	}
366:
367:	public function isClassString(): TrinaryLogic
368:	{
369:	return TrinaryLogic::createNo();
370:	}
371:
372:	public function getClassStringObjectType(): Type
373:	{
374:	return new ErrorType();
375:	}
376:
377:	public function getObjectTypeOrClassStringObjectType(): Type
378:	{
379:	return new ObjectWithoutClassType();
380:	}
381:
382:	public function isVoid(): TrinaryLogic
383:	{
384:	return TrinaryLogic::createNo();
385:	}
386:
387:	public function isScalar(): TrinaryLogic
388:	{
389:	return TrinaryLogic::createNo();
390:	}
391:
392:	public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType
393:	{
394:	return new BooleanType();
395:	}
396:
397:	public function getEnumCases(): array
398:	{
399:	return [];
400:	}
401:
402:	public function inferTemplateTypes(Type $receivedType): TemplateTypeMap
403:	{
404:	if ($receivedType instanceof UnionType \|\| $receivedType instanceof IntersectionType) {
405:	return $receivedType->inferTemplateTypesOn($this);
406:	}
407:
408:	if (!$receivedType->isIterable()->yes()) {
409:	return TemplateTypeMap::createEmpty();
410:	}
411:
412:	$keyTypeMap = $this->getIterableKeyType()->inferTemplateTypes($receivedType->getIterableKeyType());
413:	$valueTypeMap = $this->getIterableValueType()->inferTemplateTypes($receivedType->getIterableValueType());
414:
415:	return $keyTypeMap->union($valueTypeMap);
416:	}
417:
418:	public function getReferencedTemplateTypes(TemplateTypeVariance $positionVariance): array
419:	{
420:	$variance = $positionVariance->compose(TemplateTypeVariance::createCovariant());
421:
422:	return array_merge(
423:	$this->getIterableKeyType()->getReferencedTemplateTypes($variance),
424:	$this->getIterableValueType()->getReferencedTemplateTypes($variance),
425:	);
426:	}
427:
428:	public function traverse(callable $cb): Type
429:	{
430:	$keyType = $cb($this->keyType);
431:	$itemType = $cb($this->itemType);
432:
433:	if ($keyType !== $this->keyType \|\| $itemType !== $this->itemType) {
434:	return new self($keyType, $itemType);
435:	}
436:
437:	return $this;
438:	}
439:
440:	public function traverseSimultaneously(Type $right, callable $cb): Type
441:	{
442:	$keyType = $cb($this->keyType, $right->getIterableKeyType());
443:	$itemType = $cb($this->itemType, $right->getIterableValueType());
444:
445:	if ($keyType !== $this->keyType \|\| $itemType !== $this->itemType) {
446:	return new self($keyType, $itemType);
447:	}
448:
449:	return $this;
450:	}
451:
452:	public function tryRemove(Type $typeToRemove): ?Type
453:	{
454:	$arrayType = new ArrayType(new MixedType(), new MixedType());
455:	if ($typeToRemove->isSuperTypeOf($arrayType)->yes()) {
456:	return new GenericObjectType(Traversable::class, [
457:	$this->getIterableKeyType(),
458:	$this->getIterableValueType(),
459:	]);
460:	}
461:
462:	$traversableType = new ObjectType(Traversable::class);
463:	if ($typeToRemove->isSuperTypeOf($traversableType)->yes()) {
464:	return new ArrayType($this->getIterableKeyType(), $this->getIterableValueType());
465:	}
466:
467:	return null;
468:	}
469:
470:	public function exponentiate(Type $exponent): Type
471:	{
472:	return new ErrorType();
473:	}
474:
475:	public function getFiniteTypes(): array
476:	{
477:	return [];
478:	}
479:
480:	public function toPhpDocNode(): TypeNode
481:	{
482:	$isMixedKeyType = $this->keyType instanceof MixedType && $this->keyType->describe(VerbosityLevel::precise()) === 'mixed';
483:	$isMixedItemType = $this->itemType instanceof MixedType && $this->itemType->describe(VerbosityLevel::precise()) === 'mixed';
484:
485:	if ($isMixedKeyType) {
486:	if ($isMixedItemType) {
487:	return new IdentifierTypeNode('iterable');
488:	}
489:
490:	return new GenericTypeNode(
491:	new IdentifierTypeNode('iterable'),
492:	[
493:	$this->itemType->toPhpDocNode(),
494:	],
495:	);
496:	}
497:
498:	return new GenericTypeNode(
499:	new IdentifierTypeNode('iterable'),
500:	[
501:	$this->keyType->toPhpDocNode(),
502:	$this->itemType->toPhpDocNode(),
503:	],
504:	);
505:	}
506:
507:	}
508:

Namespaces

Classes

Interfaces