Add IntRangeType and ExplicitStringType

symfony · DerManoMann · Feb 2, 2025 · Feb 20, 2025 · Feb 20, 2025 · Feb 21, 2025
commit 16d885de9fd9fc7e62fe9a56d26698014f334369
diff --git a/src/Symfony/Component/TypeInfo/CHANGELOG.md b/src/Symfony/Component/TypeInfo/CHANGELOG.md
@@ -4,6 +4,7 @@ CHANGELOG
 7.3
 ---
 
+ * Add `IntRangeType` and `ExplicitStringType` classes to capture more specific type detals for `int` and `string` builtin types
- * Add `IntRangeType` and `ExplicitStringType` classes to capture more specific type detals for `int` and `string` builtin types
+ * Add `IntRangeType` and `ExplicitStringType` classes to hold specific type details for `int` and `string` builtin types
- * Add `IntRangeType` and `ExplicitStringType` classes to capture more specific type detals for `int` and `string` builtin types
+ * Add `IntRangeType` and `ExplicitStringType` classes to hold specific type details for `int` and `string` builtin types
  * Add `Type::accepts()` method
  * Add `TypeFactoryTrait::fromValue()` method
  * Deprecate constructing a `CollectionType` instance as a list that is not an array

diff --git a/src/Symfony/Component/TypeInfo/Tests/Type/IntRangeTypeTest.php b/src/Symfony/Component/TypeInfo/Tests/Type/IntRangeTypeTest.php
@@ -0,0 +1,60 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\TypeInfo\Tests\Type;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\TypeInfo\Type\BuiltinType;
+use Symfony\Component\TypeInfo\Type\IntRangeType;
+use Symfony\Component\TypeInfo\TypeIdentifier;
+
+class IntRangeTypeTest extends TestCase
+{
+    public function testToString()
+    {
+            $this->assertSame('non-negative-int', (string) new IntRangeType(0, \PHP_INT_MAX));
+        $this->assertSame('non-positive-int', (string) new IntRangeType(\PHP_INT_MIN, 0));
+        $this->assertSame('positive-int', (string) new IntRangeType(1, \PHP_INT_MAX));
+        $this->assertSame('negative-int', (string) new IntRangeType(\PHP_INT_MIN, -1));
+        $this->assertSame('int<-3, 5>', (string) new IntRangeType(-3, 5));
+        $this->assertSame('int<min, max>', (string) new IntRangeType(\PHP_INT_MIN, \PHP_INT_MAX));
+        $this->assertSame('int<min, 5>', (string) new IntRangeType(\PHP_INT_MIN, 5));
+    }
+
+    public function testIsIdentifiedBy()
+    {
+        $this->assertFalse((new IntRangeType(0, 5))->isIdentifiedBy(TypeIdentifier::ARRAY));
+        $this->assertTrue((new BuiltinType(TypeIdentifier::INT))->isIdentifiedBy(TypeIdentifier::INT));
+
+        $this->assertFalse((new IntRangeType(0, 5))->isIdentifiedBy('array'));
+        $this->assertTrue((new IntRangeType(0, 5))->isIdentifiedBy('int'));
+
+        $this->assertTrue((new IntRangeType(0, 5))->isIdentifiedBy('string', 'int'));
+    }
+
+    public function testIsNullable()
+    {
+        $this->assertFalse((new IntRangeType(0, 5))->isNullable());
+    }
+
+    public function testAccepts()
+    {
+        $this->assertFalse((new IntRangeType(0, 5))->accepts('string'));
+        $this->assertFalse((new IntRangeType(0, 5))->accepts([]));
+
+        $this->assertFalse((new IntRangeType(-1, 5))->accepts(-3));
+        $this->assertTrue((new IntRangeType(-1, 5))->accepts(0));
+        $this->assertTrue((new IntRangeType(-1, 5))->accepts(2));
+        $this->assertFalse((new IntRangeType(-1, 5))->accepts(6));
+
+        $this->assertFalse((new IntRangeType(\PHP_INT_MIN, \PHP_INT_MAX, false))->accepts(0));
+    }
+}
diff --git a/src/Symfony/Component/TypeInfo/Tests/TypeResolver/StringTypeResolverTest.php b/src/Symfony/Component/TypeInfo/Tests/TypeResolver/StringTypeResolverTest.php
@@ -98,26 +98,17 @@ public static function resolveDataProvider(): iterable
         yield [Type::false(), 'false'];
         yield [Type::int(), 'int'];
         yield [Type::int(), 'integer'];
-        yield [Type::int(), 'positive-int'];
-        yield [Type::int(), 'negative-int'];
-        yield [Type::int(), 'non-positive-int'];
-        yield [Type::int(), 'non-negative-int'];
-        yield [Type::int(), 'non-zero-int'];
+        yield [Type::intRange(1, \PHP_INT_MAX), 'positive-int'];
+        yield [Type::intRange(\PHP_INT_MIN, -1), 'negative-int'];
+        yield [Type::intRange(\PHP_INT_MIN, 0), 'non-positive-int'];
+        yield [Type::intRange(0, \PHP_INT_MAX), 'non-negative-int'];
+        yield [Type::intRange(\PHP_INT_MIN, \PHP_INT_MAX, false), 'non-zero-int'];
         yield [Type::float(), 'float'];
         yield [Type::float(), 'double'];
         yield [Type::string(), 'string'];
-        yield [Type::string(), 'class-string'];
-        yield [Type::string(), 'trait-string'];
-        yield [Type::string(), 'interface-string'];
-        yield [Type::string(), 'callable-string'];
-        yield [Type::string(), 'n
8000
umeric-string'];
-        yield [Type::string(), 'lowercase-string'];
-        yield [Type::string(), 'non-empty-lowercase-string'];
-        yield [Type::string(), 'non-empty-string'];
-        yield [Type::string(), 'non-falsy-string'];
-        yield [Type::string(), 'truthy-string'];
-        yield [Type::string(), 'literal-string'];
-        yield [Type::string(), 'html-escaped-string'];
+        yield [Type::explicitString('class-string'), 'class-string'];
+        yield [Type::explicitString('literal-string'), 'literal-string'];
+        yield [Type::explicitString('html-escaped-string'), 'html-escaped-string'];
         yield [Type::resource(), 'resource'];
         yield [Type::object(), 'object'];
         yield [Type::callable(), 'callable'];
@@ -152,7 +143,8 @@ public static function resolveDataProvider(): iterable
         // generic
         yield [Type::generic(Type::object(\DateTime::class), Type::string(), Type::bool()), \DateTime::class.'<string, bool>'];
         yield [Type::generic(Type::object(\DateTime::class), Type::generic(Type::object(\Stringable::class), Type::bool())), \sprintf('%s<%s<bool>>', \DateTime::class, \Stringable::class)];
-        yield [Type::int(), 'int<0, 100>'];
+        yield [Type::intRange(0, 100), 'int<0, 100>'];
-        yield [Type::intRange(0, 100), 'int<0, 100>'];
+
+        // int range
+        yield [Type::intRange(0, 100), 'int<0, 100>'];
-        yield [Type::intRange(0, 100), 'int<0, 100>'];
+
+        // int range
+        yield [Type::intRange(0, 100), 'int<0, 100>'];
+        yield [Type::intRange(\PHP_INT_MIN, \PHP_INT_MAX), 'int<min, max>'];
 
         // union
         yield [Type::union(Type::int(), Type::string()), 'int|string'];

diff --git a/src/Symfony/Component/TypeInfo/Type/BuiltinType.php b/src/Symfony/Component/TypeInfo/Type/BuiltinType.php
@@ -20,7 +20,7 @@
  *
  * @template T of TypeIdentifier
  */
-final class BuiltinType extends Type
+class BuiltinType extends Type
 {
     /**
      * @param T $typeIdentifier

diff --git a/src/Symfony/Component/TypeInfo/Type/ExplicitStringType.php b/src/Symfony/Component/TypeInfo/Type/ExplicitStringType.php
@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\TypeInfo\Type;
+
+use Symfony\Component\TypeInfo\TypeIdentifier;
+
+/**
+ * Explicit string type.
- * Explicit string type.
+ * Represents a string with explicit constraints.
- * Explicit string type.
+ * Represents a string with explicit constraints.
+ *
+ * @author Martin Rademacher <mano@radebatz.net>
+ *
+ * @extends BuiltinType<TypeIdentifier::STRING>
+ */
+class ExplicitStringType extends BuiltinType
-class ExplicitStringType extends BuiltinType
+final class ExplicitStringType extends BuiltinType
-class ExplicitStringType extends BuiltinType
+final class ExplicitStringType extends BuiltinType
+{
+    public function __construct(private string $explicitType)
-    public function __construct(private string $explicitType)
+    public function __construct(private StringConstraint $constraint)
-    public function __construct(private string $explicitType)
+    public function __construct(private StringConstraint $constraint)
+    {
+        parent::__construct(TypeIdentifier::STRING);
+    }
+
+    public function getExplicitType(): string
+    {
+        return $this->explicitType;
+    }
+}
diff --git a/src/Symfony/Component/TypeInfo/Type/IntRangeType.php b/src/Symfony/Component/TypeInfo/Type/IntRangeType.php
@@ -0,0 +1,73 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\TypeInfo\Type;
+
+use Symfony\Component\TypeInfo\TypeIdentifier;
+
+/**
+ * Int range type.
- * Int range type.
+ * Represents a range of integer values.
- * Int range type.
+ * Represents a range of integer values.
+ *
+ * @author Martin Rademacher <mano@radebatz.net>
+ *
+ * @extends BuiltinType<TypeIdentifier::INT>
+ */
+class IntRangeType extends BuiltinType
-class IntRangeType extends BuiltinType
+final class IntRangeType extends BuiltinType
-class IntRangeType extends BuiltinType
+final class IntRangeType extends BuiltinType
+{
+    public function __construct(
+        private int $from = \PHP_INT_MIN,
+        private int $to = \PHP_INT_MAX,
+        private bool $zeroIncluded = true,
+    ) {
+        parent::__construct(TypeIdentifier::INT);
+    }
+
+    public function getFrom(): int
+    {
+        return $this->from;
+    }
+
+    public function getTo(): int
+    {
+        return $this->to;
+    }
+
+    public function isZeroIncluded(): bool
+    {
+        return $this->zeroIncluded;
+    }
+
+    public function accepts(mixed $value): bool
+    {
+        return \is_int($value)
-        return \is_int($value)
+        return parent::accepts($value)
-        return \is_int($value)
+        return parent::accepts($value)
+            && $this->from <= $value && $value <= $this->to
+            && (0 !== $value || $this->zeroIncluded);
+    }
+
+    public function __toString(): string
+    {
+        $min = \PHP_INT_MIN === $this->from ? 'min' : $this->from;
+        $max = \PHP_INT_MAX === $this->to ? 'max' : $this->to;
+
+        $template = 'int<%s, %s>';
+        if (\is_string($min) && \is_string($max)) {
+            return $this->zeroIncluded ? \sprintf($template, $min, $max) : 'non-zero-int';
+        }
+
+        if (\in_array($min, [0, 1], true) && 'max' === $max) {
+            return 0 === $min ? 'non-negative-int' : 'positive-int';
+        } elseif ('min' === $min && \in_array($max, [-1, 0])) {
+            return 0 === $max ? 'non-positive-int' : 'negative-int';
+        }
+
+        return \sprintf($template, $min, $max);
-        $template = 'int<%s, %s>';
-        if (\is_string($min) && \is_string($max)) {
-            return $this->zeroIncluded ? \sprintf($template, $min, $max) : 'non-zero-int';
-        }
-
-        if (\in_array($min, [0, 1], true) && 'max' === $max) {
-            return 0 === $min ? 'non-negative-int' : 'positive-int';
-        } elseif ('min' === $min && \in_array($max, [-1, 0])) {
-            return 0 === $max ? 'non-positive-int' : 'negative-int';
-        }
-
-        return \sprintf($template, $min, $max);
+        return \sprintf('int<%s, %s>', $min, $max);
-        $template = 'int<%s, %s>';
-        if (\is_string($min) && \is_string($max)) {
-            return $this->zeroIncluded ? \sprintf($template, $min, $max) : 'non-zero-int';
-        }
-
-        if (\in_array($min, [0, 1], true) && 'max' === $max) {
-            return 0 === $min ? 'non-negative-int' : 'positive-int';
-        } elseif ('min' === $min && \in_array($max, [-1, 0])) {
-            return 0 === $max ? 'non-positive-int' : 'negative-int';
-        }
-
-        return \sprintf($template, $min, $max);
+        return \sprintf('int<%s, %s>', $min, $max);
+    }
+}
diff --git a/src/Symfony/Component/TypeInfo/TypeFactoryTrait.php b/src/Symfony/Component/TypeInfo/TypeFactoryTrait.php
@@ -15,8 +15,10 @@
 use Symfony\Component\TypeInfo\Type\BuiltinType;
 use Symfony\Component\TypeInfo\Type\CollectionType;
 use Symfony\Component\TypeInfo\Type\EnumType;
+use Symfony\Component\TypeInfo\Type\ExplicitStringType;
 use Symfony\Component\TypeInfo\Type\GenericType;
 use Symfony\Component\TypeInfo\Type\IntersectionType;
+use Symfony\Component\TypeInfo\Type\IntRangeType;
 use Symfony\Component\TypeInfo\Type\NullableType;
 use Symfony\Component\TypeInfo\Type\ObjectType;
 use Symfony\Component\TypeInfo\Type\TemplateType;
@@ -54,6 +56,11 @@ public static function int(): BuiltinType
         return self::builtin(TypeIdentifier::INT);
     }
 
+    public static function intRange(int $from, int $to, bool $zeroIncluded = true): IntRangeType
-    public static function intRange(int $from, int $to, bool $zeroIncluded = true): IntRangeType
+    public static function intRange(int $from = \PHP_INT_MIN, int $to = \PHP_INT_MAX): IntRangeType
-    public static function intRange(int $from, int $to, bool $zeroIncluded = true): IntRangeType
+    public static function intRange(int $from = \PHP_INT_MIN, int $to = \PHP_INT_MAX): IntRangeType
+    {
+        return new IntRangeType($from, $to, $zeroIncluded);
+    }
+
     /**
      * @return BuiltinType<TypeIdentifier::FLOAT>
      */
@@ -70,6 +77,11 @@ public static function string(): BuiltinType
         return self::builtin(TypeIdentifier::STRING);
     }
 
+    public static function explicitString(string $explicitType): ExplicitStringType
+    {
+        return new ExplicitStringType($explicitType);
+    }
+
     /**
      * @return BuiltinType<TypeIdentifier::BOOL>
      */

diff --git a/src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php b/src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php
@@ -135,9 +135,14 @@ private function getTypeFromNode(TypeNode $node, ?TypeContext $typeContext): Typ
                 'bool', 'boolean' => Type::bool(),
                 'true' => Type::true(),
                 'false' => Type::false(),
-                'int', 'integer', 'positive-int', 'negative-int', 'non-positive-int', 'non-negative-int', 'non-zero-int' => Type::int(),
+                'int', 'integer' => Type::int(),
+                'positive-int' => Type::intRange(1, \PHP_INT_MAX),
+                'negative-int' => Type::intRange(\PHP_INT_MIN, -1),
+                'non-positive-int' => Type::intRange(\PHP_INT_MIN, 0),
+                'non-negative-int' => Type::intRange(0, \PHP_INT_MAX),
+                'non-zero-int' => Type::intRange(\PHP_INT_MIN, \PHP_INT_MAX, false),
                 'float', 'double' => Type::float(),
-                'string',
+                'string' => Type::string(),
                 'class-string',
                 'trait-string',
                 'interface-string',
@@ -149,7 +154,7 @@ private function getTypeFromNode(TypeNode $node, ?TypeContext $typeContext): Typ
                 'non-falsy-string',
                 'truthy-string',
                 'literal-string',
-                'html-escaped-string' => Type::string(),
+                'html-escaped-string' => Type::explicitString($node->name),
                 'resource' => Type::resource(),
                 'object' => Type::object(),
                 'callable' => Type::callable(),
@@ -184,9 +189,27 @@ private function getTypeFromNode(TypeNode $node, ?TypeContext $typeContext): Typ
         if ($node instanceof GenericTypeNode) {
             $type = $this->getTypeFromNode($node->type, $typeContext);
 
-            // handle integer ranges as simple integers
+            // handle integer ranges
             if ($type->isIdentifiedBy(TypeIdentifier::INT)) {
-                return $type;
+                $getValueFromNode = function (TypeNode $node) {
+                    if ($node instanceof IdentifierTypeNode) {
+                        return match ($node->name) {
+                            'min' => \PHP_INT_MIN,
+                            'max' => \PHP_INT_MAX,
+                            default => throw new \DomainException(\sprintf('Invalid int range value "%s".', $node->name)),
+                        };
+                    }
+
+                    if ($node->constExpr instanceof ConstExprIntegerNode) {
+                        return (int) $node->constExpr->value;
+                    }
+
+                    throw new \DomainException(\sprintf('Invalid int range expression "%s".', \get_class($node->constExpr)));
+                };
+
+                $range = array_map(fn (TypeNode $t): int => $getValueFromNode($t), $node->genericTypes);
-                $range = array_map(fn (TypeNode $t): int => $getValueFromNode($t), $node->genericTypes);
+                $boundaries = array_map(static fn (TypeNode $t): int => $getBoundaryFromNode($t), $node->genericTypes);
-                $range = array_map(fn (TypeNode $t): int => $getValueFromNode($t), $node->genericTypes);
+                $boundaries = array_map(static fn (TypeNode $t): int => $getBoundaryFromNode($t), $node->genericTypes);
+
+                return Type::intRange(...$range);
-                return Type::intRange(...$range);
+                return Type::intRange($boudaries[0], $boundaries[1]);
-                return Type::intRange(...$range);
+                return Type::intRange($boudaries[0], $boundaries[1]);
             }
 
             $variableTypes = array_map(fn (TypeNode $t): Type => $this->getTypeFromNode($t, $typeContext), $node->genericTypes);