AstBuilder::visitNamedParameter() - Code Metrics - Inspection of "Support standalone constants" - Majkl578/doctrine-annotations - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions
Push — new-parser-ast-metadata ( cfd696...cc9a79 )

by Michael
created 2018-12-16 17:24 UTC
AstBuilder::visitNamedParameter() A

↳ Parent: AstBuilder
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	1
Importance

Changes
Metric	Value
eloc	3
dl	0
loc	5
ccs	4
cts	4
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1
<?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\ClassConstantFetch;
use Doctrine\Annotations\Parser\Ast\Collection\ListCollection;
use Doctrine\Annotations\Parser\Ast\Collection\MapCollection;
use Doctrine\Annotations\Parser\Ast\ConstantFetch;
use Doctrine\Annotations\Parser\Ast\Node;
use Doctrine\Annotations\Parser\Ast\Pair;
use Doctrine\Annotations\Parser\Ast\Parameter\NamedParameter;
use Doctrine\Annotations\Parser\Ast\Parameter\UnnamedParameter;
use Doctrine\Annotations\Parser\Ast\Parameters;
use Doctrine\Annotations\Parser\Ast\Reference;
use Doctrine\Annotations\Parser\Ast\Scalar;
use Doctrine\Annotations\Parser\Ast\Scalar\BooleanScalar;
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\Nodes;
use Doctrine\Annotations\Parser\Tokens;
use Hoa\Compiler\Llk\TreeNode;
use Hoa\Visitor\Element;
use Hoa\Visitor\Visit;
use function assert;
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::STANDALONE_CONSTANT:
                return $this->visitStandaloneConstant($node);
            case Nodes::CLASS_CONSTANT:
                return $this->visitClassConstant($node);
            case Nodes::REFERENCE:
                return $this->visitReference($node);
            case Nodes::STRING:
                return $this->visitString($node);
        }

        assert(false, sprintf('Unsupported node %s.', $node->getId()));
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
    }

    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()));
interface ReturnsInt {
    public function returnsIntHinted(): int;
}

class MyClass implements ReturnsInt {
    public function returnsIntHinted(): int
    {
        if (foo()) {
            return 123;
        }
        // here: null is implicitly returned
    }
}
    }

    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()
            /** @scrutinizer ignore-type */ $node->childExists(1) ? $node->getChild(1)->accept($this) : new Parameters()
        );
    }

    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),
            /** @scrutinizer ignore-type */ $node->getChild(0)->accept($this),
            $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 visitStandaloneConstant(TreeNode $node) : ConstantFetch
    {
        return new ConstantFetch($node->getChild(0)->accept($this));
        return new ConstantFetch(/** @scrutinizer ignore-type */ $node->getChild(0)->accept($this));
    }

    private function visitClassConstant(TreeNode $node) : ClassConstantFetch
    {
        return new ClassConstantFetch(
            $node->getChild(0)->accept($this),
            $node->getChild(1)->accept($this)
            /** @scrutinizer ignore-type */ $node->getChild(1)->accept($this)
        );
    }

    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() : ''));
    }
}

Majkl578 / doctrine-annotations

Push — new-parser-ast-metadata ( cfd696...cc9a79 )

AstBuilder::visitNamedParameter() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
