nodeNameResolver = $nodeNameResolver; $this->astResolver = $astResolver; $this->staticTypeMapper = $staticTypeMapper; $this->typeComparator = $typeComparator; } /** * @return null|\PhpParser\Node\Identifier|\PhpParser\Node\Name|\PhpParser\Node\NullableType|\PhpParser\Node\UnionType|\PhpParser\Node\ComplexType */ public function matchCallParamType(Param $param, Param $callParam) { if (!$callParam->type instanceof Node) { return null; } if (!$param->default instanceof Expr && !$callParam->default instanceof Expr) { // skip as mixed is not helpful and possibly requires more precise change elsewhere if ($this->isCallParamMixed($callParam->type)) { return null; } return $callParam->type; } $default = $param->default ?? $callParam->default; if (!$default instanceof Expr) { return null; } $callParamType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($callParam->type); $defaultType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($default); if ($this->typeComparator->areTypesEqual($callParamType, $defaultType)) { return $callParam->type; } if ($this->typeComparator->isSubtype($defaultType, $callParamType)) { return $callParam->type; } if (!$defaultType instanceof NullType) { return null; } if ($callParam->type instanceof Name || $callParam->type instanceof Identifier) { return new NullableType($callParam->type); } if ($callParam->type instanceof IntersectionType || $callParam->type instanceof UnionType) { return new UnionType(\array_merge($callParam->type->types, [new Identifier('null')])); } return null; } public function matchParentParam(StaticCall $parentStaticCall, Param $param, Scope $scope) : ?Param { $methodName = $this->nodeNameResolver->getName($parentStaticCall->name); if ($methodName === null) { return null; } // match current param to parent call position $parentStaticCallArgPosition = $this->matchCallArgPosition($parentStaticCall, $param); if ($parentStaticCallArgPosition === null) { return null; } return $this->resolveParentMethodParam($scope, $methodName, $parentStaticCallArgPosition); } /** * @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\FuncCall $call */ public function matchCallParam($call, Param $param, Scope $scope) : ?Param { $callArgPosition = $this->matchCallArgPosition($call, $param); if ($callArgPosition === null) { return null; } $classMethodOrFunction = $this->astResolver->resolveClassMethodOrFunctionFromCall($call, $scope); if ($classMethodOrFunction === null) { return null; } return $classMethodOrFunction->params[$callArgPosition] ?? null; } /** * @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\FuncCall $call */ private function matchCallArgPosition($call, Param $param) : ?int { $paramName = $this->nodeNameResolver->getName($param); foreach ($call->args as $argPosition => $arg) { if (!$arg instanceof Arg) { continue; } if (!$arg->value instanceof Variable) { continue; } if (!$this->nodeNameResolver->isName($arg->value, $paramName)) { continue; } return $argPosition; } return null; } private function resolveParentMethodParam(Scope $scope, string $methodName, int $paramPosition) : ?Param { $classReflection = $scope->getClassReflection(); if (!$classReflection instanceof ClassReflection) { return null; } foreach ($classReflection->getParents() as $parentClassReflection) { if (!$parentClassReflection->hasMethod($methodName)) { continue; } $parentClassMethod = $this->astResolver->resolveClassMethod($parentClassReflection->getName(), $methodName); if (!$parentClassMethod instanceof ClassMethod) { continue; } return $parentClassMethod->params[$paramPosition] ?? null; } return null; } private function isCallParamMixed(Node $node) : bool { $callParamType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($node); return $callParamType instanceof MixedType; } }