Ducks\Component\SplTypes\Reflection\SplReflectionEnumHelper

Complexity

Total Complexity

5

Size/Duplication

Total Lines	37
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

3 Methods

Rating	Name	Duplication	Size	Complexity
A	getIntReflectionNamedType()	0	8	2
A	__construct()	0	2	1
A	getStringReflectionNamedType()	0	8	2

<?php

/**
 * Part of SplTypes package.
 *
 * (c) Adrien Loyant <donald_duck@team-df.org>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Ducks\Component\SplTypes\Reflection;

/**
 * The ReflectionEnum class reports information about an Enum.
 *
 * @link https://php.net/manual/en/class.reflectionenum.php
 */
final class SplReflectionEnumHelper
{
    private static ?\ReflectionNamedType $rnts = null;
    private static ?\ReflectionNamedType $rnti = null;

    private function __construct()
    {
    }

    /**
     * Only way to generate a string ReflectionNamedType (Internal use).
     *
     * @return \ReflectionNamedType
     */
    public static function getStringReflectionNamedType(): \ReflectionNamedType
    {
        if (null === static::$rnts) {

Since $rnts is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $rnts to at least protected.

            $func = new \ReflectionFunction(static fn(string $param): string => $param);
            static::$rnts = ($func->getParameters()[0])->getType();
        }

        return static::$rnts;

The expression return static::rnts could return the type null which is incompatible with the type-hinted return ReflectionNamedType. Consider adding an additional type-check to rule them out.

    }

    /**
     * Only way to generate an int ReflectionNamedType (Internal use).
     *
     * @return \ReflectionNamedType
     */
    public static function getIntReflectionNamedType(): \ReflectionNamedType
    {
        if (null === static::$rnti) {

Since $rnti is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $rnti to at least protected.

            $func = new \ReflectionFunction(static fn(int $param): int => $param);
            static::$rnti = ($func->getParameters()[0])->getType();
        }

        return static::$rnti;

The expression return static::rnti could return the type null which is incompatible with the type-hinted return ReflectionNamedType. Consider adding an additional type-check to rule them out.

    }
}