1: | <?php declare(strict_types = 1); |
2: | |
3: | namespace PHPStan\Reflection; |
4: | |
5: | use Attribute; |
6: | use PhpParser\Node\Arg; |
7: | use PhpParser\Node\Expr\StaticCall; |
8: | use PhpParser\Node\Identifier; |
9: | use PhpParser\Node\Name\FullyQualified; |
10: | use PHPStan\Analyser\ArgumentsNormalizer; |
11: | use PHPStan\BetterReflection\Reflection\Adapter\ReflectionClass; |
12: | use PHPStan\BetterReflection\Reflection\Adapter\ReflectionEnum; |
13: | use PHPStan\BetterReflection\Reflection\Adapter\ReflectionEnumBackedCase; |
14: | use PHPStan\BetterReflection\Reflection\Adapter\ReflectionMethod; |
15: | use PHPStan\Php\PhpVersion; |
16: | use PHPStan\PhpDoc\PhpDocInheritanceResolver; |
17: | use PHPStan\PhpDoc\ResolvedPhpDocBlock; |
18: | use PHPStan\PhpDoc\StubPhpDocProvider; |
19: | use PHPStan\PhpDoc\Tag\ExtendsTag; |
20: | use PHPStan\PhpDoc\Tag\ImplementsTag; |
21: | use PHPStan\PhpDoc\Tag\MethodTag; |
22: | use PHPStan\PhpDoc\Tag\MixinTag; |
23: | use PHPStan\PhpDoc\Tag\PropertyTag; |
24: | use PHPStan\PhpDoc\Tag\TemplateTag; |
25: | use PHPStan\PhpDoc\Tag\TypeAliasImportTag; |
26: | use PHPStan\PhpDoc\Tag\TypeAliasTag; |
27: | use PHPStan\Reflection\Php\PhpClassReflectionExtension; |
28: | use PHPStan\Reflection\Php\PhpPropertyReflection; |
29: | use PHPStan\ShouldNotHappenException; |
30: | use PHPStan\Type\CircularTypeAliasDefinitionException; |
31: | use PHPStan\Type\Constant\ConstantIntegerType; |
32: | use PHPStan\Type\ErrorType; |
33: | use PHPStan\Type\FileTypeMapper; |
34: | use PHPStan\Type\Generic\GenericObjectType; |
35: | use PHPStan\Type\Generic\TemplateTypeFactory; |
36: | use PHPStan\Type\Generic\TemplateTypeHelper; |
37: | use PHPStan\Type\Generic\TemplateTypeMap; |
38: | use PHPStan\Type\Generic\TemplateTypeScope; |
39: | use PHPStan\Type\Type; |
40: | use PHPStan\Type\TypeAlias; |
41: | use PHPStan\Type\TypehintHelper; |
42: | use PHPStan\Type\VerbosityLevel; |
43: | use ReflectionException; |
44: | use stdClass; |
45: | use function array_diff; |
46: | use function array_filter; |
47: | use function array_key_exists; |
48: | use function array_map; |
49: | use function array_merge; |
50: | use function array_shift; |
51: | use function array_unique; |
52: | use function array_values; |
53: | use function count; |
54: | use function implode; |
55: | use function in_array; |
56: | use function is_bool; |
57: | use function is_file; |
58: | use function is_int; |
59: | use function reset; |
60: | use function sprintf; |
61: | use function strtolower; |
62: | |
63: | |
64: | class ClassReflection |
65: | { |
66: | |
67: | |
68: | private array $methods = []; |
69: | |
70: | |
71: | private array $properties = []; |
72: | |
73: | |
74: | private array $constants = []; |
75: | |
76: | |
77: | private ?array $classHierarchyDistances = null; |
78: | |
79: | private ?string $deprecatedDescription = null; |
80: | |
81: | private ?bool $isDeprecated = null; |
82: | |
83: | private ?bool $isGeneric = null; |
84: | |
85: | private ?bool $isInternal = null; |
86: | |
87: | private ?bool $isFinal = null; |
88: | |
89: | private ?bool $isImmutable = null; |
90: | |
91: | private ?bool $hasConsistentConstructor = null; |
92: | |
93: | private ?TemplateTypeMap $templateTypeMap = null; |
94: | |
95: | private ?TemplateTypeMap $activeTemplateTypeMap = null; |
96: | |
97: | |
98: | private ?array $ancestors = null; |
99: | |
100: | private ?string $cacheKey = null; |
101: | |
102: | |
103: | private array $subclasses = []; |
104: | |
105: | private string|false|null $filename = false; |
106: | |
107: | private string|false|null $reflectionDocComment = false; |
108: | |
109: | |
110: | private ?array $cachedInterfaces = null; |
111: | |
112: | private ClassReflection|false|null $cachedParentClass = false; |
113: | |
114: | |
115: | private ?array $typeAliases = null; |
116: | |
117: | |
118: | private static array $resolvingTypeAliasImports = []; |
119: | |
120: | |
121: | |
122: | |
123: | |
124: | public function __construct( |
125: | private ReflectionProvider $reflectionProvider, |
126: | private InitializerExprTypeResolver $initializerExprTypeResolver, |
127: | private FileTypeMapper $fileTypeMapper, |
128: | private StubPhpDocProvider $stubPhpDocProvider, |
129: | private PhpDocInheritanceResolver $phpDocInheritanceResolver, |
130: | private PhpVersion $phpVersion, |
131: | private array $propertiesClassReflectionExtensions, |
132: | private array $methodsClassReflectionExtensions, |
133: | private string $displayName, |
134: | private ReflectionClass|ReflectionEnum $reflection, |
135: | private ?string $anonymousFilename, |
136: | private ?TemplateTypeMap $resolvedTemplateTypeMap, |
137: | private ?ResolvedPhpDocBlock $stubPhpDocBlock, |
138: | private ?string $extraCacheKey = null, |
139: | ) |
140: | { |
141: | } |
142: | |
143: | public function getNativeReflection(): ReflectionClass|ReflectionEnum |
144: | { |
145: | return $this->reflection; |
146: | } |
147: | |
148: | public function getFileName(): ?string |
149: | { |
150: | if (!is_bool($this->filename)) { |
151: | return $this->filename; |
152: | } |
153: | |
154: | if ($this->anonymousFilename !== null) { |
155: | return $this->filename = $this->anonymousFilename; |
156: | } |
157: | $fileName = $this->reflection->getFileName(); |
158: | if ($fileName === false) { |
159: | return $this->filename = null; |
160: | } |
161: | |
162: | if (!is_file($fileName)) { |
163: | return $this->filename = null; |
164: | } |
165: | |
166: | return $this->filename = $fileName; |
167: | } |
168: | |
169: | |
170: | |
171: | |
172: | public function getFileNameWithPhpDocs(): ?string |
173: | { |
174: | return $this->getFileName(); |
175: | } |
176: | |
177: | public function getParentClass(): ?ClassReflection |
178: | { |
179: | if (!is_bool($this->cachedParentClass)) { |
180: | return $this->cachedParentClass; |
181: | } |
182: | |
183: | $parentClass = $this->reflection->getParentClass(); |
184: | |
185: | if ($parentClass === false) { |
186: | return $this->cachedParentClass = null; |
187: | } |
188: | |
189: | $extendsTag = $this->getFirstExtendsTag(); |
190: | |
191: | if ($extendsTag !== null && $this->isValidAncestorType($extendsTag->getType(), [$parentClass->getName()])) { |
192: | $extendedType = $extendsTag->getType(); |
193: | |
194: | if ($this->isGeneric()) { |
195: | $extendedType = TemplateTypeHelper::resolveTemplateTypes( |
196: | $extendedType, |
197: | $this->getPossiblyIncompleteActiveTemplateTypeMap(), |
198: | true, |
199: | ); |
200: | } |
201: | |
202: | if (!$extendedType instanceof GenericObjectType) { |
203: | return $this->reflectionProvider->getClass($parentClass->getName()); |
204: | } |
205: | |
206: | return $extendedType->getClassReflection() ?? $this->reflectionProvider->getClass($parentClass->getName()); |
207: | } |
208: | |
209: | $parentReflection = $this->reflectionProvider->getClass($parentClass->getName()); |
210: | if ($parentReflection->isGeneric()) { |
211: | return $parentReflection->withTypes( |
212: | array_values($parentReflection->getTemplateTypeMap()->map(static fn (): Type => new ErrorType())->getTypes()), |
213: | ); |
214: | } |
215: | |
216: | $this->cachedParentClass = $parentReflection; |
217: | |
218: | return $parentReflection; |
219: | } |
220: | |
221: | |
222: | |
223: | |
224: | public function getName(): string |
225: | { |
226: | return $this->reflection->getName(); |
227: | } |
228: | |
229: | public function getDisplayName(bool $withTemplateTypes = true): string |
230: | { |
231: | $name = $this->displayName; |
232: | |
233: | if ( |
234: | $withTemplateTypes === false |
235: | || $this->resolvedTemplateTypeMap === null |
236: | || count($this->resolvedTemplateTypeMap->getTypes()) === 0 |
237: | ) { |
238: | return $name; |
239: | } |
240: | |
241: | return $name . '<' . implode(',', array_map(static fn (Type $type): string => $type->describe(VerbosityLevel::typeOnly()), $this->getActiveTemplateTypeMap()->getTypes())) . '>'; |
242: | } |
243: | |
244: | public function getCacheKey(): string |
245: | { |
246: | $cacheKey = $this->cacheKey; |
247: | if ($cacheKey !== null) { |
248: | return $this->cacheKey; |
249: | } |
250: | |
251: | $cacheKey = $this->displayName; |
252: | |
253: | if ($this->resolvedTemplateTypeMap !== null) { |
254: | $cacheKey .= '<' . implode(',', array_map(static fn (Type $type): string => $type->describe(VerbosityLevel::cache()), $this->resolvedTemplateTypeMap->getTypes())) . '>'; |
255: | } |
256: | |
257: | if ($this->extraCacheKey !== null) { |
258: | $cacheKey .= '-' . $this->extraCacheKey; |
259: | } |
260: | |
261: | $this->cacheKey = $cacheKey; |
262: | |
263: | return $cacheKey; |
264: | } |
265: | |
266: | |
267: | |
268: | |
269: | public function getClassHierarchyDistances(): array |
270: | { |
271: | if ($this->classHierarchyDistances === null) { |
272: | $distance = 0; |
273: | $distances = [ |
274: | $this->getName() => $distance, |
275: | ]; |
276: | $currentClassReflection = $this->getNativeReflection(); |
277: | foreach ($this->collectTraits($this->getNativeReflection()) as $trait) { |
278: | $distance++; |
279: | if (array_key_exists($trait->getName(), $distances)) { |
280: | continue; |
281: | } |
282: | |
283: | $distances[$trait->getName()] = $distance; |
284: | } |
285: | |
286: | while ($currentClassReflection->getParentClass() !== false) { |
287: | $distance++; |
288: | $parentClassName = $currentClassReflection->getParentClass()->getName(); |
289: | if (!array_key_exists($parentClassName, $distances)) { |
290: | $distances[$parentClassName] = $distance; |
291: | } |
292: | $currentClassReflection = $currentClassReflection->getParentClass(); |
293: | foreach ($this->collectTraits($currentClassReflection) as $trait) { |
294: | $distance++; |
295: | if (array_key_exists($trait->getName(), $distances)) { |
296: | continue; |
297: | } |
298: | |
299: | $distances[$trait->getName()] = $distance; |
300: | } |
301: | } |
302: | foreach ($this->getNativeReflection()->getInterfaces() as $interface) { |
303: | $distance++; |
304: | if (array_key_exists($interface->getName(), $distances)) { |
305: | continue; |
306: | } |
307: | |
308: | $distances[$interface->getName()] = $distance; |
309: | } |
310: | |
311: | $this->classHierarchyDistances = $distances; |
312: | } |
313: | |
314: | return $this->classHierarchyDistances; |
315: | } |
316: | |
317: | |
318: | |
319: | |
320: | private function collectTraits(ReflectionClass|ReflectionEnum $class): array |
321: | { |
322: | $traits = []; |
323: | $traitsLeftToAnalyze = $class->getTraits(); |
324: | |
325: | while (count($traitsLeftToAnalyze) !== 0) { |
326: | $trait = reset($traitsLeftToAnalyze); |
327: | $traits[] = $trait; |
328: | |
329: | foreach ($trait->getTraits() as $subTrait) { |
330: | if (in_array($subTrait, $traits, true)) { |
331: | continue; |
332: | } |
333: | |
334: | $traitsLeftToAnalyze[] = $subTrait; |
335: | } |
336: | |
337: | array_shift($traitsLeftToAnalyze); |
338: | } |
339: | |
340: | return $traits; |
341: | } |
342: | |
343: | public function allowsDynamicProperties(): bool |
344: | { |
345: | if (!$this->phpVersion->deprecatesDynamicProperties()) { |
346: | return true; |
347: | } |
348: | |
349: | if ($this->isReadOnly()) { |
350: | return false; |
351: | } |
352: | |
353: | if ($this->is(stdClass::class)) { |
354: | return true; |
355: | } |
356: | |
357: | $class = $this; |
358: | $attributes = $class->reflection->getAttributes('AllowDynamicProperties'); |
359: | while (count($attributes) === 0 && $class->getParentClass() !== null) { |
360: | $attributes = $class->getParentClass()->reflection->getAttributes('AllowDynamicProperties'); |
361: | $class = $class->getParentClass(); |
362: | } |
363: | |
364: | return count($attributes) > 0; |
365: | } |
366: | |
367: | private function allowsDynamicPropertiesExtensions(): bool |
368: | { |
369: | if ($this->allowsDynamicProperties()) { |
370: | return true; |
371: | } |
372: | |
373: | return $this->hasNativeMethod('__get') || $this->hasNativeMethod('__set') || $this->hasNativeMethod('__isset'); |
374: | } |
375: | |
376: | public function hasProperty(string $propertyName): bool |
377: | { |
378: | if ($this->isEnum()) { |
379: | return $this->hasNativeProperty($propertyName); |
380: | } |
381: | |
382: | foreach ($this->propertiesClassReflectionExtensions as $i => $extension) { |
383: | if ($i > 0 && !$this->allowsDynamicPropertiesExtensions()) { |
384: | continue; |
385: | } |
386: | if ($extension->hasProperty($this, $propertyName)) { |
387: | return true; |
388: | } |
389: | } |
390: | |
391: | return false; |
392: | } |
393: | |
394: | public function hasMethod(string $methodName): bool |
395: | { |
396: | foreach ($this->methodsClassReflectionExtensions as $extension) { |
397: | if ($extension->hasMethod($this, $methodName)) { |
398: | return true; |
399: | } |
400: | } |
401: | |
402: | return false; |
403: | } |
404: | |
405: | public function getMethod(string $methodName, ClassMemberAccessAnswerer $scope): ExtendedMethodReflection |
406: | { |
407: | $key = $methodName; |
408: | if ($scope->isInClass()) { |
409: | $key = sprintf('%s-%s', $key, $scope->getClassReflection()->getCacheKey()); |
410: | } |
411: | if (!isset($this->methods[$key])) { |
412: | foreach ($this->methodsClassReflectionExtensions as $extension) { |
413: | if (!$extension->hasMethod($this, $methodName)) { |
414: | continue; |
415: | } |
416: | |
417: | $method = $this->wrapExtendedMethod($extension->getMethod($this, $methodName)); |
418: | if ($scope->canCallMethod($method)) { |
419: | return $this->methods[$key] = $method; |
420: | } |
421: | $this->methods[$key] = $method; |
422: | } |
423: | } |
424: | |
425: | if (!isset($this->methods[$key])) { |
426: | throw new MissingMethodFromReflectionException($this->getName(), $methodName); |
427: | } |
428: | |
429: | return $this->methods[$key]; |
430: | } |
431: | |
432: | private function wrapExtendedMethod(MethodReflection $method): ExtendedMethodReflection |
433: | { |
434: | if ($method instanceof ExtendedMethodReflection) { |
435: | return $method; |
436: | } |
437: | |
438: | return new WrappedExtendedMethodReflection($method); |
439: | } |
440: | |
441: | public function hasNativeMethod(string $methodName): bool |
442: | { |
443: | return $this->getPhpExtension()->hasNativeMethod($this, $methodName); |
444: | } |
445: | |
446: | public function getNativeMethod(string $methodName): ExtendedMethodReflection |
447: | { |
448: | if (!$this->hasNativeMethod($methodName)) { |
449: | throw new MissingMethodFromReflectionException($this->getName(), $methodName); |
450: | } |
451: | return $this->getPhpExtension()->getNativeMethod($this, $methodName); |
452: | } |
453: | |
454: | public function hasConstructor(): bool |
455: | { |
456: | return $this->findConstructor() !== null; |
457: | } |
458: | |
459: | public function getConstructor(): ExtendedMethodReflection |
460: | { |
461: | $constructor = $this->findConstructor(); |
462: | if ($constructor === null) { |
463: | throw new ShouldNotHappenException(); |
464: | } |
465: | return $this->getNativeMethod($constructor->getName()); |
466: | } |
467: | |
468: | private function findConstructor(): ?ReflectionMethod |
469: | { |
470: | $constructor = $this->reflection->getConstructor(); |
471: | if ($constructor === null) { |
472: | return null; |
473: | } |
474: | |
475: | if ($this->phpVersion->supportsLegacyConstructor()) { |
476: | return $constructor; |
477: | } |
478: | |
479: | if (strtolower($constructor->getName()) !== '__construct') { |
480: | return null; |
481: | } |
482: | |
483: | return $constructor; |
484: | } |
485: | |
486: | private function getPhpExtension(): PhpClassReflectionExtension |
487: | { |
488: | $extension = $this->methodsClassReflectionExtensions[0]; |
489: | if (!$extension instanceof PhpClassReflectionExtension) { |
490: | throw new ShouldNotHappenException(); |
491: | } |
492: | |
493: | return $extension; |
494: | } |
495: | |
496: | |
497: | public function evictPrivateSymbols(): void |
498: | { |
499: | foreach ($this->constants as $name => $constant) { |
500: | if (!$constant->isPrivate()) { |
501: | continue; |
502: | } |
503: | |
504: | unset($this->constants[$name]); |
505: | } |
506: | foreach ($this->properties as $name => $property) { |
507: | if (!$property->isPrivate()) { |
508: | continue; |
509: | } |
510: | |
511: | unset($this->properties[$name]); |
512: | } |
513: | foreach ($this->methods as $name => $method) { |
514: | if (!$method->isPrivate()) { |
515: | continue; |
516: | } |
517: | |
518: | unset($this->methods[$name]); |
519: | } |
520: | $this->getPhpExtension()->evictPrivateSymbols($this->getCacheKey()); |
521: | } |
522: | |
523: | public function getProperty(string $propertyName, ClassMemberAccessAnswerer $scope): PropertyReflection |
524: | { |
525: | if ($this->isEnum()) { |
526: | return $this->getNativeProperty($propertyName); |
527: | } |
528: | |
529: | $key = $propertyName; |
530: | if ($scope->isInClass()) { |
531: | $key = sprintf('%s-%s', $key, $scope->getClassReflection()->getCacheKey()); |
532: | } |
533: | if (!isset($this->properties[$key])) { |
534: | foreach ($this->propertiesClassReflectionExtensions as $i => $extension) { |
535: | if ($i > 0 && !$this->allowsDynamicPropertiesExtensions()) { |
536: | continue; |
537: | } |
538: | if (!$extension->hasProperty($this, $propertyName)) { |
539: | continue; |
540: | } |
541: | |
542: | $property = $extension->getProperty($this, $propertyName); |
543: | if ($scope->canAccessProperty($property)) { |
544: | return $this->properties[$key] = $property; |
545: | } |
546: | $this->properties[$key] = $property; |
547: | } |
548: | } |
549: | |
550: | if (!isset($this->properties[$key])) { |
551: | throw new MissingPropertyFromReflectionException($this->getName(), $propertyName); |
552: | } |
553: | |
554: | return $this->properties[$key]; |
555: | } |
556: | |
557: | public function hasNativeProperty(string $propertyName): bool |
558: | { |
559: | return $this->getPhpExtension()->hasProperty($this, $propertyName); |
560: | } |
561: | |
562: | public function getNativeProperty(string $propertyName): PhpPropertyReflection |
563: | { |
564: | if (!$this->hasNativeProperty($propertyName)) { |
565: | throw new MissingPropertyFromReflectionException($this->getName(), $propertyName); |
566: | } |
567: | |
568: | return $this->getPhpExtension()->getNativeProperty($this, $propertyName); |
569: | } |
570: | |
571: | public function isAbstract(): bool |
572: | { |
573: | return $this->reflection->isAbstract(); |
574: | } |
575: | |
576: | public function isInterface(): bool |
577: | { |
578: | return $this->reflection->isInterface(); |
579: | } |
580: | |
581: | public function isTrait(): bool |
582: | { |
583: | return $this->reflection->isTrait(); |
584: | } |
585: | |
586: | public function isEnum(): bool |
587: | { |
588: | return $this->reflection->isEnum(); |
589: | } |
590: | |
591: | public function isReadOnly(): bool |
592: | { |
593: | return $this->reflection->isReadOnly(); |
594: | } |
595: | |
596: | public function isBackedEnum(): bool |
597: | { |
598: | if (!$this->reflection instanceof ReflectionEnum) { |
599: | return false; |
600: | } |
601: | |
602: | return $this->reflection->isBacked(); |
603: | } |
604: | |
605: | public function getBackedEnumType(): ?Type |
606: | { |
607: | if (!$this->reflection instanceof ReflectionEnum) { |
608: | return null; |
609: | } |
610: | |
611: | if (!$this->reflection->isBacked()) { |
612: | return null; |
613: | } |
614: | |
615: | $reflectionType = $this->reflection->getBackingType(); |
616: | if ($reflectionType === null) { |
617: | return null; |
618: | } |
619: | |
620: | return TypehintHelper::decideTypeFromReflection($reflectionType); |
621: | } |
622: | |
623: | public function hasEnumCase(string $name): bool |
624: | { |
625: | if (!$this->isEnum()) { |
626: | return false; |
627: | } |
628: | |
629: | if (!$this->reflection instanceof ReflectionEnum) { |
630: | return false; |
631: | } |
632: | |
633: | return $this->reflection->hasCase($name); |
634: | } |
635: | |
636: | |
637: | |
638: | |
639: | public function getEnumCases(): array |
640: | { |
641: | if (!$this->reflection instanceof ReflectionEnum) { |
642: | throw new ShouldNotHappenException(); |
643: | } |
644: | |
645: | $cases = []; |
646: | foreach ($this->reflection->getCases() as $case) { |
647: | $valueType = null; |
648: | if ($case instanceof ReflectionEnumBackedCase) { |
649: | $valueType = $this->initializerExprTypeResolver->getType($case->getValueExpression(), InitializerExprContext::fromClassReflection($this)); |
650: | } |
651: | |
652: | $caseName = $case->getName(); |
653: | $cases[$caseName] = new EnumCaseReflection($this, $caseName, $valueType); |
654: | } |
655: | |
656: | return $cases; |
657: | } |
658: | |
659: | public function getEnumCase(string $name): EnumCaseReflection |
660: | { |
661: | if (!$this->hasEnumCase($name)) { |
662: | throw new ShouldNotHappenException(sprintf('Enum case %s::%s does not exist.', $this->getDisplayName(), $name)); |
663: | } |
664: | |
665: | if (!$this->reflection instanceof ReflectionEnum) { |
666: | throw new ShouldNotHappenException(); |
667: | } |
668: | |
669: | $case = $this->reflection->getCase($name); |
670: | $valueType = null; |
671: | if ($case instanceof ReflectionEnumBackedCase) { |
672: | $valueType = $this->initializerExprTypeResolver->getType($case->getValueExpression(), InitializerExprContext::fromClassReflection($this)); |
673: | } |
674: | |
675: | return new EnumCaseReflection($this, $name, $valueType); |
676: | } |
677: | |
678: | public function isClass(): bool |
679: | { |
680: | return !$this->isInterface() && !$this->isTrait() && !$this->isEnum(); |
681: | } |
682: | |
683: | public function isAnonymous(): bool |
684: | { |
685: | return $this->anonymousFilename !== null; |
686: | } |
687: | |
688: | public function is(string $className): bool |
689: | { |
690: | return $this->getName() === $className || $this->isSubclassOf($className); |
691: | } |
692: | |
693: | public function isSubclassOf(string $className): bool |
694: | { |
695: | if (isset($this->subclasses[$className])) { |
696: | return $this->subclasses[$className]; |
697: | } |
698: | |
699: | if (!$this->reflectionProvider->hasClass($className)) { |
700: | return $this->subclasses[$className] = false; |
701: | } |
702: | |
703: | try { |
704: | return $this->subclasses[$className] = $this->reflection->isSubclassOf($className); |
705: | } catch (ReflectionException) { |
706: | return $this->subclasses[$className] = false; |
707: | } |
708: | } |
709: | |
710: | public function implementsInterface(string $className): bool |
711: | { |
712: | try { |
713: | return $this->reflection->implementsInterface($className); |
714: | } catch (ReflectionException) { |
715: | return false; |
716: | } |
717: | } |
718: | |
719: | |
720: | |
721: | |
722: | public function getParents(): array |
723: | { |
724: | $parents = []; |
725: | $parent = $this->getParentClass(); |
726: | while ($parent !== null) { |
727: | $parents[] = $parent; |
728: | $parent = $parent->getParentClass(); |
729: | } |
730: | |
731: | return $parents; |
732: | } |
733: | |
734: | |
735: | |
736: | |
737: | public function getInterfaces(): array |
738: | { |
739: | if ($this->cachedInterfaces !== null) { |
740: | return $this->cachedInterfaces; |
741: | } |
742: | |
743: | $interfaces = $this->getImmediateInterfaces(); |
744: | $immediateInterfaces = $interfaces; |
745: | $parent = $this->getParentClass(); |
746: | while ($parent !== null) { |
747: | foreach ($parent->getImmediateInterfaces() as $parentInterface) { |
748: | $interfaces[$parentInterface->getName()] = $parentInterface; |
749: | foreach ($this->collectInterfaces($parentInterface) as $parentInterfaceInterface) { |
750: | $interfaces[$parentInterfaceInterface->getName()] = $parentInterfaceInterface; |
751: | } |
752: | } |
753: | |
754: | $parent = $parent->getParentClass(); |
755: | } |
756: | |
757: | foreach ($immediateInterfaces as $immediateInterface) { |
758: | foreach ($this->collectInterfaces($immediateInterface) as $interfaceInterface) { |
759: | $interfaces[$interfaceInterface->getName()] = $interfaceInterface; |
760: | } |
761: | } |
762: | |
763: | $this->cachedInterfaces = $interfaces; |
764: | |
765: | return $interfaces; |
766: | } |
767: | |
768: | |
769: | |
770: | |
771: | private function collectInterfaces(ClassReflection $interface): array |
772: | { |
773: | $interfaces = []; |
774: | foreach ($interface->getImmediateInterfaces() as $immediateInterface) { |
775: | $interfaces[$immediateInterface->getName()] = $immediateInterface; |
776: | foreach ($this->collectInterfaces($immediateInterface) as $immediateInterfaceInterface) { |
777: | $interfaces[$immediateInterfaceInterface->getName()] = $immediateInterfaceInterface; |
778: | } |
779: | } |
780: | |
781: | return $interfaces; |
782: | } |
783: | |
784: | |
785: | |
786: | |
787: | public function getImmediateInterfaces(): array |
788: | { |
789: | $indirectInterfaceNames = []; |
790: | $parent = $this->getParentClass(); |
791: | while ($parent !== null) { |
792: | foreach ($parent->getNativeReflection()->getInterfaceNames() as $parentInterfaceName) { |
793: | $indirectInterfaceNames[] = $parentInterfaceName; |
794: | } |
795: | |
796: | $parent = $parent->getParentClass(); |
797: | } |
798: | |
799: | foreach ($this->getNativeReflection()->getInterfaces() as $interfaceInterface) { |
800: | foreach ($interfaceInterface->getInterfaceNames() as $interfaceInterfaceName) { |
801: | $indirectInterfaceNames[] = $interfaceInterfaceName; |
802: | } |
803: | } |
804: | |
805: | if ($this->reflection->isInterface()) { |
806: | $implementsTags = $this->getExtendsTags(); |
807: | } else { |
808: | $implementsTags = $this->getImplementsTags(); |
809: | } |
810: | |
811: | $immediateInterfaceNames = array_diff($this->getNativeReflection()->getInterfaceNames(), $indirectInterfaceNames); |
812: | $immediateInterfaces = []; |
813: | foreach ($immediateInterfaceNames as $immediateInterfaceName) { |
814: | if (!$this->reflectionProvider->hasClass($immediateInterfaceName)) { |
815: | continue; |
816: | } |
817: | |
818: | $immediateInterface = $this->reflectionProvider->getClass($immediateInterfaceName); |
819: | if (array_key_exists($immediateInterface->getName(), $implementsTags)) { |
820: | $implementsTag = $implementsTags[$immediateInterface->getName()]; |
821: | $implementedType = $implementsTag->getType(); |
822: | if ($this->isGeneric()) { |
823: | $implementedType = TemplateTypeHelper::resolveTemplateTypes( |
824: | $implementedType, |
825: | $this->getPossiblyIncompleteActiveTemplateTypeMap(), |
826: | true, |
827: | ); |
828: | } |
829: | |
830: | if ( |
831: | $implementedType instanceof GenericObjectType |
832: | && $implementedType->getClassReflection() !== null |
833: | ) { |
834: | $immediateInterfaces[$immediateInterface->getName()] = $implementedType->getClassReflection(); |
835: | continue; |
836: | } |
837: | } |
838: | |
839: | if ($immediateInterface->isGeneric()) { |
840: | $immediateInterfaces[$immediateInterface->getName()] = $immediateInterface->withTypes( |
841: | array_values($immediateInterface->getTemplateTypeMap()->map(static fn (): Type => new ErrorType())->getTypes()), |
842: | ); |
843: | continue; |
844: | } |
845: | |
846: | $immediateInterfaces[$immediateInterface->getName()] = $immediateInterface; |
847: | } |
848: | |
849: | return $immediateInterfaces; |
850: | } |
851: | |
852: | |
853: | |
854: | |
855: | public function getTraits(bool $recursive = false): array |
856: | { |
857: | $traits = []; |
858: | |
859: | if ($recursive) { |
860: | foreach ($this->collectTraits($this->getNativeReflection()) as $trait) { |
861: | $traits[$trait->getName()] = $trait; |
862: | } |
863: | } else { |
864: | $traits = $this->getNativeReflection()->getTraits(); |
865: | } |
866: | |
867: | $traits = array_map(fn (ReflectionClass $trait): ClassReflection => $this->reflectionProvider->getClass($trait->getName()), $traits); |
868: | |
869: | if ($recursive) { |
870: | $parentClass = $this->getNativeReflection()->getParentClass(); |
871: | |
872: | if ($parentClass !== false) { |
873: | return array_merge( |
874: | $traits, |
875: | $this->reflectionProvider->getClass($parentClass->getName())->getTraits(true), |
876: | ); |
877: | } |
878: | } |
879: | |
880: | return $traits; |
881: | } |
882: | |
883: | |
884: | |
885: | |
886: | public function getParentClassesNames(): array |
887: | { |
888: | $parentNames = []; |
889: | $currentClassReflection = $this; |
890: | while ($currentClassReflection->getParentClass() !== null) { |
891: | $parentNames[] = $currentClassReflection->getParentClass()->getName(); |
892: | $currentClassReflection = $currentClassReflection->getParentClass(); |
893: | } |
894: | |
895: | return $parentNames; |
896: | } |
897: | |
898: | public function hasConstant(string $name): bool |
899: | { |
900: | if (!$this->getNativeReflection()->hasConstant($name)) { |
901: | return false; |
902: | } |
903: | |
904: | $reflectionConstant = $this->getNativeReflection()->getReflectionConstant($name); |
905: | if ($reflectionConstant === false) { |
906: | return false; |
907: | } |
908: | |
909: | return $this->reflectionProvider->hasClass($reflectionConstant->getDeclaringClass()->getName()); |
910: | } |
911: | |
912: | public function getConstant(string $name): ConstantReflection |
913: | { |
914: | if (!isset($this->constants[$name])) { |
915: | $reflectionConstant = $this->getNativeReflection()->getReflectionConstant($name); |
916: | if ($reflectionConstant === false) { |
917: | throw new MissingConstantFromReflectionException($this->getName(), $name); |
918: | } |
919: | |
920: | $declaringClass = $this->reflectionProvider->getClass($reflectionConstant->getDeclaringClass()->getName()); |
921: | $fileName = $declaringClass->getFileName(); |
922: | $phpDocType = null; |
923: | $resolvedPhpDoc = $this->stubPhpDocProvider->findClassConstantPhpDoc( |
924: | $declaringClass->getName(), |
925: | $name, |
926: | ); |
927: | if ($resolvedPhpDoc === null) { |
928: | $docComment = null; |
929: | if ($reflectionConstant->getDocComment() !== false) { |
930: | $docComment = $reflectionConstant->getDocComment(); |
931: | } |
932: | $resolvedPhpDoc = $this->phpDocInheritanceResolver->resolvePhpDocForConstant( |
933: | $docComment, |
934: | $declaringClass, |
935: | $fileName, |
936: | $name, |
937: | ); |
938: | } |
939: | |
940: | $deprecatedDescription = $resolvedPhpDoc->getDeprecatedTag() !== null ? $resolvedPhpDoc->getDeprecatedTag()->getMessage() : null; |
941: | $isDeprecated = $resolvedPhpDoc->isDeprecated(); |
942: | $isInternal = $resolvedPhpDoc->isInternal(); |
943: | $varTags = $resolvedPhpDoc->getVarTags(); |
944: | if (isset($varTags[0]) && count($varTags) === 1) { |
945: | $phpDocType = $varTags[0]->getType(); |
946: | } |
947: | |
948: | $this->constants[$name] = new ClassConstantReflection( |
949: | $this->initializerExprTypeResolver, |
950: | $declaringClass, |
951: | $reflectionConstant, |
952: | $phpDocType, |
953: | $deprecatedDescription, |
954: | $isDeprecated, |
955: | $isInternal, |
956: | ); |
957: | } |
958: | return $this->constants[$name]; |
959: | } |
960: | |
961: | public function hasTraitUse(string $traitName): bool |
962: | { |
963: | return in_array($traitName, $this->getTraitNames(), true); |
964: | } |
965: | |
966: | |
967: | |
968: | |
969: | private function getTraitNames(): array |
970: | { |
971: | $class = $this->reflection; |
972: | $traitNames = $class->getTraitNames(); |
973: | while ($class->getParentClass() !== false) { |
974: | $traitNames = array_values(array_unique(array_merge($traitNames, $class->getParentClass()->getTraitNames()))); |
975: | $class = $class->getParentClass(); |
976: | } |
977: | |
978: | return $traitNames; |
979: | } |
980: | |
981: | |
982: | |
983: | |
984: | public function getTypeAliases(): array |
985: | { |
986: | if ($this->typeAliases === null) { |
987: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
988: | if ($resolvedPhpDoc === null) { |
989: | return $this->typeAliases = []; |
990: | } |
991: | |
992: | $typeAliasImportTags = $resolvedPhpDoc->getTypeAliasImportTags(); |
993: | $typeAliasTags = $resolvedPhpDoc->getTypeAliasTags(); |
994: | |
995: | |
996: | if (array_key_exists($this->getName(), self::$resolvingTypeAliasImports)) { |
997: | throw new CircularTypeAliasDefinitionException(); |
998: | } |
999: | |
1000: | self::$resolvingTypeAliasImports[$this->getName()] = true; |
1001: | |
1002: | $importedAliases = array_map(function (TypeAliasImportTag $typeAliasImportTag): ?TypeAlias { |
1003: | $importedAlias = $typeAliasImportTag->getImportedAlias(); |
1004: | $importedFromClassName = $typeAliasImportTag->getImportedFrom(); |
1005: | |
1006: | if (!$this->reflectionProvider->hasClass($importedFromClassName)) { |
1007: | return null; |
1008: | } |
1009: | |
1010: | $importedFromReflection = $this->reflectionProvider->getClass($importedFromClassName); |
1011: | |
1012: | try { |
1013: | $typeAliases = $importedFromReflection->getTypeAliases(); |
1014: | } catch (CircularTypeAliasDefinitionException) { |
1015: | return TypeAlias::invalid(); |
1016: | } |
1017: | |
1018: | if (!array_key_exists($importedAlias, $typeAliases)) { |
1019: | return null; |
1020: | } |
1021: | |
1022: | return $typeAliases[$importedAlias]; |
1023: | }, $typeAliasImportTags); |
1024: | |
1025: | unset(self::$resolvingTypeAliasImports[$this->getName()]); |
1026: | |
1027: | $localAliases = array_map(static fn (TypeAliasTag $typeAliasTag): TypeAlias => $typeAliasTag->getTypeAlias(), $typeAliasTags); |
1028: | |
1029: | $this->typeAliases = array_filter( |
1030: | array_merge($importedAliases, $localAliases), |
1031: | static fn (?TypeAlias $typeAlias): bool => $typeAlias !== null, |
1032: | ); |
1033: | } |
1034: | |
1035: | return $this->typeAliases; |
1036: | } |
1037: | |
1038: | public function getDeprecatedDescription(): ?string |
1039: | { |
1040: | if ($this->deprecatedDescription === null && $this->isDeprecated()) { |
1041: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1042: | if ($resolvedPhpDoc !== null && $resolvedPhpDoc->getDeprecatedTag() !== null) { |
1043: | $this->deprecatedDescription = $resolvedPhpDoc->getDeprecatedTag()->getMessage(); |
1044: | } |
1045: | } |
1046: | |
1047: | return $this->deprecatedDescription; |
1048: | } |
1049: | |
1050: | public function isDeprecated(): bool |
1051: | { |
1052: | if ($this->isDeprecated === null) { |
1053: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1054: | $this->isDeprecated = $resolvedPhpDoc !== null && $resolvedPhpDoc->isDeprecated(); |
1055: | } |
1056: | |
1057: | return $this->isDeprecated; |
1058: | } |
1059: | |
1060: | public function isBuiltin(): bool |
1061: | { |
1062: | return $this->reflection->isInternal(); |
1063: | } |
1064: | |
1065: | public function isInternal(): bool |
1066: | { |
1067: | if ($this->isInternal === null) { |
1068: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1069: | $this->isInternal = $resolvedPhpDoc !== null && $resolvedPhpDoc->isInternal(); |
1070: | } |
1071: | |
1072: | return $this->isInternal; |
1073: | } |
1074: | |
1075: | public function isFinal(): bool |
1076: | { |
1077: | if ($this->isFinalByKeyword()) { |
1078: | return true; |
1079: | } |
1080: | |
1081: | if ($this->isFinal === null) { |
1082: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1083: | $this->isFinal = $resolvedPhpDoc !== null && $resolvedPhpDoc->isFinal(); |
1084: | } |
1085: | |
1086: | return $this->isFinal; |
1087: | } |
1088: | |
1089: | public function isImmutable(): bool |
1090: | { |
1091: | if ($this->isImmutable === null) { |
1092: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1093: | $this->isImmutable = $resolvedPhpDoc !== null && $resolvedPhpDoc->isImmutable(); |
1094: | |
1095: | $parentClass = $this->getParentClass(); |
1096: | if ($parentClass !== null && !$this->isImmutable) { |
1097: | $this->isImmutable = $parentClass->isImmutable(); |
1098: | } |
1099: | } |
1100: | |
1101: | return $this->isImmutable; |
1102: | } |
1103: | |
1104: | public function hasConsistentConstructor(): bool |
1105: | { |
1106: | if ($this->hasConsistentConstructor === null) { |
1107: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1108: | $this->hasConsistentConstructor = $resolvedPhpDoc !== null && $resolvedPhpDoc->hasConsistentConstructor(); |
1109: | } |
1110: | |
1111: | return $this->hasConsistentConstructor; |
1112: | } |
1113: | |
1114: | public function isFinalByKeyword(): bool |
1115: | { |
1116: | if ($this->isAnonymous()) { |
1117: | return true; |
1118: | } |
1119: | |
1120: | return $this->reflection->isFinal(); |
1121: | } |
1122: | |
1123: | public function isAttributeClass(): bool |
1124: | { |
1125: | return $this->findAttributeFlags() !== null; |
1126: | } |
1127: | |
1128: | private function findAttributeFlags(): ?int |
1129: | { |
1130: | if ($this->isInterface() || $this->isTrait() || $this->isEnum()) { |
1131: | return null; |
1132: | } |
1133: | |
1134: | $nativeAttributes = $this->reflection->getAttributes(Attribute::class); |
1135: | if (count($nativeAttributes) === 1) { |
1136: | if (!$this->reflectionProvider->hasClass(Attribute::class)) { |
1137: | return null; |
1138: | } |
1139: | |
1140: | $attributeClass = $this->reflectionProvider->getClass(Attribute::class); |
1141: | $arguments = []; |
1142: | foreach ($nativeAttributes[0]->getArgumentsExpressions() as $i => $expression) { |
1143: | $arguments[] = new Arg($expression, false, false, [], is_int($i) ? null : new Identifier($i)); |
1144: | } |
1145: | |
1146: | $attributeConstructor = $attributeClass->getConstructor(); |
1147: | $attributeConstructorVariant = ParametersAcceptorSelector::selectSingle($attributeConstructor->getVariants()); |
1148: | |
1149: | if (count($arguments) === 0) { |
1150: | $flagType = $attributeConstructorVariant->getParameters()[0]->getDefaultValue(); |
1151: | } else { |
1152: | $staticCall = ArgumentsNormalizer::reorderStaticCallArguments( |
1153: | $attributeConstructorVariant, |
1154: | new StaticCall(new FullyQualified(Attribute::class), $attributeConstructor->getName(), $arguments), |
1155: | ); |
1156: | if ($staticCall === null) { |
1157: | return null; |
1158: | } |
1159: | $flagExpr = $staticCall->getArgs()[0]->value; |
1160: | $flagType = $this->initializerExprTypeResolver->getType($flagExpr, InitializerExprContext::fromClassReflection($this)); |
1161: | } |
1162: | |
1163: | if (!$flagType instanceof ConstantIntegerType) { |
1164: | return null; |
1165: | } |
1166: | |
1167: | return $flagType->getValue(); |
1168: | } |
1169: | |
1170: | return null; |
1171: | } |
1172: | |
1173: | public function getAttributeClassFlags(): int |
1174: | { |
1175: | $flags = $this->findAttributeFlags(); |
1176: | if ($flags === null) { |
1177: | throw new ShouldNotHappenException(); |
1178: | } |
1179: | |
1180: | return $flags; |
1181: | } |
1182: | |
1183: | public function getTemplateTypeMap(): TemplateTypeMap |
1184: | { |
1185: | if ($this->templateTypeMap !== null) { |
1186: | return $this->templateTypeMap; |
1187: | } |
1188: | |
1189: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1190: | if ($resolvedPhpDoc === null) { |
1191: | $this->templateTypeMap = TemplateTypeMap::createEmpty(); |
1192: | return $this->templateTypeMap; |
1193: | } |
1194: | |
1195: | $templateTypeScope = TemplateTypeScope::createWithClass($this->getName()); |
1196: | |
1197: | $templateTypeMap = new TemplateTypeMap(array_map(static fn (TemplateTag $tag): Type => TemplateTypeFactory::fromTemplateTag($templateTypeScope, $tag), $this->getTemplateTags())); |
1198: | |
1199: | $this->templateTypeMap = $templateTypeMap; |
1200: | |
1201: | return $templateTypeMap; |
1202: | } |
1203: | |
1204: | public function getActiveTemplateTypeMap(): TemplateTypeMap |
1205: | { |
1206: | if ($this->activeTemplateTypeMap !== null) { |
1207: | return $this->activeTemplateTypeMap; |
1208: | } |
1209: | $resolved = $this->resolvedTemplateTypeMap; |
1210: | if ($resolved !== null) { |
1211: | $templateTypeMap = $this->getTemplateTypeMap(); |
1212: | return $this->activeTemplateTypeMap = $resolved->map(static function (string $name, Type $type) use ($templateTypeMap): Type { |
1213: | if ($type instanceof ErrorType) { |
1214: | $templateType = $templateTypeMap->getType($name); |
1215: | if ($templateType !== null) { |
1216: | return TemplateTypeHelper::resolveToBounds($templateType); |
1217: | } |
1218: | } |
1219: | |
1220: | return $type; |
1221: | }); |
1222: | } |
1223: | |
1224: | return $this->activeTemplateTypeMap = $this->getTemplateTypeMap(); |
1225: | } |
1226: | |
1227: | public function getPossiblyIncompleteActiveTemplateTypeMap(): TemplateTypeMap |
1228: | { |
1229: | return $this->resolvedTemplateTypeMap ?? $this->getTemplateTypeMap(); |
1230: | } |
1231: | |
1232: | public function isGeneric(): bool |
1233: | { |
1234: | if ($this->isGeneric === null) { |
1235: | if ($this->isEnum()) { |
1236: | return $this->isGeneric = false; |
1237: | } |
1238: | |
1239: | $this->isGeneric = count($this->getTemplateTags()) > 0; |
1240: | } |
1241: | |
1242: | return $this->isGeneric; |
1243: | } |
1244: | |
1245: | |
1246: | |
1247: | |
1248: | public function typeMapFromList(array $types): TemplateTypeMap |
1249: | { |
1250: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1251: | if ($resolvedPhpDoc === null) { |
1252: | return TemplateTypeMap::createEmpty(); |
1253: | } |
1254: | |
1255: | $map = []; |
1256: | $i = 0; |
1257: | foreach ($resolvedPhpDoc->getTemplateTags() as $tag) { |
1258: | $map[$tag->getName()] = $types[$i] ?? new ErrorType(); |
1259: | $i++; |
1260: | } |
1261: | |
1262: | return new TemplateTypeMap($map); |
1263: | } |
1264: | |
1265: | |
1266: | public function typeMapToList(TemplateTypeMap $typeMap): array |
1267: | { |
1268: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1269: | if ($resolvedPhpDoc === null) { |
1270: | return []; |
1271: | } |
1272: | |
1273: | $list = []; |
1274: | foreach ($resolvedPhpDoc->getTemplateTags() as $tag) { |
1275: | $list[] = $typeMap->getType($tag->getName()) ?? $tag->getBound(); |
1276: | } |
1277: | |
1278: | return $list; |
1279: | } |
1280: | |
1281: | |
1282: | |
1283: | |
1284: | public function withTypes(array $types): self |
1285: | { |
1286: | return new self( |
1287: | $this->reflectionProvider, |
1288: | $this->initializerExprTypeResolver, |
1289: | $this->fileTypeMapper, |
1290: | $this->stubPhpDocProvider, |
1291: | $this->phpDocInheritanceResolver, |
1292: | $this->phpVersion, |
1293: | $this->propertiesClassReflectionExtensions, |
1294: | $this->methodsClassReflectionExtensions, |
1295: | $this->displayName, |
1296: | $this->reflection, |
1297: | $this->anonymousFilename, |
1298: | $this->typeMapFromList($types), |
1299: | $this->stubPhpDocBlock, |
1300: | ); |
1301: | } |
1302: | |
1303: | public function getResolvedPhpDoc(): ?ResolvedPhpDocBlock |
1304: | { |
1305: | if ($this->stubPhpDocBlock !== null) { |
1306: | return $this->stubPhpDocBlock; |
1307: | } |
1308: | |
1309: | $fileName = $this->getFileName(); |
1310: | if (is_bool($this->reflectionDocComment)) { |
1311: | $docComment = $this->reflection->getDocComment(); |
1312: | $this->reflectionDocComment = $docComment !== false ? $docComment : null; |
1313: | } |
1314: | |
1315: | if ($this->reflectionDocComment === null) { |
1316: | return null; |
1317: | } |
1318: | |
1319: | return $this->fileTypeMapper->getResolvedPhpDoc($fileName, $this->getName(), null, null, $this->reflectionDocComment); |
1320: | } |
1321: | |
1322: | private function getFirstExtendsTag(): ?ExtendsTag |
1323: | { |
1324: | foreach ($this->getExtendsTags() as $tag) { |
1325: | return $tag; |
1326: | } |
1327: | |
1328: | return null; |
1329: | } |
1330: | |
1331: | |
1332: | public function getExtendsTags(): array |
1333: | { |
1334: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1335: | if ($resolvedPhpDoc === null) { |
1336: | return []; |
1337: | } |
1338: | |
1339: | return $resolvedPhpDoc->getExtendsTags(); |
1340: | } |
1341: | |
1342: | |
1343: | public function getImplementsTags(): array |
1344: | { |
1345: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1346: | if ($resolvedPhpDoc === null) { |
1347: | return []; |
1348: | } |
1349: | |
1350: | return $resolvedPhpDoc->getImplementsTags(); |
1351: | } |
1352: | |
1353: | |
1354: | public function getTemplateTags(): array |
1355: | { |
1356: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1357: | if ($resolvedPhpDoc === null) { |
1358: | return []; |
1359: | } |
1360: | |
1361: | return $resolvedPhpDoc->getTemplateTags(); |
1362: | } |
1363: | |
1364: | |
1365: | |
1366: | |
1367: | public function getAncestors(): array |
1368: | { |
1369: | $ancestors = $this->ancestors; |
1370: | |
1371: | if ($ancestors === null) { |
1372: | $ancestors = [ |
1373: | $this->getName() => $this, |
1374: | ]; |
1375: | |
1376: | $addToAncestors = static function (string $name, ClassReflection $classReflection) use (&$ancestors): void { |
1377: | if (array_key_exists($name, $ancestors)) { |
1378: | return; |
1379: | } |
1380: | |
1381: | $ancestors[$name] = $classReflection; |
1382: | }; |
1383: | |
1384: | foreach ($this->getInterfaces() as $interface) { |
1385: | $addToAncestors($interface->getName(), $interface); |
1386: | foreach ($interface->getAncestors() as $name => $ancestor) { |
1387: | $addToAncestors($name, $ancestor); |
1388: | } |
1389: | } |
1390: | |
1391: | foreach ($this->getTraits() as $trait) { |
1392: | $addToAncestors($trait->getName(), $trait); |
1393: | foreach ($trait->getAncestors() as $name => $ancestor) { |
1394: | $addToAncestors($name, $ancestor); |
1395: | } |
1396: | } |
1397: | |
1398: | $parent = $this->getParentClass(); |
1399: | if ($parent !== null) { |
1400: | $addToAncestors($parent->getName(), $parent); |
1401: | foreach ($parent->getAncestors() as $name => $ancestor) { |
1402: | $addToAncestors($name, $ancestor); |
1403: | } |
1404: | } |
1405: | |
1406: | $this->ancestors = $ancestors; |
1407: | } |
1408: | |
1409: | return $ancestors; |
1410: | } |
1411: | |
1412: | public function getAncestorWithClassName(string $className): ?self |
1413: | { |
1414: | return $this->getAncestors()[$className] ?? null; |
1415: | } |
1416: | |
1417: | |
1418: | |
1419: | |
1420: | private function isValidAncestorType(Type $type, array $ancestorClasses): bool |
1421: | { |
1422: | if (!$type instanceof GenericObjectType) { |
1423: | return false; |
1424: | } |
1425: | |
1426: | $reflection = $type->getClassReflection(); |
1427: | if ($reflection === null) { |
1428: | return false; |
1429: | } |
1430: | |
1431: | return in_array($reflection->getName(), $ancestorClasses, true); |
1432: | } |
1433: | |
1434: | |
1435: | |
1436: | |
1437: | public function getMixinTags(): array |
1438: | { |
1439: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1440: | if ($resolvedPhpDoc === null) { |
1441: | return []; |
1442: | } |
1443: | |
1444: | return $resolvedPhpDoc->getMixinTags(); |
1445: | } |
1446: | |
1447: | |
1448: | |
1449: | |
1450: | public function getPropertyTags(): array |
1451: | { |
1452: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1453: | if ($resolvedPhpDoc === null) { |
1454: | return []; |
1455: | } |
1456: | |
1457: | return $resolvedPhpDoc->getPropertyTags(); |
1458: | } |
1459: | |
1460: | |
1461: | |
1462: | |
1463: | public function getMethodTags(): array |
1464: | { |
1465: | $resolvedPhpDoc = $this->getResolvedPhpDoc(); |
1466: | if ($resolvedPhpDoc === null) { |
1467: | return []; |
1468: | } |
1469: | |
1470: | return $resolvedPhpDoc->getMethodTags(); |
1471: | } |
1472: | |
1473: | |
1474: | |
1475: | |
1476: | public function getResolvedMixinTypes(): array |
1477: | { |
1478: | $types = []; |
1479: | foreach ($this->getMixinTags() as $mixinTag) { |
1480: | if (!$this->isGeneric()) { |
1481: | $types[] = $mixinTag->getType(); |
1482: | continue; |
1483: | } |
1484: | |
1485: | $types[] = TemplateTypeHelper::resolveTemplateTypes( |
1486: | $mixinTag->getType(), |
1487: | $this->getActiveTemplateTypeMap(), |
1488: | ); |
1489: | } |
1490: | |
1491: | return $types; |
1492: | } |
1493: | |
1494: | } |
1495: | |