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

Namespaces

Classes