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:	if ($type instanceof CompoundType) {
78:	return $type->isAcceptedBy($this, $strictTypes);
79:	}
80:
81:	return new AcceptsResult($type->isLiteralString(), []);
82:	}
83:
84:	public function isSuperTypeOf(Type $type): IsSuperTypeOfResult
85:	{
86:	if ($type instanceof CompoundType) {
87:	return $type->isSubTypeOf($this);
88:	}
89:
90:	if ($this->equals($type)) {
91:	return IsSuperTypeOfResult::createYes();
92:	}
93:
94:	return new IsSuperTypeOfResult($type->isLiteralString(), []);
95:	}
96:
97:	public function isSubTypeOf(Type $otherType): IsSuperTypeOfResult
98:	{
99:	if ($otherType instanceof UnionType \|\| $otherType instanceof IntersectionType) {
100:	return $otherType->isSuperTypeOf($this);
101:	}
102:
103:	return (new IsSuperTypeOfResult($otherType->isLiteralString(), []))
104:	->and($otherType instanceof self ? IsSuperTypeOfResult::createYes() : IsSuperTypeOfResult::createMaybe());
105:	}
106:
107:	public function isAcceptedBy(Type $acceptingType, bool $strictTypes): AcceptsResult
108:	{
109:	return $this->isSubTypeOf($acceptingType)->toAcceptsResult();
110:	}
111:
112:	public function equals(Type $type): bool
113:	{
114:	return $type instanceof self;
115:	}
116:
117:	public function describe(VerbosityLevel $level): string
118:	{
119:	return 'literal-string';
120:	}
121:
122:	public function isOffsetAccessible(): TrinaryLogic
123:	{
124:	return TrinaryLogic::createYes();
125:	}
126:
127:	public function isOffsetAccessLegal(): TrinaryLogic
128:	{
129:	return TrinaryLogic::createYes();
130:	}
131:
132:	public function hasOffsetValueType(Type $offsetType): TrinaryLogic
133:	{
134:	return $offsetType->isInteger()->and(TrinaryLogic::createMaybe());
135:	}
136:
137:	public function getOffsetValueType(Type $offsetType): Type
138:	{
139:	if ($this->hasOffsetValueType($offsetType)->no()) {
140:	return new ErrorType();
141:	}
142:
143:	return new StringType();
144:	}
145:
146:	public function setOffsetValueType(?Type $offsetType, Type $valueType, bool $unionValues = true): Type
147:	{
148:	$stringOffset = (new StringType())->setOffsetValueType($offsetType, $valueType, $unionValues);
149:
150:	if ($stringOffset instanceof ErrorType) {
151:	return $stringOffset;
152:	}
153:
154:	if ($valueType->isLiteralString()->yes()) {
155:	return $this;
156:	}
157:
158:	return new StringType();
159:	}
160:
161:	public function setExistingOffsetValueType(Type $offsetType, Type $valueType): Type
162:	{
163:	return $this;
164:	}
165:
166:	public function unsetOffset(Type $offsetType): Type
167:	{
168:	return new ErrorType();
169:	}
170:
171:	public function toNumber(): Type
172:	{
173:	return new ErrorType();
174:	}
175:
176:	public function toAbsoluteNumber(): Type
177:	{
178:	return new ErrorType();
179:	}
180:
181:	public function toInteger(): Type
182:	{
183:	return new IntegerType();
184:	}
185:
186:	public function toFloat(): Type
187:	{
188:	return new FloatType();
189:	}
190:
191:	public function toString(): Type
192:	{
193:	return $this;
194:	}
195:
196:	public function toBoolean(): BooleanType
197:	{
198:	return new BooleanType();
199:	}
200:
201:	public function toArray(): Type
202:	{
203:	return new ConstantArrayType(
204:	[new ConstantIntegerType(0)],
205:	[$this],
206:	[1],
207:	isList: TrinaryLogic::createYes(),
208:	);
209:	}
210:
211:	public function toArrayKey(): Type
212:	{
213:	return $this;
214:	}
215:
216:	public function toCoercedArgumentType(bool $strictTypes): Type
217:	{
218:	if (!$strictTypes) {
219:	return TypeCombinator::union($this->toInteger(), $this->toFloat(), $this, $this->toBoolean());
220:	}
221:
222:	return $this;
223:	}
224:
225:	public function isNull(): TrinaryLogic
226:	{
227:	return TrinaryLogic::createNo();
228:	}
229:
230:	public function isConstantValue(): TrinaryLogic
231:	{
232:	return TrinaryLogic::createMaybe();
233:	}
234:
235:	public function isConstantScalarValue(): TrinaryLogic
236:	{
237:	return TrinaryLogic::createMaybe();
238:	}
239:
240:	public function getConstantScalarTypes(): array
241:	{
242:	return [];
243:	}
244:
245:	public function getConstantScalarValues(): array
246:	{
247:	return [];
248:	}
249:
250:	public function isTrue(): TrinaryLogic
251:	{
252:	return TrinaryLogic::createNo();
253:	}
254:
255:	public function isFalse(): TrinaryLogic
256:	{
257:	return TrinaryLogic::createNo();
258:	}
259:
260:	public function isBoolean(): TrinaryLogic
261:	{
262:	return TrinaryLogic::createNo();
263:	}
264:
265:	public function isFloat(): TrinaryLogic
266:	{
267:	return TrinaryLogic::createNo();
268:	}
269:
270:	public function isInteger(): TrinaryLogic
271:	{
272:	return TrinaryLogic::createNo();
273:	}
274:
275:	public function isString(): TrinaryLogic
276:	{
277:	return TrinaryLogic::createYes();
278:	}
279:
280:	public function isNumericString(): TrinaryLogic
281:	{
282:	return TrinaryLogic::createMaybe();
283:	}
284:
285:	public function isNonEmptyString(): TrinaryLogic
286:	{
287:	return TrinaryLogic::createMaybe();
288:	}
289:
290:	public function isNonFalsyString(): TrinaryLogic
291:	{
292:	return TrinaryLogic::createMaybe();
293:	}
294:
295:	public function isLiteralString(): TrinaryLogic
296:	{
297:	return TrinaryLogic::createYes();
298:	}
299:
300:	public function isLowercaseString(): TrinaryLogic
301:	{
302:	return TrinaryLogic::createMaybe();
303:	}
304:
305:	public function isClassString(): TrinaryLogic
306:	{
307:	return TrinaryLogic::createMaybe();
308:	}
309:
310:	public function isUppercaseString(): TrinaryLogic
311:	{
312:	return TrinaryLogic::createMaybe();
313:	}
314:
315:	public function getClassStringObjectType(): Type
316:	{
317:	return new ObjectWithoutClassType();
318:	}
319:
320:	public function getObjectTypeOrClassStringObjectType(): Type
321:	{
322:	return new ObjectWithoutClassType();
323:	}
324:
325:	public function hasMethod(string $methodName): TrinaryLogic
326:	{
327:	return TrinaryLogic::createMaybe();
328:	}
329:
330:	public function isVoid(): TrinaryLogic
331:	{
332:	return TrinaryLogic::createNo();
333:	}
334:
335:	public function isScalar(): TrinaryLogic
336:	{
337:	return TrinaryLogic::createYes();
338:	}
339:
340:	public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType
341:	{
342:	return new BooleanType();
343:	}
344:
345:	public function traverse(callable $cb): Type
346:	{
347:	return $this;
348:	}
349:
350:	public function traverseSimultaneously(Type $right, callable $cb): Type
351:	{
352:	return $this;
353:	}
354:
355:	public function generalize(GeneralizePrecision $precision): Type
356:	{
357:	return new StringType();
358:	}
359:
360:	public function exponentiate(Type $exponent): Type
361:	{
362:	return new BenevolentUnionType([
363:	new FloatType(),
364:	new IntegerType(),
365:	]);
366:	}
367:
368:	public function getFiniteTypes(): array
369:	{
370:	return [];
371:	}
372:
373:	public function toPhpDocNode(): TypeNode
374:	{
375:	return new IdentifierTypeNode('literal-string');
376:	}
377:
378:	}
379:

Namespaces

Classes