Rade\DI\NodeVisitor\AutowiringResolver

Complexity

Total Complexity

33

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Importance

Changes	5
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	enterNode()	0	12	3
A	afterTraverse()	0	21	6
D	resolveStmt()	0	56	18
A	doReplacement()	0	17	6

<?php

declare(strict_types=1);

/*
 * This file is part of DivineNii opensource projects.
 *
 * PHP version 7.4 and above required
 *
 * @author    Divine Niiquaye Ibok <divineibok@gmail.com>
 * @copyright 2021 DivineNii (https://divinenii.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Rade\DI\NodeVisitor;

use PhpParser\Node\Expr;
use PhpParser\Node\Stmt\{Class_, ClassMethod, Expression, Nop, Return_};
use PhpParser\NodeVisitorAbstract;

/**
 * Autowiring Enhancement for class methods stmts.
 *
 * Resolves same object id used multiple times in class methods stmts
 * and create a variable for the object.
 *
 * Example of how it works:
 *
 * ```php
 * $hello = $container->call(HelloWorld::class);
 * $container->set('foo', new Definition('MyWorld', [$hello]))->bind('addGreeting', [$hello]);
 *
 * // A variable is created for $hello object, then mapped to receiving nodes.
 * ```
 *
 * @author Divine Niiquaye Ibok <divineibok@gmail.com>
 */
class AutowiringResolver extends NodeVisitorAbstract
{
    /** @var array<string,array<int,Expr\Assign> */

The doc comment array<string,array<int,Expr\Assign> at position 9 could not be parsed: Expected '>' at position 9, but found '>'.

    private array $replacement = [];

    /** @var array<string,array<string,string>> */
    private array $sameArgs = [];

    /**
     * {@inheritdoc}
     */
    public function enterNode(\PhpParser\Node $node)
    {
        if ($node instanceof ClassMethod) {
            $nodeId = $node->name->toString();

            if (!isset($this->sameArgs[$nodeId])) {
                $methodsStmts = &$node->stmts;
                $this->resolveStmt($methodsStmts, $nodeId);

It seems like $methodsStmts can also be of type null; however, parameter $expressions of Rade\DI\NodeVisitor\AutowiringResolver::resolveStmt() does only seem to accept array, maybe add an additional type check?

            }
        }

        return parent::enterNode($node);

Are you sure the usage of parent::enterNode($node) targeting PhpParser\NodeVisitorAbstract::enterNode() seems to always return null.

    }

    /**
     * {@inheritdoc}
     */
    public function afterTraverse(array $nodes)
    {
        foreach ($nodes as $node) {
            if ($node instanceof Class_) {
                foreach ($node->stmts as $methodNode) {
                    if ($methodNode instanceof ClassMethod) {
                        $nodeId = $methodNode->name->toString();

                        if (isset($this->replacement[$nodeId])) {
                            $methodsStmts = &$methodNode->stmts;
                            $this->resolveStmt($methodsStmts, $nodeId, true);

It seems like $methodsStmts can also be of type null; however, parameter $expressions of Rade\DI\NodeVisitor\AutowiringResolver::resolveStmt() does only seem to accept array, maybe add an additional type check?

                            $replacements = \array_map(fn (Expr\Assign $node) => new Expression($node), $this->replacement[$nodeId]);
                            $methodNode->stmts = [...\array_values($replacements), new Nop(), ...$methodsStmts];
                        }
                    }
                }
            }
        }

        return parent::afterTraverse($nodes);

Are you sure the usage of parent::afterTraverse($nodes) targeting PhpParser\NodeVisitorAbstract::afterTraverse() seems to always return null.

    }

    /**
     * @param array<int,Expression|Return_|Expr> $expressions
     */
    private function resolveStmt(array $expressions, string $parentId, bool $leaveNodes = false): void
    {
        foreach ($expressions as &$expression) {
            if ($expression instanceof Expression || $expression instanceof Return_) {
                $expression = $expression->expr;
                $fromStmt = true; // $expression is from stmt

                if ($expression instanceof Expr\Assign) {
                    $expression = &$expression->expr;
                }
            } elseif (\property_exists($expression, 'value') && $expression->value instanceof \PhpParser\Node) {
                $expression = &$expression->value;
            }

            if (\property_exists($expression, 'expr')) {
                $this->doReplacement($expression, $parentId, $leaveNodes, $expR);

                if ($expression instanceof Expr\Variable || $expR) {
                    continue;
                }

                $expression = &$expression->expr;
            }

            if ($expression instanceof Expr\MethodCall) {
                $exprVar = &$expression->var;

                if (!$expression instanceof Expr\Variable) {
                    $this->doReplacement($exprVar, $parentId, $leaveNodes);
                }
            }

            if ($expression instanceof Expr\CallLike) {
                $this->resolveStmt($expression->args, $parentId, $leaveNodes);

                if (isset($fromStmt)) {
                    continue;
                }
            }

            if ($expression instanceof Expr\Array_) {
                if (isset($this->replacement[$parentId][\spl_object_id($expression)]) && $leaveNodes) {
                    $removeIds = \array_intersect_key(
                        \array_keys($this->replacement[$parentId]),
                        \array_map(fn (Expr\ArrayItem $i) => \spl_object_id($i->value), $expression->items)
                    );

                    foreach ($removeIds as $removeId) {
                        unset($this->replacement[$parentId][$removeId]);
                    }
                }

                $this->resolveStmt($expression->items, $parentId, $leaveNodes);
            }

            $this->doReplacement($expression, $parentId, $leaveNodes);
        }
    }

    private function doReplacement(\PhpParser\Node &$nodeValue, string $parentId, bool $leaveNodes, ?bool &$replaced = false): void
    {
        if ($nodeValue instanceof Expr\Variable || $nodeValue instanceof Expr\Closure) {
            return; // @Todo: work in progress ...
        }

        $nodeId = \spl_object_id($nodeValue);

        if ($leaveNodes) {
            if (isset($this->replacement[$parentId][$nodeId])) {
                $nodeValue = $this->replacement[$parentId][$nodeId]->var;
            }
        } elseif (null === $varName = $this->sameArgs[$parentId][$nodeId] ?? null) {
            $this->sameArgs[$parentId][$nodeId] = 'v_' . \substr(\hash('sha256', \serialize($nodeValue)), 0, 5);
        } else {
            $this->replacement[$parentId][$nodeId] = new Expr\Assign(new Expr\Variable($varName), $nodeValue);
            $replaced = true;
        }
    }
}