Improve types

Author: Kirill Nesmeyanov

src/Type/ArrayKeyType.php

@@ -8,6 +8,9 @@ class ArrayKeyType extends UnionType
 {
     public function __construct()
     {
-        parent::__construct([new IntType(), new StringType()]);
+        parent::__construct([
+            new IntType(),
+            new StringType(),
+        ]);
     }
 }

src/Type/ArrayType.php

@@ -6,6 +6,7 @@
 
 use TypeLang\Mapper\Exception\Definition\TypeNotFoundException;
 use TypeLang\Mapper\Exception\Mapping\InvalidValueException;
+use TypeLang\Mapper\Exception\Mapping\RuntimeExceptionInterface;
 use TypeLang\Mapper\Runtime\Context\LocalContext;
 use TypeLang\Mapper\Runtime\Path\Entry\ArrayIndexEntry;
 
@@ -54,6 +55,8 @@ public function match(mixed $value, LocalContext $context): bool
      * @return array<array-key, mixed>
      * @throws InvalidValueException
      * @throws TypeNotFoundException
+     * @throws \Throwable
+     * @throws RuntimeExceptionInterface
      */
     public function cast(mixed $value, LocalContext $context): array
     {

src/Type/BackedEnumType.php

@@ -5,6 +5,7 @@
 namespace TypeLang\Mapper\Type;
 
 use TypeLang\Mapper\Exception\Mapping\InvalidValueException;
+use TypeLang\Mapper\Exception\Mapping\RuntimeExceptionInterface;
 use TypeLang\Mapper\Runtime\Context\LocalContext;
 
 class BackedEnumType extends AsymmetricType
@@ -40,6 +41,10 @@ public function normalize(mixed $value, LocalContext $context): int|string
         return $value->value;
     }
 
+    /**
+     * @throws \Throwable
+     * @throws RuntimeExceptionInterface
+     */
     protected function isDenormalizable(mixed $value, LocalContext $context): bool
     {
         $isSupportsType = $this->type->match($value, $context);
@@ -62,6 +67,8 @@ protected function isDenormalizable(mixed $value, LocalContext $context): bool
      * Converts a scalar representation of an enum to an enum case object.
      *
      * @throws InvalidValueException
+     * @throws RuntimeExceptionInterface
+     * @throws \Throwable
      */
     public function denormalize(mixed $value, LocalContext $context): \BackedEnum
     {

src/Type/Builder/BackedEnumTypeBuilder.php

@@ -25,7 +25,7 @@ public function isSupported(TypeStatement $statement): bool
         $enum = $statement->name->toString();
 
         return \enum_exists($statement->name->toString())
-            && \is_subclass_of($enum, \BackedEnum::class, true);
+            && \is_subclass_of($enum, \BackedEnum::class);
     }
 
     /**

src/Type/Builder/IntTypeBuilder.php

@@ -12,7 +12,7 @@
 use TypeLang\Parser\Node\Literal\IntLiteralNode;
 use TypeLang\Parser\Node\Literal\StringLiteralNode;
 use TypeLang\Parser\Node\Stmt\NamedTypeNode;
-use TypeLang\Parser\Node\Stmt\Template\TemplateArgumentNode;
+use TypeLang\Parser\Node\Stmt\Template\TemplateArgumentNode as ArgNode;
 use TypeLang\Parser\Node\Stmt\TypeStatement;
 use TypeLang\Parser\Node\Stmt\UnionTypeNode;
 
@@ -29,13 +29,8 @@ public function build(TypeStatement $statement, RepositoryInterface $types): Int
 
         return match (\count($arguments)) {
             0 => new IntType(),
-            1 => new IntType(
-                min: $this->fetchTemplateArgumentValue($statement, $arguments[0]),
-            ),
-            2 => new IntType(
-                min: $this->fetchTemplateArgumentValue($statement, $arguments[0]),
-                max: $this->fetchTemplateArgumentValue($statement, $arguments[1]),
-            ),
+            1 => $this->buildWithMinValue($statement, $arguments[0]),
+            2 => $this->buildWithMinMaxValues($statement, $arguments[0], $arguments[1]),
             default => throw TooManyTemplateArgumentsException::becauseTemplateArgumentsRangeOverflows(
                 passedArgumentsCount: \count($arguments),
                 minSupportedArgumentsCount: 0,
@@ -49,7 +44,30 @@ public function build(TypeStatement $statement, RepositoryInterface $types): Int
      * @throws InvalidTemplateArgumentException
      * @throws TemplateArgumentHintsNotSupportedException
      */
-    private function fetchTemplateArgumentValue(TypeStatement $statement, TemplateArgumentNode $argument): int
+    private function buildWithMinValue(NamedTypeNode $statement, ArgNode $min): IntType
+    {
+        $value = $this->fetchTemplateArgumentValue($statement, $min);
+
+        return new IntType($value);
+    }
+
+    /**
+     * @throws InvalidTemplateArgumentException
+     * @throws TemplateArgumentHintsNotSupportedException
+     */
+    private function buildWithMinMaxValues(NamedTypeNode $statement, ArgNode $min, ArgNode $max): IntType
+    {
+        $from = $this->fetchTemplateArgumentValue($statement, $min);
+        $to = $this->fetchTemplateArgumentValue($statement, $max);
+
+        return new IntType($from, $to);
+    }
+
+    /**
+     * @throws InvalidTemplateArgumentException
+     * @throws TemplateArgumentHintsNotSupportedException
+     */
+    private function fetchTemplateArgumentValue(TypeStatement $statement, ArgNode $argument): int
     {
         $this->expectNoTemplateArgumentHint($statement, $argument);
 

src/Type/FloatLiteralType.php

@@ -19,6 +19,9 @@ public function match(mixed $value, LocalContext $context): bool
         return $value === (float) $this->value;
     }
 
+    /**
+     * @throws InvalidValueException
+     */
     #[\Override]
     public function cast(mixed $value, LocalContext $context): float
     {

src/Type/IntLiteralType.php

@@ -21,6 +21,9 @@ public function match(mixed $value, LocalContext $context): bool
         return $value === $this->value;
     }
 
+    /**
+     * @throws InvalidValueException
+     */
     #[\Override]
     public function cast(mixed $value, LocalContext $context): int
     {

src/Type/MixedType.php

@@ -16,9 +16,9 @@ public function match(mixed $value, LocalContext $context): bool
     }
 
     /**
-     * @throws \Throwable
      * @throws TypeNotFoundException
      * @throws RuntimeExceptionInterface
+     * @throws \Throwable
      */
     public function cast(mixed $value, LocalContext $context): mixed
     {

src/Type/NamedType.php

@@ -5,6 +5,7 @@
 namespace TypeLang\Mapper\Type;
 
 use TypeLang\Mapper\Exception\Mapping\InvalidValueException;
+use TypeLang\Mapper\Exception\Mapping\RuntimeExceptionInterface;
 use TypeLang\Mapper\Runtime\Context\LocalContext;
 
 class NonEmpty implements TypeInterface
@@ -26,6 +27,8 @@ public function match(mixed $value, LocalContext $context): bool
 
     /**
      * @throws InvalidValueException
+     * @throws RuntimeExceptionInterface
+     * @throws \Throwable
      */
     public function cast(mixed $value, LocalContext $context): mixed
     {