1: <?php declare(strict_types = 1);
2:
3: namespace PHPStan\Reflection;
4:
5: use Closure;
6: use PhpParser\Node;
7: use PhpParser\Node\Expr;
8: use PHPStan\Analyser\ArgumentsNormalizer;
9: use PHPStan\Analyser\MutatingScope;
10: use PHPStan\Analyser\Scope;
11: use PHPStan\Node\Expr\ParameterVariableOriginalValueExpr;
12: use PHPStan\Parser\ArrayFilterArgVisitor;
13: use PHPStan\Parser\ArrayFindArgVisitor;
14: use PHPStan\Parser\ArrayMapArgVisitor;
15: use PHPStan\Parser\ArrayWalkArgVisitor;
16: use PHPStan\Parser\ClosureBindArgVisitor;
17: use PHPStan\Parser\ClosureBindToVarVisitor;
18: use PHPStan\Parser\CurlSetOptArgVisitor;
19: use PHPStan\Parser\CurlSetOptArrayArgVisitor;
20: use PHPStan\Parser\ImplodeArgVisitor;
21: use PHPStan\Reflection\Callables\CallableParametersAcceptor;
22: use PHPStan\Reflection\Native\NativeParameterReflection;
23: use PHPStan\Reflection\Php\DummyParameter;
24: use PHPStan\Reflection\Php\ExtendedDummyParameter;
25: use PHPStan\ShouldNotHappenException;
26: use PHPStan\TrinaryLogic;
27: use PHPStan\Turbo\ShadowedByTurboExtension;
28: use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
29: use PHPStan\Type\ArrayType;
30: use PHPStan\Type\BooleanType;
31: use PHPStan\Type\CallableType;
32: use PHPStan\Type\Constant\ConstantArrayTypeBuilder;
33: use PHPStan\Type\Constant\ConstantIntegerType;
34: use PHPStan\Type\Generic\TemplateTypeMap;
35: use PHPStan\Type\Generic\TemplateTypeVarianceMap;
36: use PHPStan\Type\IntegerType;
37: use PHPStan\Type\IntersectionType;
38: use PHPStan\Type\MixedType;
39: use PHPStan\Type\NullType;
40: use PHPStan\Type\ObjectType;
41: use PHPStan\Type\ResourceType;
42: use PHPStan\Type\StringType;
43: use PHPStan\Type\Type;
44: use PHPStan\Type\TypeCombinator;
45: use PHPStan\Type\UnionType;
46: use function array_key_exists;
47: use function array_key_last;
48: use function array_last;
49: use function array_map;
50: use function array_merge;
51: use function array_slice;
52: use function array_values;
53: use function constant;
54: use function count;
55: use function defined;
56: use function is_int;
57: use function is_string;
58: use function sprintf;
59: use const ARRAY_FILTER_USE_BOTH;
60: use const ARRAY_FILTER_USE_KEY;
61: use const CURLOPT_SHARE;
62: use const CURLOPT_SSL_VERIFYHOST;
63:
64: /**
65: * @api
66: */
67: #[ShadowedByTurboExtension(implementation: __DIR__ . '/../../turbo-ext/src/ParametersAcceptorSelector.cpp')]
68: final class ParametersAcceptorSelector
69: {
70:
71: /**
72: * @param Node\Arg[] $args
73: * @param ParametersAcceptor[] $parametersAcceptors
74: * @param ParametersAcceptor[]|null $namedArgumentsVariants
75: */
76: public static function selectFromArgs(
77: Scope $scope,
78: array $args,
79: array $parametersAcceptors,
80: ?array $namedArgumentsVariants = null,
81: ): ParametersAcceptor
82: {
83: $types = [];
84: $unpack = false;
85: $parametersAcceptors = self::applyIntrinsicArgOverrides(
86: $args,
87: $parametersAcceptors,
88: $namedArgumentsVariants,
89: $scope,
90: static fn (Expr $e): Type => $scope->getType($e),
91: static fn (Expr $e): Type => $scope->getNativeType($e),
92: static fn (Type $t): Type => $scope->getIterableValueType($t),
93: static fn (Type $t): Type => $scope->getIterableKeyType($t),
94: );
95:
96: if (count($parametersAcceptors) === 1) {
97: $acceptor = $parametersAcceptors[0];
98: if (!self::hasAcceptorTemplateOrLateResolvableType($acceptor)) {
99: return $acceptor;
100: }
101: }
102:
103: $reorderedArgs = $args;
104: $singleParametersAcceptor = null;
105: if (count($parametersAcceptors) === 1) {
106: $reorderedArgs = ArgumentsNormalizer::reorderArgs($parametersAcceptors[0], $args);
107: $singleParametersAcceptor = $parametersAcceptors[0];
108: }
109:
110: $hasName = false;
111: foreach ($reorderedArgs ?? $args as $i => $arg) {
112: $originalArg = $arg->getAttribute(ArgumentsNormalizer::ORIGINAL_ARG_ATTRIBUTE) ?? $arg;
113: $parameter = null;
114: if ($singleParametersAcceptor !== null) {
115: $parameters = $singleParametersAcceptor->getParameters();
116: if (isset($parameters[$i])) {
117: $parameter = $parameters[$i];
118: } elseif (count($parameters) > 0 && $singleParametersAcceptor->isVariadic()) {
119: $parameter = array_last($parameters);
120: }
121: }
122:
123: if ($parameter !== null && $scope instanceof MutatingScope) {
124: $rememberTypes = !$originalArg->value instanceof Node\Expr\Closure && !$originalArg->value instanceof Node\Expr\ArrowFunction;
125: $scope = $scope->pushInFunctionCall(null, $parameter, $rememberTypes);
126: }
127:
128: $type = $scope->getType($originalArg->value);
129:
130: if ($parameter !== null && $scope instanceof MutatingScope) {
131: $scope = $scope->popInFunctionCall();
132: }
133:
134: if ($originalArg->name !== null) {
135: $index = $originalArg->name->toString();
136: $hasName = true;
137: } else {
138: $index = $i;
139: }
140: if ($originalArg->unpack) {
141: $unpack = true;
142: $constantArrays = $type->getConstantArrays();
143: if (count($constantArrays) > 0) {
144: foreach ($constantArrays as $constantArray) {
145: $values = $constantArray->getValueTypes();
146: foreach ($constantArray->getKeyTypes() as $j => $keyType) {
147: $valueType = $values[$j];
148: $valueIndex = $keyType->getValue();
149: if (is_string($valueIndex)) {
150: $hasName = true;
151: } else {
152: $valueIndex = $i + $j;
153: }
154:
155: $types[$valueIndex] = isset($types[$valueIndex])
156: ? TypeCombinator::union($types[$valueIndex], $valueType)
157: : $valueType;
158: }
159: }
160: } else {
161: $types[$index] = $type->getIterableValueType();
162: }
163: } else {
164: $types[$index] = $type;
165: }
166: }
167:
168: if ($hasName && $namedArgumentsVariants !== null) {
169: return self::selectFromTypes($types, $namedArgumentsVariants, $unpack);
170: }
171:
172: return self::selectFromTypes($types, $parametersAcceptors, $unpack);
173: }
174:
175: /**
176: * The intrinsic overrides read sibling arguments by their parameter
177: * position, so named arguments are put in signature order first.
178: *
179: * @param Node\Arg[] $args
180: * @return Node\Arg[]
181: */
182: private static function reorderIntrinsicArgs(array $args, ParametersAcceptor $parametersAcceptor): array
183: {
184: foreach ($args as $arg) {
185: if ($arg->name === null) {
186: continue;
187: }
188:
189: $reorderedArgs = ArgumentsNormalizer::reorderArgs($parametersAcceptor, $args);
190: if ($reorderedArgs === null || count($reorderedArgs) === 0) {
191: return $args;
192: }
193:
194: return $reorderedArgs;
195: }
196:
197: return $args;
198: }
199:
200: /**
201: * @internal
202: * @param Node\Arg[] $args
203: * @param ParametersAcceptor[] $parametersAcceptors
204: * @param ParametersAcceptor[]|null $namedArgumentsVariants
205: * @param Closure(Expr): Type $typeGetter
206: * @param Closure(Expr): Type $nativeTypeGetter
207: * @param Closure(Type): Type $iterableValueTypeGetter
208: * @param Closure(Type): Type $iterableKeyTypeGetter
209: * @return ParametersAcceptor[]
210: */
211: public static function applyIntrinsicArgOverrides(
212: array $args,
213: array $parametersAcceptors,
214: ?array $namedArgumentsVariants,
215: Scope $scope,
216: Closure $typeGetter,
217: Closure $nativeTypeGetter,
218: Closure $iterableValueTypeGetter,
219: Closure $iterableKeyTypeGetter,
220: ): array
221: {
222: if (
223: count($args) > 0
224: && count($parametersAcceptors) > 0
225: ) {
226: $positionalArgs = self::reorderIntrinsicArgs($args, $namedArgumentsVariants[0] ?? $parametersAcceptors[0]);
227: $arrayMapArgs = $positionalArgs[0]->value->getAttribute(ArrayMapArgVisitor::ATTRIBUTE_NAME);
228: if ($arrayMapArgs !== null) {
229: $callbackValueTypes = [];
230: $callbackArrayTypes = [];
231: $nativeCallbackValueTypes = [];
232: $nativeCallbackArrayTypes = [];
233: foreach ($arrayMapArgs as $arg) {
234: $argType = ($typeGetter)($arg->value);
235: $nativeArgType = ($nativeTypeGetter)($arg->value);
236: if ($arg->unpack) {
237: $constantArrays = $argType->getConstantArrays();
238: if (count($constantArrays) > 0) {
239: foreach ($constantArrays as $constantArray) {
240: $valueTypes = $constantArray->getValueTypes();
241: foreach ($valueTypes as $valueType) {
242: $callbackValueTypes[] = ($iterableValueTypeGetter)($valueType);
243: $callbackArrayTypes[] = $valueType;
244: }
245: }
246: }
247: $nativeConstantArrays = $nativeArgType->getConstantArrays();
248: if (count($nativeConstantArrays) > 0) {
249: foreach ($nativeConstantArrays as $constantArray) {
250: $valueTypes = $constantArray->getValueTypes();
251: foreach ($valueTypes as $valueType) {
252: $nativeCallbackValueTypes[] = ($iterableValueTypeGetter)($valueType);
253: $nativeCallbackArrayTypes[] = $valueType;
254: }
255: }
256: }
257: } else {
258: $callbackValueTypes[] = ($iterableValueTypeGetter)($argType);
259: $callbackArrayTypes[] = $argType;
260: $nativeCallbackValueTypes[] = ($iterableValueTypeGetter)($nativeArgType);
261: $nativeCallbackArrayTypes[] = $nativeArgType;
262: }
263: }
264:
265: $callbackParameters = [];
266: foreach (ArrayMapCallbackParameterTypes::addPaddingNull($callbackValueTypes, $callbackArrayTypes) as $valueType) {
267: $callbackParameters[] = new DummyParameter('item', $valueType, optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null);
268: }
269: $nativeCallbackParameters = [];
270: foreach (ArrayMapCallbackParameterTypes::addPaddingNull($nativeCallbackValueTypes, $nativeCallbackArrayTypes) as $valueType) {
271: $nativeCallbackParameters[] = new DummyParameter('item', $valueType, optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null);
272: }
273:
274: $acceptor = $parametersAcceptors[0];
275: $parameters = $acceptor->getParameters();
276: if (isset($parameters[0])) {
277: $callableType = new UnionType([
278: new CallableType($callbackParameters, new MixedType(), false),
279: new NullType(),
280: ]);
281: $nativeCallableType = new UnionType([
282: new CallableType($nativeCallbackParameters, new MixedType(), false),
283: new NullType(),
284: ]);
285: $parameters[0] = self::overrideParameterType($parameters[0], $callableType, $nativeCallableType);
286: $parametersAcceptors = [self::overrideAcceptorParameters($acceptor, $parameters)];
287: }
288: }
289:
290: if (count($positionalArgs) >= 3 && (bool) $positionalArgs[0]->getAttribute(CurlSetOptArgVisitor::ATTRIBUTE_NAME)) {
291: $optType = ($typeGetter)($positionalArgs[1]->value);
292:
293: $valueTypes = [];
294: foreach ($optType->getConstantScalarValues() as $scalarValue) {
295: if (!is_int($scalarValue)) {
296: $valueTypes = [];
297: break;
298: }
299:
300: $valueType = self::getCurlOptValueType($scalarValue);
301: if ($valueType === null) {
302: $valueTypes = [];
303: break;
304: }
305:
306: $valueTypes[] = $valueType;
307: }
308:
309: $acceptor = $parametersAcceptors[0];
310: $parameters = $acceptor->getParameters();
311: if (count($valueTypes) !== 0 && isset($parameters[2])) {
312: $parameters[2] = new NativeParameterReflection(
313: $parameters[2]->getName(),
314: $parameters[2]->isOptional(),
315: TypeCombinator::union(...$valueTypes),
316: $parameters[2]->passedByReference(),
317: $parameters[2]->isVariadic(),
318: $parameters[2]->getDefaultValue(),
319: );
320:
321: $parametersAcceptors = [
322: new FunctionVariant(
323: $acceptor->getTemplateTypeMap(),
324: $acceptor->getResolvedTemplateTypeMap(),
325: $parameters,
326: $acceptor->isVariadic(),
327: $acceptor->getReturnType(),
328: $acceptor instanceof ExtendedParametersAcceptor ? $acceptor->getCallSiteVarianceMap() : TemplateTypeVarianceMap::createEmpty(),
329: ),
330: ];
331: }
332: }
333:
334: if (count($positionalArgs) >= 2 && (bool) $positionalArgs[1]->getAttribute(CurlSetOptArrayArgVisitor::ATTRIBUTE_NAME)) {
335: $optArrayType = ($typeGetter)($positionalArgs[1]->value);
336:
337: $hasTypes = false;
338: $builder = ConstantArrayTypeBuilder::createEmpty();
339: foreach ($optArrayType->getIterableKeyType()->getConstantScalarTypes() as $optType) {
340: $optValue = $optType->getValue();
341:
342: if (!is_int($optValue)) {
343: $hasTypes = false;
344: break;
345: }
346:
347: $optValueType = self::getCurlOptValueType($optValue);
348: if ($optValueType === null) {
349: $hasTypes = false;
350: break;
351: }
352:
353: $hasTypes = true;
354: $builder->setOffsetValueType(
355: new ConstantIntegerType($optValue),
356: $optValueType,
357: !$optArrayType->hasOffsetValueType($optType)->yes(),
358: );
359: }
360:
361: $acceptor = $parametersAcceptors[0];
362: $parameters = $acceptor->getParameters();
363: if ($hasTypes && isset($parameters[1])) {
364: $parameters[1] = new NativeParameterReflection(
365: $parameters[1]->getName(),
366: $parameters[1]->isOptional(),
367: $builder->getArray(),
368: $parameters[1]->passedByReference(),
369: $parameters[1]->isVariadic(),
370: $parameters[1]->getDefaultValue(),
371: );
372:
373: $parametersAcceptors = [
374: new FunctionVariant(
375: $acceptor->getTemplateTypeMap(),
376: $acceptor->getResolvedTemplateTypeMap(),
377: $parameters,
378: $acceptor->isVariadic(),
379: $acceptor->getReturnType(),
380: $acceptor instanceof ExtendedParametersAcceptor ? $acceptor->getCallSiteVarianceMap() : TemplateTypeVarianceMap::createEmpty(),
381: ),
382: ];
383: }
384: }
385:
386: if ((bool) $positionalArgs[0]->getAttribute(ArrayFilterArgVisitor::ATTRIBUTE_NAME)) {
387: $arrayFilterParameters = null;
388: $nativeArrayFilterParameters = null;
389: if (isset($positionalArgs[2])) {
390: $mode = ($typeGetter)($positionalArgs[2]->value);
391: if ($mode instanceof ConstantIntegerType) {
392: if ($mode->getValue() === ARRAY_FILTER_USE_KEY) {
393: $arrayFilterParameters = [
394: new DummyParameter('key', ($iterableKeyTypeGetter)(($typeGetter)($positionalArgs[0]->value)), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
395: ];
396: $nativeArrayFilterParameters = [
397: new DummyParameter('key', ($iterableKeyTypeGetter)(($nativeTypeGetter)($positionalArgs[0]->value)), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
398: ];
399: } elseif ($mode->getValue() === ARRAY_FILTER_USE_BOTH) {
400: $arrayFilterParameters = [
401: new DummyParameter('item', ($iterableValueTypeGetter)(($typeGetter)($positionalArgs[0]->value)), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
402: new DummyParameter('key', ($iterableKeyTypeGetter)(($typeGetter)($positionalArgs[0]->value)), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
403: ];
404: $nativeArrayFilterParameters = [
405: new DummyParameter('item', ($iterableValueTypeGetter)(($nativeTypeGetter)($positionalArgs[0]->value)), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
406: new DummyParameter('key', ($iterableKeyTypeGetter)(($nativeTypeGetter)($positionalArgs[0]->value)), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
407: ];
408: }
409: }
410: }
411:
412: $acceptor = $parametersAcceptors[0];
413: $parameters = $acceptor->getParameters();
414: if (isset($parameters[1])) {
415: $arrayArgType = ($typeGetter)($positionalArgs[0]->value);
416: $callableType = new UnionType([
417: new CallableType(
418: $arrayFilterParameters ?? [
419: new DummyParameter('item', ($iterableValueTypeGetter)($arrayArgType), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
420: ],
421: new BooleanType(),
422: false,
423: ),
424: new NullType(),
425: ]);
426: $nativeArrayArgType = ($nativeTypeGetter)($positionalArgs[0]->value);
427: $nativeCallableType = new UnionType([
428: new CallableType(
429: $nativeArrayFilterParameters ?? [
430: new DummyParameter('item', ($iterableValueTypeGetter)($nativeArrayArgType), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
431: ],
432: new BooleanType(),
433: false,
434: ),
435: new NullType(),
436: ]);
437: $parameters[1] = self::overrideParameterType($parameters[1], $callableType, $nativeCallableType);
438: $parametersAcceptors = [self::overrideAcceptorParameters($acceptor, $parameters)];
439: }
440: }
441:
442: if (count($args) <= 2 && (bool) $args[0]->getAttribute(ImplodeArgVisitor::ATTRIBUTE_NAME)) {
443: $acceptor = $namedArgumentsVariants[0] ?? $parametersAcceptors[0];
444: $parameters = $acceptor->getParameters();
445: if (
446: (isset($args[1]) || ($args[0]->name !== null && $args[0]->name->name === 'array'))
447: && isset($parameters[0]) && isset($parameters[1])
448: ) {
449: $parameters = [
450: new NativeParameterReflection($parameters[0]->getName(), optional: false, type: new StringType(), passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
451: new NativeParameterReflection($parameters[1]->getName(), optional: false, type: new ArrayType(new MixedType(), new MixedType()), passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
452: ];
453: } elseif (isset($parameters[0])) {
454: $parameters = [
455: new NativeParameterReflection($parameters[0]->getName(), optional: false, type: new ArrayType(new MixedType(), new MixedType()), passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
456: ];
457: }
458:
459: $parametersAcceptors = [
460: new FunctionVariant(
461: $acceptor->getTemplateTypeMap(),
462: $acceptor->getResolvedTemplateTypeMap(),
463: $parameters,
464: $acceptor->isVariadic(),
465: $acceptor->getReturnType(),
466: $acceptor instanceof ExtendedParametersAcceptor ? $acceptor->getCallSiteVarianceMap() : TemplateTypeVarianceMap::createEmpty(),
467: ),
468: ];
469: }
470:
471: if ((bool) $positionalArgs[0]->getAttribute(ArrayWalkArgVisitor::ATTRIBUTE_NAME)) {
472: $arrayArgType = ($typeGetter)($positionalArgs[0]->value);
473: $nativeArrayArgType = ($nativeTypeGetter)($positionalArgs[0]->value);
474: $arrayWalkParameters = [
475: new DummyParameter('item', ($iterableValueTypeGetter)($arrayArgType), optional: false, passedByReference: PassedByReference::createReadsArgument(), variadic: false, defaultValue: null),
476: new DummyParameter('key', ($iterableKeyTypeGetter)($arrayArgType), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
477: ];
478: $nativeArrayWalkParameters = [
479: new DummyParameter('item', ($iterableValueTypeGetter)($nativeArrayArgType), optional: false, passedByReference: PassedByReference::createReadsArgument(), variadic: false, defaultValue: null),
480: new DummyParameter('key', ($iterableKeyTypeGetter)($nativeArrayArgType), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
481: ];
482: if (isset($positionalArgs[2])) {
483: $arrayWalkParameters[] = new DummyParameter('arg', ($typeGetter)($positionalArgs[2]->value), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null);
484: $nativeArrayWalkParameters[] = new DummyParameter('arg', ($nativeTypeGetter)($positionalArgs[2]->value), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null);
485: }
486:
487: $acceptor = $parametersAcceptors[0];
488: $parameters = $acceptor->getParameters();
489: if (isset($parameters[1])) {
490: $callableType = new CallableType($arrayWalkParameters, new MixedType(), false);
491: $nativeCallableType = new CallableType($nativeArrayWalkParameters, new MixedType(), false);
492: $parameters[1] = self::overrideParameterType($parameters[1], $callableType, $nativeCallableType);
493: $parametersAcceptors = [self::overrideAcceptorParameters($acceptor, $parameters)];
494: }
495: }
496:
497: if ((bool) $positionalArgs[0]->getAttribute(ArrayFindArgVisitor::ATTRIBUTE_NAME)) {
498: $acceptor = $parametersAcceptors[0];
499: $parameters = $acceptor->getParameters();
500: if (isset($parameters[1])) {
501: $argType = ($typeGetter)($positionalArgs[0]->value);
502: $callableType = new CallableType(
503: [
504: new DummyParameter('value', ($iterableValueTypeGetter)($argType), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
505: new DummyParameter('key', ($iterableKeyTypeGetter)($argType), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
506: ],
507: new BooleanType(),
508: false,
509: );
510: $nativeArgType = ($nativeTypeGetter)($positionalArgs[0]->value);
511: $nativeCallableType = new CallableType(
512: [
513: new DummyParameter('value', ($iterableValueTypeGetter)($nativeArgType), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
514: new DummyParameter('key', ($iterableKeyTypeGetter)($nativeArgType), optional: false, passedByReference: PassedByReference::createNo(), variadic: false, defaultValue: null),
515: ],
516: new BooleanType(),
517: false,
518: );
519: $parameters[1] = self::overrideParameterType($parameters[1], $callableType, $nativeCallableType);
520: $parametersAcceptors = [self::overrideAcceptorParameters($acceptor, $parameters)];
521: }
522: }
523:
524: $closureBindToVar = $args[0]->getAttribute(ClosureBindToVarVisitor::ATTRIBUTE_NAME);
525: if (
526: $closureBindToVar instanceof Node\Expr\Variable
527: && is_string($closureBindToVar->name)
528: ) {
529: $varType = ($typeGetter)($closureBindToVar);
530: if ((new ObjectType(Closure::class))->isSuperTypeOf($varType)->yes()) {
531: $inFunction = $scope->getFunction();
532: if ($inFunction !== null) {
533: $closureThisParameters = [];
534: foreach ($inFunction->getParameters() as $parameter) {
535: if ($parameter->getClosureThisType() === null) {
536: continue;
537: }
538: $closureThisParameters[$parameter->getName()] = $parameter->getClosureThisType();
539: }
540: if (array_key_exists($closureBindToVar->name, $closureThisParameters)) {
541: if ($scope->hasExpressionType(new ParameterVariableOriginalValueExpr($closureBindToVar->name))->yes()) {
542: $acceptor = $parametersAcceptors[0];
543: $parameters = $acceptor->getParameters();
544: if (isset($parameters[0])) {
545: $parameters[0] = new NativeParameterReflection(
546: $parameters[0]->getName(),
547: $parameters[0]->isOptional(),
548: $closureThisParameters[$closureBindToVar->name],
549: $parameters[0]->passedByReference(),
550: $parameters[0]->isVariadic(),
551: $parameters[0]->getDefaultValue(),
552: );
553: $parametersAcceptors = [
554: new FunctionVariant(
555: $acceptor->getTemplateTypeMap(),
556: $acceptor->getResolvedTemplateTypeMap(),
557: $parameters,
558: $acceptor->isVariadic(),
559: $acceptor->getReturnType(),
560: $acceptor instanceof ExtendedParametersAcceptor ? $acceptor->getCallSiteVarianceMap() : TemplateTypeVarianceMap::createEmpty(),
561: ),
562: ];
563: }
564: }
565: }
566: }
567: }
568: }
569:
570: if (
571: $args[0]->getAttribute(ClosureBindArgVisitor::ATTRIBUTE_NAME) !== null
572: && $args[0]->value instanceof Node\Expr\Variable
573: && is_string($args[0]->value->name)
574: ) {
575: $closureVarName = $args[0]->value->name;
576: $inFunction = $scope->getFunction();
577: if ($inFunction !== null) {
578: $closureThisParameters = [];
579: foreach ($inFunction->getParameters() as $parameter) {
580: if ($parameter->getClosureThisType() === null) {
581: continue;
582: }
583: $closureThisParameters[$parameter->getName()] = $parameter->getClosureThisType();
584: }
585: if (array_key_exists($closureVarName, $closureThisParameters)) {
586: if ($scope->hasExpressionType(new ParameterVariableOriginalValueExpr($closureVarName))->yes()) {
587: $acceptor = $parametersAcceptors[0];
588: $parameters = $acceptor->getParameters();
589:
590: if (isset($parameters[1])) {
591: $parameters[1] = new NativeParameterReflection(
592: $parameters[1]->getName(),
593: $parameters[1]->isOptional(),
594: $closureThisParameters[$closureVarName],
595: $parameters[1]->passedByReference(),
596: $parameters[1]->isVariadic(),
597: $parameters[1]->getDefaultValue(),
598: );
599: $parametersAcceptors = [
600: new FunctionVariant(
601: $acceptor->getTemplateTypeMap(),
602: $acceptor->getResolvedTemplateTypeMap(),
603: $parameters,
604: $acceptor->isVariadic(),
605: $acceptor->getReturnType(),
606: $acceptor instanceof ExtendedParametersAcceptor ? $acceptor->getCallSiteVarianceMap() : TemplateTypeVarianceMap::createEmpty(),
607: ),
608: ];
609: }
610: }
611: }
612: }
613: }
614: }
615:
616: return $parametersAcceptors;
617: }
618:
619: /**
620: * @internal
621: */
622: public static function hasAcceptorTemplateOrLateResolvableType(ParametersAcceptor $acceptor): bool
623: {
624: if ($acceptor->getReturnType()->hasTemplateOrLateResolvableType()) {
625: return true;
626: }
627:
628: return self::hasAcceptorTemplateOrLateResolvableParameterType($acceptor);
629: }
630:
631: public static function hasAcceptorTemplateOrLateResolvableParameterType(ParametersAcceptor $acceptor): bool
632: {
633: foreach ($acceptor->getParameters() as $parameter) {
634: if (
635: $parameter instanceof ExtendedParameterReflection
636: && $parameter->getOutType() !== null
637: && $parameter->getOutType()->hasTemplateOrLateResolvableType()
638: ) {
639: return true;
640: }
641:
642: if (
643: $parameter instanceof ExtendedParameterReflection
644: && $parameter->getClosureThisType() !== null
645: && $parameter->getClosureThisType()->hasTemplateOrLateResolvableType()
646: ) {
647: return true;
648: }
649:
650: if (!$parameter->getType()->hasTemplateOrLateResolvableType()) {
651: continue;
652: }
653:
654: return true;
655: }
656:
657: return false;
658: }
659:
660: /**
661: * @param array<int|string, Type> $types
662: * @param ParametersAcceptor[] $parametersAcceptors
663: */
664: public static function selectFromTypes(
665: array $types,
666: array $parametersAcceptors,
667: bool $unpack,
668: ): ParametersAcceptor
669: {
670: if (count($parametersAcceptors) === 1) {
671: return GenericParametersAcceptorResolver::resolve($types, $parametersAcceptors[0]);
672: }
673:
674: if (count($parametersAcceptors) === 0) {
675: throw new ShouldNotHappenException(
676: 'getVariants() must return at least one variant.',
677: );
678: }
679:
680: $typesCount = count($types);
681: $acceptableAcceptors = [];
682:
683: foreach ($parametersAcceptors as $parametersAcceptor) {
684: if ($unpack) {
685: $acceptableAcceptors[] = $parametersAcceptor;
686: continue;
687: }
688:
689: $functionParametersMinCount = 0;
690: $functionParametersMaxCount = 0;
691: foreach ($parametersAcceptor->getParameters() as $parameter) {
692: if (!$parameter->isOptional()) {
693: $functionParametersMinCount++;
694: }
695:
696: $functionParametersMaxCount++;
697: }
698:
699: if ($typesCount < $functionParametersMinCount) {
700: continue;
701: }
702:
703: if (
704: !$parametersAcceptor->isVariadic()
705: && $typesCount > $functionParametersMaxCount
706: ) {
707: continue;
708: }
709:
710: $acceptableAcceptors[] = $parametersAcceptor;
711: }
712:
713: if (count($acceptableAcceptors) === 0) {
714: return GenericParametersAcceptorResolver::resolve($types, self::combineAcceptors($parametersAcceptors));
715: }
716:
717: if (count($acceptableAcceptors) === 1) {
718: return GenericParametersAcceptorResolver::resolve($types, $acceptableAcceptors[0]);
719: }
720:
721: $winningAcceptors = [];
722: $winningCertainty = null;
723: foreach ($acceptableAcceptors as $acceptableAcceptor) {
724: $isSuperType = TrinaryLogic::createYes();
725: $acceptableAcceptor = GenericParametersAcceptorResolver::resolve($types, $acceptableAcceptor);
726: foreach ($acceptableAcceptor->getParameters() as $i => $parameter) {
727: if (!isset($types[$i])) {
728: if (!$unpack || count($types) <= 0) {
729: break;
730: }
731:
732: $type = $types[array_key_last($types)];
733: } else {
734: $type = $types[$i];
735: }
736:
737: if ($parameter->getType() instanceof MixedType) {
738: $isSuperType = $isSuperType->and(TrinaryLogic::createMaybe());
739: } else {
740: $isSuperType = $isSuperType->and($parameter->getType()->isSuperTypeOf($type)->result);
741: }
742: }
743:
744: if ($isSuperType->no()) {
745: continue;
746: }
747:
748: if ($winningCertainty === null) {
749: $winningAcceptors[] = $acceptableAcceptor;
750: $winningCertainty = $isSuperType;
751: } else {
752: $comparison = $winningCertainty->compareTo($isSuperType);
753: if ($comparison === $isSuperType) {
754: $winningAcceptors = [$acceptableAcceptor];
755: $winningCertainty = $isSuperType;
756: } elseif ($comparison === null) {
757: $winningAcceptors[] = $acceptableAcceptor;
758: }
759: }
760: }
761:
762: if (count($winningAcceptors) === 0) {
763: return GenericParametersAcceptorResolver::resolve($types, self::combineAcceptors($acceptableAcceptors));
764: }
765:
766: return GenericParametersAcceptorResolver::resolve($types, self::combineAcceptors($winningAcceptors));
767: }
768:
769: /**
770: * Picks the structural ParametersAcceptor (parameter names/positions/variadic
771: * only) that drives argument normalization / reordering. Unlike selectFromArgs()
772: * it never reads argument types from a Scope, so it is safe to call before the
773: * arguments have been processed - generics are resolved separately, type-driven.
774: *
775: * @internal
776: * @param Node\Arg[] $args
777: * @param ParametersAcceptor[] $variants
778: * @param ParametersAcceptor[]|null $namedArgumentsVariants
779: */
780: public static function combineVariantsForNormalization(array $args, array $variants, ?array $namedArgumentsVariants): ParametersAcceptor
781: {
782: $hasName = false;
783: foreach ($args as $arg) {
784: if ($arg->name !== null) {
785: $hasName = true;
786: break;
787: }
788: }
789:
790: $selectedVariants = $hasName && $namedArgumentsVariants !== null ? $namedArgumentsVariants : $variants;
791:
792: return count($selectedVariants) === 1
793: ? $selectedVariants[0]
794: : self::combineAcceptors($selectedVariants);
795: }
796:
797: /**
798: * @param ParametersAcceptor[] $acceptors
799: */
800: public static function combineAcceptors(array $acceptors): ExtendedParametersAcceptor
801: {
802: if (count($acceptors) === 0) {
803: throw new ShouldNotHappenException(
804: 'getVariants() must return at least one variant.',
805: );
806: }
807: if (count($acceptors) === 1) {
808: return self::wrapAcceptor($acceptors[0]);
809: }
810:
811: $minimumNumberOfParameters = null;
812: foreach ($acceptors as $acceptor) {
813: $acceptorParametersMinCount = 0;
814: foreach ($acceptor->getParameters() as $parameter) {
815: if ($parameter->isOptional()) {
816: continue;
817: }
818:
819: $acceptorParametersMinCount++;
820: }
821:
822: if ($minimumNumberOfParameters !== null && $minimumNumberOfParameters <= $acceptorParametersMinCount) {
823: continue;
824: }
825:
826: $minimumNumberOfParameters = $acceptorParametersMinCount;
827: }
828:
829: $parameters = [];
830: $isVariadic = false;
831: $returnTypes = [];
832: $phpDocReturnTypes = [];
833: $nativeReturnTypes = [];
834: $callableOccurred = false;
835: $throwPoints = [];
836: $isPure = TrinaryLogic::createNo();
837: $impurePoints = [];
838: $invalidateExpressions = [];
839: $usedVariables = [];
840: $acceptsNamedArguments = TrinaryLogic::createNo();
841: $mustUseReturnValue = TrinaryLogic::createMaybe();
842: $isStaticClosure = TrinaryLogic::createMaybe();
843:
844: foreach ($acceptors as $acceptor) {
845: $returnTypes[] = $acceptor->getReturnType();
846:
847: if ($acceptor instanceof ExtendedParametersAcceptor) {
848: $phpDocReturnTypes[] = $acceptor->getPhpDocReturnType();
849: $nativeReturnTypes[] = $acceptor->getNativeReturnType();
850: }
851: if ($acceptor instanceof CallableParametersAcceptor) {
852: $callableOccurred = true;
853: $throwPoints = array_merge($throwPoints, $acceptor->getThrowPoints());
854: $isPure = $isPure->or($acceptor->isPure());
855: $impurePoints = array_merge($impurePoints, $acceptor->getImpurePoints());
856: $invalidateExpressions = array_merge($invalidateExpressions, $acceptor->getInvalidateExpressions());
857: $usedVariables = array_merge($usedVariables, $acceptor->getUsedVariables());
858: $acceptsNamedArguments = $acceptsNamedArguments->or($acceptor->acceptsNamedArguments());
859: $mustUseReturnValue = $mustUseReturnValue->or($acceptor->mustUseReturnValue());
860: $isStaticClosure = $isStaticClosure->or($acceptor->isStaticClosure());
861: }
862: $isVariadic = $isVariadic || $acceptor->isVariadic();
863:
864: foreach ($acceptor->getParameters() as $i => $parameter) {
865: if (!isset($parameters[$i])) {
866: $parameters[$i] = new ExtendedDummyParameter(
867: $parameter->getName(),
868: $parameter->getType(),
869: $i + 1 > $minimumNumberOfParameters,
870: $parameter->passedByReference(),
871: $parameter->isVariadic(),
872: $parameter->getDefaultValue(),
873: $parameter instanceof ExtendedParameterReflection ? $parameter->getNativeType() : new MixedType(),
874: $parameter instanceof ExtendedParameterReflection ? $parameter->getPhpDocType() : new MixedType(),
875: $parameter instanceof ExtendedParameterReflection ? $parameter->getOutType() : null,
876: $parameter instanceof ExtendedParameterReflection ? $parameter->isImmediatelyInvokedCallable() : TrinaryLogic::createMaybe(),
877: $parameter instanceof ExtendedParameterReflection ? $parameter->getClosureThisType() : null,
878: $parameter instanceof ExtendedParameterReflection ? $parameter->getAttributes() : [],
879: $parameter instanceof ExtendedParameterReflection ? $parameter->getAllowedConstants() : null,
880: $parameter instanceof ExtendedParameterReflection ? $parameter->isPureUnlessCallableIsImpureParameter() : TrinaryLogic::createNo(),
881: $parameter instanceof ExtendedParameterReflection ? $parameter->isPureUnlessParameterPassedParameter() : TrinaryLogic::createNo(),
882: );
883: continue;
884: }
885:
886: $isParameterVariadic = $parameters[$i]->isVariadic() || $parameter->isVariadic();
887: $defaultValueLeft = $parameters[$i]->getDefaultValue();
888: $defaultValueRight = $parameter->getDefaultValue();
889: if ($defaultValueLeft !== null && $defaultValueRight !== null) {
890: $defaultValue = TypeCombinator::union($defaultValueLeft, $defaultValueRight);
891: } else {
892: $defaultValue = null;
893: }
894:
895: $type = TypeCombinator::union($parameters[$i]->getType(), $parameter->getType());
896: $nativeType = $parameters[$i]->getNativeType();
897: $phpDocType = $parameters[$i]->getPhpDocType();
898: $outType = $parameters[$i]->getOutType();
899: $immediatelyInvokedCallable = $parameters[$i]->isImmediatelyInvokedCallable();
900: $closureThisType = $parameters[$i]->getClosureThisType();
901: $attributes = $parameters[$i]->getAttributes();
902: if ($parameter instanceof ExtendedParameterReflection) {
903: $nativeType = TypeCombinator::union($nativeType, $parameter->getNativeType());
904: $phpDocType = TypeCombinator::union($phpDocType, $parameter->getPhpDocType());
905:
906: if ($parameter->getOutType() !== null) {
907: $outType = $outType === null ? null : TypeCombinator::union($outType, $parameter->getOutType());
908: } else {
909: $outType = null;
910: }
911:
912: if ($parameter->getClosureThisType() !== null && $closureThisType !== null) {
913: $closureThisType = TypeCombinator::union($closureThisType, $parameter->getClosureThisType());
914: } else {
915: $closureThisType = null;
916: }
917:
918: $immediatelyInvokedCallable = $parameter->isImmediatelyInvokedCallable()->or($immediatelyInvokedCallable);
919: $attributes = array_merge($attributes, $parameter->getAttributes());
920: } else {
921: $nativeType = new MixedType();
922: $phpDocType = $type;
923: $outType = null;
924: $immediatelyInvokedCallable = TrinaryLogic::createMaybe();
925: $closureThisType = null;
926: }
927:
928: if ($isParameterVariadic) {
929: // the variadic parameter swallows every parameter behind it,
930: // so their types have to be merged into it before they're dropped
931: $droppedParameters = array_merge(
932: array_slice($parameters, $i + 1),
933: array_slice($acceptor->getParameters(), $i + 1),
934: );
935: foreach ($droppedParameters as $droppedParameter) {
936: $type = TypeCombinator::union($type, $droppedParameter->getType());
937: if ($droppedParameter instanceof ExtendedParameterReflection) {
938: $nativeType = TypeCombinator::union($nativeType, $droppedParameter->getNativeType());
939: $phpDocType = TypeCombinator::union($phpDocType, $droppedParameter->getPhpDocType());
940: continue;
941: }
942:
943: $nativeType = new MixedType();
944: $phpDocType = TypeCombinator::union($phpDocType, $droppedParameter->getType());
945: }
946: }
947:
948: $allowedConstants = $parameters[$i]->getAllowedConstants();
949: if ($allowedConstants !== null) {
950: $otherAllowedConstants = $parameter instanceof ExtendedParameterReflection ? $parameter->getAllowedConstants() : null;
951: if ($otherAllowedConstants === null || !$allowedConstants->equals($otherAllowedConstants)) {
952: $allowedConstants = null;
953: }
954: }
955:
956: $leftPureUnless = $parameters[$i]->isPureUnlessCallableIsImpureParameter();
957: $rightPureUnless = $parameter instanceof ExtendedParameterReflection ? $parameter->isPureUnlessCallableIsImpureParameter() : TrinaryLogic::createNo();
958: $pureUnlessCallableIsImpureParameter = $leftPureUnless->equals($rightPureUnless) ? $leftPureUnless : TrinaryLogic::createMaybe();
959:
960: $leftPureUnlessParameterPassed = $parameters[$i]->isPureUnlessParameterPassedParameter();
961: $rightPureUnlessParameterPassed = $parameter instanceof ExtendedParameterReflection ? $parameter->isPureUnlessParameterPassedParameter() : TrinaryLogic::createNo();
962: $pureUnlessParameterPassedParameter = $leftPureUnlessParameterPassed->equals($rightPureUnlessParameterPassed) ? $leftPureUnlessParameterPassed : TrinaryLogic::createMaybe();
963:
964: $parameters[$i] = new ExtendedDummyParameter(
965: $parameters[$i]->getName() !== $parameter->getName() ? sprintf('%s|%s', $parameters[$i]->getName(), $parameter->getName()) : $parameter->getName(),
966: $type,
967: $i + 1 > $minimumNumberOfParameters,
968: $parameters[$i]->passedByReference()->combine($parameter->passedByReference()),
969: $isParameterVariadic,
970: $defaultValue,
971: $nativeType,
972: $phpDocType,
973: $outType,
974: $immediatelyInvokedCallable,
975: $closureThisType,
976: $attributes,
977: $allowedConstants,
978: $pureUnlessCallableIsImpureParameter,
979: $pureUnlessParameterPassedParameter,
980: );
981:
982: if ($isParameterVariadic) {
983: $parameters = array_slice($parameters, 0, $i + 1);
984: break;
985: }
986: }
987: }
988:
989: $returnType = TypeCombinator::union(...$returnTypes);
990: $phpDocReturnType = $phpDocReturnTypes === [] ? null : TypeCombinator::union(...$phpDocReturnTypes);
991: $nativeReturnType = $nativeReturnTypes === [] ? null : TypeCombinator::union(...$nativeReturnTypes);
992:
993: if ($callableOccurred) {
994: return new ExtendedCallableFunctionVariant(
995: TemplateTypeMap::createEmpty(),
996: null,
997: array_values($parameters),
998: $isVariadic,
999: $returnType,
1000: $phpDocReturnType ?? $returnType,
1001: $nativeReturnType ?? new MixedType(),
1002: null,
1003: $throwPoints,
1004: $isPure,
1005: $impurePoints,
1006: $invalidateExpressions,
1007: $usedVariables,
1008: $acceptsNamedArguments,
1009: $mustUseReturnValue,
1010: isStatic: $isStaticClosure,
1011: );
1012: }
1013:
1014: return new ExtendedFunctionVariant(
1015: TemplateTypeMap::createEmpty(),
1016: null,
1017: array_values($parameters),
1018: $isVariadic,
1019: $returnType,
1020: $phpDocReturnType ?? $returnType,
1021: $nativeReturnType ?? new MixedType(),
1022: );
1023: }
1024:
1025: private static function wrapAcceptor(ParametersAcceptor $acceptor): ExtendedParametersAcceptor
1026: {
1027: if ($acceptor instanceof ExtendedParametersAcceptor) {
1028: return $acceptor;
1029: }
1030:
1031: if ($acceptor instanceof CallableParametersAcceptor) {
1032: return new ExtendedCallableFunctionVariant(
1033: $acceptor->getTemplateTypeMap(),
1034: $acceptor->getResolvedTemplateTypeMap(),
1035: array_map(static fn (ParameterReflection $parameter): ExtendedParameterReflection => self::wrapParameter($parameter), $acceptor->getParameters()),
1036: $acceptor->isVariadic(),
1037: $acceptor->getReturnType(),
1038: $acceptor->getReturnType(),
1039: new MixedType(),
1040: TemplateTypeVarianceMap::createEmpty(),
1041: $acceptor->getThrowPoints(),
1042: $acceptor->isPure(),
1043: $acceptor->getImpurePoints(),
1044: $acceptor->getInvalidateExpressions(),
1045: $acceptor->getUsedVariables(),
1046: $acceptor->acceptsNamedArguments(),
1047: $acceptor->mustUseReturnValue(),
1048: $acceptor->getAsserts(),
1049: $acceptor->isStaticClosure(),
1050: );
1051: }
1052:
1053: return new ExtendedFunctionVariant(
1054: $acceptor->getTemplateTypeMap(),
1055: $acceptor->getResolvedTemplateTypeMap(),
1056: array_map(static fn (ParameterReflection $parameter): ExtendedParameterReflection => self::wrapParameter($parameter), $acceptor->getParameters()),
1057: $acceptor->isVariadic(),
1058: $acceptor->getReturnType(),
1059: $acceptor->getReturnType(),
1060: new MixedType(),
1061: TemplateTypeVarianceMap::createEmpty(),
1062: );
1063: }
1064:
1065: private static function wrapParameter(ParameterReflection $parameter): ExtendedParameterReflection
1066: {
1067: return $parameter instanceof ExtendedParameterReflection ? $parameter : new ExtendedDummyParameter(
1068: $parameter->getName(),
1069: $parameter->getType(),
1070: $parameter->isOptional(),
1071: $parameter->passedByReference(),
1072: $parameter->isVariadic(),
1073: $parameter->getDefaultValue(),
1074: new MixedType(),
1075: $parameter->getType(),
1076: null,
1077: TrinaryLogic::createMaybe(),
1078: null,
1079: [],
1080: null,
1081: TrinaryLogic::createNo(),
1082: TrinaryLogic::createNo(),
1083: );
1084: }
1085:
1086: private static function getCurlOptValueType(int $curlOpt): ?Type
1087: {
1088: if (defined('CURLOPT_SSL_VERIFYHOST') && $curlOpt === CURLOPT_SSL_VERIFYHOST) {
1089: return new UnionType([new ConstantIntegerType(0), new ConstantIntegerType(2)]);
1090: }
1091:
1092: $boolConstants = [
1093: 'CURLOPT_AUTOREFERER',
1094: 'CURLOPT_COOKIESESSION',
1095: 'CURLOPT_CERTINFO',
1096: 'CURLOPT_CONNECT_ONLY',
1097: 'CURLOPT_CRLF',
1098: 'CURLOPT_DISALLOW_USERNAME_IN_URL',
1099: 'CURLOPT_DNS_SHUFFLE_ADDRESSES',
1100: 'CURLOPT_HAPROXYPROTOCOL',
1101: 'CURLOPT_SSH_COMPRESSION',
1102: 'CURLOPT_DNS_USE_GLOBAL_CACHE',
1103: 'CURLOPT_FAILONERROR',
1104: 'CURLOPT_SSL_FALSESTART',
1105: 'CURLOPT_FILETIME',
1106: 'CURLOPT_FOLLOWLOCATION',
1107: 'CURLOPT_FORBID_REUSE',
1108: 'CURLOPT_FRESH_CONNECT',
1109: 'CURLOPT_FTP_USE_EPRT',
1110: 'CURLOPT_FTP_USE_EPSV',
1111: 'CURLOPT_FTP_CREATE_MISSING_DIRS',
1112: 'CURLOPT_FTPAPPEND',
1113: 'CURLOPT_TCP_NODELAY',
1114: 'CURLOPT_FTPASCII',
1115: 'CURLOPT_FTPLISTONLY',
1116: 'CURLOPT_HEADER',
1117: 'CURLOPT_HTTP09_ALLOWED',
1118: 'CURLOPT_HTTPGET',
1119: 'CURLOPT_HTTPPROXYTUNNEL',
1120: 'CURLOPT_HTTP_CONTENT_DECODING',
1121: 'CURLOPT_KEEP_SENDING_ON_ERROR',
1122: 'CURLOPT_MUTE',
1123: 'CURLOPT_NETRC',
1124: 'CURLOPT_NOBODY',
1125: 'CURLOPT_NOPROGRESS',
1126: 'CURLOPT_NOSIGNAL',
1127: 'CURLOPT_PATH_AS_IS',
1128: 'CURLOPT_PIPEWAIT',
1129: 'CURLOPT_POST',
1130: 'CURLOPT_PUT',
1131: 'CURLOPT_RETURNTRANSFER',
1132: 'CURLOPT_SASL_IR',
1133: 'CURLOPT_SSL_ENABLE_ALPN',
1134: 'CURLOPT_SSL_ENABLE_NPN',
1135: 'CURLOPT_SSL_VERIFYPEER',
1136: 'CURLOPT_SSL_VERIFYSTATUS',
1137: 'CURLOPT_PROXY_SSL_VERIFYPEER',
1138: 'CURLOPT_SUPPRESS_CONNECT_HEADERS',
1139: 'CURLOPT_TCP_FASTOPEN',
1140: 'CURLOPT_TFTP_NO_OPTIONS',
1141: 'CURLOPT_TRANSFERTEXT',
1142: 'CURLOPT_UNRESTRICTED_AUTH',
1143: 'CURLOPT_UPLOAD',
1144: 'CURLOPT_VERBOSE',
1145: ];
1146: foreach ($boolConstants as $constName) {
1147: if (defined($constName) && constant($constName) === $curlOpt) {
1148: return new BooleanType();
1149: }
1150: }
1151:
1152: $intConstants = [
1153: 'CURLOPT_BUFFERSIZE',
1154: 'CURLOPT_CONNECTTIMEOUT',
1155: 'CURLOPT_CONNECTTIMEOUT_MS',
1156: 'CURLOPT_DNS_CACHE_TIMEOUT',
1157: 'CURLOPT_EXPECT_100_TIMEOUT_MS',
1158: 'CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS',
1159: 'CURLOPT_FTPSSLAUTH',
1160: 'CURLOPT_HEADEROPT',
1161: 'CURLOPT_HTTP_VERSION',
1162: 'CURLOPT_HTTPAUTH',
1163: 'CURLOPT_INFILESIZE',
1164: 'CURLOPT_LOW_SPEED_LIMIT',
1165: 'CURLOPT_LOW_SPEED_TIME',
1166: 'CURLOPT_MAXCONNECTS',
1167: 'CURLOPT_MAXREDIRS',
1168: 'CURLOPT_PORT',
1169: 'CURLOPT_POSTREDIR',
1170: 'CURLOPT_PROTOCOLS',
1171: 'CURLOPT_PROXYAUTH',
1172: 'CURLOPT_PROXYPORT',
1173: 'CURLOPT_PROXYTYPE',
1174: 'CURLOPT_REDIR_PROTOCOLS',
1175: 'CURLOPT_RESUME_FROM',
1176: 'CURLOPT_SOCKS5_AUTH',
1177: 'CURLOPT_SSL_OPTIONS',
1178: 'CURLOPT_SSL_VERIFYHOST',
1179: 'CURLOPT_SSLVERSION',
1180: 'CURLOPT_PROXY_SSL_OPTIONS',
1181: 'CURLOPT_PROXY_SSL_VERIFYHOST',
1182: 'CURLOPT_PROXY_SSLVERSION',
1183: 'CURLOPT_STREAM_WEIGHT',
1184: 'CURLOPT_TCP_KEEPALIVE',
1185: 'CURLOPT_TCP_KEEPIDLE',
1186: 'CURLOPT_TCP_KEEPINTVL',
1187: 'CURLOPT_TIMECONDITION',
1188: 'CURLOPT_TIMEOUT',
1189: 'CURLOPT_TIMEOUT_MS',
1190: 'CURLOPT_TIMEVALUE',
1191: 'CURLOPT_TIMEVALUE_LARGE',
1192: 'CURLOPT_MAX_RECV_SPEED_LARGE',
1193: 'CURLOPT_SSH_AUTH_TYPES',
1194: 'CURLOPT_IPRESOLVE',
1195: 'CURLOPT_FTP_FILEMETHOD',
1196: ];
1197: foreach ($intConstants as $constName) {
1198: if (defined($constName) && constant($constName) === $curlOpt) {
1199: return new IntegerType();
1200: }
1201: }
1202:
1203: $nullableStringConstants = [
1204: 'CURLOPT_CUSTOMREQUEST',
1205: 'CURLOPT_DNS_INTERFACE',
1206: 'CURLOPT_DNS_LOCAL_IP4',
1207: 'CURLOPT_DNS_LOCAL_IP6',
1208: 'CURLOPT_DOH_URL',
1209: 'CURLOPT_FTP_ACCOUNT',
1210: 'CURLOPT_FTPPORT',
1211: 'CURLOPT_HSTS',
1212: 'CURLOPT_KRBLEVEL',
1213: 'CURLOPT_RANGE',
1214: 'CURLOPT_RTSP_SESSION_ID',
1215: 'CURLOPT_UNIX_SOCKET_PATH',
1216: 'CURLOPT_XOAUTH2_BEARER',
1217: ];
1218: foreach ($nullableStringConstants as $constName) {
1219: if (defined($constName) && constant($constName) === $curlOpt) {
1220: return new UnionType([
1221: new NullType(),
1222: new IntersectionType([
1223: new StringType(),
1224: new AccessoryNonEmptyStringType(),
1225: ]),
1226: ]);
1227: }
1228: }
1229:
1230: $nonEmptyStringConstants = [
1231: 'CURLOPT_ABSTRACT_UNIX_SOCKET',
1232: 'CURLOPT_ALTSVC',
1233: 'CURLOPT_AWS_SIGV4',
1234: 'CURLOPT_CAINFO',
1235: 'CURLOPT_CAPATH',
1236: 'CURLOPT_COOKIE',
1237: 'CURLOPT_COOKIEJAR',
1238: 'CURLOPT_COOKIELIST',
1239: 'CURLOPT_DEFAULT_PROTOCOL',
1240: 'CURLOPT_DNS_SERVERS',
1241: 'CURLOPT_EGDSOCKET',
1242: 'CURLOPT_FTP_ALTERNATIVE_TO_USER',
1243: 'CURLOPT_INTERFACE',
1244: 'CURLOPT_KEYPASSWD',
1245: 'CURLOPT_KRB4LEVEL',
1246: 'CURLOPT_LOGIN_OPTIONS',
1247: 'CURLOPT_MAIL_AUTH',
1248: 'CURLOPT_MAIL_FROM',
1249: 'CURLOPT_NOPROXY',
1250: 'CURLOPT_PASSWORD',
1251: 'CURLOPT_PINNEDPUBLICKEY',
1252: 'CURLOPT_PROTOCOLS_STR',
1253: 'CURLOPT_PROXY_CAINFO',
1254: 'CURLOPT_PROXY_CAPATH',
1255: 'CURLOPT_PROXY_CRLFILE',
1256: 'CURLOPT_PROXY_ISSUERCERT',
1257: 'CURLOPT_PROXY_KEYPASSWD',
1258: 'CURLOPT_PROXY_PINNEDPUBLICKEY',
1259: 'CURLOPT_PROXY_SERVICE_NAME',
1260: 'CURLOPT_PROXY_SSL_CIPHER_LIST',
1261: 'CURLOPT_PROXY_SSLCERT',
1262: 'CURLOPT_PROXY_SSLCERTTYPE',
1263: 'CURLOPT_PROXY_SSLKEY',
1264: 'CURLOPT_PROXY_SSLKEYTYPE',
1265: 'CURLOPT_PROXY_TLS13_CIPHERS',
1266: 'CURLOPT_PROXY_TLSAUTH_PASSWORD',
1267: 'CURLOPT_PROXY_TLSAUTH_TYPE',
1268: 'CURLOPT_PROXY_TLSAUTH_USERNAME',
1269: 'CURLOPT_PROXYPASSWORD',
1270: 'CURLOPT_PROXYUSERNAME',
1271: 'CURLOPT_PROXYUSERPWD',
1272: 'CURLOPT_RANDOM_FILE',
1273: 'CURLOPT_REDIR_PROTOCOLS_STR',
1274: 'CURLOPT_REFERER',
1275: 'CURLOPT_REQUEST_TARGET',
1276: 'CURLOPT_RTSP_STREAM_URI',
1277: 'CURLOPT_RTSP_TRANSPORT',
1278: 'CURLOPT_SASL_AUTHZID',
1279: 'CURLOPT_SERVICE_NAME',
1280: 'CURLOPT_SOCKS5_GSSAPI_SERVICE',
1281: 'CURLOPT_SSH_HOST_PUBLIC_KEY_MD5',
1282: 'CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256',
1283: 'CURLOPT_SSH_PRIVATE_KEYFILE',
1284: 'CURLOPT_SSH_PUBLIC_KEYFILE',
1285: 'CURLOPT_SSL_CIPHER_LIST',
1286: 'CURLOPT_SSL_EC_CURVES',
1287: 'CURLOPT_SSLCERT',
1288: 'CURLOPT_SSLCERTPASSWD',
1289: 'CURLOPT_SSLCERTTYPE',
1290: 'CURLOPT_SSLENGINE',
1291: 'CURLOPT_SSLENGINE_DEFAULT',
1292: 'CURLOPT_SSLKEY',
1293: 'CURLOPT_SSLKEYPASSWD',
1294: 'CURLOPT_SSLKEYTYPE',
1295: 'CURLOPT_TLS13_CIPHERS',
1296: 'CURLOPT_TLSAUTH_PASSWORD',
1297: 'CURLOPT_TLSAUTH_TYPE',
1298: 'CURLOPT_TLSAUTH_USERNAME',
1299: 'CURLOPT_TRANSFER_ENCODING',
1300: 'CURLOPT_URL',
1301: 'CURLOPT_USERAGENT',
1302: 'CURLOPT_USERNAME',
1303: 'CURLOPT_USERPWD',
1304: ];
1305: foreach ($nonEmptyStringConstants as $constName) {
1306: if (defined($constName) && constant($constName) === $curlOpt) {
1307: return new IntersectionType([
1308: new StringType(),
1309: new AccessoryNonEmptyStringType(),
1310: ]);
1311: }
1312: }
1313:
1314: $stringConstants = [
1315: 'CURLOPT_COOKIEFILE',
1316: 'CURLOPT_ENCODING', // Alias: CURLOPT_ACCEPT_ENCODING
1317: 'CURLOPT_PRE_PROXY',
1318: 'CURLOPT_PRIVATE',
1319: 'CURLOPT_PROXY',
1320: ];
1321: foreach ($stringConstants as $constName) {
1322: if (defined($constName) && constant($constName) === $curlOpt) {
1323: return new StringType();
1324: }
1325: }
1326:
1327: $intArrayStringKeysConstants = [
1328: 'CURLOPT_HTTPHEADER',
1329: ];
1330: foreach ($intArrayStringKeysConstants as $constName) {
1331: if (defined($constName) && constant($constName) === $curlOpt) {
1332: return new ArrayType(new IntegerType(), new StringType());
1333: }
1334: }
1335:
1336: $arrayConstants = [
1337: 'CURLOPT_CONNECT_TO',
1338: 'CURLOPT_HTTP200ALIASES',
1339: 'CURLOPT_POSTQUOTE',
1340: 'CURLOPT_PROXYHEADER',
1341: 'CURLOPT_QUOTE',
1342: 'CURLOPT_RESOLVE',
1343: ];
1344: foreach ($arrayConstants as $constName) {
1345: if (defined($constName) && constant($constName) === $curlOpt) {
1346: return new ArrayType(new MixedType(), new MixedType());
1347: }
1348: }
1349:
1350: $arrayOrStringConstants = [
1351: 'CURLOPT_POSTFIELDS',
1352: ];
1353: foreach ($arrayOrStringConstants as $constName) {
1354: if (defined($constName) && constant($constName) === $curlOpt) {
1355: return new UnionType([
1356: new StringType(),
1357: new ArrayType(new MixedType(), new MixedType()),
1358: ]);
1359: }
1360: }
1361:
1362: $resourceConstants = [
1363: 'CURLOPT_FILE',
1364: 'CURLOPT_INFILE',
1365: 'CURLOPT_STDERR',
1366: 'CURLOPT_WRITEHEADER',
1367: ];
1368: foreach ($resourceConstants as $constName) {
1369: if (defined($constName) && constant($constName) === $curlOpt) {
1370: return new ResourceType();
1371: }
1372: }
1373:
1374: if (defined('CURLOPT_SHARE') && $curlOpt === CURLOPT_SHARE) {
1375: $phpversion = PhpVersionStaticAccessor::getInstance();
1376:
1377: if ($phpversion->supportsCurlShareHandle()) {
1378: $shareType = new ObjectType('CurlShareHandle');
1379: } else {
1380: $shareType = new ResourceType();
1381: }
1382: if ($phpversion->supportsCurlSharePersistentHandle()) {
1383: $shareType = TypeCombinator::union($shareType, new ObjectType('CurlSharePersistentHandle'));
1384: }
1385:
1386: return $shareType;
1387: }
1388:
1389: $curlHandleType = PhpVersionStaticAccessor::getInstance()->supportsCurlShareHandle()
1390: ? new ObjectType('CurlHandle')
1391: : new ResourceType();
1392:
1393: // callback options: [parameter types passed to the callback (after the handle), expected return type]
1394: $callbackConstants = [
1395: 'CURLOPT_WRITEFUNCTION' => [[new StringType()], new IntegerType()],
1396: 'CURLOPT_HEADERFUNCTION' => [[new StringType()], new IntegerType()],
1397: 'CURLOPT_READFUNCTION' => [[new ResourceType(), new IntegerType()], new StringType()],
1398: 'CURLOPT_PROGRESSFUNCTION' => [[new IntegerType(), new IntegerType(), new IntegerType(), new IntegerType()], new IntegerType()],
1399: 'CURLOPT_XFERINFOFUNCTION' => [[new IntegerType(), new IntegerType(), new IntegerType(), new IntegerType()], new IntegerType()],
1400: 'CURLOPT_PREREQFUNCTION' => [[new StringType(), new StringType(), new IntegerType(), new IntegerType()], new IntegerType()],
1401: ];
1402: foreach ($callbackConstants as $constName => [$paramTypes, $returnType]) {
1403: if (defined($constName) && constant($constName) === $curlOpt) {
1404: $parameters = [
1405: new DummyParameter('handle', $curlHandleType, false, PassedByReference::createNo(), false, null),
1406: ];
1407: foreach ($paramTypes as $i => $paramType) {
1408: $parameters[] = new DummyParameter('param' . $i, $paramType, false, PassedByReference::createNo(), false, null);
1409: }
1410:
1411: return new UnionType([
1412: new CallableType($parameters, $returnType, false),
1413: new NullType(),
1414: ]);
1415: }
1416: }
1417:
1418: // unknown constant
1419: return null;
1420: }
1421:
1422: private static function overrideParameterType(ParameterReflection $original, Type $type, Type $nativeType): ExtendedDummyParameter
1423: {
1424: $wrapped = self::wrapParameter($original);
1425:
1426: return new ExtendedDummyParameter(
1427: $wrapped->getName(),
1428: $type,
1429: $wrapped->isOptional(),
1430: $wrapped->passedByReference(),
1431: $wrapped->isVariadic(),
1432: $wrapped->getDefaultValue(),
1433: $nativeType,
1434: $type,
1435: $wrapped->getOutType(),
1436: $wrapped->isImmediatelyInvokedCallable(),
1437: $wrapped->getClosureThisType(),
1438: $wrapped->getAttributes(),
1439: $wrapped->getAllowedConstants(),
1440: $wrapped->isPureUnlessCallableIsImpureParameter(),
1441: $wrapped->isPureUnlessParameterPassedParameter(),
1442: );
1443: }
1444:
1445: /**
1446: * @param list<ParameterReflection> $parameters
1447: */
1448: private static function overrideAcceptorParameters(ParametersAcceptor $acceptor, array $parameters): ParametersAcceptor
1449: {
1450: if ($acceptor instanceof ExtendedParametersAcceptor) {
1451: return new ExtendedFunctionVariant(
1452: $acceptor->getTemplateTypeMap(),
1453: $acceptor->getResolvedTemplateTypeMap(),
1454: array_map(static fn (ParameterReflection $p): ExtendedParameterReflection => $p instanceof ExtendedParameterReflection ? $p : self::wrapParameter($p), $parameters),
1455: $acceptor->isVariadic(),
1456: $acceptor->getReturnType(),
1457: $acceptor->getPhpDocReturnType(),
1458: $acceptor->getNativeReturnType(),
1459: $acceptor->getCallSiteVarianceMap(),
1460: );
1461: }
1462:
1463: return new FunctionVariant(
1464: $acceptor->getTemplateTypeMap(),
1465: $acceptor->getResolvedTemplateTypeMap(),
1466: $parameters,
1467: $acceptor->isVariadic(),
1468: $acceptor->getReturnType(),
1469: TemplateTypeVarianceMap::createEmpty(),
1470: );
1471: }
1472:
1473: }
1474: