PHPSA\Compiler\DefinitionVisitor

Complexity

Total Complexity

24

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

18.64%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setFilePath()	0	4	1
A	enterNode()	0	10	4
A	prepareTrait()	0	14	2
A	prepareFunction()	0	13	2
C	prepareClass()	0	46	14

<?php
/**
 * @author Patsura Dmitry https://github.com/ovr <talk@dmtry.me>
 */

namespace PHPSA\Compiler;

use PhpParser\Node;
use PhpParser\NodeVisitorAbstract;
use PhpParser\Node\Stmt;
use PHPSA\Compiler;
use PHPSA\Definition\ClassDefinition;
use PHPSA\Definition\ClassMethod;
use PHPSA\Definition\FunctionDefinition;
use PHPSA\Definition\TraitDefinition;

class DefinitionVisitor extends NodeVisitorAbstract
{
    /**
     * @var Compiler
     */
    protected $compiler;

    /**
     * @var string|null
     */
    protected $filepath;

    public function __construct(Compiler $compiler)
    {
        $this->compiler = $compiler;
    }

    /**
     * @param Node $node
     * @return void
     */
    public function enterNode(Node $node)
    {
        if ($node instanceof Stmt\Class_) {
            $this->prepareClass($node);
        } elseif ($node instanceof Stmt\Function_) {
            $this->prepareFunction($node);
        } elseif ($node instanceof Stmt\Trait_) {
            $this->prepareTrait($node);
        }
    }

    /**
     * @param Stmt\Trait_ $statement
     */
    public function prepareTrait(Stmt\Trait_ $statement)
    {
        $definition = new TraitDefinition($statement->name, $statement);

$statement->name is of type object<PhpParser\Node\Identifier>|null, but the function expects a string.

        $definition->setFilepath($this->filepath);

        if (isset($statement->namespace)) {
            /** @var \PhpParser\Node\Name $namespace */
            $namespace = $statement->namespace;
            $definition->setNamespace($namespace->toString());
        }

        $definition->precompile();
        $this->compiler->addTrait($definition);
    }

    /**
     * @param Stmt\Function_ $statement
     */
    public function prepareFunction(Stmt\Function_ $statement)
    {
        $definition = new FunctionDefinition($statement->name, $statement);
        $definition->setFilepath($this->filepath);

        if (isset($statement->namespace)) {
            /** @var \PhpParser\Node\Name $namespace */
            $namespace = $statement->namespace;
            $definition->setNamespace($namespace->toString());
        }

        $this->compiler->addFunction($definition);
    }

    /**
     * @param Stmt\Class_ $statement
     */
    public function prepareClass(Stmt\Class_ $statement)
    {
        $definition = new ClassDefinition($statement->name, $statement, $statement->flags);

$statement->name is of type object<PhpParser\Node\Identifier>|null, but the function expects a string.

        $definition->setFilepath($this->filepath);

        if (isset($statement->namespace)) {
            /** @var \PhpParser\Node\Name $namespace */
            $namespace = $statement->namespace;
            $definition->setNamespace($namespace->toString());
        }

        if ($statement->extends) {
            $definition->setExtendsClass($statement->extends->toString());
        }

        if ($statement->implements) {

The expression $statement->implements of type PhpParser\Node\Name[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($statement->implements as $interface) {
                $definition->addInterface($interface->toString());
            }
        }

        foreach ($statement->stmts as $stmt) {
            if ($stmt instanceof Node\Stmt\ClassMethod) {
                $definition->addMethod(
                    new ClassMethod($stmt->name, $stmt, $stmt->flags)
                );
            } elseif ($stmt instanceof Node\Stmt\Property) {
                $definition->addProperty($stmt);
            } elseif ($stmt instanceof Node\Stmt\TraitUse) {
                foreach ($stmt->traits as $traitPart) {
                    $traitDefinition = $this->compiler->getTrait($traitPart->toString());

Are you sure the assignment to $traitDefinition is correct as $this->compiler->getTrait($traitPart->toString()) (which targets PHPSA\Compiler::getTrait()) seems to always return null.

                    if (!$traitDefinition && $definition->getNamespace()) {
                        $traitDefinition = $this->compiler->getTrait($definition->getNamespace() . '\\' . $traitPart);

Are you sure the assignment to $traitDefinition is correct as $this->compiler->getTrait($definition->getNamespace() . '\\' . $traitPart) (which targets PHPSA\Compiler::getTrait()) seems to always return null.

                    }

                    if ($traitDefinition) {
                        $definition->mergeTrait($traitDefinition, $stmt->adaptations);
                    }
                }
            } elseif ($stmt instanceof Node\Stmt\ClassConst) {
                $definition->addConst($stmt);
            }
        }

        $this->compiler->addClass($definition);
    }

    /**
     * @param string $filepath
     */
    public function setFilePath($filepath)
    {
        $this->filepath = $filepath;
    }
}