File src/Type/Accessory/HasOffsetType.php

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:

Namespaces

Classes