File src/Type/NeverType.php

1:	<?php declare(strict_types = 1);
2:
3:	namespace PHPStan\Type;
4:
5:	use PHPStan\Reflection\ClassMemberAccessAnswerer;
6:	use PHPStan\Reflection\ConstantReflection;
7:	use PHPStan\Reflection\ExtendedMethodReflection;
8:	use PHPStan\Reflection\ParametersAcceptor;
9:	use PHPStan\Reflection\PropertyReflection;
10:	use PHPStan\Reflection\TrivialParametersAcceptor;
11:	use PHPStan\Reflection\Type\UnresolvedMethodPrototypeReflection;
12:	use PHPStan\Reflection\Type\UnresolvedPropertyPrototypeReflection;
13:	use PHPStan\ShouldNotHappenException;
14:	use PHPStan\TrinaryLogic;
15:	use PHPStan\Type\Traits\NonGeneralizableTypeTrait;
16:	use PHPStan\Type\Traits\NonGenericTypeTrait;
17:	use PHPStan\Type\Traits\NonRemoveableTypeTrait;
18:	use PHPStan\Type\Traits\UndecidedBooleanTypeTrait;
19:	use PHPStan\Type\Traits\UndecidedComparisonCompoundTypeTrait;
20:
21:	/** @api */
22:	class NeverType implements CompoundType
23:	{
24:
25:	use UndecidedBooleanTypeTrait;
26:	use NonGenericTypeTrait;
27:	use UndecidedComparisonCompoundTypeTrait;
28:	use NonRemoveableTypeTrait;
29:	use NonGeneralizableTypeTrait;
30:
31:	/** @api */
32:	public function __construct(private bool $isExplicit = false)
33:	{
34:	}
35:
36:	public function isExplicit(): bool
37:	{
38:	return $this->isExplicit;
39:	}
40:
41:	/**
42:	* @return string[]
43:	*/
44:	public function getReferencedClasses(): array
45:	{
46:	return [];
47:	}
48:
49:	public function getArrays(): array
50:	{
51:	return [];
52:	}
53:
54:	public function getConstantArrays(): array
55:	{
56:	return [];
57:	}
58:
59:	public function getConstantStrings(): array
60:	{
61:	return [];
62:	}
63:
64:	public function accepts(Type $type, bool $strictTypes): TrinaryLogic
65:	{
66:	return TrinaryLogic::createYes();
67:	}
68:
69:	public function isSuperTypeOf(Type $type): TrinaryLogic
70:	{
71:	if ($type instanceof self) {
72:	return TrinaryLogic::createYes();
73:	}
74:
75:	return TrinaryLogic::createNo();
76:	}
77:
78:	public function equals(Type $type): bool
79:	{
80:	return $type instanceof self;
81:	}
82:
83:	public function isSubTypeOf(Type $otherType): TrinaryLogic
84:	{
85:	return TrinaryLogic::createYes();
86:	}
87:
88:	public function isAcceptedBy(Type $acceptingType, bool $strictTypes): TrinaryLogic
89:	{
90:	return $this->isSubTypeOf($acceptingType);
91:	}
92:
93:	public function describe(VerbosityLevel $level): string
94:	{
95:	return 'NEVER';
96:	}
97:
98:	public function canAccessProperties(): TrinaryLogic
99:	{
100:	return TrinaryLogic::createYes();
101:	}
102:
103:	public function hasProperty(string $propertyName): TrinaryLogic
104:	{
105:	return TrinaryLogic::createNo();
106:	}
107:
108:	public function getProperty(string $propertyName, ClassMemberAccessAnswerer $scope): PropertyReflection
109:	{
110:	throw new ShouldNotHappenException();
111:	}
112:
113:	public function getUnresolvedPropertyPrototype(string $propertyName, ClassMemberAccessAnswerer $scope): UnresolvedPropertyPrototypeReflection
114:	{
115:	throw new ShouldNotHappenException();
116:	}
117:
118:	public function canCallMethods(): TrinaryLogic
119:	{
120:	return TrinaryLogic::createYes();
121:	}
122:
123:	public function hasMethod(string $methodName): TrinaryLogic
124:	{
125:	return TrinaryLogic::createNo();
126:	}
127:
128:	public function getMethod(string $methodName, ClassMemberAccessAnswerer $scope): ExtendedMethodReflection
129:	{
130:	throw new ShouldNotHappenException();
131:	}
132:
133:	public function getUnresolvedMethodPrototype(string $methodName, ClassMemberAccessAnswerer $scope): UnresolvedMethodPrototypeReflection
134:	{
135:	throw new ShouldNotHappenException();
136:	}
137:
138:	public function canAccessConstants(): TrinaryLogic
139:	{
140:	return TrinaryLogic::createYes();
141:	}
142:
143:	public function hasConstant(string $constantName): TrinaryLogic
144:	{
145:	return TrinaryLogic::createNo();
146:	}
147:
148:	public function getConstant(string $constantName): ConstantReflection
149:	{
150:	throw new ShouldNotHappenException();
151:	}
152:
153:	public function isIterable(): TrinaryLogic
154:	{
155:	return TrinaryLogic::createYes();
156:	}
157:
158:	public function isIterableAtLeastOnce(): TrinaryLogic
159:	{
160:	return TrinaryLogic::createMaybe();
161:	}
162:
163:	public function getArraySize(): Type
164:	{
165:	return new NeverType();
166:	}
167:
168:	public function getIterableKeyType(): Type
169:	{
170:	return new NeverType();
171:	}
172:
173:	public function getFirstIterableKeyType(): Type
174:	{
175:	return new NeverType();
176:	}
177:
178:	public function getLastIterableKeyType(): Type
179:	{
180:	return new NeverType();
181:	}
182:
183:	public function getIterableValueType(): Type
184:	{
185:	return new NeverType();
186:	}
187:
188:	public function getFirstIterableValueType(): Type
189:	{
190:	return new NeverType();
191:	}
192:
193:	public function getLastIterableValueType(): Type
194:	{
195:	return new NeverType();
196:	}
197:
198:	public function isArray(): TrinaryLogic
199:	{
200:	return TrinaryLogic::createNo();
201:	}
202:
203:	public function isConstantArray(): TrinaryLogic
204:	{
205:	return TrinaryLogic::createNo();
206:	}
207:
208:	public function isOversizedArray(): TrinaryLogic
209:	{
210:	return TrinaryLogic::createNo();
211:	}
212:
213:	public function isList(): TrinaryLogic
214:	{
215:	return TrinaryLogic::createNo();
216:	}
217:
218:	public function isOffsetAccessible(): TrinaryLogic
219:	{
220:	return TrinaryLogic::createYes();
221:	}
222:
223:	public function hasOffsetValueType(Type $offsetType): TrinaryLogic
224:	{
225:	return TrinaryLogic::createYes();
226:	}
227:
228:	public function getOffsetValueType(Type $offsetType): Type
229:	{
230:	return new NeverType();
231:	}
232:
233:	public function setOffsetValueType(?Type $offsetType, Type $valueType, bool $unionValues = true): Type
234:	{
235:	return new ErrorType();
236:	}
237:
238:	public function unsetOffset(Type $offsetType): Type
239:	{
240:	return new NeverType();
241:	}
242:
243:	public function getKeysArray(): Type
244:	{
245:	return new NeverType();
246:	}
247:
248:	public function getValuesArray(): Type
249:	{
250:	return new NeverType();
251:	}
252:
253:	public function fillKeysArray(Type $valueType): Type
254:	{
255:	return new NeverType();
256:	}
257:
258:	public function flipArray(): Type
259:	{
260:	return new NeverType();
261:	}
262:
263:	public function intersectKeyArray(Type $otherArraysType): Type
264:	{
265:	return new NeverType();
266:	}
267:
268:	public function popArray(): Type
269:	{
270:	return new NeverType();
271:	}
272:
273:	public function searchArray(Type $needleType): Type
274:	{
275:	return new NeverType();
276:	}
277:
278:	public function shiftArray(): Type
279:	{
280:	return new NeverType();
281:	}
282:
283:	public function shuffleArray(): Type
284:	{
285:	return new NeverType();
286:	}
287:
288:	public function isCallable(): TrinaryLogic
289:	{
290:	return TrinaryLogic::createYes();
291:	}
292:
293:	/**
294:	* @return ParametersAcceptor[]
295:	*/
296:	public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope): array
297:	{
298:	return [new TrivialParametersAcceptor()];
299:	}
300:
301:	public function isCloneable(): TrinaryLogic
302:	{
303:	return TrinaryLogic::createYes();
304:	}
305:
306:	public function toNumber(): Type
307:	{
308:	return $this;
309:	}
310:
311:	public function toString(): Type
312:	{
313:	return $this;
314:	}
315:
316:	public function toInteger(): Type
317:	{
318:	return $this;
319:	}
320:
321:	public function toFloat(): Type
322:	{
323:	return $this;
324:	}
325:
326:	public function toArray(): Type
327:	{
328:	return $this;
329:	}
330:
331:	public function toArrayKey(): Type
332:	{
333:	return $this;
334:	}
335:
336:	public function traverse(callable $cb): Type
337:	{
338:	return $this;
339:	}
340:
341:	public function isNull(): TrinaryLogic
342:	{
343:	return TrinaryLogic::createNo();
344:	}
345:
346:	public function isTrue(): TrinaryLogic
347:	{
348:	return TrinaryLogic::createNo();
349:	}
350:
351:	public function isFalse(): TrinaryLogic
352:	{
353:	return TrinaryLogic::createNo();
354:	}
355:
356:	public function isBoolean(): TrinaryLogic
357:	{
358:	return TrinaryLogic::createNo();
359:	}
360:
361:	public function isFloat(): TrinaryLogic
362:	{
363:	return TrinaryLogic::createNo();
364:	}
365:
366:	public function isInteger(): TrinaryLogic
367:	{
368:	return TrinaryLogic::createNo();
369:	}
370:
371:	public function isString(): TrinaryLogic
372:	{
373:	return TrinaryLogic::createNo();
374:	}
375:
376:	public function isNumericString(): TrinaryLogic
377:	{
378:	return TrinaryLogic::createNo();
379:	}
380:
381:	public function isNonEmptyString(): TrinaryLogic
382:	{
383:	return TrinaryLogic::createNo();
384:	}
385:
386:	public function isNonFalsyString(): TrinaryLogic
387:	{
388:	return TrinaryLogic::createNo();
389:	}
390:
391:	public function isLiteralString(): TrinaryLogic
392:	{
393:	return TrinaryLogic::createNo();
394:	}
395:
396:	public function isClassStringType(): TrinaryLogic
397:	{
398:	return TrinaryLogic::createNo();
399:	}
400:
401:	public function isVoid(): TrinaryLogic
402:	{
403:	return TrinaryLogic::createNo();
404:	}
405:
406:	public function isScalar(): TrinaryLogic
407:	{
408:	return TrinaryLogic::createNo();
409:	}
410:
411:	/**
412:	* @param mixed[] $properties
413:	*/
414:	public static function __set_state(array $properties): Type
415:	{
416:	return new self($properties['isExplicit']);
417:	}
418:
419:	}
420:

Namespaces

Classes

Interfaces