\\d+)#'; public function __construct(NodeNameResolver $nodeNameResolver, BetterNodeFinder $betterNodeFinder, NodeFactory $nodeFactory, StaticTypeMapper $staticTypeMapper, SimpleCallableNodeTraverser $simpleCallableNodeTraverser, SimplePhpParser $simplePhpParser, AstResolver $astResolver, InlineCodeParser $inlineCodeParser) { $this->nodeNameResolver = $nodeNameResolver; $this->betterNodeFinder = $betterNodeFinder; $this->nodeFactory = $nodeFactory; $this->staticTypeMapper = $staticTypeMapper; $this->simpleCallableNodeTraverser = $simpleCallableNodeTraverser; $this->simplePhpParser = $simplePhpParser; $this->astResolver = $astResolver; $this->inlineCodeParser = $inlineCodeParser; } /** * @api * @param Param[] $params * @param Stmt[] $stmts * @param \PhpParser\Node\Identifier|\PhpParser\Node\Name|\PhpParser\Node\NullableType|\PhpParser\Node\UnionType|\PhpParser\Node\ComplexType|null $returnTypeNode */ public function create(array $params, array $stmts, $returnTypeNode, bool $static = \false) : Closure { $useVariables = $this->createUseVariablesFromParams($stmts, $params); $anonymousFunctionClosure = new Closure(); $anonymousFunctionClosure->params = $params; if ($static) { $anonymousFunctionClosure->static = $static; } foreach ($useVariables as $useVariable) { $anonymousFunctionClosure->uses[] = new ClosureUse($useVariable); } if ($returnTypeNode instanceof Node) { $anonymousFunctionClosure->returnType = $returnTypeNode; } $anonymousFunctionClosure->stmts = $stmts; return $anonymousFunctionClosure; } public function createFromPhpMethodReflection(PhpMethodReflection $phpMethodReflection, Expr $expr) : ?Closure { /** @var FunctionVariantWithPhpDocs $parametersAcceptorWithPhpDocs */ $parametersAcceptorWithPhpDocs = ParametersAcceptorSelector::selectSingle($phpMethodReflection->getVariants()); $newParams = $this->createParams($phpMethodReflection, $parametersAcceptorWithPhpDocs->getParameters()); $innerMethodCall = $this->createInnerMethodCall($phpMethodReflection, $expr, $newParams); if ($innerMethodCall === null) { return null; } $returnTypeNode = null; if (!$parametersAcceptorWithPhpDocs->getReturnType() instanceof MixedType) { $returnTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($parametersAcceptorWithPhpDocs->getReturnType(), TypeKind::RETURN); } $uses = []; if ($expr instanceof Variable && !$this->nodeNameResolver->isName($expr, 'this')) { $uses[] = new ClosureUse($expr); } // does method return something? $stmts = $this->resolveStmts($parametersAcceptorWithPhpDocs, $innerMethodCall); return new Closure(['params' => $newParams, 'returnType' => $returnTypeNode, 'uses' => $uses, 'stmts' => $stmts]); } public function createAnonymousFunctionFromExpr(Expr $expr) : ?Closure { $stringValue = $this->inlineCodeParser->stringify($expr); $phpCode = 'simplePhpParser->parseString($phpCode); $anonymousFunction = new Closure(); $firstNode = $contentStmts[0] ?? null; if (!$firstNode instanceof Expression) { return null; } $stmt = $firstNode->expr; $this->simpleCallableNodeTraverser->traverseNodesWithCallable($stmt, static function (Node $node) : Node { if (!$node instanceof String_) { return $node; } $match = Strings::match($node->value, self::DIM_FETCH_REGEX); if ($match === null) { return $node; } $matchesVariable = new Variable('matches'); return new ArrayDimFetch($matchesVariable, new LNumber((int) $match['number'])); }); $anonymousFunction->stmts[] = new Return_($stmt); $anonymousFunction->params[] = new Param(new Variable('matches')); $variables = $expr instanceof Variable ? [] : $this->betterNodeFinder->findInstanceOf($expr, Variable::class); $anonymousFunction->uses = \array_map(static function (Variable $variable) : ClosureUse { return new ClosureUse($variable); }, $variables); return $anonymousFunction; } /** * @param Param[] $params * @return string[] */ private function collectParamNames(array $params) : array { $paramNames = []; foreach ($params as $param) { $paramNames[] = $this->nodeNameResolver->getName($param); } return $paramNames; } /** * @param Node[] $nodes * @param Param[] $params * @return array */ private function createUseVariablesFromParams(array $nodes, array $params) : array { $paramNames = $this->collectParamNames($params); /** @var Variable[] $variables */ $variables = $this->betterNodeFinder->findInstanceOf($nodes, Variable::class); /** @var array $filteredVariables */ $filteredVariables = []; $alreadyAssignedVariables = []; foreach ($variables as $variable) { // "$this" is allowed if ($this->nodeNameResolver->isName($variable, 'this')) { continue; } $variableName = $this->nodeNameResolver->getName($variable); if ($variableName === null) { continue; } if (\in_array($variableName, $paramNames, \true)) { continue; } if ($variable->getAttribute(AttributeKey::IS_BEING_ASSIGNED) === \true || $variable->getAttribute(AttributeKey::IS_PARAM_VAR) === \true || $variable->getAttribute(AttributeKey::IS_VARIABLE_LOOP) === \true) { $alreadyAssignedVariables[] = $variableName; } if (!$this->nodeNameResolver->isNames($variable, $alreadyAssignedVariables)) { $filteredVariables[$variableName] = $variable; } } return $filteredVariables; } /** * @param ParameterReflection[] $parameterReflections * @return Param[] */ private function createParams(PhpMethodReflection $phpMethodReflection, array $parameterReflections) : array { $classReflection = $phpMethodReflection->getDeclaringClass(); $className = $classReflection->getName(); $methodName = $phpMethodReflection->getName(); /** @var ClassMethod $classMethod */ $classMethod = $this->astResolver->resolveClassMethod($className, $methodName); $params = []; foreach ($parameterReflections as $key => $parameterReflection) { $variable = new Variable($parameterReflection->getName()); $defaultExpr = $this->resolveParamDefaultExpr($parameterReflection, $key, $classMethod); $type = $this->resolveParamType($parameterReflection); $byRef = $parameterReflection->passedByReference()->yes(); $params[] = new Param($variable, $defaultExpr, $type, $byRef); } return $params; } /** * @return \PhpParser\Node\Name|\PhpParser\Node\ComplexType|\PhpParser\Node\Identifier|null */ private function resolveParamType(ParameterReflection $parameterReflection) { if ($parameterReflection->getType() instanceof MixedType) { return null; } return $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($parameterReflection->getType(), TypeKind::PARAM); } private function resolveParamDefaultExpr(ParameterReflection $parameterReflection, int $key, ClassMethod $classMethod) : ?Expr { if (!$parameterReflection->getDefaultValue() instanceof Type) { return null; } $paramDefaultExpr = $classMethod->params[$key]->default; if (!$paramDefaultExpr instanceof Expr) { return null; } return $this->nodeFactory->createReprintedExpr($paramDefaultExpr); } /** * @param Param[] $params * @return \PhpParser\Node\Expr\MethodCall|\PhpParser\Node\Expr\StaticCall|null */ private function createInnerMethodCall(PhpMethodReflection $phpMethodReflection, Expr $expr, array $params) { if ($phpMethodReflection->isStatic()) { $expr = $this->normalizeClassConstFetchForStatic($expr); if (!$expr instanceof Node) { return null; } $innerMethodCall = new StaticCall($expr, $phpMethodReflection->getName()); } else { $expr = $this->resolveExpr($expr); if (!$expr instanceof Expr) { return null; } $innerMethodCall = new MethodCall($expr, $phpMethodReflection->getName()); } $innerMethodCall->args = $this->nodeFactory->createArgsFromParams($params); return $innerMethodCall; } /** * @return null|\PhpParser\Node\Name|\PhpParser\Node\Name\FullyQualified|\PhpParser\Node\Expr */ private function normalizeClassConstFetchForStatic(Expr $expr) { if (!$expr instanceof ClassConstFetch) { return $expr; } if (!$this->nodeNameResolver->isName($expr->name, 'class')) { return $expr; } // dynamic name, nothing we can do $className = $this->nodeNameResolver->getName($expr->class); if ($className === null) { return null; } $name = new Name($className); if ($name->isSpecialClassName()) { return $name; } return new FullyQualified($className); } /** * @return \PhpParser\Node\Expr\New_|\PhpParser\Node\Expr|null */ private function resolveExpr(Expr $expr) { if (!$expr instanceof ClassConstFetch) { return $expr; } if (!$this->nodeNameResolver->isName($expr->name, 'class')) { return $expr; } // dynamic name, nothing we can do $className = $this->nodeNameResolver->getName($expr->class); return $className === null ? null : new New_(new FullyQualified($className)); } /** * @return Stmt[] * @param \PhpParser\Node\Expr\StaticCall|\PhpParser\Node\Expr\MethodCall $innerMethodCall */ private function resolveStmts(FunctionVariantWithPhpDocs $functionVariantWithPhpDocs, $innerMethodCall) : array { if ($functionVariantWithPhpDocs->getReturnType()->isVoid()->yes()) { return [new Expression($innerMethodCall)]; } return [new Return_($innerMethodCall)]; } }