[TypeInfo] Add `IntRangeType` to hold specific type details for `int` builtin types #59676

DerManoMann · 2025-02-02T22:15:50Z

Q	A
Branch?	7.3
Bug fix?	no
New feature?	yes
Deprecations?	no
License	MIT

Adds IntRangeType that extends BuiltinType and holds specific int range details for int builtin types.

Includes explicit int types like positive-int or non-negative-int and also custom ranges like int<3, 12> or int<min, 5>.

DerManoMann · 2025-02-14T01:40:35Z

No takers?

OskarStark · 2025-02-14T07:54:37Z

friendly ping @mtarld

mtarld

Thanks for your PR @DerManoMann!

On a general note, I'm wondering if we should add such precise types in TypeInfo.
I'm a bit afraid to "re-do" PHPStan in Symfony, which will introduce a lot of complexity. Indeed, I'm not sure that knowing that a string type is a callable string, or an integer type is positive is a really common use case.

I'm not against this addition, but I think we need to decide if the use cases really worth it. 🙂

mtarld · 2025-02-14T08:59:43Z

src/Symfony/Component/TypeInfo/IntRangeBoundBuiltinType.php

+ */
+class IntRangeBoundBuiltinType extends BoundBuiltinType
+{
+    public function __construct(private array $range)


Suggested change

public function __construct(private array $range)

public function __construct(

private int $from = \PHP_INT_MIN,

private int $to = \PHP_INT_MAX,

) {

parent::__construct(TypeIndentifier::INT);

}

mtarld · 2025-02-14T08:59:54Z

src/Symfony/Component/TypeInfo/IntRangeBoundBuiltinType.php

+ *
+ * @extends BoundBuiltinType<BoundBuiltinTypeIdentifier::RANGE_INT>
+ */
+class IntRangeBoundBuiltinType extends BoundBuiltinType


Suggested change

class IntRangeBoundBuiltinType extends BoundBuiltinType

final class IntRangeType extends BuiltinType

I'd rather make the BuiltinType non-final, and then created a IntRangeType instead. It'll make it more logic, as an integer range is indeed a subtype of integer.

If in the future there are other subtypes, such as key-of, value-of, class-string, ... (see https://phpstan.org/writing-php-code/phpdoc-types), I think it'll be clearer to create a dedicated class for each use case.

Yeah, I thought about that. If we do go down that path, how would you see simple bound type enum values (for example html-escaped-string) be attached to builtin types in general? Optionally passed in directly into the constructor? (removing the need for my BoundBuiltinType)- something like:

// TypeFactoryTrait /** * @return BuiltinType<TypeIdentifier::STRING> */ public static function string(?BoundBuiltinTypeIdentifier $boundBuiltinType = null): BuiltinType { return self::builtin(TypeIdentifier::STRING, $boundBuiltinType); }

mtarld · 2025-02-14T09:01:55Z

src/Symfony/Component/TypeInfo/IntRangeBoundBuiltinType.php

+ *
+ * @author Martin Rademacher <mano@radebatz.net>
+ *
+ * @extends BoundBuiltinType<BoundBuiltinTypeIdentifier::RANGE_INT>


Suggested change

* @extends BoundBuiltinType<BoundBuiltinTypeIdentifier::RANGE_INT>

* @extends BuiltinType<TypeIdentifier::INT>

mtarld · 2025-02-14T09:06:33Z

src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php

+                'never' => Type::never(),
+                'never-return', 'never-returns', 'no-return' => Type::never(new BoundBuiltinType(BoundBuiltinTypeIdentifier::tryFrom($node->name))),


Suggested change

'never' => Type::never(),

'never-return', 'never-returns', 'no-return' => Type::never(new BoundBuiltinType(BoundBuiltinTypeIdentifier::tryFrom($node->name))),

'never', 'never-return', 'never-returns', 'no-return' => Type::never(),

I don't think there is any value to be this precise, never should be enough.

mtarld · 2025-02-14T09:30:03Z

src/Symfony/Component/TypeInfo/BoundBuiltinTypeIdentifier.php

+    case CLASS_STRING = 'class-string';
+    case TRAIT_STRING = 'trait-string';
+    case INTERFACE_STRING = 'interface-string';
+    case CALLABLE_STRING = 'callable-string';
+    case NUMERIC_STRING = 'numeric-string';
+    case LOWERCASE_STRING = 'lowercase-string';
+    case NON_EMPTY_LOWERCASE_STRING = 'non-empty-lowercase-string';
+    case NON_EMPTY_STRING = 'non-empty-string';
+    case NON_FALSY_STRING = 'non-falsy-string';
+    case TRUTHY_STRING = 'truthy-string';
+    case LITERAL_STRING = 'literal-string';
+    case HTML_ESCAPED_STRING = 'html-escaped-string';


This should result in a ExplicitStringType IMHO.

Not sure what you mean here. Are you suggesting to rename the enum to ExplicitStringType? TBH I think the current name it too long too :)

Ah, I think I see. It is the subclass of the builtin string. Yes, makes sense.

mtarld · 2025-02-14T09:32:29Z

src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php

+                    switch (\get_class($node->constExpr)) {
+                        case ConstExprIntegerNode::class: return (int) $node->constExpr->value;
+                        default: throw new \DomainException(\sprintf('Unhandled "%s" constant expression.', \get_class($node->constExpr)));
+                    }


Suggested change

switch (\get_class($node->constExpr)) {

case ConstExprIntegerNode::class: return (int) $node->constExpr->value;

default: throw new \DomainException(\sprintf('Unhandled "%s" constant expression.', \get_class($node->constExpr)));

}

if ($node->constExpr instanceof ConstExprIntegerNode:) {

return (int) $node->constExpr->value;

}

throw new \DomainException(\sprintf('Unhandled "%s" constant expression.', $node->constExpr::class));

}

mtarld · 2025-02-14T09:33:46Z

src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php

+                    }
+                };
+
+                $variableValues = array_map(fn (TypeNode $t): string|int => $getValueFromNode($t), $node->genericTypes);


Why are string allowed here?

The range allows for int value and the string literals min and max.

Actually there is one more peculiarity with the range; non-zero-int cannot be expressed as just a min/max as it is either a single range with exclusion, or two ranges 🤷
I suggest adding a $zeroIncluded or similar property in addition to min and max.

mtarld · 2025-02-14T09:34:13Z

src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php

+                    }
+                };
+
+                $variableValues = array_map(fn (TypeNode $t): string|int => $getValueFromNode($t), $node->genericTypes);


The $getValueFromNode can be inlined.

Left as-is as it feels quite big already. Is this a hard CS requirement?

mtarld · 2025-02-14T09:54:40Z

src/Symfony/Component/TypeInfo/IntRangeBoundBuiltinType.php

+    {
+        return $this->range;
+    }
+}


The accepts method must be overridden as well.

Neirda24 · 2025-02-19T09:34:50Z

Hi @mtarld . Thank you for the component. I think it would be worth adding this. IMO it does not collide (yet) with phpstan features. PHPStan allows to collect this kind of data only through Modules (executed with the cli) not in projects at runtime.

One use case I have at the moment would be to extract informations about methods and its arguments to try to generate a semantic configuration dynamically. To do so we do need to extract the array shape. For example list<array{plop: string}> is a prototype array with a scalar node plop which seems to be required. without this feature I would simply have a prototype array with a prototype variable

Neirda24 · 2025-02-19T09:35:47Z

Another use case I can think of is for the validator component. We could think of a "auto guesser" which using this type info component would create the constraints dynamically.

Neirda24 · 2025-02-19T09:38:00Z

Another use case I can think of is for the validator component. We could think of a "auto guesser" which using this type info component would create the constraints dynamically.

I think it is the FormTypeGuesser or something that based on Assert / ORM attributes it guesses what kind of attributes to apply to html inputs.

DerManoMann · 2025-02-20T02:09:31Z

I'm not against this addition, but I think we need to decide if the use cases really worth it. 🙂

Glad to hear :) It is a tricky situation. For my use case the alternative is to clone and add a few things, so it made sense to try a PR first ;)

DerManoMann · 2025-02-20T05:10:54Z

Deng! Will fix the PropertyInfo tests tomorrow :{

mtarld

Next round 😉

mtarld · 2025-02-20T08:37:25Z

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


Suggested change

* 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

mtarld · 2025-02-20T08:50:02Z

src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php

+                    throw new \DomainException(\sprintf('Invalid int range expression "%s".', \get_class($node->constExpr)));
+                };
+
+                $range = array_map(fn (TypeNode $t): int => $getValueFromNode($t), $node->genericTypes);


Suggested change

$range = array_map(fn (TypeNode $t): int => $getValueFromNode($t), $node->genericTypes);

$boundaries = array_map(static fn (TypeNode $t): int => $getBoundaryFromNode($t), $node->genericTypes);

mtarld · 2025-02-20T08:50:24Z

src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php

+
+                $range = array_map(fn (TypeNode $t): int => $getValueFromNode($t), $node->genericTypes);
+
+                return Type::intRange(...$range);


Suggested change

return Type::intRange(...$range);

return Type::intRange($boudaries[0], $boundaries[1]);

mtarld · 2025-02-20T08:51:39Z

src/Symfony/Component/TypeInfo/Type/IntRangeType.php

+
+    public function accepts(mixed $value): bool
+    {
+        return \is_int($value)


Suggested change

return \is_int($value)

return parent::accepts($value)

mtarld · 2025-02-20T08:51:59Z

src/Symfony/Component/TypeInfo/Type/IntRangeType.php

+ *
+ * @extends BuiltinType<TypeIdentifier::INT>
+ */
+class IntRangeType extends BuiltinType


Suggested change

class IntRangeType extends BuiltinType

final class IntRangeType extends BuiltinType

mtarld · 2025-02-20T09:25:59Z

src/Symfony/Component/TypeInfo/TypeFactoryTrait.php

@@ -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


Suggested change

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

Ok, but keeing $zeroIncluded, right?

Because of #59676 (comment), I think we can remove it

Ah, good point. Sorry, I missed that one.

mtarld · 2025-02-20T09:27:13Z

src/Symfony/Component/TypeInfo/Tests/TypeResolver/StringTypeResolverTest.php

+        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'];


These can be moved to // int range section

mtarld · 2025-02-20T09:27:41Z

src/Symfony/Component/TypeInfo/Tests/TypeResolver/StringTypeResolverTest.php

+        yield [Type::explicitString('class-string'), 'class-string'];
+        yield [Type::explicitString('literal-string'), 'literal-string'];
+        yield [Type::explicitString('html-escaped-string'), 'html-escaped-string'];


Let's have a section for these as well

mtarld · 2025-02-20T09:29:19Z

src/Symfony/Component/TypeInfo/Tests/Type/IntRangeTypeTest.php

+    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'));
+    }


I'm not sure this test is needed (we are testing that IntRangeType is extending BuiltinType<int> here)

fair enough, removing

mtarld · 2025-02-20T09:29:32Z

src/Symfony/Component/TypeInfo/Tests/Type/IntRangeTypeTest.php

+    public function testIsNullable()
+    {
+        $this->assertFalse((new IntRangeType(0, 5))->isNullable());
+    }


DerManoMann · 2025-02-20T20:01:18Z

Next round 😉

Keep it coming...

DerManoMann · 2025-02-20T20:15:04Z

Hmm, I wonder how this is going to work with PropertyInfo...

PropertyInfo does require "symfony/type-info": "~7.1.9|^7.2.2" - that means I shouldn't update the tests as this PR is against 7.3.
OTOH, running all tests on 7.3 will fail then...

mtarld · 2025-02-21T07:23:21Z

^7.2.2 doesn't restrict TypeInfo to 7.2, see https://getcomposer.org/doc/articles/versions.md#caret-version-range-

mtarld

Can you update the PR title and description as well?

mtarld · 2025-02-21T07:25:17Z

src/Symfony/Component/TypeInfo/Tests/TypeResolver/StringTypeResolverTest.php

@@ -151,7 +142,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>'];


This can be put under // int range section

mtarld · 2025-02-21T07:31:00Z

src/Symfony/Component/TypeInfo/TypeResolver/StringTypeResolver.php

                'float', 'double' => Type::float(),
-                'string',
+                'string' => Type::string(),
                'class-string',


I think we'll need to handle class-string<Foo>, and interface-string<Bar> in a specific way.
IMHO, we should split the work in 2 PRs, on for the integers stuff, and on other for the strings stuff.

Yeah, I was wondering about that. Seems wrong to leave things half finished.
Happy to create a second PR. Not sure what the pattern is here - wait until this is merged, or base thge second off this branch?

Sorry, I meant to move all the string related stuff (ie: ExplicitString) in another PR. By doing that, you won't have to base the second PR on the first.

True. Getting late here...

DerManoMann · 2025-02-21T08:09:07Z

Can you update the PR title and description as well?

Tried :) Let me know if you need more.

mtarld · 2025-02-21T08:51:37Z

It misses the title update as well 🙂

DerManoMann · 2025-02-22T03:27:54Z

Some more cleanup and moved string handloing into #59833

mtarld · 2025-02-22T08:23:03Z

src/Symfony/Component/TypeInfo/CHANGELOG.md

@@ -9,6 +9,7 @@ CHANGELOG
 * Deprecate constructing a `CollectionType` instance as a list that is not an array
 * Deprecate the third `$asList` argument of `TypeFactoryTrait::iterable()`, use `TypeFactoryTrait::list()` instead
 * Add type alias support in `TypeContext` and `StringTypeResolver`
+ * Add `IntRangeType` class to hold specific type details for `int` builtin types


Suggested change

* Add `IntRangeType` class to hold specific type details for `int` builtin types

* Add `IntRangeType` class that represents a range of integer values

mtarld · 2025-02-22T08:24:20Z

src/Symfony/Component/PropertyInfo/Tests/Extractor/PhpStanExtractorTest.php

        yield ['nonEmptyArray', Type::array()];
        yield ['nonEmptyList', Type::list()];
        yield ['scalar', Type::union(Type::int(), Type::float(), Type::string(), Type::bool())];
        yield ['number', Type::union(Type::int(), Type::float())];
        yield ['numeric', Type::union(Type::int(), Type::float(), Type::string())];
        yield ['arrayKey', Type::union(Type::int(), Type::string())];
        yield ['double', Type::float()];
+
+        if (method_exists(Type::class, 'intRange')) {


Suggested change

if (method_exists(Type::class, 'intRange')) {

// BC layer for symfony/type-info < 7.3

if (method_exists(Type::class, 'intRange')) {

mtarld · 2025-02-22T08:24:37Z

src/Symfony/Component/PropertyInfo/Tests/Extractor/PhpStanExtractorTest.php

+        if (method_exists(Type::class, 'intRange')) {
+            yield ['positiveInt', Type::intRange(1)];
+            yield ['negativeInt', Type::intRange(\PHP_INT_MIN, -1)];
+        }


It misses the else

mtarld · 2025-02-22T08:25:08Z

src/Symfony/Component/PropertyInfo/Tests/Extractor/PhpStanExtractorTest.php

-        yield ['a', Type::int()];
-        yield ['b', Type::nullable(Type::int())];
-        yield ['c', Type::int()];
+        if (method_exists(Type::class, 'intRange')) {


Suggested change

if (method_exists(Type::class, 'intRange')) {

// BC layer for symfony/type-info < 7.3

if (method_exists(Type::class, 'intRange')) {

mtarld · 2025-02-22T08:26:06Z

src/Symfony/Component/TypeInfo/Type/IntRangeType.php

+            return \sprintf($template, $min, $max);
+        }
+
+        if (\in_array($min, [0, 1], true) && 'max' === $max) {


I'd have removed these conditions to only have a int<foo, bar> canonical string representation

It might be more in line with what we do with non-zero-int. Also, come to think of it, there is no telling where we started anyway...

DerManoMann · 2025-02-23T01:42:43Z

Right, so far so good.
I am just a bit at a loss as to how to replicate the test failures locally now. (8.2, high-deps) looks like it has the branch changes, but doesn't use them somehow.
Didn't have time to look into 8.5, but that looks somewhat unrelated; might be wrong, though ;)

carsonbot added Status: Needs Review Feature TypeInfo labels Feb 2, 2025

carsonbot added this to the 7.3 milestone Feb 2, 2025

DerManoMann changed the title ~~[TypeInfo] Add specific (boudn) type details to builtin int and string type~~ [TypeInfo] Add specific (bound) type details to builtin int and string type Feb 2, 2025

DerManoMann force-pushed the bound-builtin-types branch from ca577cc to 26806cc Compare February 2, 2025 23:00

mtarld requested changes Feb 14, 2025

View reviewed changes

carsonbot added Status: Needs Work and removed Status: Needs Review labels Feb 14, 2025

mtarld mentioned this pull request Feb 14, 2025

Expand TypeInfo component to support advanced scalar types #59733

Open

mtarld requested changes Feb 20, 2025

View reviewed changes

DerManoMann requested a review from dunglas as a code owner February 20, 2025 20:00

carsonbot added Status: Needs Review and removed Status: Needs Work labels Feb 20, 2025

DerManoMann mentioned this pull request Feb 20, 2025

Array shapes support zircote/swagger-php#1676

Open

mtarld reviewed Feb 21, 2025

View reviewed changes

DerManoMann changed the title ~~[TypeInfo] Add specific (bound) type details to builtin int and string type~~ [TypeInfo] Add IntRangeType and ExplicitStringType classes to hold specific type details for int and string builtin types Feb 21, 2025

Add IntRangeType and ExplicitStringType

16d885d

DerManoMann added 3 commits February 22, 2025 16:10

Update PropertyInfo tests

49a43b4

Make types final

f67554e

Split ExplicitStringType off into separate branch

e76cbc1

DerManoMann force-pushed the bound-builtin-types branch from 712ba1d to e76cbc1 Compare February 22, 2025 03:11

DerManoMann changed the title ~~[TypeInfo] Add IntRangeType and ExplicitStringType classes to hold specific type details for int and string builtin types~~ [TypeInfo] Add IntRangeType to hold specific type details for int builtin types Feb 22, 2025

CS

79249d9

DerManoMann added 2 commits February 22, 2025 16:32

Update CHANGELOG.md

3f63fb9

Make intRange tests conditional

007cb6d

mtarld requested changes Feb 22, 2025

View reviewed changes

carsonbot added Status: Needs Work and removed Status: Needs Review labels Feb 22, 2025

DerManoMann added 3 commits February 23, 2025 14:19

Update wording

acee37f

Always serialize to int<a, b>

50c5576

Add BC comments and missing else case

c6e6ead

mtarld mentioned this pull request Feb 24, 2025

[TypeInfo] Add ExplicitStringType and ClassLikeStringType classes to hold specific type details for string builtin types #59833

Closed

DerManoMann closed this Feb 25, 2025

DerManoMann deleted the bound-builtin-types branch February 26, 2025 03:38

-    public function __construct(private array $range)
+    public function __construct(
+        private int $from = \PHP_INT_MIN,
+        private int $to = \PHP_INT_MAX,
+    ) {
+        parent::__construct(TypeIndentifier::INT);
+    }

	class IntRangeBoundBuiltinType extends BoundBuiltinType
	final class IntRangeType extends BuiltinType

	* @extends BoundBuiltinType<BoundBuiltinTypeIdentifier::RANGE_INT>
	* @extends BuiltinType<TypeIdentifier::INT>

		'never' => Type::never(),
		'never-return', 'never-returns', 'no-return' => Type::never(new BoundBuiltinType(BoundBuiltinTypeIdentifier::tryFrom($node->name))),

	'never' => Type::never(),
	'never-return', 'never-returns', 'no-return' => Type::never(new BoundBuiltinType(BoundBuiltinTypeIdentifier::tryFrom($node->name))),
	'never', 'never-return', 'never-returns', 'no-return' => Type::never(),

	* 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

	$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);

		return Type::intRange(...$range);

	return Type::intRange(...$range);
	return Type::intRange($boudaries[0], $boundaries[1]);

	class IntRangeType extends BuiltinType
	final class IntRangeType extends BuiltinType

	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

	* Add `IntRangeType` class to hold specific type details for `int` builtin types
	* Add `IntRangeType` class that represents a range of integer values

	if (method_exists(Type::class, 'intRange')) {
	// BC layer for symfony/type-info < 7.3
	if (method_exists(Type::class, 'intRange')) {

[TypeInfo] Add IntRangeType to hold specific type details for int builtin types #59676

[TypeInfo] Add IntRangeType to hold specific type details for int builtin types #59676

Conversation

DerManoMann commented Feb 2, 2025 • edited Loading

DerManoMann commented Feb 14, 2025

OskarStark commented Feb 14, 2025

mtarld left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Neirda24 commented Feb 19, 2025

Neirda24 commented Feb 19, 2025

Neirda24 commented Feb 19, 2025

DerManoMann commented Feb 20, 2025

DerManoMann commented Feb 20, 2025

mtarld left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

DerManoMann commented Feb 20, 2025

DerManoMann commented Feb 20, 2025

mtarld commented Feb 21, 2025

mtarld left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

DerManoMann commented Feb 21, 2025

mtarld commented Feb 21, 2025

DerManoMann commented Feb 22, 2025

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

DerManoMann commented Feb 23, 2025

[TypeInfo] Add `IntRangeType` to hold specific type details for `int` builtin types #59676

[TypeInfo] Add `IntRangeType` to hold specific type details for `int` builtin types #59676

DerManoMann commented Feb 2, 2025 •

edited

Loading