File src/Type/VoidType.php

1:	<?php declare(strict_types = 1);
2:
3:	namespace PHPStan\Type;
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\Turbo\ShadowedByTurboExtension;
10:	use PHPStan\Type\Traits\FalseyBooleanTypeTrait;
11:	use PHPStan\Type\Traits\NonArrayTypeTrait;
12:	use PHPStan\Type\Traits\NonCallableTypeTrait;
13:	use PHPStan\Type\Traits\NonGeneralizableTypeTrait;
14:	use PHPStan\Type\Traits\NonGenericTypeTrait;
15:	use PHPStan\Type\Traits\NonIterableTypeTrait;
16:	use PHPStan\Type\Traits\NonObjectTypeTrait;
17:	use PHPStan\Type\Traits\NonOffsetAccessibleTypeTrait;
18:	use PHPStan\Type\Traits\NonRemoveableTypeTrait;
19:	use PHPStan\Type\Traits\UndecidedComparisonTypeTrait;
20:
21:	/** @api */
22:	#[ShadowedByTurboExtension(implementation: __DIR__ . '/../../turbo-ext/src/VoidType.cpp')]
23:	#[InstanceofDeprecated(insteadUse: 'Type::isVoid()')]
24:	class VoidType implements Type
25:	{
26:
27:	use NonArrayTypeTrait;
28:	use NonCallableTypeTrait;
29:	use NonIterableTypeTrait;
30:	use NonObjectTypeTrait;
31:	use NonOffsetAccessibleTypeTrait;
32:	use FalseyBooleanTypeTrait;
33:	use NonGenericTypeTrait;
34:	use UndecidedComparisonTypeTrait;
35:	use NonRemoveableTypeTrait;
36:	use NonGeneralizableTypeTrait;
37:
38:	/** @api */
39:	public function __construct()
40:	{
41:	}
42:
43:	public function getReferencedClasses(): array
44:	{
45:	return [];
46:	}
47:
48:	public function getObjectClassNames(): array
49:	{
50:	return [];
51:	}
52:
53:	public function getObjectClassReflections(): array
54:	{
55:	return [];
56:	}
57:
58:	public function accepts(Type $type, bool $strictTypes): AcceptsResult
59:	{
60:	if ($type instanceof CompoundType) {
61:	return $type->isAcceptedBy($this, $strictTypes);
62:	}
63:
64:	return new AcceptsResult($type->isVoid()->or($type->isNull()), []);
65:	}
66:
67:	public function isSuperTypeOf(Type $type): IsSuperTypeOfResult
68:	{
69:	if ($type instanceof self) {
70:	return IsSuperTypeOfResult::createYes();
71:	}
72:
73:	if ($type instanceof CompoundType) {
74:	return $type->isSubTypeOf($this);
75:	}
76:
77:	return IsSuperTypeOfResult::createNo();
78:	}
79:
80:	public function equals(Type $type): bool
81:	{
82:	return $type instanceof self;
83:	}
84:
85:	public function describe(VerbosityLevel $level): string
86:	{
87:	return 'void';
88:	}
89:
90:	public function toNumber(): Type
91:	{
92:	return new ErrorType();
93:	}
94:
95:	public function toBitwiseNotType(): Type
96:	{
97:	return new ErrorType();
98:	}
99:
100:	public function toAbsoluteNumber(): Type
101:	{
102:	return new ErrorType();
103:	}
104:
105:	public function toString(): Type
106:	{
107:	return new ErrorType();
108:	}
109:
110:	public function toInteger(): Type
111:	{
112:	return new ErrorType();
113:	}
114:
115:	public function toFloat(): Type
116:	{
117:	return new ErrorType();
118:	}
119:
120:	public function toArray(): Type
121:	{
122:	return new ErrorType();
123:	}
124:
125:	public function toArrayKey(): Type
126:	{
127:	return new ErrorType();
128:	}
129:
130:	public function toCoercedArgumentType(bool $strictTypes): Type
131:	{
132:	return new NullType();
133:	}
134:
135:	public function isOffsetAccessLegal(): TrinaryLogic
136:	{
137:	return TrinaryLogic::createYes();
138:	}
139:
140:	public function isNull(): TrinaryLogic
141:	{
142:	return TrinaryLogic::createNo();
143:	}
144:
145:	public function isConstantValue(): TrinaryLogic
146:	{
147:	return TrinaryLogic::createNo();
148:	}
149:
150:	public function isConstantScalarValue(): TrinaryLogic
151:	{
152:	return TrinaryLogic::createNo();
153:	}
154:
155:	public function getConstantScalarTypes(): array
156:	{
157:	return [];
158:	}
159:
160:	public function getConstantScalarValues(): array
161:	{
162:	return [];
163:	}
164:
165:	public function isTrue(): TrinaryLogic
166:	{
167:	return TrinaryLogic::createNo();
168:	}
169:
170:	public function isFalse(): TrinaryLogic
171:	{
172:	return TrinaryLogic::createNo();
173:	}
174:
175:	public function isBoolean(): TrinaryLogic
176:	{
177:	return TrinaryLogic::createNo();
178:	}
179:
180:	public function isFloat(): TrinaryLogic
181:	{
182:	return TrinaryLogic::createNo();
183:	}
184:
185:	public function isInteger(): TrinaryLogic
186:	{
187:	return TrinaryLogic::createNo();
188:	}
189:
190:	public function isString(): TrinaryLogic
191:	{
192:	return TrinaryLogic::createNo();
193:	}
194:
195:	public function isNumericString(): TrinaryLogic
196:	{
197:	return TrinaryLogic::createNo();
198:	}
199:
200:	public function isDecimalIntegerString(): TrinaryLogic
201:	{
202:	return TrinaryLogic::createNo();
203:	}
204:
205:	public function isNonEmptyString(): TrinaryLogic
206:	{
207:	return TrinaryLogic::createNo();
208:	}
209:
210:	public function isNonFalsyString(): TrinaryLogic
211:	{
212:	return TrinaryLogic::createNo();
213:	}
214:
215:	public function isLiteralString(): TrinaryLogic
216:	{
217:	return TrinaryLogic::createNo();
218:	}
219:
220:	public function isLowercaseString(): TrinaryLogic
221:	{
222:	return TrinaryLogic::createNo();
223:	}
224:
225:	public function isUppercaseString(): TrinaryLogic
226:	{
227:	return TrinaryLogic::createNo();
228:	}
229:
230:	public function isClassString(): TrinaryLogic
231:	{
232:	return TrinaryLogic::createNo();
233:	}
234:
235:	public function getClassStringObjectType(): Type
236:	{
237:	return new ErrorType();
238:	}
239:
240:	public function getObjectTypeOrClassStringObjectType(): Type
241:	{
242:	return new ErrorType();
243:	}
244:
245:	public function isVoid(): TrinaryLogic
246:	{
247:	return TrinaryLogic::createYes();
248:	}
249:
250:	public function isScalar(): TrinaryLogic
251:	{
252:	return TrinaryLogic::createNo();
253:	}
254:
255:	public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType
256:	{
257:	return new BooleanType();
258:	}
259:
260:	public function traverse(callable $cb): Type
261:	{
262:	return $this;
263:	}
264:
265:	public function traverseSimultaneously(Type $right, callable $cb): Type
266:	{
267:	return $this;
268:	}
269:
270:	public function exponentiate(Type $exponent): Type
271:	{
272:	return new ErrorType();
273:	}
274:
275:	public function getFiniteTypes(): array
276:	{
277:	return [];
278:	}
279:
280:	public function toPhpDocNode(): TypeNode
281:	{
282:	return new IdentifierTypeNode('void');
283:	}
284:
285:	public function hasTemplateOrLateResolvableType(): bool
286:	{
287:	return false;
288:	}
289:
290:	}
291:

Namespaces

Classes

Interfaces