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\ConstantBooleanType;
15: use PHPStan\Type\Constant\ConstantIntegerType;
16: use PHPStan\Type\ErrorType;
17: use PHPStan\Type\FloatType;
18: use PHPStan\Type\GeneralizePrecision;
19: use PHPStan\Type\IntegerType;
20: use PHPStan\Type\IntersectionType;
21: use PHPStan\Type\IsSuperTypeOfResult;
22: use PHPStan\Type\ObjectWithoutClassType;
23: use PHPStan\Type\StaticTypeFactory;
24: use PHPStan\Type\StringType;
25: use PHPStan\Type\Traits\MaybeCallableTypeTrait;
26: use PHPStan\Type\Traits\NonArrayTypeTrait;
27: use PHPStan\Type\Traits\NonGenericTypeTrait;
28: use PHPStan\Type\Traits\NonIterableTypeTrait;
29: use PHPStan\Type\Traits\NonObjectTypeTrait;
30: use PHPStan\Type\Traits\NonRemoveableTypeTrait;
31: use PHPStan\Type\Traits\TruthyBooleanTypeTrait;
32: use PHPStan\Type\Traits\UndecidedComparisonCompoundTypeTrait;
33: use PHPStan\Type\Type;
34: use PHPStan\Type\TypeCombinator;
35: use PHPStan\Type\UnionType;
36: use PHPStan\Type\VerbosityLevel;
37:
38: class AccessoryNonFalsyStringType implements CompoundType, AccessoryType
39: {
40:
41: use MaybeCallableTypeTrait;
42: use NonArrayTypeTrait;
43: use NonObjectTypeTrait;
44: use NonIterableTypeTrait;
45: use TruthyBooleanTypeTrait;
46: use UndecidedComparisonCompoundTypeTrait;
47: use NonGenericTypeTrait;
48: use NonRemoveableTypeTrait;
49:
50: /** @api */
51: public function __construct()
52: {
53: }
54:
55: public function getReferencedClasses(): array
56: {
57: return [];
58: }
59:
60: public function getObjectClassNames(): array
61: {
62: return [];
63: }
64:
65: public function getObjectClassReflections(): array
66: {
67: return [];
68: }
69:
70: public function getConstantStrings(): array
71: {
72: return [];
73: }
74:
75: public function accepts(Type $type, bool $strictTypes): AcceptsResult
76: {
77: if ($type instanceof CompoundType) {
78: return $type->isAcceptedBy($this, $strictTypes);
79: }
80:
81: return new AcceptsResult($type->isNonFalsyString(), []);
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->isNonFalsyString(), []);
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: if ($otherType instanceof AccessoryNonEmptyStringType) {
104: return IsSuperTypeOfResult::createYes();
105: }
106:
107: return (new IsSuperTypeOfResult($otherType->isNonFalsyString(), []))
108: ->and($otherType instanceof self ? IsSuperTypeOfResult::createYes() : IsSuperTypeOfResult::createMaybe());
109: }
110:
111: public function isAcceptedBy(Type $acceptingType, bool $strictTypes): AcceptsResult
112: {
113: return $this->isSubTypeOf($acceptingType)->toAcceptsResult();
114: }
115:
116: public function equals(Type $type): bool
117: {
118: return $type instanceof self;
119: }
120:
121: public function describe(VerbosityLevel $level): string
122: {
123: return 'non-falsy-string';
124: }
125:
126: public function isOffsetAccessible(): TrinaryLogic
127: {
128: return TrinaryLogic::createYes();
129: }
130:
131: public function isOffsetAccessLegal(): TrinaryLogic
132: {
133: return TrinaryLogic::createYes();
134: }
135:
136: public function hasOffsetValueType(Type $offsetType): TrinaryLogic
137: {
138: return $offsetType->isInteger()->and(TrinaryLogic::createMaybe());
139: }
140:
141: public function getOffsetValueType(Type $offsetType): Type
142: {
143: if ($this->hasOffsetValueType($offsetType)->no()) {
144: return new ErrorType();
145: }
146:
147: return new StringType();
148: }
149:
150: public function setOffsetValueType(?Type $offsetType, Type $valueType, bool $unionValues = true): Type
151: {
152: $stringOffset = (new StringType())->setOffsetValueType($offsetType, $valueType, $unionValues);
153:
154: if ($stringOffset instanceof ErrorType) {
155: return $stringOffset;
156: }
157:
158: if ($valueType->isNonFalsyString()->yes()) {
159: return $this;
160: }
161:
162: return new StringType();
163: }
164:
165: public function setExistingOffsetValueType(Type $offsetType, Type $valueType): Type
166: {
167: return $this;
168: }
169:
170: public function unsetOffset(Type $offsetType): Type
171: {
172: return new ErrorType();
173: }
174:
175: public function toNumber(): Type
176: {
177: return new ErrorType();
178: }
179:
180: public function toAbsoluteNumber(): Type
181: {
182: return new ErrorType();
183: }
184:
185: public function toInteger(): Type
186: {
187: // Do not remove `0` since `(int) '00'` is still `0`.
188: return new IntegerType();
189: }
190:
191: public function toFloat(): Type
192: {
193: return new FloatType();
194: }
195:
196: public function toString(): Type
197: {
198: return $this;
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::createYes();
288: }
289:
290: public function isNonFalsyString(): TrinaryLogic
291: {
292: return TrinaryLogic::createYes();
293: }
294:
295: public function isLiteralString(): TrinaryLogic
296: {
297: return TrinaryLogic::createMaybe();
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 isVoid(): TrinaryLogic
326: {
327: return TrinaryLogic::createNo();
328: }
329:
330: public function isScalar(): TrinaryLogic
331: {
332: return TrinaryLogic::createYes();
333: }
334:
335: public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType
336: {
337: $falseyTypes = StaticTypeFactory::falsey();
338: if ($falseyTypes->isSuperTypeOf($type)->yes()) {
339: return new ConstantBooleanType(false);
340: }
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('non-falsy-string');
376: }
377:
378: }
379: