Dgame\Annotation\AnnotationType

Complexity

Total Complexity

24

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	parse()	0	14	3
A	getType()	0	4	1
A	hasNext()	0	4	1
A	next()	0	4	1
A	isImplicit()	0	11	3
A	isSame()	0	11	3
A	compare()	0	10	3
A	getDimension()	0	6	1
A	getBaseType()	0	6	2
A	iterate()	0	11	3
A	export()	0	6	2

<?php

namespace Dgame\Annotation;

use Dgame\Type\Type;
use Dgame\Type\TypeFactory;
use Exception;

/**
 * Class AnnotationType
 * @package Dgame\Annotation
 */
final class AnnotationType
{
    /**
     * @var Type
     */
    private $type;
    /**
     * @var AnnotationType|null
     */
    private $next;

    /**
     * AnnotationType constructor.
     *
     * @param string              $type
     * @param AnnotationType|null $next

Should the type for parameter $next not be null|\self?

     *
     * @throws Exception
     */
    private function __construct(string $type, self $next = null)
    {
        $this->type = Type::import($type);

It seems like \Dgame\Type\Type::import($type) of type object<self> is incompatible with the declared type object<Dgame\Type\Type> of property $type.

        $this->next = $next;

It seems like $next can also be of type object<self>. However, the property $next is declared as type object<Dgame\Annotation\AnnotationType>|null. Maybe add an additional type check?

    }

    /**
     * @param string $type
     *
     * @return AnnotationType

Should the return type not be \self?

     * @throws Exception
     */
    public static function parse(string $type): self
    {
        if (preg_match_all('/(\[\s*\])/S', $type, $brackets)) {
            $base = str_replace(['[', ']'], '', $type);
            $type = new self('array', new self($base));

new self($base) is of type object<Dgame\Annotation\AnnotationType>, but the function expects a null|object<self>.

Consider using a different name than the parameter $type. This often makes code more readable.

            for ($i = 1, $c = count($brackets[1]); $i < $c; $i++) {
                $type = new self('array', $type);

$type is of type object<Dgame\Annotation\AnnotationType>, but the function expects a null|object<self>.

Consider using a different name than the parameter $type. This often makes code more readable.

            }

            return $type;
        }

        return new self($type);
    }

    /**
     * @return Type
     */
    public function getType(): Type
    {
        return $this->type;
    }

    /**
     * @return bool
     */
    public function hasNext(): bool
    {
        return $this->next !== null;
    }

    /**
     * @return AnnotationType|null
     */
    public function next(): ?self
    {
        return $this->next;
    }

    /**
     * @param mixed $expression
     *
     * @return bool
     * @throws Exception
     */
    public function isImplicit($expression): bool
    {
        $type = TypeFactory::expression($expression);
        if ($type->isArray() && $this->hasNext()) {
            return $this->compare($expression, function (self $type, $expr): bool {
                return $type->isImplicit($expr);
            });
        }

        return $type->isImplicitSame($this->type);

$this->type is of type object<Dgame\Type\Type>, but the function expects a object<self>.

    }

    /**
     * @param mixed $expression
     *
     * @return bool
     * @throws Exception
     */
    public function isSame($expression): bool
    {
        $type = TypeFactory::expression($expression);
        if ($type->isArray() && $this->hasNext()) {
            return $this->compare($expression, function (self $type, $expr): bool {
                return $type->isSame($expr);
            });
        }

        return $type->isSame($this->type);

$this->type is of type object<Dgame\Type\Type>, but the function expects a object<self>.

    }

    /**
     * @param array    $expression
     * @param callable $callback
     *
     * @return bool
     */
    private function compare(array $expression, callable $callback): bool
    {
        foreach ($expression as $expr) {
            if (!$callback($this->next(), $expr)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @return int
     */
    public function getDimension(): int
    {
        $this->iterate($dimension);

        return $dimension;
    }

    /**
     * @return Type|null
     */
    public function getBaseType(): ?Type
    {
        $type = $this->iterate();

        return $type === null ? null : $type->getType();
    }

    /**
     * @param int|null $dimension
     *
     * @return AnnotationType|null
     */
    private function iterate(int &$dimension = null): ?self
    {
        $dimension = 0;
        $type      = $this;
        while ($type !== null && $type->hasNext()) {
            $type = $type->next();
            $dimension++;
        }

        return $type;
    }

    /**
     * @return string|null
     */
    public function export(): ?string
    {
        $type = $this->getBaseType();

        return $type === null ? null : $type->export() . str_repeat('[]', $this->getDimension());
    }
}