Ray\Aop\ReflectionClass

Complexity

Total Complexity

10

Size/Duplication

Total Lines	74
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	6
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getParentClass()	0	6	2
A	getAnnotation()	0	10	3
A	getConstructor()	0	8	2
A	getAnnotations()	0	6	1
A	getMethods()	0	10	2

<?php

declare(strict_types=1);

namespace Ray\Aop;

use Ray\ServiceLocator\ServiceLocator;
use ReturnTypeWillChange;

The type ReturnTypeWillChange was not found. Maybe you did not declare it correctly or list all dependencies?

use function get_class_methods;

/**
 * @template T of object
 * @template-extends \ReflectionClass<T>
 */
class ReflectionClass extends \ReflectionClass implements Reader
{
    /**
     * {@inheritDoc}
     *
     * @psalm-suppress NoInterfaceProperties
     */
    public function getAnnotations(): array
    {
        /** @var list<object> $annotations */
        $annotations = ServiceLocator::getReader()->getClassAnnotations(new \ReflectionClass($this->name));

        return $annotations;

The expression return $annotations returns the type Ray\Aop\list which is incompatible with the type-hinted return array.

    }

    /**
     * {@inheritDoc}
     */
    public function getAnnotation(string $annotationName)
    {
        $annotations = $this->getAnnotations();
        foreach ($annotations as $annotation) {
            if ($annotation instanceof $annotationName) {
                return $annotation;
            }
        }

        return null;
    }

    /**
     * @param int|null $filter
     *
     * @return list<ReflectionMethod>

The type Ray\Aop\list was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @psalm-external-mutation-free
     */
    public function getMethods($filter = null): array
    {
        unset($filter);
        $methods = [];
        $methodNames = get_class_methods($this->name);
        foreach ($methodNames as $methodName) {
            $methods[] = new ReflectionMethod($this->name, $methodName);
        }

        return $methods;

The expression return $methods returns the type Ray\Aop\ReflectionMethod[]|array which is incompatible with the documented return type Ray\Aop\list.

    }

    /**
     * @psalm-suppress MethodSignatureMismatch
     * @psalm-external-mutation-free
     */
    public function getConstructor(): ?ReflectionMethod
    {
        $parent = parent::getConstructor();
        if ($parent === null) {
            return null;
        }

        return new ReflectionMethod($parent->class, $parent->name);
    }

    /**
     * @return ReflectionClass<object>|false
     *
     * @psalm-external-mutation-free
     */
    #[ReturnTypeWillChange]
    public function getParentClass()
    {
        $parent = \ReflectionClass::getParentClass();

        return $parent instanceof \ReflectionClass ? (new ReflectionClass($parent->getName())) : false;

$parent is always a sub-type of ReflectionClass.

    }
}