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