feat(core) : phpstan check and optimization

.gitignore

@@ -11,6 +11,10 @@
 /phpunit.xml
 .phpunit.result.cache
 
+# phpcs
+.phpcs.cache
+.php-cs-fixer.cache
+
 # Composer PHAR
 /composer.phar
 #/composer.lock
@@ -27,6 +31,8 @@
 
 # vscode
 *.code-workspace
+.vscode
+.vscode-insiders
 
 # Swap & temp files
 *~

Reflection/SplReflectionEnum.php

@@ -18,6 +18,9 @@
 /**
  * The ReflectionEnum class reports information about an Enum.
  *
+ * @template T of SplUnitEnum
+ * @extends \ReflectionClass<\Ducks\Component\SplTypes\SplUnitEnum>
+ *
  * @link https://php.net/manual/en/class.reflectionenum.php
  */
 class SplReflectionEnum extends \ReflectionClass
@@ -38,26 +41,29 @@ class SplReflectionEnum extends \ReflectionClass
      */
     private function getProxy(): SplReflectionEnumProxy
     {
-        if (!isset(static::$instances[$this->name])) {
-            static::$instances[$this->name] = new SplReflectionEnumProxy($this);
+        if (!isset(self::$instances[$this->name])) {
+            self::$instances[$this->name] = new SplReflectionEnumProxy($this);
         }
 
-        return static::$instances[$this->name];
+        return self::$instances[$this->name];
     }
 
     /**
      * Instantiates a ReflectionEnum object
      *
      * @param object|string $objectOrClass
      *
-     * @throws ReflectionException if objectOrClass is not a SplUnitEnum
+     * @throws \ReflectionException if objectOrClass is not a SplUnitEnum
+     *
+     * @phpstan-param SplUnitEnum|class-string<T> $objectOrClass
      *
      * @link https://www.php.net/manual/en/reflectionenum.construct.php
      */
     public function __construct($objectOrClass)
     {
         // Fast check
         if (!\is_a($objectOrClass, SplUnitEnum::class, true)) {
+            // @phpstan-ignore ternary.elseUnreachable
             $classname = \is_object($objectOrClass) ? \get_class($objectOrClass) : $objectOrClass;
             throw new \ReflectionException("Class \"$classname\" is not an enum");
         }
@@ -98,11 +104,13 @@ public function getCase(string $name): SplReflectionEnumUnitCase
      *
      * @return array<int, SplReflectionEnumUnitCase|SplReflectionEnumBackedCase>
      *
+     * @phpstan-return list<SplReflectionEnumUnitCase|SplReflectionEnumBackedCase>
+     *
      * @link https://www.php.net/manual/en/reflectionenum.getcases.php
      */
     public function getCases(): array
     {
-        return $this->getProxy()->getCases();
+        return \array_values($this->getProxy()->getCases());
     }
 
     /**

Reflection/SplReflectionEnumHelper.php

@@ -35,10 +35,12 @@ private function __construct()
     public static function getStringReflectionNamedType(): \ReflectionNamedType
     {
         if (null === static::$rnts) {
-            $func = new \ReflectionFunction(static fn(string $param): string => $param);
+            $func = new \ReflectionFunction(static fn (string $param): string => $param);
+            // @phpstan-ignore-next-line
             static::$rnts = ($func->getParameters()[0])->getType();
         }
 
+        // @phpstan-ignore-next-line
         return static::$rnts;
     }
 
@@ -51,9 +53,11 @@ public static function getIntReflectionNamedType(): \ReflectionNamedType
     {
         if (null === static::$rnti) {
             $func = new \ReflectionFunction(static fn(int $param): int => $param);
+            // @phpstan-ignore-next-line
             static::$rnti = ($func->getParameters()[0])->getType();
         }
 
+        // @phpstan-ignore-next-line
         return static::$rnti;
     }
 }

Reflection/SplReflectionEnumProxy.php

@@ -18,8 +18,20 @@
 
 final class SplReflectionEnumProxy
 {
+    /**
+     * The reflection class used in proxy
+     *
+     * @var \ReflectionClass
+     *
+     * @phpstan-var \ReflectionClass<object>
+     */
     private \ReflectionClass $class;
 
+    /**
+     * Is enum is backed
+     *
+     * @var boolean|null
+     */
     private ?bool $backed = null;
 
     /**
@@ -32,7 +44,7 @@ final class SplReflectionEnumProxy
     /**
      * Array of constants class, indexed by name, as enum cases.
      *
-     * @var array<string, \ReflectionClassConstant>
+     * @var array<string,\ReflectionClassConstant>
      */
     private array $constantCases = [];
 
@@ -45,6 +57,11 @@ final class SplReflectionEnumProxy
 
     public string $name;
 
+    /**
+     * Build a proxy SplReflectionEnum from a ReflectionClass
+     *
+     * @param \ReflectionClass<object> $class
+     */
     public function __construct(\ReflectionClass $class)
     {
         $this->class = $class;
@@ -126,7 +143,7 @@ public function addConstantCase(\ReflectionClassConstant ...$constants): void
     /**
      * Return an array of class constants, indexed by name, that could be use as an enum case.
      *
-     * @return array<string, \ReflectionClassConstant>
+     * @return array<string,\ReflectionClassConstant>
      */
     public function getConstantCases(): array
     {
@@ -249,7 +266,7 @@ public function addCase(\ReflectionClassConstant ...$constants): void
     /**
      * Returns a list of all cases on an Enum
      *
-     * @return array<int, ReflectionEnumUnitCase|ReflectionEnumBackedCase>
+     * @return array<string,SplReflectionEnumUnitCase|SplReflectionEnumBackedCase>
      *
      * @link https://www.php.net/manual/en/reflectionenum.getcases.php
      */
@@ -341,7 +358,9 @@ public function getBackingType(): ?\ReflectionNamedType
         if (null === $this->backingType) {
             if ($this->isBacked()) {
                 if ($this->class->hasProperty('value')) {
-                    $this->backingType = $this->class->getProperty('value')->getType() ?? false;
+                    /** @var \ReflectionNamedType|false $type */
+                    $type = $this->class->getProperty('value')->getType() ?? false;
+                    $this->backingType = $type;
                 } else {
                     $constant = $this->getFirstCaseConstant();
                     if ($constant instanceof \ReflectionClassConstant) {

Reflection/SplReflectionEnumUnitCase.php

@@ -15,8 +15,16 @@
 
 use Ducks\Component\SplTypes\SplUnitEnum;
 
+/**
+ * The SplReflectionEnumUnitCase class reports information about an SplEnum unit case, which has no scalar equivalent.
+ */
 class SplReflectionEnumUnitCase extends \ReflectionClassConstant
 {
+    /**
+     * Internal instances enum
+     *
+     * @var array<string,array<string,SplUnitEnum>>
+     */
     private static array $instances = [];
 
     /**
@@ -25,7 +33,7 @@ class SplReflectionEnumUnitCase extends \ReflectionClassConstant
      * @param object|string $class An enum instance or a name.
      * @param string $constant An enum constant name.
      *
-     * @throws ReflectionException if $class is not a SplReflectionEnumUnitCase
+     * @throws \ReflectionException if $class is not a SplReflectionEnumUnitCase
      *
      * @link https://www.php.net/manual/en/reflectionenumunitcase.construct.php
      */
@@ -43,7 +51,9 @@ public function __construct($class, string $constant)
     /**
      * Gets the reflection of the enum of this case
      *
-     * @return ReflectionEnum instance describing the Enum this case belongs to.
+     * @return SplReflectionEnum instance describing the Enum this case belongs to.
+     *
+     * @phpstan-return SplReflectionEnum<SplUnitEnum>
      *
      * @link https://www.php.net/manual/en/reflectionenumunitcase.getenum.php
      */

Resources/functions.php

@@ -13,7 +13,11 @@
 
 namespace Ducks\Component\SplTypes;
 
-/** @disregard P1009 Undefined type */
+/**
+ * @disregard P1009 Undefined type
+ *
+ * @phpstan-ignore-next-line
+ */
 if (!\function_exists(spl_enum_exists::class)) {
     /**
      * Checks if the spl enum has been defined
@@ -23,8 +27,8 @@
      *
      * @return boolean Returns true if enum is a defined enum, false otherwise.
      */
-    function spl_enum_exists(string $class, bool $autoload = true): bool
+    function spl_enum_exists(string $enum, bool $autoload = true): bool
     {
-        return Util\Tools::isSplEnumExists($class, $autoload);
+        return Util\Tools::isSplEnumExists($enum, $autoload);
     }
 }

Resources/stubs/SplPureEnum.php

@@ -14,7 +14,14 @@
 use Ducks\Component\SplTypes\SplEnumUnit as DuckSplPureEnum;
 
 /**
+ * SplEnumUnit alias.
+ *
+ * <code>
  * \class_alias(DuckSplPureEnum::class, '\\SplPureEnum', true);
+ * </code>
+ *
+ * @template T
+ * @extends Ducks\Component\SplTypes\SplEnumUnit<T>
  */
 // phpcs:ignore PSR1.Classes.ClassDeclaration.MissingNamespace
 class SplPureEnum extends DuckSplPureEnum

SplBackedEnum.php

@@ -16,6 +16,8 @@
 /**
  * Interface used in order to implements \BackedEnum one.
  *
+ * @template T
+ *
  * @psalm-api
  */
 interface SplBackedEnum extends SplUnitEnum

SplBackedEnumTrait.php

@@ -15,16 +15,25 @@
 
 use Ducks\Component\SplTypes\Reflection\SplReflectionEnumBackedCase;
 
+/**
+ * Simplify SplBackedEnum integration
+ *
+ * @template T
+ *
+ * @phpstan-require-implements SplBackedEnum
+ */
 trait SplBackedEnumTrait
 {
     use SplUnitEnumTrait;
 
     /**
-     * Maps a scalar to an enum instance
+     * Maps a scalar to an enum instance.
      *
      * @param int|string $value The scalar value to map to an enum case.
      *
      * @return static A case instance of this enumeration.
+     *
+     * @throws \ValueError if $value is not a valid backing value for enum
      */
     final public static function from($value): self
     {
@@ -40,34 +49,45 @@ final public static function from($value): self
     }
 
     /**
-     * Maps a scalar to an enum instance or null
+     * Maps a scalar to an enum instance or null.
      *
-     * @param int|string $value e scalar value to map to an enum case.
+     * @param int|string|mixed $value e scalar value to map to an enum case.
      *
      * @return static|null A case instance of this enumeration, or null if not found.
      */
     final public static function tryFrom($value): ?self
     {
         foreach (static::cases() as $case) {
+            /**
+             * @var SplEnumBacked $case
+             * @phpstan-var SplEnumBacked<T> $case
+             */
             if ($case->value === $value) {
                 $result = $case;
                 break;
             }
         }
 
+        /** @var static $result */
         return $result ?? null;
     }
 
     /**
-     * Return a new instance of enum
+     * Return a new instance of enum.
      *
      * @param string $name
-     * @param array $arguments
+     * @param array<int,mixed> $arguments
      *
      * @return static self keywords not an equivalent
      *
-     * @psalm-suppress UnsafeInstantiation
+     * @throws \Error if $name is not a valid constant enum
+     *
+     * @phpstan-param string $name
+     * @phpstan-param list<mixed> $arguments
+     * @phpstan-return static
      * @phpstan-ignore-next-line
+     *
+     * @psalm-suppress UnsafeInstantiation
      */
     #[\ReturnTypeWillChange]
     public static function __callStatic(string $name, array $arguments)

SplBool.php

@@ -16,13 +16,19 @@
 /**
  * The SplBool class is used to enforce strong typing of the bool type.
  *
+ * @extends SplEnum<bool>
+ * @implements SplBackedEnum<bool>
+ *
  * @psalm-api
  * @psalm-suppress MissingDependency
  * @psalm-suppress UndefinedClass
  */
 class SplBool extends SplEnum implements SplBackedEnum
 {
+    /** @use SplBackedEnumTrait<bool> */
     use SplBackedEnumTrait;
+    /** @use SplEnumBackedTrait<bool> */
+    use SplEnumBackedTrait;
 
     /**
      * @var bool
@@ -63,7 +69,9 @@ public function __construct(bool $initial_value = self::__default)
     {
         parent::__construct($initial_value);
 
+        /** @psalm-suppress UnsupportedPropertyReferenceUsage */
         $this->value = &$this->__default;
+        $this->name = $this->value ? 'true' : 'false';
     }
 
     final public function &__invoke(): bool