Add downcasts support for match logic

Author: SerafimArts

src/Platform/StandardPlatform.php

@@ -141,23 +141,19 @@ public function getTypeCoercers(): iterable
 
         yield new Coercer\BoolTypeCoercer() => [
             Type\BoolType::class,
-            Type\BoolLiteralType::class,
         ];
 
         yield new Coercer\FloatTypeCoercer() => [
             Type\FloatType::class,
-            Type\FloatLiteralType::class,
         ];
 
         yield new Coercer\IntTypeCoercer() => [
             Type\IntType::class,
             Type\IntRangeType::class,
-            Type\IntLiteralType::class,
         ];
 
         yield new Coercer\StringTypeCoercer() => [
             Type\StringType::class,
-            Type\StringLiteralType::class,
         ];
 
         yield new Coercer\ArrayTypeCoercer() => [

src/Type/Builder/BoolLiteralTypeBuilder.php

@@ -14,13 +14,25 @@
  */
 class BoolLiteralTypeBuilder implements TypeBuilderInterface
 {
+    public const DEFAULT_PARENT_TYPE = 'bool';
+
+    public function __construct(
+        /**
+         * @var non-empty-string
+         */
+        protected readonly string $type = self::DEFAULT_PARENT_TYPE,
+    ) {}
+
     public function isSupported(TypeStatement $stmt): bool
     {
         return $stmt instanceof BoolLiteralNode;
     }
 
     public function build(TypeStatement $stmt, BuildingContext $context): BoolLiteralType
     {
-        return new BoolLiteralType($stmt->value);
+        return new BoolLiteralType(
+            value: $stmt->value,
+            type: $context->getTypeByDefinition($this->type),
+        );
     }
 }

src/Type/Builder/FloatLiteralTypeBuilder.php

@@ -14,13 +14,25 @@
  */
 class FloatLiteralTypeBuilder implements TypeBuilderInterface
 {
+    public const DEFAULT_PARENT_TYPE = 'float';
+
+    public function __construct(
+        /**
+         * @var non-empty-string
+         */
+        protected readonly string $type = self::DEFAULT_PARENT_TYPE,
+    ) {}
+
     public function isSupported(TypeStatement $stmt): bool
     {
         return $stmt instanceof FloatLiteralNode;
     }
 
     public function build(TypeStatement $stmt, BuildingContext $context): FloatLiteralType
     {
-        return new FloatLiteralType($stmt->value);
+        return new FloatLiteralType(
+            value: $stmt->value,
+            type: $context->getTypeByDefinition($this->type),
+        );
     }
 }

src/Type/Builder/IntLiteralTypeBuilder.php

@@ -14,13 +14,25 @@
  */
 class IntLiteralTypeBuilder implements TypeBuilderInterface
 {
+    public const DEFAULT_PARENT_TYPE = 'int';
+
+    public function __construct(
+        /**
+         * @var non-empty-string
+         */
+        protected readonly string $type = self::DEFAULT_PARENT_TYPE,
+    ) {}
+
     public function isSupported(TypeStatement $stmt): bool
     {
         return $stmt instanceof IntLiteralNode;
     }
 
     public function build(TypeStatement $stmt, BuildingContext $context): IntLiteralType
     {
-        return new IntLiteralType($stmt->value);
+        return new IntLiteralType(
+            value: $stmt->value,
+            type: $context->getTypeByDefinition($this->type),
+        );
     }
 }

src/Type/Builder/StringLiteralTypeBuilder.php

@@ -14,13 +14,25 @@
  */
 class StringLiteralTypeBuilder implements TypeBuilderInterface
 {
+    public const DEFAULT_PARENT_TYPE = 'string';
+
+    public function __construct(
+        /**
+         * @var non-empty-string
+         */
+        protected readonly string $type = self::DEFAULT_PARENT_TYPE,
+    ) {}
+
     public function isSupported(TypeStatement $stmt): bool
     {
         return $stmt instanceof StringLiteralNode;
     }
 
     public function build(TypeStatement $stmt, BuildingContext $context): StringLiteralType
     {
-        return new StringLiteralType($stmt->value);
+        return new StringLiteralType(
+            value: $stmt->value,
+            type: $context->getTypeByDefinition($this->type),
+        );
     }
 }

src/Type/DateTimeType/DateTimeFromStringType.php

@@ -52,13 +52,14 @@ private function assertDateTimeClassExists(string $class): void
      */
     public function match(mixed $value, RuntimeContext $context): bool
     {
-        if (!$this->input->match($value, $context)) {
+        try {
+            $coerced = $this->input->cast($value, $context);
+        } catch (\Throwable) {
             return false;
         }
 
         try {
-            /** @var string $value */
-            return $this->tryParseDateTime($value, $context) !== null;
+            return $this->tryParseDateTime($coerced, $context) !== null;
         } catch (\Throwable) {
             return false;
         }

src/Type/FloatLiteralType.php

@@ -9,8 +9,11 @@
  */
 class FloatLiteralType extends LiteralType
 {
-    public function __construct(int|float $value)
+    /**
+     * @param TypeInterface<float> $type
+     */
+    public function __construct(int|float $value, TypeInterface $type)
     {
-        parent::__construct((float) $value);
+        parent::__construct((float) $value, $type);
     }
 }

src/Type/IntRangeType.php

@@ -29,14 +29,24 @@ public function __construct(
      */
     public function match(mixed $value, RuntimeContext $context): bool
     {
-        return $this->type->match($value, $context)
-            && $value >= $this->min
-            && $value <= $this->max;
+        if (\is_int($value)) {
+            return $value >= $this->min
+                && $value <= $this->max;
+        }
+
+        try {
+            $coerced = $this->type->cast($value, $context);
+
+            return $coerced >= $this->min
+                && $coerced <= $this->max;
+        } catch (\Throwable) {
+            return false;
+        }
     }
 
     public function cast(mixed $value, RuntimeContext $context): int
     {
-        if ($this->match($value, $context)) {
+        if (\is_int($value) && $value >= $this->min && $value <= $this->max) {
             return $value;
         }
 

src/Type/LiteralType.php

@@ -17,20 +17,34 @@ public function __construct(
          * @var TResult
          */
         protected readonly mixed $value,
+        /**
+         * @var TypeInterface<TResult>
+         */
+        protected readonly TypeInterface $type,
     ) {}
 
     /**
      * @phpstan-assert-if-true TResult $value
      */
     public function match(mixed $value, RuntimeContext $context): bool
     {
-        return $value === $this->value;
+        if ($value === $this->value) {
+            return true;
+        }
+
+        try {
+            return $this->type->cast($value, $context) === $this->value;
+        } catch (\Throwable) {
+            return false;
+        }
     }
 
     public function cast(mixed $value, RuntimeContext $context): mixed
     {
-        if ($value === $this->value) {
-            return $value;
+        $coerced = $this->type->cast($value, $context);
+
+        if ($coerced === $this->value) {
+            return $coerced;
         }
 
         throw InvalidValueException::createFromContext($context);