1: | <?php declare(strict_types = 1); |
2: | |
3: | namespace PHPStan\Type; |
4: | |
5: | use Closure; |
6: | use PhpParser\Node; |
7: | use PHPStan\Analyser\NameScope; |
8: | use PHPStan\BetterReflection\Util\GetLastDocComment; |
9: | use PHPStan\Broker\AnonymousClassNameHelper; |
10: | use PHPStan\File\FileHelper; |
11: | use PHPStan\Parser\Parser; |
12: | use PHPStan\PhpDoc\NameScopeAlreadyBeingCreatedException; |
13: | use PHPStan\PhpDoc\PhpDocNodeResolver; |
14: | use PHPStan\PhpDoc\PhpDocStringResolver; |
15: | use PHPStan\PhpDoc\ResolvedPhpDocBlock; |
16: | use PHPStan\PhpDoc\Tag\TemplateTag; |
17: | use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode; |
18: | use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider; |
19: | use PHPStan\ShouldNotHappenException; |
20: | use PHPStan\Type\Generic\GenericObjectType; |
21: | use PHPStan\Type\Generic\TemplateTypeFactory; |
22: | use PHPStan\Type\Generic\TemplateTypeHelper; |
23: | use PHPStan\Type\Generic\TemplateTypeMap; |
24: | use PHPStan\Type\Generic\TemplateTypeVariance; |
25: | use PHPStan\Type\Generic\TemplateTypeVarianceMap; |
26: | use function array_key_exists; |
27: | use function array_keys; |
28: | use function array_map; |
29: | use function array_merge; |
30: | use function array_pop; |
31: | use function array_slice; |
32: | use function count; |
33: | use function is_array; |
34: | use function is_callable; |
35: | use function is_file; |
36: | use function ltrim; |
37: | use function md5; |
38: | use function sprintf; |
39: | use function str_contains; |
40: | use function strtolower; |
41: | |
42: | final class FileTypeMapper |
43: | { |
44: | |
45: | private const SKIP_NODE = 1; |
46: | private const POP_TYPE_MAP_STACK = 2; |
47: | |
48: | |
49: | private array $memoryCache = []; |
50: | |
51: | private int $memoryCacheCount = 0; |
52: | |
53: | |
54: | private array $inProcess = []; |
55: | |
56: | |
57: | private array $resolvedPhpDocBlockCache = []; |
58: | |
59: | private int $resolvedPhpDocBlockCacheCount = 0; |
60: | |
61: | public function __construct( |
62: | private ReflectionProviderProvider $reflectionProviderProvider, |
63: | private Parser $phpParser, |
64: | private PhpDocStringResolver $phpDocStringResolver, |
65: | private PhpDocNodeResolver $phpDocNodeResolver, |
66: | private AnonymousClassNameHelper $anonymousClassNameHelper, |
67: | private FileHelper $fileHelper, |
68: | ) |
69: | { |
70: | } |
71: | |
72: | |
73: | public function getResolvedPhpDoc( |
74: | ?string $fileName, |
75: | ?string $className, |
76: | ?string $traitName, |
77: | ?string $functionName, |
78: | string $docComment, |
79: | ): ResolvedPhpDocBlock |
80: | { |
81: | if ($className === null && $traitName !== null) { |
82: | throw new ShouldNotHappenException(); |
83: | } |
84: | |
85: | if ($docComment === '') { |
86: | return ResolvedPhpDocBlock::createEmpty(); |
87: | } |
88: | |
89: | if ($fileName !== null) { |
90: | $fileName = $this->fileHelper->normalizePath($fileName); |
91: | } |
92: | |
93: | $nameScopeKey = $this->getNameScopeKey($fileName, $className, $traitName, $functionName); |
94: | $phpDocKey = md5(sprintf('%s-%s', $nameScopeKey, $docComment)); |
95: | if (isset($this->resolvedPhpDocBlockCache[$phpDocKey])) { |
96: | return $this->resolvedPhpDocBlockCache[$phpDocKey]; |
97: | } |
98: | |
99: | if ($fileName === null) { |
100: | return $this->createResolvedPhpDocBlock($phpDocKey, new NameScope(null, []), $docComment, null); |
101: | } |
102: | |
103: | try { |
104: | $nameScope = $this->getNameScope($fileName, $className, $traitName, $functionName); |
105: | } catch (NameScopeAlreadyBeingCreatedException) { |
106: | return ResolvedPhpDocBlock::createEmpty(); |
107: | } |
108: | |
109: | return $this->createResolvedPhpDocBlock($phpDocKey, $nameScope, $docComment, $fileName); |
110: | } |
111: | |
112: | |
113: | |
114: | |
115: | public function getNameScope( |
116: | string $fileName, |
117: | ?string $className, |
118: | ?string $traitName, |
119: | ?string $functionName, |
120: | ): NameScope |
121: | { |
122: | $nameScopeKey = $this->getNameScopeKey($fileName, $className, $traitName, $functionName); |
123: | $nameScopeMap = []; |
124: | |
125: | if (!isset($this->inProcess[$fileName])) { |
126: | $nameScopeMap = $this->getNameScopeMap($fileName); |
127: | } |
128: | |
129: | if (isset($nameScopeMap[$nameScopeKey])) { |
130: | return $nameScopeMap[$nameScopeKey]; |
131: | } |
132: | |
133: | if (!isset($this->inProcess[$fileName][$nameScopeKey])) { |
134: | throw new NameScopeAlreadyBeingCreatedException(); |
135: | } |
136: | |
137: | if ($this->inProcess[$fileName][$nameScopeKey] === true) { |
138: | throw new NameScopeAlreadyBeingCreatedException(); |
139: | } |
140: | |
141: | if (is_callable($this->inProcess[$fileName][$nameScopeKey])) { |
142: | $resolveCallback = $this->inProcess[$fileName][$nameScopeKey]; |
143: | $this->inProcess[$fileName][$nameScopeKey] = true; |
144: | $this->inProcess[$fileName][$nameScopeKey] = $resolveCallback(); |
145: | } |
146: | |
147: | return $this->inProcess[$fileName][$nameScopeKey]; |
148: | } |
149: | |
150: | private function createResolvedPhpDocBlock(string $phpDocKey, NameScope $nameScope, string $phpDocString, ?string $fileName): ResolvedPhpDocBlock |
151: | { |
152: | $phpDocNode = $this->phpDocStringResolver->resolve($phpDocString); |
153: | if ($this->resolvedPhpDocBlockCacheCount >= 2048) { |
154: | $this->resolvedPhpDocBlockCache = array_slice( |
155: | $this->resolvedPhpDocBlockCache, |
156: | 1, |
157: | null, |
158: | true, |
159: | ); |
160: | |
161: | $this->resolvedPhpDocBlockCacheCount--; |
162: | } |
163: | |
164: | $templateTypeMap = $nameScope->getTemplateTypeMap(); |
165: | $phpDocTemplateTypes = []; |
166: | $templateTags = $this->phpDocNodeResolver->resolveTemplateTags($phpDocNode, $nameScope); |
167: | foreach (array_keys($templateTags) as $name) { |
168: | $templateType = $templateTypeMap->getType($name); |
169: | if ($templateType === null) { |
170: | continue; |
171: | } |
172: | $phpDocTemplateTypes[$name] = $templateType; |
173: | } |
174: | |
175: | $this->resolvedPhpDocBlockCache[$phpDocKey] = ResolvedPhpDocBlock::create( |
176: | $phpDocNode, |
177: | $phpDocString, |
178: | $fileName, |
179: | $nameScope, |
180: | new TemplateTypeMap($phpDocTemplateTypes), |
181: | $templateTags, |
182: | $this->phpDocNodeResolver, |
183: | $this->reflectionProviderProvider->getReflectionProvider(), |
184: | ); |
185: | $this->resolvedPhpDocBlockCacheCount++; |
186: | |
187: | return $this->resolvedPhpDocBlockCache[$phpDocKey]; |
188: | } |
189: | |
190: | |
191: | |
192: | |
193: | private function getNameScopeMap(string $fileName): array |
194: | { |
195: | if (!isset($this->memoryCache[$fileName])) { |
196: | $map = $this->createResolvedPhpDocMap($fileName); |
197: | if ($this->memoryCacheCount >= 2048) { |
198: | $this->memoryCache = array_slice( |
199: | $this->memoryCache, |
200: | 1, |
201: | null, |
202: | true, |
203: | ); |
204: | $this->memoryCacheCount--; |
205: | } |
206: | |
207: | $this->memoryCache[$fileName] = $map; |
208: | $this->memoryCacheCount++; |
209: | } |
210: | |
211: | return $this->memoryCache[$fileName]; |
212: | } |
213: | |
214: | |
215: | |
216: | |
217: | private function createResolvedPhpDocMap(string $fileName): array |
218: | { |
219: | $phpDocNodeMap = $this->createPhpDocNodeMap($fileName, null, $fileName, [], $fileName); |
220: | $nameScopeMap = $this->createNameScopeMap($fileName, null, null, [], $fileName, $phpDocNodeMap); |
221: | $resolvedNameScopeMap = []; |
222: | |
223: | try { |
224: | $this->inProcess[$fileName] = $nameScopeMap; |
225: | |
226: | foreach ($nameScopeMap as $nameScopeKey => $resolveCallback) { |
227: | $this->inProcess[$fileName][$nameScopeKey] = true; |
228: | $this->inProcess[$fileName][$nameScopeKey] = $data = $resolveCallback(); |
229: | $resolvedNameScopeMap[$nameScopeKey] = $data; |
230: | } |
231: | |
232: | } finally { |
233: | unset($this->inProcess[$fileName]); |
234: | } |
235: | |
236: | return $resolvedNameScopeMap; |
237: | } |
238: | |
239: | |
240: | |
241: | |
242: | |
243: | private function createPhpDocNodeMap(string $fileName, ?string $lookForTrait, ?string $traitUseClass, array $traitMethodAliases, string $originalClassFileName): array |
244: | { |
245: | |
246: | $phpDocNodeMap = []; |
247: | |
248: | |
249: | $classStack = []; |
250: | if ($lookForTrait !== null && $traitUseClass !== null) { |
251: | $classStack[] = $traitUseClass; |
252: | } |
253: | $namespace = null; |
254: | |
255: | $traitFound = false; |
256: | |
257: | |
258: | $functionStack = []; |
259: | $this->processNodes( |
260: | $this->phpParser->parseFile($fileName), |
261: | function (Node $node) use ($fileName, $lookForTrait, &$traitFound, $traitMethodAliases, $originalClassFileName, &$phpDocNodeMap, &$classStack, &$namespace, &$functionStack): ?int { |
262: | if ($node instanceof Node\Stmt\ClassLike) { |
263: | if ($traitFound && $fileName === $originalClassFileName) { |
264: | return self::SKIP_NODE; |
265: | } |
266: | |
267: | if ($lookForTrait !== null && !$traitFound) { |
268: | if (!$node instanceof Node\Stmt\Trait_) { |
269: | return self::SKIP_NODE; |
270: | } |
271: | if ((string) $node->namespacedName !== $lookForTrait) { |
272: | return self::SKIP_NODE; |
273: | } |
274: | |
275: | $traitFound = true; |
276: | $functionStack[] = null; |
277: | } else { |
278: | if ($node->name === null) { |
279: | if (!$node instanceof Node\Stmt\Class_) { |
280: | throw new ShouldNotHappenException(); |
281: | } |
282: | |
283: | $className = $this->anonymousClassNameHelper->getAnonymousClassName($node, $fileName); |
284: | } elseif ($node instanceof Node\Stmt\Class_ && $node->isAnonymous()) { |
285: | $className = $node->name->name; |
286: | } else { |
287: | if ($traitFound) { |
288: | return self::SKIP_NODE; |
289: | } |
290: | $className = ltrim(sprintf('%s\\%s', $namespace, $node->name->name), '\\'); |
291: | } |
292: | $classStack[] = $className; |
293: | $functionStack[] = null; |
294: | } |
295: | } elseif ($node instanceof Node\Stmt\ClassMethod) { |
296: | if (array_key_exists($node->name->name, $traitMethodAliases)) { |
297: | $functionStack[] = $traitMethodAliases[$node->name->name]; |
298: | } else { |
299: | $functionStack[] = $node->name->name; |
300: | } |
301: | } elseif ($node instanceof Node\Stmt\Function_) { |
302: | $functionStack[] = ltrim(sprintf('%s\\%s', $namespace, $node->name->name), '\\'); |
303: | } elseif ($node instanceof Node\PropertyHook) { |
304: | $propertyName = $node->getAttribute('propertyName'); |
305: | if ($propertyName !== null) { |
306: | $functionStack[] = sprintf('$%s::%s', $propertyName, $node->name->toString()); |
307: | } |
308: | } |
309: | |
310: | $className = $classStack[count($classStack) - 1] ?? null; |
311: | $functionName = $functionStack[count($functionStack) - 1] ?? null; |
312: | |
313: | if ($node instanceof Node\Stmt\ClassLike || $node instanceof Node\Stmt\ClassMethod || $node instanceof Node\Stmt\Function_) { |
314: | $docComment = GetLastDocComment::forNode($node); |
315: | if ($docComment !== null) { |
316: | $nameScopeKey = $this->getNameScopeKey($originalClassFileName, $className, $lookForTrait, $functionName); |
317: | $phpDocNodeMap[$nameScopeKey] = $this->phpDocStringResolver->resolve($docComment); |
318: | } |
319: | |
320: | return null; |
321: | } elseif ($node instanceof Node\PropertyHook) { |
322: | $propertyName = $node->getAttribute('propertyName'); |
323: | if ($propertyName !== null) { |
324: | $docComment = GetLastDocComment::forNode($node); |
325: | if ($docComment !== null) { |
326: | $nameScopeKey = $this->getNameScopeKey($originalClassFileName, $className, $lookForTrait, $functionName); |
327: | $phpDocNodeMap[$nameScopeKey] = $this->phpDocStringResolver->resolve($docComment); |
328: | } |
329: | } |
330: | |
331: | return null; |
332: | } |
333: | |
334: | if ($node instanceof Node\Stmt\Namespace_) { |
335: | $namespace = $node->name !== null ? (string) $node->name : null; |
336: | } elseif ($node instanceof Node\Stmt\TraitUse) { |
337: | $traitMethodAliases = []; |
338: | foreach ($node->adaptations as $traitUseAdaptation) { |
339: | if (!$traitUseAdaptation instanceof Node\Stmt\TraitUseAdaptation\Alias) { |
340: | continue; |
341: | } |
342: | |
343: | if ($traitUseAdaptation->newName === null) { |
344: | continue; |
345: | } |
346: | |
347: | $methodName = $traitUseAdaptation->method->toString(); |
348: | $newTraitName = $traitUseAdaptation->newName->toString(); |
349: | |
350: | if ($traitUseAdaptation->trait === null) { |
351: | foreach ($node->traits as $traitName) { |
352: | $traitMethodAliases[$traitName->toString()][$methodName] = $newTraitName; |
353: | } |
354: | continue; |
355: | } |
356: | |
357: | $traitMethodAliases[$traitUseAdaptation->trait->toString()][$methodName] = $newTraitName; |
358: | } |
359: | |
360: | foreach ($node->traits as $traitName) { |
361: | |
362: | $traitName = (string) $traitName; |
363: | $reflectionProvider = $this->reflectionProviderProvider->getReflectionProvider(); |
364: | if (!$reflectionProvider->hasClass($traitName)) { |
365: | continue; |
366: | } |
367: | |
368: | $traitReflection = $reflectionProvider->getClass($traitName); |
369: | if (!$traitReflection->isTrait()) { |
370: | continue; |
371: | } |
372: | if ($traitReflection->getFileName() === null) { |
373: | continue; |
374: | } |
375: | if (!is_file($traitReflection->getFileName())) { |
376: | continue; |
377: | } |
378: | |
379: | $className = $classStack[count($classStack) - 1] ?? null; |
380: | if ($className === null) { |
381: | throw new ShouldNotHappenException(); |
382: | } |
383: | |
384: | $phpDocNodeMap = array_merge($phpDocNodeMap, $this->createPhpDocNodeMap( |
385: | $traitReflection->getFileName(), |
386: | $traitName, |
387: | $className, |
388: | $traitMethodAliases[$traitName] ?? [], |
389: | $originalClassFileName, |
390: | )); |
391: | } |
392: | } |
393: | |
394: | return null; |
395: | }, |
396: | static function (Node $node) use (&$namespace, &$functionStack, &$classStack): void { |
397: | if ($node instanceof Node\Stmt\ClassLike) { |
398: | if (count($classStack) === 0) { |
399: | throw new ShouldNotHappenException(); |
400: | } |
401: | array_pop($classStack); |
402: | |
403: | if (count($functionStack) === 0) { |
404: | throw new ShouldNotHappenException(); |
405: | } |
406: | |
407: | array_pop($functionStack); |
408: | } elseif ($node instanceof Node\Stmt\Namespace_) { |
409: | $namespace = null; |
410: | } elseif ($node instanceof Node\Stmt\ClassMethod || $node instanceof Node\Stmt\Function_) { |
411: | if (count($functionStack) === 0) { |
412: | throw new ShouldNotHappenException(); |
413: | } |
414: | |
415: | array_pop($functionStack); |
416: | } elseif ($node instanceof Node\PropertyHook) { |
417: | $propertyName = $node->getAttribute('propertyName'); |
418: | if ($propertyName !== null) { |
419: | if (count($functionStack) === 0) { |
420: | throw new ShouldNotHappenException(); |
421: | } |
422: | |
423: | array_pop($functionStack); |
424: | } |
425: | } |
426: | }, |
427: | ); |
428: | |
429: | return $phpDocNodeMap; |
430: | } |
431: | |
432: | |
433: | |
434: | |
435: | |
436: | |
437: | private function createNameScopeMap( |
438: | string $fileName, |
439: | ?string $lookForTrait, |
440: | ?string $traitUseClass, |
441: | array $traitMethodAliases, |
442: | string $originalClassFileName, |
443: | array $phpDocNodeMap, |
444: | ): array |
445: | { |
446: | |
447: | $nameScopeMap = []; |
448: | |
449: | |
450: | $typeMapStack = []; |
451: | |
452: | |
453: | $typeAliasStack = []; |
454: | |
455: | |
456: | $classStack = []; |
457: | if ($lookForTrait !== null && $traitUseClass !== null) { |
458: | $classStack[] = $traitUseClass; |
459: | $typeAliasStack[] = []; |
460: | } |
461: | $namespace = null; |
462: | |
463: | $traitFound = false; |
464: | |
465: | |
466: | $functionStack = []; |
467: | $uses = []; |
468: | $constUses = []; |
469: | $this->processNodes( |
470: | $this->phpParser->parseFile($fileName), |
471: | function (Node $node) use ($fileName, $lookForTrait, $phpDocNodeMap, &$traitFound, $traitMethodAliases, $originalClassFileName, &$nameScopeMap, &$classStack, &$typeAliasStack, &$namespace, &$functionStack, &$uses, &$typeMapStack, &$constUses): ?int { |
472: | if ($node instanceof Node\Stmt\ClassLike) { |
473: | if ($traitFound && $fileName === $originalClassFileName) { |
474: | return self::SKIP_NODE; |
475: | } |
476: | |
477: | if ($lookForTrait !== null && !$traitFound) { |
478: | if (!$node instanceof Node\Stmt\Trait_) { |
479: | return self::SKIP_NODE; |
480: | } |
481: | if ((string) $node->namespacedName !== $lookForTrait) { |
482: | return self::SKIP_NODE; |
483: | } |
484: | |
485: | $traitFound = true; |
486: | $traitNameScopeKey = $this->getNameScopeKey($originalClassFileName, $classStack[count($classStack) - 1] ?? null, $lookForTrait, null); |
487: | if (array_key_exists($traitNameScopeKey, $phpDocNodeMap)) { |
488: | $typeAliasStack[] = $this->getTypeAliasesMap($phpDocNodeMap[$traitNameScopeKey]); |
489: | } else { |
490: | $typeAliasStack[] = []; |
491: | } |
492: | $functionStack[] = null; |
493: | } else { |
494: | if ($node->name === null) { |
495: | if (!$node instanceof Node\Stmt\Class_) { |
496: | throw new ShouldNotHappenException(); |
497: | } |
498: | |
499: | $className = $this->anonymousClassNameHelper->getAnonymousClassName($node, $fileName); |
500: | } elseif ($node instanceof Node\Stmt\Class_ && $node->isAnonymous()) { |
501: | $className = $node->name->name; |
502: | } else { |
503: | if ($traitFound) { |
504: | return self::SKIP_NODE; |
505: | } |
506: | $className = ltrim(sprintf('%s\\%s', $namespace, $node->name->name), '\\'); |
507: | } |
508: | $classStack[] = $className; |
509: | $classNameScopeKey = $this->getNameScopeKey($originalClassFileName, $className, $lookForTrait, null); |
510: | if (array_key_exists($classNameScopeKey, $phpDocNodeMap)) { |
511: | $typeAliasStack[] = $this->getTypeAliasesMap($phpDocNodeMap[$classNameScopeKey]); |
512: | } else { |
513: | $typeAliasStack[] = []; |
514: | } |
515: | $functionStack[] = null; |
516: | } |
517: | } elseif ($node instanceof Node\Stmt\ClassMethod) { |
518: | if (array_key_exists($node->name->name, $traitMethodAliases)) { |
519: | $functionStack[] = $traitMethodAliases[$node->name->name]; |
520: | } else { |
521: | $functionStack[] = $node->name->name; |
522: | } |
523: | } elseif ($node instanceof Node\Stmt\Function_) { |
524: | $functionStack[] = ltrim(sprintf('%s\\%s', $namespace, $node->name->name), '\\'); |
525: | } elseif ($node instanceof Node\PropertyHook) { |
526: | $propertyName = $node->getAttribute('propertyName'); |
527: | if ($propertyName !== null) { |
528: | $functionStack[] = sprintf('$%s::%s', $propertyName, $node->name->toString()); |
529: | } |
530: | } |
531: | |
532: | $className = $classStack[count($classStack) - 1] ?? null; |
533: | $functionName = $functionStack[count($functionStack) - 1] ?? null; |
534: | $nameScopeKey = $this->getNameScopeKey($originalClassFileName, $className, $lookForTrait, $functionName); |
535: | |
536: | if ($node instanceof Node\Stmt\ClassLike || $node instanceof Node\Stmt\ClassMethod || $node instanceof Node\Stmt\Function_) { |
537: | |
538: | if (array_key_exists($nameScopeKey, $phpDocNodeMap)) { |
539: | $phpDocNode = $phpDocNodeMap[$nameScopeKey]; |
540: | $typeMapStack[] = function () use ($namespace, $uses, $className, $lookForTrait, $functionName, $phpDocNode, $typeMapStack, $typeAliasStack, $constUses): TemplateTypeMap { |
541: | $typeMapCb = $typeMapStack[count($typeMapStack) - 1] ?? null; |
542: | $currentTypeMap = $typeMapCb !== null ? $typeMapCb() : null; |
543: | $typeAliasesMap = $typeAliasStack[count($typeAliasStack) - 1] ?? []; |
544: | $nameScope = new NameScope($namespace, $uses, $className, $functionName, $currentTypeMap, $typeAliasesMap, false, $constUses, $lookForTrait); |
545: | $templateTags = $this->phpDocNodeResolver->resolveTemplateTags($phpDocNode, $nameScope); |
546: | $templateTypeScope = $nameScope->getTemplateTypeScope(); |
547: | if ($templateTypeScope === null) { |
548: | throw new ShouldNotHappenException(); |
549: | } |
550: | $templateTypeMap = new TemplateTypeMap(array_map(static fn (TemplateTag $tag): Type => TemplateTypeFactory::fromTemplateTag($templateTypeScope, $tag), $templateTags)); |
551: | $nameScope = $nameScope->withTemplateTypeMap($templateTypeMap); |
552: | $templateTags = $this->phpDocNodeResolver->resolveTemplateTags($phpDocNode, $nameScope); |
553: | $templateTypeMap = new TemplateTypeMap(array_map(static fn (TemplateTag $tag): Type => TemplateTypeFactory::fromTemplateTag($templateTypeScope, $tag), $templateTags)); |
554: | |
555: | return new TemplateTypeMap(array_merge( |
556: | $currentTypeMap !== null ? $currentTypeMap->getTypes() : [], |
557: | $templateTypeMap->getTypes(), |
558: | )); |
559: | }; |
560: | } |
561: | } |
562: | |
563: | $typeMapCb = $typeMapStack[count($typeMapStack) - 1] ?? null; |
564: | $typeAliasesMap = $typeAliasStack[count($typeAliasStack) - 1] ?? []; |
565: | |
566: | if ( |
567: | ( |
568: | $node instanceof Node\PropertyHook |
569: | || ( |
570: | $node instanceof Node\Stmt |
571: | && !$node instanceof Node\Stmt\Namespace_ |
572: | && !$node instanceof Node\Stmt\Declare_ |
573: | && !$node instanceof Node\Stmt\Use_ |
574: | && !$node instanceof Node\Stmt\GroupUse |
575: | && !$node instanceof Node\Stmt\TraitUse |
576: | && !$node instanceof Node\Stmt\TraitUseAdaptation |
577: | && !$node instanceof Node\Stmt\InlineHTML |
578: | && !($node instanceof Node\Stmt\Expression && $node->expr instanceof Node\Expr\Include_) |
579: | ) |
580: | ) && !array_key_exists($nameScopeKey, $nameScopeMap) |
581: | ) { |
582: | $nameScopeMap[$nameScopeKey] = static fn (): NameScope => new NameScope( |
583: | $namespace, |
584: | $uses, |
585: | $className, |
586: | $functionName, |
587: | ($typeMapCb !== null ? $typeMapCb() : TemplateTypeMap::createEmpty()), |
588: | $typeAliasesMap, |
589: | false, |
590: | $constUses, |
591: | $lookForTrait, |
592: | ); |
593: | } |
594: | |
595: | if ($node instanceof Node\Stmt\ClassLike || $node instanceof Node\Stmt\ClassMethod || $node instanceof Node\Stmt\Function_) { |
596: | |
597: | if (array_key_exists($nameScopeKey, $phpDocNodeMap)) { |
598: | return self::POP_TYPE_MAP_STACK; |
599: | } |
600: | |
601: | return null; |
602: | } |
603: | |
604: | if ($node instanceof Node\Stmt\Namespace_) { |
605: | $namespace = $node->name !== null ? (string) $node->name : null; |
606: | } elseif ($node instanceof Node\Stmt\Use_) { |
607: | if ($node->type === Node\Stmt\Use_::TYPE_NORMAL) { |
608: | foreach ($node->uses as $use) { |
609: | $uses[strtolower($use->getAlias()->name)] = (string) $use->name; |
610: | } |
611: | } elseif ($node->type === Node\Stmt\Use_::TYPE_CONSTANT) { |
612: | foreach ($node->uses as $use) { |
613: | $constUses[strtolower($use->getAlias()->name)] = (string) $use->name; |
614: | } |
615: | } |
616: | } elseif ($node instanceof Node\Stmt\GroupUse) { |
617: | $prefix = (string) $node->prefix; |
618: | foreach ($node->uses as $use) { |
619: | if ($node->type === Node\Stmt\Use_::TYPE_NORMAL || $use->type === Node\Stmt\Use_::TYPE_NORMAL) { |
620: | $uses[strtolower($use->getAlias()->name)] = sprintf('%s\\%s', $prefix, (string) $use->name); |
621: | } elseif ($node->type === Node\Stmt\Use_::TYPE_CONSTANT || $use->type === Node\Stmt\Use_::TYPE_CONSTANT) { |
622: | $constUses[strtolower($use->getAlias()->name)] = sprintf('%s\\%s', $prefix, (string) $use->name); |
623: | } |
624: | } |
625: | } elseif ($node instanceof Node\Stmt\TraitUse) { |
626: | $traitMethodAliases = []; |
627: | foreach ($node->adaptations as $traitUseAdaptation) { |
628: | if (!$traitUseAdaptation instanceof Node\Stmt\TraitUseAdaptation\Alias) { |
629: | continue; |
630: | } |
631: | |
632: | if ($traitUseAdaptation->newName === null) { |
633: | continue; |
634: | } |
635: | |
636: | $methodName = $traitUseAdaptation->method->toString(); |
637: | $newTraitName = $traitUseAdaptation->newName->toString(); |
638: | |
639: | if ($traitUseAdaptation->trait === null) { |
640: | foreach ($node->traits as $traitName) { |
641: | $traitMethodAliases[$traitName->toString()][$methodName] = $newTraitName; |
642: | } |
643: | continue; |
644: | } |
645: | |
646: | $traitMethodAliases[$traitUseAdaptation->trait->toString()][$methodName] = $newTraitName; |
647: | } |
648: | |
649: | $useDocComment = null; |
650: | if ($node->getDocComment() !== null) { |
651: | $useDocComment = $node->getDocComment()->getText(); |
652: | } |
653: | |
654: | foreach ($node->traits as $traitName) { |
655: | |
656: | $traitName = (string) $traitName; |
657: | $reflectionProvider = $this->reflectionProviderProvider->getReflectionProvider(); |
658: | if (!$reflectionProvider->hasClass($traitName)) { |
659: | continue; |
660: | } |
661: | |
662: | $traitReflection = $reflectionProvider->getClass($traitName); |
663: | if (!$traitReflection->isTrait()) { |
664: | continue; |
665: | } |
666: | if ($traitReflection->getFileName() === null) { |
667: | continue; |
668: | } |
669: | if (!is_file($traitReflection->getFileName())) { |
670: | continue; |
671: | } |
672: | |
673: | $className = $classStack[count($classStack) - 1] ?? null; |
674: | if ($className === null) { |
675: | throw new ShouldNotHappenException(); |
676: | } |
677: | |
678: | $traitPhpDocMap = $this->createNameScopeMap( |
679: | $traitReflection->getFileName(), |
680: | $traitName, |
681: | $className, |
682: | $traitMethodAliases[$traitName] ?? [], |
683: | $originalClassFileName, |
684: | $phpDocNodeMap, |
685: | ); |
686: | $finalTraitPhpDocMap = []; |
687: | foreach ($traitPhpDocMap as $nameScopeTraitKey => $callback) { |
688: | $finalTraitPhpDocMap[$nameScopeTraitKey] = function () use ($callback, $traitReflection, $fileName, $className, $lookForTrait, $useDocComment): NameScope { |
689: | |
690: | $original = $callback(); |
691: | if (!$traitReflection->isGeneric()) { |
692: | return $original; |
693: | } |
694: | |
695: | $traitTemplateTypeMap = $traitReflection->getTemplateTypeMap(); |
696: | |
697: | $useType = null; |
698: | if ($useDocComment !== null) { |
699: | $useTags = $this->getResolvedPhpDoc( |
700: | $fileName, |
701: | $className, |
702: | $lookForTrait, |
703: | null, |
704: | $useDocComment, |
705: | )->getUsesTags(); |
706: | foreach ($useTags as $useTag) { |
707: | $useTagType = $useTag->getType(); |
708: | if (!$useTagType instanceof GenericObjectType) { |
709: | continue; |
710: | } |
711: | |
712: | if ($useTagType->getClassName() !== $traitReflection->getName()) { |
713: | continue; |
714: | } |
715: | |
716: | $useType = $useTagType; |
717: | break; |
718: | } |
719: | } |
720: | |
721: | if ($useType === null) { |
722: | return $original->withTemplateTypeMap($traitTemplateTypeMap->resolveToBounds()); |
723: | } |
724: | |
725: | $transformedTraitTypeMap = $traitReflection->typeMapFromList($useType->getTypes()); |
726: | |
727: | return $original->withTemplateTypeMap($traitTemplateTypeMap->map(static fn (string $name, Type $type): Type => TemplateTypeHelper::resolveTemplateTypes($type, $transformedTraitTypeMap, TemplateTypeVarianceMap::createEmpty(), TemplateTypeVariance::createStatic()))); |
728: | }; |
729: | } |
730: | $nameScopeMap = array_merge($nameScopeMap, $finalTraitPhpDocMap); |
731: | } |
732: | } |
733: | |
734: | return null; |
735: | }, |
736: | static function (Node $node, $callbackResult) use (&$namespace, &$functionStack, &$classStack, &$typeAliasStack, &$uses, &$typeMapStack, &$constUses): void { |
737: | if ($node instanceof Node\Stmt\ClassLike) { |
738: | if (count($classStack) === 0) { |
739: | throw new ShouldNotHappenException(); |
740: | } |
741: | array_pop($classStack); |
742: | |
743: | if (count($typeAliasStack) === 0) { |
744: | throw new ShouldNotHappenException(); |
745: | } |
746: | |
747: | array_pop($typeAliasStack); |
748: | |
749: | if (count($functionStack) === 0) { |
750: | throw new ShouldNotHappenException(); |
751: | } |
752: | |
753: | array_pop($functionStack); |
754: | } elseif ($node instanceof Node\Stmt\Namespace_) { |
755: | $namespace = null; |
756: | $uses = []; |
757: | $constUses = []; |
758: | } elseif ($node instanceof Node\Stmt\ClassMethod || $node instanceof Node\Stmt\Function_) { |
759: | if (count($functionStack) === 0) { |
760: | throw new ShouldNotHappenException(); |
761: | } |
762: | |
763: | array_pop($functionStack); |
764: | } elseif ($node instanceof Node\PropertyHook) { |
765: | $propertyName = $node->getAttribute('propertyName'); |
766: | if ($propertyName !== null) { |
767: | if (count($functionStack) === 0) { |
768: | throw new ShouldNotHappenException(); |
769: | } |
770: | |
771: | array_pop($functionStack); |
772: | } |
773: | } |
774: | if ($callbackResult !== self::POP_TYPE_MAP_STACK) { |
775: | return; |
776: | } |
777: | |
778: | if (count($typeMapStack) === 0) { |
779: | throw new ShouldNotHappenException(); |
780: | } |
781: | array_pop($typeMapStack); |
782: | }, |
783: | ); |
784: | |
785: | if (count($typeMapStack) > 0) { |
786: | throw new ShouldNotHappenException(); |
787: | } |
788: | |
789: | return $nameScopeMap; |
790: | } |
791: | |
792: | |
793: | |
794: | |
795: | private function getTypeAliasesMap(PhpDocNode $phpDocNode): array |
796: | { |
797: | $nameScope = new NameScope(null, []); |
798: | |
799: | $aliasesMap = []; |
800: | foreach (array_keys($this->phpDocNodeResolver->resolveTypeAliasImportTags($phpDocNode, $nameScope)) as $key) { |
801: | $aliasesMap[$key] = true; |
802: | } |
803: | |
804: | foreach (array_keys($this->phpDocNodeResolver->resolveTypeAliasTags($phpDocNode, $nameScope)) as $key) { |
805: | $aliasesMap[$key] = true; |
806: | } |
807: | |
808: | return $aliasesMap; |
809: | } |
810: | |
811: | |
812: | |
813: | |
814: | |
815: | |
816: | private function processNodes($node, Closure $nodeCallback, Closure $endNodeCallback): void |
817: | { |
818: | if ($node instanceof Node) { |
819: | $callbackResult = $nodeCallback($node); |
820: | if ($callbackResult === self::SKIP_NODE) { |
821: | return; |
822: | } |
823: | foreach ($node->getSubNodeNames() as $subNodeName) { |
824: | $subNode = $node->{$subNodeName}; |
825: | $this->processNodes($subNode, $nodeCallback, $endNodeCallback); |
826: | } |
827: | $endNodeCallback($node, $callbackResult); |
828: | } elseif (is_array($node)) { |
829: | foreach ($node as $subNode) { |
830: | $this->processNodes($subNode, $nodeCallback, $endNodeCallback); |
831: | } |
832: | } |
833: | } |
834: | |
835: | private function getNameScopeKey( |
836: | ?string $file, |
837: | ?string $class, |
838: | ?string $trait, |
839: | ?string $function, |
840: | ): string |
841: | { |
842: | if ($class === null && $trait === null && $function === null) { |
843: | return md5(sprintf('%s', $file ?? 'no-file')); |
844: | } |
845: | |
846: | if ($class !== null && str_contains($class, 'class@anonymous')) { |
847: | throw new ShouldNotHappenException('Wrong anonymous class name, FilTypeMapper should be called with ClassReflection::getName().'); |
848: | } |
849: | |
850: | return md5(sprintf('%s-%s-%s-%s', $file ?? 'no-file', $class, $trait, $function)); |
851: | } |
852: | |
853: | } |
854: | |