Go\Instrument\Transformer\SelfValueVisitor

Complexity

Total Complexity

21

Size/Duplication

Total Lines	121
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

93.18%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getReplacedNodes()	0	4	1
A	beforeTraverse()	0	6	1
C	enterNode()	0	27	14
A	resolveClassName()	0	19	2
A	resolveType()	0	12	3

<?php
/*
 * Go! AOP framework
 *
 * @copyright Copyright 2018, Lisachenko Alexander <lisachenko.it@gmail.com>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Go\Instrument\Transformer;

use PhpParser\Node;
use PhpParser\Node\Name;
use PhpParser\Node\Name\FullyQualified;
use PhpParser\Node\Stmt;
use PhpParser\Node\Expr;
use PhpParser\NodeVisitorAbstract;

/**
 * Node visitor that resolves class name for `self` nodes with FQN
 */
final class SelfValueVisitor extends NodeVisitorAbstract
{
    /**
     * List of replaced nodes
     *
     * @var Node[]
     */
    protected $replacedNodes = [];

    /**
     * Current namespace
     *
     * @var null|Name|string
     */
    protected $namespace;

    /**
     * Current class name
     *
     * @var null|Name
     */
    protected $className;

    /**
     * Returns list of changed `self` nodes
     *
     * @return Node[]
     */
    public function getReplacedNodes()
    {
        return $this->replacedNodes;
    }

    /**
     * @inheritDoc
     */
    public function beforeTraverse(array $nodes)
    {
        $this->namespace     = null;
        $this->className     = null;
        $this->replacedNodes = [];
    }

    /**
     * @inheritDoc
     */
    public function enterNode(Node $node)
    {
        if ($node instanceof Stmt\Namespace_) {
            $this->namespace = $node->name;
        } elseif ($node instanceof Stmt\Class_) {
            if ($node->name !== null) {
                $this->className = new Name($node->name);
            }
        } elseif ($node instanceof Stmt\ClassMethod || $node instanceof Expr\Closure) {
            $node->returnType = $this->resolveType($node->returnType);
        } elseif ($node instanceof Node\Param) {
            $node->type = $this->resolveType($node->type);

It seems like $this->resolveType($node->type) can also be of type object<PhpParser\Node>. However, the property $type is declared as type null|string|object<PhpParser\Node\Name>|object<PhpParser\Node\NullableType>. Maybe add an additional type check?

        } elseif (
            $node instanceof Expr\StaticCall
            || $node instanceof Expr\ClassConstFetch
            || $node instanceof Expr\New_
            || $node instanceof Expr\Instanceof_
        ) {
            if ($node->class instanceof Name) {
                $node->class = $this->resolveClassName($node->class);
            }
        } elseif ($node instanceof Stmt\Catch_) {
            foreach ($node->types as &$type) {
                $type = $this->resolveClassName($type);
            }
        }
    }

    /**
     * Resolves `self` class name with value
     *
     * @param Name $name Instance of original node
     *
     * @return Name|FullyQualified
     */
    protected function resolveClassName(Name $name)
    {
        // Skip all names except special `self`
        if (strtolower($name->toString()) !== 'self') {
            return $name;
        }

        // Save the original name
        $originalName = $name;
        $name = clone $originalName;
        $name->setAttribute('originalName', $originalName);

        $fullClassName    = Name::concat($this->namespace, $this->className);
        $resolvedSelfName = new FullyQualified('\\' . $fullClassName->toString(), $name->getAttributes());

        $this->replacedNodes[] = $resolvedSelfName;

        return $resolvedSelfName;
    }

    /**
     * Helper method for resolving type nodes
     *
     * @param Node|string|null $node Instance of node
     *
     * @return Node|Name|FullyQualified
     */
    private function resolveType($node)
    {
        if ($node instanceof Node\NullableType) {
            $node->type = $this->resolveType($node->type);
            return $node;
        }
        if ($node instanceof Name) {
            return $this->resolveClassName($node);
        }

        return $node;

The expression return $node; of type PhpParser\Node|string|null is incompatible with the return type documented by Go\Instrument\Transformer\SelfValueVisitor::resolveType of type PhpParser\Node|null as it can also be of type string which is not included in this return type.

    }
}