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