Add non-empty-string and numeric-string

Author: SerafimArts

src/Platform/StandardPlatform.php

@@ -76,13 +76,22 @@ public function getTypes(Direction $direction): iterable
         // Adds support for the float literal types
         yield new Builder\FloatLiteralTypeBuilder();
 
+        // Adds support for the string literal types
+        yield new Builder\StringLiteralTypeBuilder();
+
         // Adds support for the "T[]" statement
         yield new Builder\TypesListBuilder();
 
         // Adds support for the "T|U" union types
         yield new Builder\UnionTypeBuilder();
 
         if ($direction === Direction::Normalize) {
+            // Adds support for "non-empty-string", "numeric-string" which
+            // are similar to simple string
+            yield new Builder\SimpleTypeBuilder(
+                names: ['non-empty-string', 'numeric-string'],
+                type: Type\StringType::class,
+            );
             // Adds support for the "iterable<T> -> list<T>" type
             yield new Builder\ListFromIterableTypeBuilder('list', 'mixed');
             // Adds support for the "object -> array{ ... }" type
@@ -96,6 +105,10 @@ public function getTypes(Direction $direction): iterable
             // Adds support for the "object(ClassName) -> array{ ... }" type
             yield new Builder\ClassToArrayTypeBuilder($this->meta);
         } else {
+            // Adds support for "non-empty-string"
+            yield new Builder\SimpleTypeBuilder('non-empty-string', Type\NonEmptyString::class);
+            // Adds support for "numeric-string"
+            yield new Builder\SimpleTypeBuilder('numeric-string', Type\NumericString::class);
             // Adds support for the "array<T> -> list<T>" type
             yield new Builder\ListFromArrayTypeBuilder('list', 'mixed');
             // Adds support for the "array{ ... } -> object" type

src/Type/ArrayKeyType.php

@@ -30,7 +30,7 @@ public function __construct(
     ) {}
 
     /**
-     * @phpstan-assert-if-true string|int $value
+     * @phpstan-assert-if-true array-key $value
      */
     public function match(mixed $value, Context $context): bool
     {

src/Type/BoolLiteralType.php

@@ -9,25 +9,27 @@
 use TypeLang\Mapper\Type\Coercer\BoolTypeCoercer;
 use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
 
-class BoolLiteralType extends BoolType
+/**
+ * @template-implements TypeInterface<bool>
+ */
+class BoolLiteralType implements TypeInterface
 {
-    /**
-     * @param TypeCoercerInterface<bool> $coercer
-     */
     public function __construct(
         protected readonly bool $value,
-        TypeCoercerInterface $coercer = new BoolTypeCoercer(),
-    ) {
-        parent::__construct($coercer);
-    }
+        /**
+         * @var TypeCoercerInterface<bool>
+         */
+        protected readonly TypeCoercerInterface $coercer = new BoolTypeCoercer(),
+    ) {}
 
-    #[\Override]
+    /**
+     * @phpstan-assert-if-true bool $value
+     */
     public function match(mixed $value, Context $context): bool
     {
         return $value === $this->value;
     }
 
-    #[\Override]
     public function cast(mixed $value, Context $context): bool
     {
         // Fast return in case of value if not castable

src/Type/BoolType.php

@@ -21,6 +21,9 @@ public function __construct(
         protected readonly TypeCoercerInterface $coercer = new BoolTypeCoercer(),
     ) {}
 
+    /**
+     * @phpstan-assert-if-true bool $value
+     */
     public function match(mixed $value, Context $context): bool
     {
         return \is_bool($value);

src/Type/Builder/StringLiteralTypeBuilder.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Type\Builder;
+
+use TypeLang\Mapper\Runtime\Parser\TypeParserInterface;
+use TypeLang\Mapper\Runtime\Repository\TypeRepositoryInterface;
+use TypeLang\Mapper\Type\StringLiteralType;
+use TypeLang\Parser\Node\Literal\StringLiteralNode;
+use TypeLang\Parser\Node\Stmt\TypeStatement;
+
+/**
+ * @template-implements TypeBuilderInterface<StringLiteralNode, StringLiteralType>
+ */
+class StringLiteralTypeBuilder implements TypeBuilderInterface
+{
+    public function isSupported(TypeStatement $statement): bool
+    {
+        return $statement instanceof StringLiteralNode;
+    }
+
+    public function build(
+        TypeStatement $statement,
+        TypeRepositoryInterface $types,
+        TypeParserInterface $parser,
+    ): StringLiteralType {
+        return new StringLiteralType($statement->value);
+    }
+}

src/Type/FloatLiteralType.php

@@ -9,20 +9,21 @@
 use TypeLang\Mapper\Type\Coercer\FloatTypeCoercer;
 use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
 
-class FloatLiteralType extends FloatType
+/**
+ * @template-implements TypeInterface<float>
+ */
+class FloatLiteralType implements TypeInterface
 {
     private readonly float $value;
 
-    /**
-     * @param TypeCoercerInterface<float> $coercer
-     */
     public function __construct(
         int|float $value,
-        TypeCoercerInterface $coercer = new FloatTypeCoercer(),
+        /**
+         * @var TypeCoercerInterface<float>
+         */
+        protected readonly TypeCoercerInterface $coercer = new FloatTypeCoercer(),
     ) {
         $this->value = (float) $value;
-
-        parent::__construct($coercer);
     }
 
     /**

src/Type/IntLiteralType.php

@@ -9,18 +9,22 @@
 use TypeLang\Mapper\Type\Coercer\IntTypeCoercer;
 use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
 
-class IntLiteralType extends IntType
+/**
+ * @template-implements TypeInterface<int>
+ */
+class IntLiteralType implements TypeInterface
 {
-    /**
-     * @param TypeCoercerInterface<int> $coercer
-     */
     public function __construct(
         protected readonly int $value,
-        TypeCoercerInterface $coercer = new IntTypeCoercer(),
-    ) {
-        parent::__construct($coercer);
-    }
+        /**
+         * @var TypeCoercerInterface<int>
+         */
+        protected readonly TypeCoercerInterface $coercer = new IntTypeCoercer(),
+    ) {}
 
+    /**
+     * @phpstan-assert-if-true int $value
+     */
     public function match(mixed $value, Context $context): bool
     {
         return $value === $this->value;

src/Type/IntRangeType.php

@@ -9,34 +9,33 @@
 use TypeLang\Mapper\Type\Coercer\IntTypeCoercer;
 use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
 
-class IntRangeType extends IntType
+/**
+ * @template-implements TypeInterface<int>
+ */
+class IntRangeType implements TypeInterface
 {
     public const DEFAULT_INT_MIN = \PHP_INT_MIN;
     public const DEFAULT_INT_MAX = \PHP_INT_MAX;
 
-    /**
-     * @param TypeCoercerInterface<int> $coercer
-     */
     public function __construct(
         protected readonly int $min = self::DEFAULT_INT_MIN,
         protected readonly int $max = self::DEFAULT_INT_MAX,
-        TypeCoercerInterface $coercer = new IntTypeCoercer(),
-    ) {
-        parent::__construct($coercer);
-    }
+        /**
+         * @var TypeCoercerInterface<int>
+         */
+        protected readonly TypeCoercerInterface $coercer = new IntTypeCoercer(),
+    ) {}
 
     /**
      * @phpstan-assert-if-true int $value
      */
-    #[\Override]
     public function match(mixed $value, Context $context): bool
     {
         return \is_int($value)
             && $value >= $this->min
             && $value <= $this->max;
     }
 
-    #[\Override]
     public function cast(mixed $value, Context $context): int
     {
         $coerced = $value;

src/Type/IntType.php

@@ -21,6 +21,9 @@ public function __construct(
         protected readonly TypeCoercerInterface $coercer = new IntTypeCoercer(),
     ) {}
 
+    /**
+     * @phpstan-assert-if-true int $value
+     */
     public function match(mixed $value, Context $context): bool
     {
         return \is_int($value);

src/Type/NonEmptyString.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Type;
+
+use TypeLang\Mapper\Exception\Mapping\InvalidValueException;
+use TypeLang\Mapper\Runtime\Context;
+use TypeLang\Mapper\Type\Coercer\StringTypeCoercer;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
+
+/**
+ * @template-implements TypeInterface<non-empty-string>
+ */
+class NonEmptyString implements TypeInterface
+{
+    public function __construct(
+        /**
+         * @var TypeCoercerInterface<string>
+         */
+        protected readonly TypeCoercerInterface $coercer = new StringTypeCoercer(),
+    ) {}
+
+    /**
+     * @phpstan-assert-if-true non-empty-string $value
+     */
+    public function match(mixed $value, Context $context): bool
+    {
+        return \is_string($value) && $value !== '';
+    }
+
+    public function cast(mixed $value, Context $context): string
+    {
+        $coerced = $value;
+
+        if (!\is_string($value) && !$context->isStrictTypesEnabled()) {
+            $coerced = $this->coercer->coerce($value, $context);
+        }
+
+        if ($this->match($coerced, $context)) {
+            return $coerced;
+        }
+
+        throw InvalidValueException::createFromContext(
+            value: $value,
+            context: $context,
+        );
+    }
+}