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