ComposerRequireChecker\NodeVisitor\DefinedSymbolCollector

Complexity

Total Complexity

18

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Test Coverage

Coverage

90.48%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefinedSymbols()	0	3	1
A	recordConstDefinition()	0	5	3
A	__construct()	0	2	1
A	recordInterfaceDefinition()	0	4	2
A	enterNode()	0	7	1
A	recordClassDefinition()	0	4	3
A	beforeTraverse()	0	5	1
A	recordFunctionDefinition()	0	4	2
A	recordDefinitionOf()	0	12	2
A	recordTraitDefinition()	0	4	2

<?php

namespace ComposerRequireChecker\NodeVisitor;

use PhpParser\Node;
use PhpParser\NodeVisitorAbstract;

final class DefinedSymbolCollector extends NodeVisitorAbstract
{
    /**
     * @var mixed[]
     */
    private $definedSymbols = [];

    public function __construct()
    {
    }

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

        return parent::beforeTraverse($nodes);

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

    }

    /**
     * @return string[]
     */
    public function getDefinedSymbols(): array
    {
        return array_keys($this->definedSymbols);
    }

    /**
     * {@inheritDoc}
     */
    public function enterNode(Node $node)
    {
        $this->recordClassDefinition($node);
        $this->recordInterfaceDefinition($node);
        $this->recordTraitDefinition($node);
        $this->recordFunctionDefinition($node);
        $this->recordConstDefinition($node);
    }

    private function recordClassDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Class_ && !$node->isAnonymous()) {
            $this->recordDefinitionOf($node);
        }
    }

    private function recordInterfaceDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Interface_) {
            $this->recordDefinitionOf($node);
        }
    }

    private function recordTraitDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Trait_) {
            $this->recordDefinitionOf($node);
        }
    }

    private function recordFunctionDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Function_) {
            $this->recordDefinitionOf($node);
        }
    }

    private function recordConstDefinition(Node $node)
    {
        if ($node instanceof Node\Stmt\Const_) {
            foreach ($node->consts as $const) {
                $this->recordDefinitionOf($const);
            }
        }
    }

    /**
     * @param Node $node
     *
     * @return void
     */
    private function recordDefinitionOf(Node $node)
    {
        if (!isset($node->namespacedName)) {

Accessing namespacedName on the interface PhpParser\Node suggest that you code against a concrete implementation. How about adding an instanceof check?

            throw new \UnexpectedValueException(sprintf(
                'Given node of type "%s" (defined at line %s)does not have an assigned "namespacedName" property: '
                . 'did you pass it through a name resolver visitor?',
                get_class($node),
                $node->getLine()
            ));
        }

        $this->definedSymbols[(string)$node->namespacedName] = $node->namespacedName;
    }
}