Add non-zero-int type

Author: SerafimArts

src/Platform/StandardPlatform.php

@@ -48,6 +48,7 @@ public function getTypes(Direction $direction): iterable
         yield new Builder\NonPositiveIntBuilder('non-positive-int');
         yield new Builder\NegativeIntBuilder('negative-int');
         yield new Builder\NonNegativeIntBuilder('non-negative-int');
+        yield new Builder\NonZeroIntBuilder('non-zero-int');
 
         // Adds support for the "float" type
         yield new Builder\SimpleTypeBuilder(['float', 'double', 'real'], Type\FloatType::class);

src/Type/Builder/NonZeroIntBuilder.php

@@ -0,0 +1,31 @@
+<?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\NonZeroIntType;
+use TypeLang\Parser\Node\Stmt\NamedTypeNode;
+use TypeLang\Parser\Node\Stmt\TypeStatement;
+
+/**
+ * @template-extends NamedTypeBuilder<NonZeroIntType>
+ */
+final class NonZeroIntBuilder extends NamedTypeBuilder
+{
+    public function build(
+        TypeStatement $statement,
+        TypeRepositoryInterface $types,
+        TypeParserInterface $parser,
+    ): NonZeroIntType {
+        /** @phpstan-ignore-next-line : Additional DbC assertion */
+        assert($statement instanceof NamedTypeNode);
+
+        $this->expectNoShapeFields($statement);
+        $this->expectNoTemplateArguments($statement);
+
+        return new NonZeroIntType();
+    }
+}

src/Type/NonZeroIntType.php

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

tests/Type/NonZeroIntTypeTest.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace TypeLang\Mapper\Tests\Type;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Group;
+use TypeLang\Mapper\Type\Coercer\TypeCoercerInterface;
+use TypeLang\Mapper\Type\NonZeroIntType;
+use TypeLang\Mapper\Type\TypeInterface;
+
+#[Group('type')]
+#[CoversClass(NonZeroIntType::class)]
+final class NonZeroIntTypeTest extends CoercibleTypeTestCase
+{
+    protected static function createType(?TypeCoercerInterface $coercer = null): TypeInterface
+    {
+        if ($coercer !== null) {
+            return new NonZeroIntType(coercer: $coercer);
+        }
+
+        return new NonZeroIntType();
+    }
+
+    protected static function matchValues(bool $normalize): iterable
+    {
+        foreach (self::defaultMatchDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                $value === \PHP_INT_MAX,
+                $value === \PHP_INT_MIN,
+                $value === 42,
+                $value === -42,
+                $value === 1,
+                $value === -1 => true,
+                default => $default,
+            };
+        }
+    }
+
+    protected static function castValues(bool $normalize): iterable
+    {
+        foreach (self::defaultCastDataProviderSamples() as $value => $default) {
+            yield $value => match (true) {
+                $value === \PHP_INT_MAX => \PHP_INT_MAX,
+                $value === \PHP_INT_MIN => \PHP_INT_MIN,
+                $value === 42 => 42,
+                $value === -42 => -42,
+                $value === 1 => 1,
+                $value === -1 => -1,
+                default => $default,
+            };
+        }
+    }
+}