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