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($otherType->isLiteralString(), []))
110:	->and($otherType instanceof self ? IsSuperTypeOfResult::createYes() : IsSuperTypeOfResult::createMaybe());
111:	}
112:
113:	public function isAcceptedBy(Type $acceptingType, bool $strictTypes): AcceptsResult
114:	{
115:	return $this->isSubTypeOf($acceptingType)->toAcceptsResult();
116:	}
117:
118:	public function equals(Type $type): bool
119:	{
120:	return $type instanceof self;
121:	}
122:
123:	public function describe(VerbosityLevel $level): string
124:	{
125:	return 'literal-string';
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:	return $offsetType->isInteger()->and(TrinaryLogic::createMaybe());
141:	}
142:
143:	public function getOffsetValueType(Type $offsetType): Type
144:	{
145:	if ($this->hasOffsetValueType($offsetType)->no()) {
146:	return new ErrorType();
147:	}
148:
149:	return new StringType();
150:	}
151:
152:	public function setOffsetValueType(?Type $offsetType, Type $valueType, bool $unionValues = true): Type
153:	{
154:	$stringOffset = (new StringType())->setOffsetValueType($offsetType, $valueType, $unionValues);
155:
156:	if ($stringOffset instanceof ErrorType) {
157:	return $stringOffset;
158:	}
159:
160:	if ($valueType->isLiteralString()->yes()) {
161:	return $this;
162:	}
163:
164:	return new StringType();
165:	}
166:
167:	public function setExistingOffsetValueType(Type $offsetType, Type $valueType): Type
168:	{
169:	return $this;
170:	}
171:
172:	public function unsetOffset(Type $offsetType): Type
173:	{
174:	return new ErrorType();
175:	}
176:
177:	public function toNumber(): Type
178:	{
179:	return new ErrorType();
180:	}
181:
182:	public function toAbsoluteNumber(): Type
183:	{
184:	return new ErrorType();
185:	}
186:
187:	public function toInteger(): Type
188:	{
189:	return new IntegerType();
190:	}
191:
192:	public function toFloat(): Type
193:	{
194:	return new FloatType();
195:	}
196:
197:	public function toString(): Type
198:	{
199:	return $this;
200:	}
201:
202:	public function toBoolean(): BooleanType
203:	{
204:	return new BooleanType();
205:	}
206:
207:	public function toArray(): Type
208:	{
209:	return new ConstantArrayType(
210:	[new ConstantIntegerType(0)],
211:	[$this],
212:	[1],
213:	isList: TrinaryLogic::createYes(),
214:	);
215:	}
216:
217:	public function toArrayKey(): Type
218:	{
219:	return $this;
220:	}
221:
222:	public function toCoercedArgumentType(bool $strictTypes): Type
223:	{
224:	if (!$strictTypes) {
225:	return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
226:	}
227:
228:	return $this;
229:	}
230:
231:	public function isNull(): TrinaryLogic
232:	{
233:	return TrinaryLogic::createNo();
234:	}
235:
236:	public function isConstantValue(): TrinaryLogic
237:	{
238:	return TrinaryLogic::createMaybe();
239:	}
240:
241:	public function isConstantScalarValue(): TrinaryLogic
242:	{
243:	return TrinaryLogic::createMaybe();
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::createYes();
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::createYes();
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 isUppercaseString(): TrinaryLogic
317:	{
318:	return TrinaryLogic::createMaybe();
319:	}
320:
321:	public function getClassStringObjectType(): Type
322:	{
323:	return new ObjectWithoutClassType();
324:	}
325:
326:	public function getObjectTypeOrClassStringObjectType(): Type
327:	{
328:	return new ObjectWithoutClassType();
329:	}
330:
331:	public function hasMethod(string $methodName): TrinaryLogic
332:	{
333:	return TrinaryLogic::createMaybe();
334:	}
335:
336:	public function isVoid(): TrinaryLogic
337:	{
338:	return TrinaryLogic::createNo();
339:	}
340:
341:	public function isScalar(): TrinaryLogic
342:	{
343:	return TrinaryLogic::createYes();
344:	}
345:
346:	public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType
347:	{
348:	return new BooleanType();
349:	}
350:
351:	public function traverse(callable $cb): Type
352:	{
353:	return $this;
354:	}
355:
356:	public function traverseSimultaneously(Type $right, callable $cb): Type
357:	{
358:	return $this;
359:	}
360:
361:	public function generalize(GeneralizePrecision $precision): Type
362:	{
363:	return new StringType();
364:	}
365:
366:	public function exponentiate(Type $exponent): Type
367:	{
368:	return new BenevolentUnionType([
369:	new FloatType(),
370:	new IntegerType(),
371:	]);
372:	}
373:
374:	public function getFiniteTypes(): array
375:	{
376:	return [];
377:	}
378:
379:	public function toPhpDocNode(): TypeNode
380:	{
381:	return new IdentifierTypeNode('literal-string');
382:	}
383:
384:	public function hasTemplateOrLateResolvableType(): bool
385:	{
386:	return false;
387:	}
388:
389:	}
390:

Namespaces

Classes