Doctrine\Annotations\Parser\Visitor\AstBuilder

Complexity

Total Complexity

41

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Test Coverage

Coverage

95.4%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	visitAnnotations()	0	8	2
A	visitParameters()	0	8	2
A	visitConstant()	0	5	1
A	visitReference()	0	10	3
A	visitString()	0	3	2
A	visitAnnotation()	0	7	2
A	visitUnnamedParameter()	0	3	1
A	visitValue()	0	3	1
A	visitList()	0	8	2
A	visit()	0	9	2
A	visitNamedParameter()	0	5	1
A	visitToken()	0	21	6
C	visitNode()	0	30	13
A	visitPair()	0	5	1
A	visitMap()	0	8	2

<?php

declare(strict_types=1);

namespace Doctrine\Annotations\Parser\Visitor;

use Doctrine\Annotations\Parser\Ast\Annotation;
use Doctrine\Annotations\Parser\Ast\Annotations;
use Doctrine\Annotations\Parser\Ast\Collection\ListCollection;
use Doctrine\Annotations\Parser\Ast\Collection\MapCollection;
use Doctrine\Annotations\Parser\Ast\Parameter\NamedParameter;
use Doctrine\Annotations\Parser\Ast\Node;
use Doctrine\Annotations\Parser\Ast\Pair;
use Doctrine\Annotations\Parser\Ast\Reference;
use Doctrine\Annotations\Parser\Ast\Scalar;
use Doctrine\Annotations\Parser\Ast\Scalar\BooleanScalar;
use Doctrine\Annotations\Parser\Ast\ConstantFetch;
use Doctrine\Annotations\Parser\Ast\Scalar\FloatScalar;
use Doctrine\Annotations\Parser\Ast\Scalar\Identifier;
use Doctrine\Annotations\Parser\Ast\Scalar\IntegerScalar;
use Doctrine\Annotations\Parser\Ast\Scalar\NullScalar;
use Doctrine\Annotations\Parser\Ast\Scalar\StringScalar;
use Doctrine\Annotations\Parser\Ast\Parameter\UnnamedParameter;
use Doctrine\Annotations\Parser\Ast\Parameters;
use Doctrine\Annotations\Parser\Nodes;
use Doctrine\Annotations\Parser\Tokens;
use Hoa\Compiler\Llk\TreeNode;
use Hoa\Visitor\Element;
use Hoa\Visitor\Visit;
use function ltrim;
use function sprintf;
use function str_replace;
use function strcasecmp;

final class AstBuilder implements Visit
{
    /**
     * @param mixed $handle
     * @param mixed $eldnah
     */
    public function visit(Element $node, &$handle = null, $eldnah = null) : Node
    {
        assert($node instanceof TreeNode);

        if ($node->isToken()) {
            return $this->visitToken($node);
        }

        return $this->visitNode($node);
    }

    private function visitNode(TreeNode $node) : Node
    {
        switch ($node->getId()) {
            case Nodes::ANNOTATIONS:
                return $this->visitAnnotations($node);
            case Nodes::ANNOTATION:
                return $this->visitAnnotation($node);
            case Nodes::PAIR:
                return $this->visitPair($node);
            case Nodes::PARAMETERS:
                return $this->visitParameters($node);
            case Nodes::NAMED_PARAMETERS:
                return $this->visitNamedParameter($node);
            case Nodes::UNNAMED_PARAMETERS:
                return $this->visitUnnamedParameter($node);
            case Nodes::VALUE:
                return $this->visitValue($node);
            case Nodes::MAP:
                return $this->visitMap($node);
            case Nodes::LIST:
                return $this->visitList($node);
            case Nodes::CONSTANT:
                return $this->visitConstant($node);
            case Nodes::REFERENCE:
                return $this->visitReference($node);
            case Nodes::STRING:
                return $this->visitString($node);
        }

        assert(false, sprintf('Unsupported node %s.', $node->getId()));

In this branch, the function will implicitly return null which is incompatible with the type-hinted return Doctrine\Annotations\Parser\Ast\Node. Consider adding a return statement or allowing null as return value.

    }

    private function visitToken(TreeNode $node) : Scalar
    {
        $value = $node->getValueValue();

        switch ($node->getValueToken()) {
            case Tokens::IDENTIFIER:
                return new Identifier($value);
            case Tokens::NULL :
                return new NullScalar();
            case Tokens::BOOLEAN :
                return new BooleanScalar(strcasecmp($value, 'true') === 0);
            case Tokens::INTEGER :
                $intValue = (int) $value;
                assert((string) $intValue === $value, 'Integer overflow');

                return new IntegerScalar($intValue);
            case Tokens::FLOAT :
                return new FloatScalar((float) $value);
        }

        assert(false, sprintf('Unsupported token %s.', $node->getValueToken()));

In this branch, the function will implicitly return null which is incompatible with the type-hinted return Doctrine\Annotations\Parser\Ast\Scalar. Consider adding a return statement or allowing null as return value.

    }

    private function visitAnnotations(TreeNode $node) : Annotations
    {
        return new Annotations(
            ...(function (TreeNode ...$nodes) : iterable {
                foreach ($nodes as $node) {
                    yield $node->accept($this);
                }
            })(...$node->getChildren())
        );
    }

    private function visitAnnotation(TreeNode $node) : Annotation
    {
        $identifier = $node->getChild(0)->getValueValue();

        return new Annotation(
            new Reference(ltrim($identifier, '\\'), $identifier[0] === '\\'),
            $node->childExists(1) ? $node->getChild(1)->accept($this) : new Parameters()

It seems like $node->childExists(1) ? $node->getChild(1)->accept($this) : new Doctrine\Annotations\Parser\Ast\Parameters() can also be of type Doctrine\Annotations\Parser\Ast\Scalar\BooleanScalar and Doctrine\Annotations\Parser\Ast\Scalar\FloatScalar and Doctrine\Annotations\Parser\Ast\Scalar\IntegerScalar and Doctrine\Annotations\Parser\Ast\Scalar\NullScalar and Doctrine\Annotations\Parser\Ast\Scalar\Identifier; however, parameter $parameters of Doctrine\Annotations\Parser\Ast\Annotation::__construct() does only seem to accept Doctrine\Annotations\Parser\Ast\Parameters, maybe add an additional type check?

        );
    }

    private function visitPair(TreeNode $node) : Pair
    {
        return new Pair(
            $node->getChild(0)->accept($this),
            $node->getChild(1)->accept($this)
        );
    }

    private function visitParameters(TreeNode $node) : Parameters
    {
        return new Parameters(
            ...(function (TreeNode ...$nodes) : iterable {
                foreach ($nodes as $node) {
                    yield $node->accept($this);
                }
            })(...$node->getChildren())
        );
    }

    private function visitNamedParameter(TreeNode $node) : NamedParameter
    {
        return new NamedParameter(
            $node->getChild(0)->accept($this),

It seems like $node->getChild(0)->accept($this) can also be of type Doctrine\Annotations\Parser\Ast\Scalar\BooleanScalar and Doctrine\Annotations\Parser\Ast\Scalar\FloatScalar and Doctrine\Annotations\Parser\Ast\Scalar\IntegerScalar and Doctrine\Annotations\Parser\Ast\Scalar\NullScalar; however, parameter $name of Doctrine\Annotations\Parser\Ast\Parameter\NamedParameter::__construct() does only seem to accept Doctrine\Annotations\Parser\Ast\Scalar\Identifier, maybe add an additional type check?

            $node->getChild(1)->accept($this)
        );
    }

    private function visitUnnamedParameter(TreeNode $node) : UnnamedParameter
    {
        return new UnnamedParameter($node->getChild(0)->accept($this));
    }

    private function visitValue(TreeNode $node) : Node
    {
        return $node->getChild(0)->accept($this);
    }

    private function visitMap(TreeNode $node) : MapCollection
    {
        return new MapCollection(
            ...(function (TreeNode ...$nodes) : iterable {
                foreach ($nodes as $node) {
                    yield $node->accept($this);
                }
            })(...$node->getChildren())
        );
    }

    private function visitList(TreeNode $node) : ListCollection
    {
        return new ListCollection(
            ...(function (TreeNode ...$nodes) : iterable {
                foreach ($nodes as $node) {
                    yield $node->accept($this);
                }
            })(...$node->getChildren())
        );
    }

    private function visitConstant(TreeNode $node) : ConstantFetch
    {
        return new ConstantFetch(
            $node->getChild(0)->accept($this),
            $node->getChild(1)->accept($this)

It seems like $node->getChild(1)->accept($this) can also be of type Doctrine\Annotations\Parser\Ast\Scalar\BooleanScalar and Doctrine\Annotations\Parser\Ast\Scalar\FloatScalar and Doctrine\Annotations\Parser\Ast\Scalar\IntegerScalar and Doctrine\Annotations\Parser\Ast\Scalar\NullScalar; however, parameter $name of Doctrine\Annotations\Parser\Ast\ConstantFetch::__construct() does only seem to accept Doctrine\Annotations\Parser\Ast\Scalar\Identifier, maybe add an additional type check?

        );
    }

    private function visitReference(TreeNode $node) : Reference
    {
        $child = $node->getChild(0);
        $value = $child->getValueValue();

        if ($child->getValueToken() === Tokens::NAMESPACED_IDENTIFIER && $value[0] === '\\') {
            return new Reference(ltrim($value, '\\'), true);
        }

        return new Reference($value, false);
    }

    private function visitString(TreeNode $node) : StringScalar
    {
        return new StringScalar(str_replace('\\\\', '\\', $node->getChild(0) ? $node->getChild(0)->getValueValue() : ''));
    }
}