1: <?php declare(strict_types = 1);
2:
3: namespace PHPStan\Reflection;
4:
5: use PHPStan\Analyser\OutOfClassScope;
6: use PHPStan\Reflection\Callables\CallableParametersAcceptor;
7: use PHPStan\Reflection\Php\ExtendedDummyParameter;
8: use PHPStan\TrinaryLogic;
9: use PHPStan\Turbo\ReferencedByTurboExtension;
10: use PHPStan\Type\CallableAssertionsHelper;
11: use PHPStan\Type\ConditionalTypeForParameter;
12: use PHPStan\Type\ErrorType;
13: use PHPStan\Type\Generic\TemplateTypeHelper;
14: use PHPStan\Type\Generic\TemplateTypeMap;
15: use PHPStan\Type\Generic\TemplateTypeVariance;
16: use PHPStan\Type\Generic\TemplateTypeVarianceMap;
17: use PHPStan\Type\MixedType;
18: use PHPStan\Type\NeverType;
19: use PHPStan\Type\Type;
20: use PHPStan\Type\TypeCombinator;
21: use PHPStan\Type\UnionType;
22: use function array_key_exists;
23: use function array_last;
24: use function array_map;
25: use function array_merge;
26: use function count;
27: use function is_int;
28:
29: #[ReferencedByTurboExtension(key: 'genericParametersAcceptorResolver')]
30: final class GenericParametersAcceptorResolver
31: {
32:
33: /**
34: * @api
35: * @param array<int|string, Type> $argTypes
36: */
37: public static function resolve(array $argTypes, ParametersAcceptor $parametersAcceptor): ExtendedParametersAcceptor
38: {
39: $typeMap = TemplateTypeMap::createEmpty();
40: $passedArgs = [];
41:
42: $parameters = $parametersAcceptor->getParameters();
43: $namedArgTypes = [];
44: foreach ($argTypes as $i => $argType) {
45: if (is_int($i)) {
46: if (isset($parameters[$i])) {
47: $namedArgTypes[$parameters[$i]->getName()] = $argType;
48: continue;
49: }
50: if (count($parameters) > 0) {
51: $lastParameter = array_last($parameters);
52: if ($lastParameter->isVariadic()) {
53: $parameterName = $lastParameter->getName();
54: if (array_key_exists($parameterName, $namedArgTypes)) {
55: $namedArgTypes[$parameterName] = TypeCombinator::union($namedArgTypes[$parameterName], $argType);
56: continue;
57: }
58: $namedArgTypes[$parameterName] = $argType;
59: }
60: }
61: continue;
62: }
63:
64: $namedArgTypes[$i] = $argType;
65: }
66:
67: // type predicates of passed callables determine their template types exactly,
68: // so they are inferred first and substituted into the parameter types —
69: // the remaining template types are then inferred from what is left over,
70: // e.g. in partition(iterable<T0|T1> $values, callable(T0|T1): ($value is T0 ? true : false) $predicate)
71: // called with iterable<int|string> and is_int(...), T0 becomes int and T1 string
72: // null when no passed callable has a type predicate, which is almost always
73: $predicateTypeMap = null;
74: foreach ($parameters as $param) {
75: $paramName = $param->getName();
76: if (!isset($namedArgTypes[$paramName])) {
77: continue;
78: }
79:
80: $paramPredicateTypeMap = self::inferPredicateTemplateTypes($param->getType(), $namedArgTypes[$paramName]);
81: if ($paramPredicateTypeMap === null || $paramPredicateTypeMap->isEmpty()) {
82: continue;
83: }
84:
85: $predicateTypeMap = $predicateTypeMap === null ? $paramPredicateTypeMap : $predicateTypeMap->union($paramPredicateTypeMap);
86: }
87:
88: foreach ($parameters as $param) {
89: $paramName = $param->getName();
90: if (isset($namedArgTypes[$paramName])) {
91: $argType = $namedArgTypes[$paramName];
92: } elseif ($param->getDefaultValue() !== null) {
93: $argType = $param->getDefaultValue();
94: } elseif ($param->isVariadic()) {
95: $argType = new NeverType(true);
96: } else {
97: continue;
98: }
99:
100: $paramType = $predicateTypeMap === null ? $param->getType() : self::resolvePredicateTemplateTypes($param->getType(), $predicateTypeMap);
101: $typeMap = $typeMap->union($paramType->inferTemplateTypes($argType));
102: $passedArgs['$' . $paramName] = $argType;
103: }
104:
105: if ($predicateTypeMap !== null) {
106: $typeMap = $typeMap->union($predicateTypeMap);
107: }
108:
109: $returnType = $parametersAcceptor->getReturnType();
110: if (
111: $returnType instanceof ConditionalTypeForParameter
112: && !$returnType->isNegated()
113: && array_key_exists($returnType->getParameterName(), $passedArgs)
114: ) {
115: $paramType = $predicateTypeMap === null ? $returnType->getTarget() : self::resolvePredicateTemplateTypes($returnType->getTarget(), $predicateTypeMap);
116: $argType = $passedArgs[$returnType->getParameterName()];
117: $typeMap = $typeMap->union($paramType->inferTemplateTypes($argType));
118: }
119:
120: $resolvedTemplateTypeMap = new TemplateTypeMap(array_merge(
121: $parametersAcceptor->getTemplateTypeMap()->map(static fn (string $name, Type $type): Type => new ErrorType())->getTypes(),
122: $typeMap->getTypes(),
123: ));
124:
125: $originalParametersAcceptor = $parametersAcceptor;
126:
127: if (!$parametersAcceptor instanceof ExtendedParametersAcceptor) {
128: $parametersAcceptor = new ExtendedFunctionVariant(
129: $parametersAcceptor->getTemplateTypeMap(),
130: $parametersAcceptor->getResolvedTemplateTypeMap(),
131: array_map(static fn (ParameterReflection $parameter): ExtendedParameterReflection => new ExtendedDummyParameter(
132: $parameter->getName(),
133: $parameter->getType(),
134: $parameter->isOptional(),
135: $parameter->passedByReference(),
136: $parameter->isVariadic(),
137: $parameter->getDefaultValue(),
138: new MixedType(),
139: $parameter->getType(),
140: null,
141: TrinaryLogic::createMaybe(),
142: null,
143: [],
144: null,
145: TrinaryLogic::createNo(),
146: TrinaryLogic::createNo(),
147: ), $parameters),
148: $parametersAcceptor->isVariadic(),
149: $returnType,
150: $returnType,
151: new MixedType(),
152: TemplateTypeVarianceMap::createEmpty(),
153: );
154: }
155:
156: $result = new ResolvedFunctionVariantWithOriginal(
157: $parametersAcceptor,
158: $resolvedTemplateTypeMap,
159: $parametersAcceptor->getCallSiteVarianceMap(),
160: $passedArgs,
161: );
162: if ($originalParametersAcceptor instanceof CallableParametersAcceptor) {
163: return new ResolvedFunctionVariantWithCallable(
164: $result,
165: $originalParametersAcceptor->getThrowPoints(),
166: $originalParametersAcceptor->isPure(),
167: $originalParametersAcceptor->getImpurePoints(),
168: $originalParametersAcceptor->getInvalidateExpressions(),
169: $originalParametersAcceptor->getUsedVariables(),
170: $originalParametersAcceptor->acceptsNamedArguments(),
171: $originalParametersAcceptor->mustUseReturnValue(),
172: $originalParametersAcceptor->getAsserts(),
173: $originalParametersAcceptor->isStaticClosure(),
174: );
175: }
176:
177: return $result;
178: }
179:
180: /**
181: * @return TemplateTypeMap|null null when the parameter type is no callable with a type predicate
182: */
183: private static function inferPredicateTemplateTypes(Type $paramType, Type $argType): ?TemplateTypeMap
184: {
185: $typeMap = null;
186: foreach ($paramType instanceof UnionType ? $paramType->getTypes() : [$paramType] as $innerType) {
187: if (!$innerType instanceof CallableParametersAcceptor) {
188: continue;
189: }
190: if ($innerType->getAsserts()->getAll() === []) {
191: continue;
192: }
193:
194: // asked only for parameters with asserts - it reflects the class named by
195: // a callable-like argument
196: $typeMap ??= TemplateTypeMap::createEmpty();
197: if (!$argType->isCallable()->yes()) {
198: return $typeMap;
199: }
200:
201: foreach ($argType->getCallableParametersAcceptors(new OutOfClassScope()) as $receivedAcceptor) {
202: $typeMap = $typeMap->union(CallableAssertionsHelper::inferTemplateTypesOnAsserts($innerType, $receivedAcceptor));
203: }
204: }
205:
206: return $typeMap;
207: }
208:
209: private static function resolvePredicateTemplateTypes(Type $type, TemplateTypeMap $predicateTypeMap): Type
210: {
211: return TemplateTypeHelper::resolveTemplateTypes(
212: $type,
213: $predicateTypeMap,
214: TemplateTypeVarianceMap::createEmpty(),
215: TemplateTypeVariance::createInvariant(),
216: );
217: }
218:
219: }
220: