Namespaces

Classes

Interfaces

1: <?php declare(strict_types = 1);
2:
3: namespace PHPStan\Type;
4:
5: use Closure;
6: use PHPStan\Analyser\OutOfClassScope;
7: use PHPStan\Node\InvalidateExprNode;
8: use PHPStan\Php\PhpVersion;
9: use PHPStan\PhpDoc\Tag\TemplateTag;
10: use PHPStan\PhpDocParser\Ast\PhpDoc\TemplateTagValueNode;
11: use PHPStan\PhpDocParser\Ast\Type\CallableTypeNode;
12: use PHPStan\PhpDocParser\Ast\Type\CallableTypeParameterNode;
13: use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
14: use PHPStan\PhpDocParser\Ast\Type\TypeNode;
15: use PHPStan\PhpDocParser\Printer\Printer;
16: use PHPStan\Reflection\Callables\CallableParametersAcceptor;
17: use PHPStan\Reflection\Callables\SimpleImpurePoint;
18: use PHPStan\Reflection\Callables\SimpleThrowPoint;
19: use PHPStan\Reflection\ClassConstantReflection;
20: use PHPStan\Reflection\ClassMemberAccessAnswerer;
21: use PHPStan\Reflection\ClassReflection;
22: use PHPStan\Reflection\ExtendedMethodReflection;
23: use PHPStan\Reflection\ExtendedPropertyReflection;
24: use PHPStan\Reflection\Native\NativeParameterReflection;
25: use PHPStan\Reflection\ParameterReflection;
26: use PHPStan\Reflection\ParametersAcceptor;
27: use PHPStan\Reflection\ParametersAcceptorSelector;
28: use PHPStan\Reflection\PassedByReference;
29: use PHPStan\Reflection\Php\ClosureCallUnresolvedMethodPrototypeReflection;
30: use PHPStan\Reflection\Php\DummyParameter;
31: use PHPStan\Reflection\Type\UnresolvedMethodPrototypeReflection;
32: use PHPStan\Reflection\Type\UnresolvedPropertyPrototypeReflection;
33: use PHPStan\TrinaryLogic;
34: use PHPStan\Type\Constant\ConstantArrayType;
35: use PHPStan\Type\Constant\ConstantBooleanType;
36: use PHPStan\Type\Constant\ConstantIntegerType;
37: use PHPStan\Type\Generic\TemplateType;
38: use PHPStan\Type\Generic\TemplateTypeHelper;
39: use PHPStan\Type\Generic\TemplateTypeMap;
40: use PHPStan\Type\Generic\TemplateTypeVariance;
41: use PHPStan\Type\Generic\TemplateTypeVarianceMap;
42: use PHPStan\Type\Traits\NonArrayTypeTrait;
43: use PHPStan\Type\Traits\NonGeneralizableTypeTrait;
44: use PHPStan\Type\Traits\NonIterableTypeTrait;
45: use PHPStan\Type\Traits\NonOffsetAccessibleTypeTrait;
46: use PHPStan\Type\Traits\NonRemoveableTypeTrait;
47: use PHPStan\Type\Traits\UndecidedComparisonTypeTrait;
48: use function array_map;
49: use function array_merge;
50: use function count;
51:
52: /** @api */
53: class ClosureType implements TypeWithClassName, CallableParametersAcceptor
54: {
55:
56: use NonArrayTypeTrait;
57: use NonIterableTypeTrait;
58: use UndecidedComparisonTypeTrait;
59: use NonOffsetAccessibleTypeTrait;
60: use NonRemoveableTypeTrait;
61: use NonGeneralizableTypeTrait;
62:
63: /** @var list<ParameterReflection> */
64: private array $parameters;
65:
66: private Type $returnType;
67:
68: private bool $isCommonCallable;
69:
70: private ObjectType $objectType;
71:
72: private TemplateTypeMap $templateTypeMap;
73:
74: private TemplateTypeMap $resolvedTemplateTypeMap;
75:
76: private TemplateTypeVarianceMap $callSiteVarianceMap;
77:
78: /** @var SimpleImpurePoint[] */
79: private array $impurePoints;
80:
81: private TrinaryLogic $acceptsNamedArguments;
82:
83: /**
84: * @api
85: * @param list<ParameterReflection>|null $parameters
86: * @param array<non-empty-string, TemplateTag> $templateTags
87: * @param SimpleThrowPoint[] $throwPoints
88: * @param ?SimpleImpurePoint[] $impurePoints
89: * @param InvalidateExprNode[] $invalidateExpressions
90: * @param string[] $usedVariables
91: */
92: public function __construct(
93: ?array $parameters = null,
94: ?Type $returnType = null,
95: private bool $variadic = true,
96: ?TemplateTypeMap $templateTypeMap = null,
97: ?TemplateTypeMap $resolvedTemplateTypeMap = null,
98: ?TemplateTypeVarianceMap $callSiteVarianceMap = null,
99: private array $templateTags = [],
100: private array $throwPoints = [],
101: ?array $impurePoints = null,
102: private array $invalidateExpressions = [],
103: private array $usedVariables = [],
104: ?TrinaryLogic $acceptsNamedArguments = null,
105: )
106: {
107: if ($acceptsNamedArguments === null) {
108: $acceptsNamedArguments = TrinaryLogic::createYes();
109: }
110: $this->acceptsNamedArguments = $acceptsNamedArguments;
111:
112: $this->parameters = $parameters ?? [];
113: $this->returnType = $returnType ?? new MixedType();
114: $this->isCommonCallable = $parameters === null && $returnType === null;
115: $this->objectType = new ObjectType(Closure::class);
116: $this->templateTypeMap = $templateTypeMap ?? TemplateTypeMap::createEmpty();
117: $this->resolvedTemplateTypeMap = $resolvedTemplateTypeMap ?? TemplateTypeMap::createEmpty();
118: $this->callSiteVarianceMap = $callSiteVarianceMap ?? TemplateTypeVarianceMap::createEmpty();
119: $this->impurePoints = $impurePoints ?? [new SimpleImpurePoint('functionCall', 'call to an unknown Closure', false)];
120: }
121:
122: /**
123: * @return array<non-empty-string, TemplateTag>
124: */
125: public function getTemplateTags(): array
126: {
127: return $this->templateTags;
128: }
129:
130: public static function createPure(): self
131: {
132: return new self(null, null, true, null, null, null, [], [], []);
133: }
134:
135: public function isPure(): TrinaryLogic
136: {
137: $impurePoints = $this->getImpurePoints();
138: if (count($impurePoints) === 0) {
139: return TrinaryLogic::createYes();
140: }
141:
142: $certainCount = 0;
143: foreach ($impurePoints as $impurePoint) {
144: if (!$impurePoint->isCertain()) {
145: continue;
146: }
147:
148: $certainCount++;
149: }
150:
151: return $certainCount > 0 ? TrinaryLogic::createNo() : TrinaryLogic::createMaybe();
152: }
153:
154: public function getClassName(): string
155: {
156: return $this->objectType->getClassName();
157: }
158:
159: public function getClassReflection(): ?ClassReflection
160: {
161: return $this->objectType->getClassReflection();
162: }
163:
164: public function getAncestorWithClassName(string $className): ?TypeWithClassName
165: {
166: return $this->objectType->getAncestorWithClassName($className);
167: }
168:
169: public function getReferencedClasses(): array
170: {
171: $classes = $this->objectType->getReferencedClasses();
172: foreach ($this->parameters as $parameter) {
173: $classes = array_merge($classes, $parameter->getType()->getReferencedClasses());
174: }
175:
176: return array_merge($classes, $this->returnType->getReferencedClasses());
177: }
178:
179: public function getObjectClassNames(): array
180: {
181: return $this->objectType->getObjectClassNames();
182: }
183:
184: public function getObjectClassReflections(): array
185: {
186: return $this->objectType->getObjectClassReflections();
187: }
188:
189: public function accepts(Type $type, bool $strictTypes): AcceptsResult
190: {
191: if ($type instanceof CompoundType) {
192: return $type->isAcceptedBy($this, $strictTypes);
193: }
194:
195: if (!$type instanceof ClosureType) {
196: return $this->objectType->accepts($type, $strictTypes);
197: }
198:
199: return $this->isSuperTypeOfInternal($type, true)->toAcceptsResult();
200: }
201:
202: public function isSuperTypeOf(Type $type): IsSuperTypeOfResult
203: {
204: if ($type instanceof CompoundType) {
205: return $type->isSubTypeOf($this);
206: }
207:
208: return $this->isSuperTypeOfInternal($type, false);
209: }
210:
211: private function isSuperTypeOfInternal(Type $type, bool $treatMixedAsAny): IsSuperTypeOfResult
212: {
213: if ($type instanceof self) {
214: $parameterTypes = array_map(static fn ($parameter) => $parameter->getType(), $this->getParameters());
215: $variant = ParametersAcceptorSelector::selectFromTypes($parameterTypes, [$type], false);
216: if (!$variant instanceof CallableParametersAcceptor) {
217: return IsSuperTypeOfResult::createNo([]);
218: }
219: return CallableTypeHelper::isParametersAcceptorSuperTypeOf(
220: $this,
221: $variant,
222: $treatMixedAsAny,
223: );
224: }
225:
226: if ($type->getObjectClassNames() === [Closure::class]) {
227: return IsSuperTypeOfResult::createMaybe();
228: }
229:
230: return $this->objectType->isSuperTypeOf($type);
231: }
232:
233: public function equals(Type $type): bool
234: {
235: if (!$type instanceof self) {
236: return false;
237: }
238:
239: return $this->describe(VerbosityLevel::precise()) === $type->describe(VerbosityLevel::precise())
240: && $this->isPure()->equals($type->isPure());
241: }
242:
243: public function describe(VerbosityLevel $level): string
244: {
245: return $level->handle(
246: static fn (): string => 'Closure',
247: function (): string {
248: if ($this->isCommonCallable) {
249: return $this->isPure()->yes() ? 'pure-Closure' : 'Closure';
250: }
251:
252: $printer = new Printer();
253: $selfWithoutParameterNames = new self(
254: array_map(static fn (ParameterReflection $p): ParameterReflection => new DummyParameter(
255: '',
256: $p->getType(),
257: $p->isOptional() && !$p->isVariadic(),
258: PassedByReference::createNo(),
259: $p->isVariadic(),
260: $p->getDefaultValue(),
261: ), $this->parameters),
262: $this->returnType,
263: $this->variadic,
264: $this->templateTypeMap,
265: $this->resolvedTemplateTypeMap,
266: $this->callSiteVarianceMap,
267: $this->templateTags,
268: $this->throwPoints,
269: $this->impurePoints,
270: $this->invalidateExpressions,
271: $this->usedVariables,
272: );
273:
274: return $printer->print($selfWithoutParameterNames->toPhpDocNode());
275: },
276: );
277: }
278:
279: public function isOffsetAccessLegal(): TrinaryLogic
280: {
281: return TrinaryLogic::createNo();
282: }
283:
284: public function isObject(): TrinaryLogic
285: {
286: return $this->objectType->isObject();
287: }
288:
289: public function isEnum(): TrinaryLogic
290: {
291: return $this->objectType->isEnum();
292: }
293:
294: public function getTemplateType(string $ancestorClassName, string $templateTypeName): Type
295: {
296: return $this->objectType->getTemplateType($ancestorClassName, $templateTypeName);
297: }
298:
299: public function canAccessProperties(): TrinaryLogic
300: {
301: return $this->objectType->canAccessProperties();
302: }
303:
304: public function hasProperty(string $propertyName): TrinaryLogic
305: {
306: return $this->objectType->hasProperty($propertyName);
307: }
308:
309: public function getProperty(string $propertyName, ClassMemberAccessAnswerer $scope): ExtendedPropertyReflection
310: {
311: return $this->objectType->getProperty($propertyName, $scope);
312: }
313:
314: public function getUnresolvedPropertyPrototype(string $propertyName, ClassMemberAccessAnswerer $scope): UnresolvedPropertyPrototypeReflection
315: {
316: return $this->objectType->getUnresolvedPropertyPrototype($propertyName, $scope);
317: }
318:
319: public function canCallMethods(): TrinaryLogic
320: {
321: return $this->objectType->canCallMethods();
322: }
323:
324: public function hasMethod(string $methodName): TrinaryLogic
325: {
326: return $this->objectType->hasMethod($methodName);
327: }
328:
329: public function getMethod(string $methodName, ClassMemberAccessAnswerer $scope): ExtendedMethodReflection
330: {
331: return $this->getUnresolvedMethodPrototype($methodName, $scope)->getTransformedMethod();
332: }
333:
334: public function getUnresolvedMethodPrototype(string $methodName, ClassMemberAccessAnswerer $scope): UnresolvedMethodPrototypeReflection
335: {
336: if ($methodName === 'call') {
337: return new ClosureCallUnresolvedMethodPrototypeReflection(
338: $this->objectType->getUnresolvedMethodPrototype($methodName, $scope),
339: $this,
340: );
341: }
342:
343: return $this->objectType->getUnresolvedMethodPrototype($methodName, $scope);
344: }
345:
346: public function canAccessConstants(): TrinaryLogic
347: {
348: return $this->objectType->canAccessConstants();
349: }
350:
351: public function hasConstant(string $constantName): TrinaryLogic
352: {
353: return $this->objectType->hasConstant($constantName);
354: }
355:
356: public function getConstant(string $constantName): ClassConstantReflection
357: {
358: return $this->objectType->getConstant($constantName);
359: }
360:
361: public function getConstantStrings(): array
362: {
363: return [];
364: }
365:
366: public function isIterable(): TrinaryLogic
367: {
368: return TrinaryLogic::createNo();
369: }
370:
371: public function isIterableAtLeastOnce(): TrinaryLogic
372: {
373: return TrinaryLogic::createNo();
374: }
375:
376: public function isCallable(): TrinaryLogic
377: {
378: return TrinaryLogic::createYes();
379: }
380:
381: public function getEnumCases(): array
382: {
383: return [];
384: }
385:
386: public function isCommonCallable(): bool
387: {
388: return $this->isCommonCallable;
389: }
390:
391: public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope): array
392: {
393: return [$this];
394: }
395:
396: public function getThrowPoints(): array
397: {
398: return $this->throwPoints;
399: }
400:
401: public function getImpurePoints(): array
402: {
403: return $this->impurePoints;
404: }
405:
406: public function getInvalidateExpressions(): array
407: {
408: return $this->invalidateExpressions;
409: }
410:
411: public function getUsedVariables(): array
412: {
413: return $this->usedVariables;
414: }
415:
416: public function acceptsNamedArguments(): TrinaryLogic
417: {
418: return $this->acceptsNamedArguments;
419: }
420:
421: public function isCloneable(): TrinaryLogic
422: {
423: return TrinaryLogic::createYes();
424: }
425:
426: public function toBoolean(): BooleanType
427: {
428: return new ConstantBooleanType(true);
429: }
430:
431: public function toNumber(): Type
432: {
433: return new ErrorType();
434: }
435:
436: public function toAbsoluteNumber(): Type
437: {
438: return new ErrorType();
439: }
440:
441: public function toInteger(): Type
442: {
443: return new ErrorType();
444: }
445:
446: public function toFloat(): Type
447: {
448: return new ErrorType();
449: }
450:
451: public function toString(): Type
452: {
453: return new ErrorType();
454: }
455:
456: public function toArray(): Type
457: {
458: return new ConstantArrayType(
459: [new ConstantIntegerType(0)],
460: [$this],
461: [1],
462: isList: TrinaryLogic::createYes(),
463: );
464: }
465:
466: public function toArrayKey(): Type
467: {
468: return new ErrorType();
469: }
470:
471: public function toCoercedArgumentType(bool $strictTypes): Type
472: {
473: return TypeCombinator::union($this, new CallableType());
474: }
475:
476: public function getTemplateTypeMap(): TemplateTypeMap
477: {
478: return $this->templateTypeMap;
479: }
480:
481: public function getResolvedTemplateTypeMap(): TemplateTypeMap
482: {
483: return $this->resolvedTemplateTypeMap;
484: }
485:
486: public function getCallSiteVarianceMap(): TemplateTypeVarianceMap
487: {
488: return $this->callSiteVarianceMap;
489: }
490:
491: /**
492: * @return list<ParameterReflection>
493: */
494: public function getParameters(): array
495: {
496: return $this->parameters;
497: }
498:
499: public function isVariadic(): bool
500: {
501: return $this->variadic;
502: }
503:
504: public function getReturnType(): Type
505: {
506: return $this->returnType;
507: }
508:
509: public function inferTemplateTypes(Type $receivedType): TemplateTypeMap
510: {
511: if ($receivedType instanceof UnionType || $receivedType instanceof IntersectionType) {
512: return $receivedType->inferTemplateTypesOn($this);
513: }
514:
515: if ($receivedType->isCallable()->no() || ! $receivedType instanceof self) {
516: return TemplateTypeMap::createEmpty();
517: }
518:
519: $parametersAcceptors = $receivedType->getCallableParametersAcceptors(new OutOfClassScope());
520:
521: $typeMap = TemplateTypeMap::createEmpty();
522:
523: foreach ($parametersAcceptors as $parametersAcceptor) {
524: $typeMap = $typeMap->union($this->inferTemplateTypesOnParametersAcceptor($parametersAcceptor));
525: }
526:
527: return $typeMap;
528: }
529:
530: private function inferTemplateTypesOnParametersAcceptor(ParametersAcceptor $parametersAcceptor): TemplateTypeMap
531: {
532: $parameterTypes = array_map(static fn ($parameter) => $parameter->getType(), $this->getParameters());
533: $parametersAcceptor = ParametersAcceptorSelector::selectFromTypes($parameterTypes, [$parametersAcceptor], false);
534: $args = $parametersAcceptor->getParameters();
535: $returnType = $parametersAcceptor->getReturnType();
536:
537: $typeMap = TemplateTypeMap::createEmpty();
538: foreach ($this->getParameters() as $i => $param) {
539: $paramType = $param->getType();
540: if (isset($args[$i])) {
541: $argType = $args[$i]->getType();
542: } elseif ($paramType instanceof TemplateType) {
543: $argType = TemplateTypeHelper::resolveToBounds($paramType);
544: } else {
545: $argType = new NeverType();
546: }
547:
548: $typeMap = $typeMap->union($paramType->inferTemplateTypes($argType)->convertToLowerBoundTypes());
549: }
550:
551: return $typeMap->union($this->getReturnType()->inferTemplateTypes($returnType));
552: }
553:
554: public function getReferencedTemplateTypes(TemplateTypeVariance $positionVariance): array
555: {
556: $references = $this->getReturnType()->getReferencedTemplateTypes(
557: $positionVariance->compose(TemplateTypeVariance::createCovariant()),
558: );
559:
560: $paramVariance = $positionVariance->compose(TemplateTypeVariance::createContravariant());
561:
562: foreach ($this->getParameters() as $param) {
563: foreach ($param->getType()->getReferencedTemplateTypes($paramVariance) as $reference) {
564: $references[] = $reference;
565: }
566: }
567:
568: return $references;
569: }
570:
571: public function traverse(callable $cb): Type
572: {
573: if ($this->isCommonCallable) {
574: return $this;
575: }
576:
577: return new self(
578: array_map(static function (ParameterReflection $param) use ($cb): NativeParameterReflection {
579: $defaultValue = $param->getDefaultValue();
580: return new NativeParameterReflection(
581: $param->getName(),
582: $param->isOptional(),
583: $cb($param->getType()),
584: $param->passedByReference(),
585: $param->isVariadic(),
586: $defaultValue !== null ? $cb($defaultValue) : null,
587: );
588: }, $this->getParameters()),
589: $cb($this->getReturnType()),
590: $this->isVariadic(),
591: $this->templateTypeMap,
592: $this->resolvedTemplateTypeMap,
593: $this->callSiteVarianceMap,
594: $this->templateTags,
595: $this->throwPoints,
596: $this->impurePoints,
597: $this->invalidateExpressions,
598: $this->usedVariables,
599: $this->acceptsNamedArguments,
600: );
601: }
602:
603: public function traverseSimultaneously(Type $right, callable $cb): Type
604: {
605: if ($this->isCommonCallable) {
606: return $this;
607: }
608:
609: if (!$right instanceof self) {
610: return $this;
611: }
612:
613: $rightParameters = $right->getParameters();
614: if (count($this->getParameters()) !== count($rightParameters)) {
615: return $this;
616: }
617:
618: $parameters = [];
619: foreach ($this->getParameters() as $i => $leftParam) {
620: $rightParam = $rightParameters[$i];
621: $leftDefaultValue = $leftParam->getDefaultValue();
622: $rightDefaultValue = $rightParam->getDefaultValue();
623: $defaultValue = $leftDefaultValue;
624: if ($leftDefaultValue !== null && $rightDefaultValue !== null) {
625: $defaultValue = $cb($leftDefaultValue, $rightDefaultValue);
626: }
627: $parameters[] = new NativeParameterReflection(
628: $leftParam->getName(),
629: $leftParam->isOptional(),
630: $cb($leftParam->getType(), $rightParam->getType()),
631: $leftParam->passedByReference(),
632: $leftParam->isVariadic(),
633: $defaultValue,
634: );
635: }
636:
637: return new self(
638: $parameters,
639: $cb($this->getReturnType(), $right->getReturnType()),
640: $this->isVariadic(),
641: $this->templateTypeMap,
642: $this->resolvedTemplateTypeMap,
643: $this->callSiteVarianceMap,
644: $this->templateTags,
645: $this->throwPoints,
646: $this->impurePoints,
647: $this->invalidateExpressions,
648: $this->usedVariables,
649: $this->acceptsNamedArguments,
650: );
651: }
652:
653: public function isNull(): TrinaryLogic
654: {
655: return TrinaryLogic::createNo();
656: }
657:
658: public function isConstantValue(): TrinaryLogic
659: {
660: return TrinaryLogic::createNo();
661: }
662:
663: public function isConstantScalarValue(): TrinaryLogic
664: {
665: return TrinaryLogic::createNo();
666: }
667:
668: public function getConstantScalarTypes(): array
669: {
670: return [];
671: }
672:
673: public function getConstantScalarValues(): array
674: {
675: return [];
676: }
677:
678: public function isTrue(): TrinaryLogic
679: {
680: return TrinaryLogic::createNo();
681: }
682:
683: public function isFalse(): TrinaryLogic
684: {
685: return TrinaryLogic::createNo();
686: }
687:
688: public function isBoolean(): TrinaryLogic
689: {
690: return TrinaryLogic::createNo();
691: }
692:
693: public function isFloat(): TrinaryLogic
694: {
695: return TrinaryLogic::createNo();
696: }
697:
698: public function isInteger(): TrinaryLogic
699: {
700: return TrinaryLogic::createNo();
701: }
702:
703: public function isString(): TrinaryLogic
704: {
705: return TrinaryLogic::createNo();
706: }
707:
708: public function isNumericString(): TrinaryLogic
709: {
710: return TrinaryLogic::createNo();
711: }
712:
713: public function isNonEmptyString(): TrinaryLogic
714: {
715: return TrinaryLogic::createNo();
716: }
717:
718: public function isNonFalsyString(): TrinaryLogic
719: {
720: return TrinaryLogic::createNo();
721: }
722:
723: public function isLiteralString(): TrinaryLogic
724: {
725: return TrinaryLogic::createNo();
726: }
727:
728: public function isLowercaseString(): TrinaryLogic
729: {
730: return TrinaryLogic::createNo();
731: }
732:
733: public function isClassString(): TrinaryLogic
734: {
735: return TrinaryLogic::createNo();
736: }
737:
738: public function isUppercaseString(): TrinaryLogic
739: {
740: return TrinaryLogic::createNo();
741: }
742:
743: public function getClassStringObjectType(): Type
744: {
745: return new ErrorType();
746: }
747:
748: public function getObjectTypeOrClassStringObjectType(): Type
749: {
750: return $this;
751: }
752:
753: public function isVoid(): TrinaryLogic
754: {
755: return TrinaryLogic::createNo();
756: }
757:
758: public function isScalar(): TrinaryLogic
759: {
760: return TrinaryLogic::createNo();
761: }
762:
763: public function looseCompare(Type $type, PhpVersion $phpVersion): BooleanType
764: {
765: return new BooleanType();
766: }
767:
768: public function exponentiate(Type $exponent): Type
769: {
770: return new ErrorType();
771: }
772:
773: public function getFiniteTypes(): array
774: {
775: return [];
776: }
777:
778: public function toPhpDocNode(): TypeNode
779: {
780: if ($this->isCommonCallable) {
781: return new IdentifierTypeNode($this->isPure()->yes() ? 'pure-Closure' : 'Closure');
782: }
783:
784: $parameters = [];
785: foreach ($this->parameters as $parameter) {
786: $parameters[] = new CallableTypeParameterNode(
787: $parameter->getType()->toPhpDocNode(),
788: !$parameter->passedByReference()->no(),
789: $parameter->isVariadic(),
790: $parameter->getName() === '' ? '' : '$' . $parameter->getName(),
791: $parameter->isOptional(),
792: );
793: }
794:
795: $templateTags = [];
796: foreach ($this->templateTags as $templateName => $templateTag) {
797: $templateTags[] = new TemplateTagValueNode(
798: $templateName,
799: $templateTag->getBound()->toPhpDocNode(),
800: '',
801: );
802: }
803:
804: return new CallableTypeNode(
805: new IdentifierTypeNode('Closure'),
806: $parameters,
807: $this->returnType->toPhpDocNode(),
808: $templateTags,
809: );
810: }
811:
812: }
813:
PHPStan API documentation generated by ApiGen dev-master