ComposerRequireChecker\NodeVisitor\UsedSymbolCollector

Complexity

Total Complexity

43

Size/Duplication

Total Lines	173
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	10
Bugs	1	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	recordUsageOfByString()	0	3	1
B	recordFunctionParameterTypesUsage()	0	11	7
A	getCollectedSymbols()	0	3	1
A	recordCatchUsage()	0	5	3
A	__construct()	0	2	1
A	recordImplementsUsage()	0	4	2
A	beforeTraverse()	0	5	1
A	recordFunctionCallUsage()	0	6	3
A	recordExtendsUsage()	0	8	3
B	recordClassExpressionUsage()	0	11	7
A	enterNode()	0	13	1
A	recordConstantFetchUsage()	0	4	2
A	recordUsageOf()	0	3	1
A	recordFunctionReturnTypeUsage()	0	12	5
A	recordTraitUsage()	0	15	5

<?php

namespace ComposerRequireChecker\NodeVisitor;

use PhpParser\Node;
use PhpParser\NodeVisitorAbstract;

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

    public function __construct()
    {
    }

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

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

        return parent::beforeTraverse($nodes);

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

    }

    /**
     * {@inheritDoc}
     */
    public function enterNode(Node $node)
    {
        $this->recordExtendsUsage($node);
        $this->recordImplementsUsage($node);
        $this->recordClassExpressionUsage($node);
        $this->recordCatchUsage($node);
        $this->recordFunctionCallUsage($node);
        $this->recordFunctionParameterTypesUsage($node);
        $this->recordFunctionReturnTypeUsage($node);
        $this->recordConstantFetchUsage($node);
        $this->recordTraitUsage($node);

        return parent::enterNode($node);

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

    }

    private function recordExtendsUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Class_) {
            array_map([$this, 'recordUsageOf'], array_filter([$node->extends]));
        }

        if ($node instanceof Node\Stmt\Interface_) {
            array_map([$this, 'recordUsageOf'], array_filter($node->extends));
        }
    }

    private function recordImplementsUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Class_) {
            array_map([$this, 'recordUsageOf'], $node->implements);
        }
    }

    private function recordClassExpressionUsage(Node $node)
    {
        if (($node instanceof Node\Expr\StaticCall
                || $node instanceof Node\Expr\StaticPropertyFetch
                || $node instanceof Node\Expr\ClassConstFetch
                || $node instanceof Node\Expr\New_
                || $node instanceof Node\Expr\Instanceof_
            )
            && $node->class instanceof Node\Name
        ) {
            $this->recordUsageOf($node->class);
        }
    }

    private function recordCatchUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Catch_) {
            foreach ($node->types as $type) {
                $this->recordUsageOf($type);
            }
        }
    }

    private function recordFunctionCallUsage(Node $node)
    {
        if ($node instanceof Node\Expr\FuncCall
            && $node->name instanceof Node\Name
        ) {
            $this->recordUsageOf($node->name);
        }
    }

    private function recordFunctionParameterTypesUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Function_
            || $node instanceof Node\Stmt\ClassMethod
        ) {
            foreach ($node->getParams() as $param) {
                if ($param->type instanceof Node\Name) {
                    $this->recordUsageOf($param->type);
                }
                if (is_string($param->type) || $param->type instanceof Node\Identifier) {
                    $this->recordUsageOfByString($param->type);
                }
            }
        }
    }

    private function recordFunctionReturnTypeUsage(Node $node)
    {
        if ($node instanceof Node\Stmt\Function_
            || $node instanceof Node\Stmt\ClassMethod
        ) {
            $returnType = $node->getReturnType();

            if ($returnType instanceof Node\Name) {
                $this->recordUsageOf($returnType);
            }
            if ($returnType instanceof Node\Identifier) {
                $this->recordUsageOfByString($returnType->toString());
            }
        }
    }

    private function recordConstantFetchUsage(Node $node)
    {
        if ($node instanceof Node\Expr\ConstFetch) {
            $this->recordUsageOf($node->name);
        }
    }

    private function recordTraitUsage(Node $node)
    {
        if (!$node instanceof Node\Stmt\TraitUse) {
            return;
        }

        array_map([$this, 'recordUsageOf'], $node->traits);

        foreach ($node->adaptations as $adaptation) {
            if (null !== $adaptation->trait) {
                $this->recordUsageOf($adaptation->trait);
            }

            if ($adaptation instanceof Node\Stmt\TraitUseAdaptation\Precedence) {
                array_map([$this, 'recordUsageOf'], $adaptation->insteadof);
            }
        }
    }

    /**
     * @param Node\Name $symbol
     *
     * @return void
     */
    private function recordUsageOf(Node\Name $symbol)
    {
        $this->collectedSymbols[(string)$symbol] = $symbol;
    }

    /**
     * @param string $symbol
     *
     * @return void
     */
    private function recordUsageOfByString(string $symbol)
    {
        $this->collectedSymbols[$symbol] = $symbol;
    }
}