From 5d856f1a3b714e602ce11ea0b8cd4324854f4e85 Mon Sep 17 00:00:00 2001
From: Valentin Udaltsov <udaltsov.valentin@gmail.com>
Date: Mon, 3 Nov 2025 14:07:24 +0300
Subject: [PATCH] Refactor Stringify to a composable final class

---
 infection.json5.dist            |   6 +-
 src/Type/Internal/Reference.php |  27 +++
 src/Type/Visitor/Stringify.php  | 302 ++++++++++++++++----------------
 src/Type/stringify.php          |  12 +-
 tests/Type/StringifyTest.php    |  64 +++++--
 5 files changed, 230 insertions(+), 181 deletions(-)
 create mode 100644 src/Type/Internal/Reference.php

diff --git a/infection.json5.dist b/infection.json5.dist
index fa6f508..40f3f2c 100644
--- a/infection.json5.dist
+++ b/infection.json5.dist
@@ -15,6 +15,10 @@
     "minCoveredMsi": 100,
     "mutators": {
         "@default": true,
-        "ProtectedVisibility": false
+        "PublicVisibility": {
+            "ignore": [
+                "Typhoon\\Type\\Visitor\\Stringify"
+            ]
+        }
     },
 }
diff --git a/src/Type/Internal/Reference.php b/src/Type/Internal/Reference.php
new file mode 100644
index 0000000..cb3eaaf
--- /dev/null
+++ b/src/Type/Internal/Reference.php
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Type\Internal;
+
+/**
+ * @internal this class is used in {@see Stringify} to avoid `if`
+ * @template-covariant T of ?object
+ */
+final readonly class Reference
+{
+    /**
+     * @param T $object
+     */
+    public function __construct(
+        private ?object $object = null,
+    ) {}
+
+    /**
+     * @return T
+     */
+    public function get(): ?object
+    {
+        return $this->object;
+    }
+}
diff --git a/src/Type/Visitor/Stringify.php b/src/Type/Visitor/Stringify.php
index 59a84c1..dcbea65 100644
--- a/src/Type/Visitor/Stringify.php
+++ b/src/Type/Visitor/Stringify.php
@@ -24,6 +24,7 @@
 use Typhoon\Type\FloatRangeT;
 use Typhoon\Type\FloatT;
 use Typhoon\Type\FloatValueT;
+use Typhoon\Type\Internal\Reference;
 use Typhoon\Type\IntersectionT;
 use Typhoon\Type\IntRangeT;
 use Typhoon\Type\IntT;
@@ -75,8 +76,44 @@
  * @api
  * @implements Visitor<non-empty-string>
  */
-abstract class Stringify implements Visitor
+final readonly class Stringify implements Visitor
 {
+    /**
+     * @var Reference<?Visitor<non-empty-string>>|\WeakReference<Visitor<non-empty-string>>
+     */
+    private Reference|\WeakReference $next;
+
+    /**
+     * @param null|Visitor<non-empty-string>|\WeakReference<Visitor<non-empty-string>> $next
+     */
+    public function __construct(null|Visitor|\WeakReference $next = null)
+    {
+        $this->next = $next instanceof \WeakReference ? $next : new Reference($next);
+    }
+
+    /**
+     * @return non-empty-string
+     */
+    public function safe(Type $type): string
+    {
+        return $type->accept($this->next->get() ?? $this);
+    }
+
+    /**
+     * @return non-empty-string
+     */
+    public function unsafe(Type $type): string
+    {
+        $string = $this->safe($type);
+
+        if ($string[0] === '(') {
+            /** @phpstan-ignore return.type */
+            return substr($string, 1, -1);
+        }
+
+        return $string;
+    }
+
     #[\Override]
     public function neverT(NeverT $type): string
     {
@@ -168,7 +205,7 @@ public function positiveIntT(PositiveIntT $type): string
     #[\Override]
     public function bitmaskT(BitmaskT $type): string
     {
-        return \sprintf('int-mask-of<%s>', $this->stringifyUnwrap($type->intType));
+        return \sprintf('int-mask-of<%s>', $this->unsafe($type->intType));
     }
 
     #[\Override]
@@ -241,7 +278,7 @@ public function stringValueT(StringValueT $type): string
     #[\Override]
     public function classT(ClassT $type): string
     {
-        return \sprintf('class-string<%s>', $this->stringifyUnwrap($type->objectType));
+        return \sprintf('class-string<%s>', $this->unsafe($type->objectType));
     }
 
     #[\Override]
@@ -265,9 +302,9 @@ public function scalarT(ScalarT $type): string
     #[\Override]
     public function listT(ListT $type): string
     {
-        $value = $this->stringifyUnwrap($type->valueType);
+        $value = $this->unsafe($type->valueType);
 
-        $elements = implode(', ', array_map($this->stringifyUnwrap(...), $type->elementTypes));
+        $elements = implode(', ', array_map($this->unsafe(...), $type->elementTypes));
 
         if ($value === 'never') {
             return \sprintf('list{%s}', $elements);
@@ -275,13 +312,13 @@ public function listT(ListT $type): string
 
         $name = $type->isNonEmpty ? 'non-empty-list' : 'list';
 
-        $unsealed = $value === 'mixed' ? '' : \sprintf('<%s>', $value);
+        $unsealed = \sprintf('<%s>', $value);
 
         if ($elements === '') {
             return $name . $unsealed;
         }
 
-        return \sprintf('%s{%s, ...%s}', $name, $elements, $unsealed);
+        return \sprintf('%s{%s, ...%s}', $name, $elements, $unsealed === '<mixed>' ? '' : $unsealed);
     }
 
     #[\Override]
@@ -293,7 +330,7 @@ public function arrayBareT(ArrayBareT $type): string
     #[\Override]
     public function arrayT(ArrayT $type): string
     {
-        $value = $this->stringifyUnwrap($type->valueType);
+        $value = $this->unsafe($type->valueType);
 
         $elements = implode(', ', array_map($this->arrayElement(...), $type->elements));
 
@@ -303,10 +340,10 @@ public function arrayT(ArrayT $type): string
 
         $name = $type->isNonEmpty ? 'non-empty-array' : 'array';
 
-        $key = $this->stringifyUnwrap($type->keyType);
+        $key = $this->unsafe($type->keyType);
 
         $unsealed = match ($key) {
-            'array-key', 'int|string', 'string|int' => $value === 'mixed' ? '' : \sprintf('<%s>', $value),
+            'array-key', 'int|string', 'string|int' => \sprintf('<%s>', $value),
             default => \sprintf('<%s, %s>', $key, $value),
         };
 
@@ -314,20 +351,7 @@ public function arrayT(ArrayT $type): string
             return $name . $unsealed;
         }
 
-        return \sprintf('%s{%s, ...%s}', $name, $elements, $unsealed);
-    }
-
-    /**
-     * @return non-empty-string
-     */
-    protected function arrayElement(ArrayElement $element): string
-    {
-        return \sprintf(
-            '%s%s: %s',
-            \is_int($element->key) ? $element->key : $this->stringValueT(new StringValueT($element->key)),
-            $element->isOptional ? '?' : '',
-            $this->stringifyUnwrap($element->type),
-        );
+        return \sprintf('%s{%s, ...%s}', $name, $elements, $unsealed === '<mixed>' ? '' : $unsealed);
     }
 
     #[\Override]
@@ -339,7 +363,7 @@ public function objectBareT(ObjectBareT $type): string
     #[\Override]
     public function namedObjectT(NamedObjectT $type): string
     {
-        return $this->constructor($type->class, $type->templateArguments);
+        return $type->class . $this->templateArguments($type->templateArguments);
     }
 
     #[\Override]
@@ -352,53 +376,26 @@ public function objectT(ObjectT $type): string
                 fn(NamedObjectT $inherited): string => ':' . $this->namedObjectT($inherited),
                 $type->supertypes,
             )),
-            $type->properties === [] ? '' : \sprintf('{%s}', implode(', ', array_map($this->property(...), $type->properties))),
-        );
-    }
-
-    /**
-     * @return non-empty-string
-     */
-    protected function property(Property $property): string
-    {
-        return \sprintf(
-            '%s%s: %s',
-            $property->name,
-            $property->isOptional ? '?' : '',
-            $this->stringifyUnwrap($property->type),
+            \sprintf('{%s}', implode(', ', array_map($this->property(...), $type->properties))),
         );
     }
 
     #[\Override]
     public function selfT(SelfT $type): string
     {
-        return $this->constructor('self', $type->templateArguments);
+        return 'self' . $this->templateArguments($type->templateArguments);
     }
 
     #[\Override]
     public function parentT(ParentT $type): string
     {
-        return $this->constructor('parent', $type->templateArguments);
+        return 'parent' . $this->templateArguments($type->templateArguments);
     }
 
     #[\Override]
     public function staticT(StaticT $type): string
     {
-        return $this->constructor('static', $type->templateArguments);
-    }
-
-    /**
-     * @param non-empty-string $name
-     * @param list<Type> $templateArguments
-     * @return non-empty-string
-     */
-    protected function constructor(string $name, array $templateArguments): string
-    {
-        if ($templateArguments === []) {
-            return $name;
-        }
-
-        return \sprintf('%s<%s>', $name, implode(', ', array_map($this->stringifyUnwrap(...), $templateArguments)));
+        return 'static' . $this->templateArguments($type->templateArguments);
     }
 
     #[\Override]
@@ -410,14 +407,10 @@ public function iterableBareT(IterableBareT $type): string
     #[\Override]
     public function iterableT(IterableT $type): string
     {
-        $key = $this->stringifyUnwrap($type->keyType);
-        $value = $this->stringifyUnwrap($type->valueType);
+        $key = $this->unsafe($type->keyType);
+        $value = $this->unsafe($type->valueType);
 
         if ($key === 'mixed') {
-            if ($value === 'mixed') {
-                return 'iterable';
-            }
-
             return \sprintf('iterable<%s>', $value);
         }
 
@@ -431,73 +424,21 @@ public function callableBareT(CallableBareT $type): string
     }
 
     #[\Override]
-    public function callableT(CallableT $type): string
+    public function callableT(CallableT|ClosureT $type): string
     {
-        return $this->callables($type);
-    }
-
-    #[\Override]
-    public function closureT(ClosureT $type): string
-    {
-        return $this->callables($type);
-    }
-
-    /**
-     * @return non-empty-string
-     */
-    protected function callables(CallableT|ClosureT $type): string
-    {
-        $prefix = $type instanceof CallableT ? 'callable' : 'Closure';
-
-        $string = \sprintf(
+        return \sprintf(
             '(%s%s(%s): %s)',
-            $prefix,
+            $type instanceof CallableT ? 'callable' : 'Closure',
             $this->templates($type->templates),
             implode(', ', array_map($this->parameter(...), $type->parameters)),
-            $this->stringify($type->returnType),
+            $this->safe($type->returnType),
         );
-
-        if ($string === "({$prefix}(): mixed)") {
-            return $prefix;
-        }
-
-        return $string;
     }
 
-    /**
-     * @return non-empty-string
-     */
-    protected function parameter(Parameter $parameter): string
+    #[\Override]
+    public function closureT(ClosureT $type): string
     {
-        $string = $this->stringify($parameter->type);
-
-        if ($parameter->name !== null) {
-            $string .= ' ';
-        }
-
-        if ($parameter->isPassedByReference) {
-            $string .= '&';
-
-            // todo $parameter->outType
-        }
-
-        if ($parameter->isVariadic) {
-            $string .= '...';
-        }
-
-        if ($parameter->name !== null) {
-            $string .= '$' . $parameter->name;
-        }
-
-        if ($parameter->hasDefault) {
-            $string .= '=';
-
-            if ($parameter->defaultType !== null) {
-                $string .= $this->stringify($parameter->defaultType);
-            }
-        }
-
-        return $string;
+        return $this->callableT($type);
     }
 
     #[\Override]
@@ -509,13 +450,13 @@ public function resourceT(ResourceT $type): string
     #[\Override]
     public function intersectionT(IntersectionT $type): string
     {
-        return \sprintf('%s', implode('&', array_map($this->stringify(...), $type->types)));
+        return \sprintf('(%s)', implode('&', array_map($this->safe(...), $type->types)));
     }
 
     #[\Override]
     public function unionT(UnionT $type): string
     {
-        return \sprintf('(%s)', implode('|', array_map($this->stringify(...), $type->types)));
+        return \sprintf('(%s)', implode('|', array_map($this->safe(...), $type->types)));
     }
 
     #[\Override]
@@ -545,19 +486,19 @@ public function classConstantMaskT(ClassConstantMaskT $type): string
     #[\Override]
     public function keyOfT(KeyOfT $type): string
     {
-        return \sprintf('key-of<%s>', $this->stringifyUnwrap($type->arrayType));
+        return \sprintf('key-of<%s>', $this->unsafe($type->arrayType));
     }
 
     #[\Override]
     public function valueOfT(ValueOfT $type): string
     {
-        return \sprintf('value-of<%s>', $this->stringifyUnwrap($type->arrayType));
+        return \sprintf('value-of<%s>', $this->unsafe($type->arrayType));
     }
 
     #[\Override]
     public function offsetT(OffsetT $type): string
     {
-        return \sprintf('%s[%s]', $this->stringify($type->arrayType), $this->stringifyUnwrap($type->keyType));
+        return \sprintf('%s[%s]', $this->safe($type->arrayType), $this->unsafe($type->keyType));
     }
 
     #[\Override]
@@ -565,8 +506,8 @@ public function isSubtypeT(IsSubtypeT $type): string
     {
         return \sprintf(
             '(%s is %s)',
-            $this->stringify($type->leftType),
-            $this->stringify($type->rightType),
+            $this->safe($type->leftType),
+            $this->safe($type->rightType),
         );
     }
 
@@ -575,16 +516,16 @@ public function ternaryT(TernaryT $type): string
     {
         return \sprintf(
             '(%s ? %s : %s)',
-            $this->stringify($type->conditionType),
-            $this->stringify($type->thenType),
-            $this->stringify($type->elseType),
+            $this->safe($type->conditionType),
+            $this->safe($type->thenType),
+            $this->safe($type->elseType),
         );
     }
 
     #[\Override]
     public function aliasT(AliasT $type): string
     {
-        return $this->constructor(\sprintf('%s@%s', $type->class, $type->name), $type->templateArguments);
+        return \sprintf('%s@%s%s', $type->class, $type->name, $this->templateArguments($type->templateArguments));
     }
 
     #[\Override]
@@ -593,10 +534,34 @@ public function templateT(TemplateT $type): string
         return $type->name;
     }
 
+    #[\Override]
+    public function mixedT(MixedT $type): string
+    {
+        return 'mixed';
+    }
+
+    #[\Override]
+    public function untypedT(UntypedT $type): mixed
+    {
+        return 'untyped-mixed';
+    }
+
+    /**
+     * @param list<Type> $templateArguments
+     */
+    public function templateArguments(array $templateArguments): string
+    {
+        if ($templateArguments === []) {
+            return '';
+        }
+
+        return \sprintf('<%s>', implode(', ', array_map($this->unsafe(...), $templateArguments)));
+    }
+
     /**
      * @param list<Template> $templates
      */
-    protected function templates(array $templates): string
+    public function templates(array $templates): string
     {
         if ($templates === []) {
             return '';
@@ -605,11 +570,15 @@ protected function templates(array $templates): string
         return \sprintf('<%s>', implode(', ', array_map($this->template(...), $templates)));
     }
 
-    protected function template(Template $template): string
+    /**
+     * @return non-empty-string
+     */
+    public function template(Template $template): string
     {
-        $lowerBound = $this->stringifyUnwrap($template->lowerBound);
-        $upperBound = $this->stringifyUnwrap($template->upperBound);
+        $lowerBound = $this->unsafe($template->lowerBound);
+        $upperBound = $this->unsafe($template->upperBound);
 
+        /** @phpstan-ignore return.type */
         return \sprintf(
             '%s%s%s%s%s',
             match ($template->variance) {
@@ -620,40 +589,67 @@ protected function template(Template $template): string
             $template->name,
             $upperBound === 'mixed' ? '' : ' of ' . $upperBound,
             $lowerBound === 'never' ? '' : ' super ' . $lowerBound,
-            $template->default === null ? '' : ' = ' . $this->stringifyUnwrap($template->default),
+            $template->default === null ? '' : ' = ' . $this->unsafe($template->default),
         );
     }
 
-    #[\Override]
-    public function mixedT(MixedT $type): string
-    {
-        return 'mixed';
-    }
-
-    #[\Override]
-    public function untypedT(UntypedT $type): mixed
+    /**
+     * @return non-empty-string
+     */
+    public function arrayElement(ArrayElement $element): string
     {
-        return 'untyped-mixed';
+        return \sprintf(
+            '%s%s: %s',
+            $this->safe(\is_int($element->key) ? new IntValueT($element->key) : new StringValueT($element->key)),
+            $element->isOptional ? '?' : '',
+            $this->unsafe($element->type),
+        );
     }
 
     /**
      * @return non-empty-string
      */
-    private function stringify(Type $type): string
+    public function property(Property $property): string
     {
-        return $type->accept($this);
+        return \sprintf(
+            '%s%s: %s',
+            $property->name,
+            $property->isOptional ? '?' : '',
+            $this->unsafe($property->type),
+        );
     }
 
     /**
      * @return non-empty-string
      */
-    private function stringifyUnwrap(Type $type): string
+    public function parameter(Parameter $parameter): string
     {
-        $string = $type->accept($this);
+        $string = $this->safe($parameter->type);
 
-        if ($string[0] === '(') {
-            /** @phpstan-ignore return.type */
-            return substr($string, 1, -1);
+        if ($parameter->name !== null) {
+            $string .= ' ';
+        }
+
+        if ($parameter->isPassedByReference) {
+            $string .= '&';
+
+            // todo $parameter->outType
+        }
+
+        if ($parameter->isVariadic) {
+            $string .= '...';
+        }
+
+        if ($parameter->name !== null) {
+            $string .= '$' . $parameter->name;
+        }
+
+        if ($parameter->hasDefault) {
+            $string .= '=';
+
+            if ($parameter->defaultType !== null) {
+                $string .= $this->safe($parameter->defaultType);
+            }
         }
 
         return $string;
diff --git a/src/Type/stringify.php b/src/Type/stringify.php
index abf49ad..c988d0d 100644
--- a/src/Type/stringify.php
+++ b/src/Type/stringify.php
@@ -11,14 +11,10 @@
  * @api
  * @return non-empty-string
  */
-function stringify(Type $type, bool $unwrap = true): string
+function stringify(Type $type): string
 {
-    $string = $type->accept(new class extends Stringify {});
+    /** @var Stringify */
+    static $stringify = new Stringify();
 
-    if ($unwrap && $string[0] === '(') {
-        /** @phpstan-ignore return.type */
-        return substr($string, 1, -1);
-    }
-
-    return $string;
+    return $stringify->unsafe($type);
 }
diff --git a/tests/Type/StringifyTest.php b/tests/Type/StringifyTest.php
index 576cca5..350405f 100644
--- a/tests/Type/StringifyTest.php
+++ b/tests/Type/StringifyTest.php
@@ -10,6 +10,7 @@
 use PHPUnit\Framework\Attributes\DoesNotPerformAssertions;
 use PHPUnit\Framework\TestCase;
 use Typhoon\Type;
+use Typhoon\Type\Visitor\Fallback;
 use Typhoon\Type\Visitor\Stringify;
 
 #[CoversClass(Stringify::class)]
@@ -126,28 +127,28 @@ public static function provideCases(): iterable
         yield [classT(\stdClass::class), 'class-string<stdClass>'];
         yield [scalarT, 'scalar'];
         yield [resourceT, 'resource'];
-        yield [nonEmptyListT(), 'non-empty-list'];
+        yield [nonEmptyListT(), 'non-empty-list<mixed>'];
         yield [nonEmptyListT(stringT), 'non-empty-list<string>'];
-        yield [listT(), 'list'];
+        yield [listT(), 'list<mixed>'];
         yield [listT(stringT), 'list<string>'];
         yield [listShapeT(), 'list{}'];
-        yield [unsealedListShapeT(), 'list'];
+        yield [unsealedListShapeT(), 'list<mixed>'];
         yield [listShapeT([intT]), 'list{int}'];
         yield [listShapeT([intT, stringT]), 'list{int, string}'];
         yield [unsealedListShapeT([intT, 1 => stringT]), 'list{int, string, ...}'];
         yield [unsealedListShapeT([floatT], value: stringT), 'list{float, ...<string>}'];
-        yield [nonEmptyArrayT(), 'non-empty-array'];
+        yield [nonEmptyArrayT(), 'non-empty-array<mixed>'];
         yield [nonEmptyArrayT(value: stringT), 'non-empty-array<string>'];
         yield [nonEmptyArrayT(stringT, intT), 'non-empty-array<string, int>'];
         yield [arrayT, 'array'];
-        yield [arrayT(), 'array'];
-        yield [arrayT(orT(intT, stringT)), 'array'];
-        yield [arrayT(orT(stringT, intT)), 'array'];
+        yield [arrayT(), 'array<mixed>'];
+        yield [arrayT(orT(intT, stringT)), 'array<mixed>'];
+        yield [arrayT(orT(stringT, intT)), 'array<mixed>'];
         yield [arrayT(nonEmptyStringT), 'array<non-empty-string, mixed>'];
         yield [arrayT(value: stringT), 'array<string>'];
         yield [arrayT(stringT, intT), 'array<string, int>'];
         yield [arrayShapeT(), 'array{}'];
-        yield [unsealedArrayShapeT(), 'array'];
+        yield [unsealedArrayShapeT(), 'array<mixed>'];
         yield [arrayShapeT([intT]), 'array{0: int}'];
         yield [arrayShapeT([intT, 'a' => stringT]), "array{0: int, 'a': string}"];
         yield [unsealedArrayShapeT([intT, 'a' => stringT]), "array{0: int, 'a': string, ...}"];
@@ -170,20 +171,19 @@ public static function provideCases(): iterable
         yield [staticT([stringT]), 'static<string>'];
         yield [orT(intT, stringT), 'int|string'];
         yield [orT(intT, orT(stringT, floatT)), 'int|(string|float)'];
-        yield [orT(intT, andT(stringT, floatT)), 'int|string&float'];
+        yield [orT(intT, andT(stringT, floatT)), 'int|(string&float)'];
         yield [nullOrT(stringT), 'null|string'];
         yield [andT(intT, stringT), 'int&string'];
-        yield [andT(intT, andT(stringT, floatT)), 'int&string&float'];
         yield [andT(intT, orT(stringT, floatT)), 'int&(string|float)'];
         yield [iterableT, 'iterable'];
-        yield [iterableT(), 'iterable'];
+        yield [iterableT(), 'iterable<mixed>'];
         yield [iterableT(value: stringT), 'iterable<string>'];
         yield [iterableT(stringT, intT), 'iterable<string, int>'];
         yield [callableT, 'callable'];
-        yield [callableT(), 'callable'];
+        yield [callableT(), 'callable(): mixed'];
         yield [callableT(return: UntypedT::T), 'callable(): untyped-mixed'];
         yield [callableT([template('T')]), 'callable<T>(): mixed'];
-        yield [callableT(return: callableT()), 'callable(): callable'];
+        yield [callableT(return: callableT()), 'callable(): (callable(): mixed)'];
         yield [callableT(return: voidT), 'callable(): void'];
         yield [callableT(params: [stringT]), 'callable(string): mixed'];
         yield [callableT(params: [param(type: stringT, default: true)]), 'callable(string=): mixed'];
@@ -192,9 +192,9 @@ public static function provideCases(): iterable
         yield [callableT(params: [param(type: stringT, byRef: true)]), 'callable(string&): mixed'];
         yield [callableT(params: [param(type: stringT, byRef: true, variadic: true)]), 'callable(string&...): mixed'];
         yield [callableT(params: [param('a', stringT, byRef: true, variadic: true)]), 'callable(string &...$a): mixed'];
-        yield [closureT(), 'Closure'];
+        yield [closureT(), 'Closure(): mixed'];
         yield [closureT([template('T')]), 'Closure<T>(): mixed'];
-        yield [closureT(return: closureT()), 'Closure(): Closure'];
+        yield [closureT(return: closureT()), 'Closure(): (Closure(): mixed)'];
         yield [closureT(return: voidT), 'Closure(): void'];
         yield [closureT(params: [stringT]), 'Closure(string): mixed'];
         yield [closureT(params: [param(type: stringT, default: true)]), 'Closure(string=): mixed'];
@@ -203,7 +203,7 @@ public static function provideCases(): iterable
         yield [closureT(params: [param(type: stringT, byRef: true)]), 'Closure(string&): mixed'];
         yield [closureT(params: [param(type: stringT, byRef: true, variadic: true)]), 'Closure(string&...): mixed'];
         yield [closureT(params: [param('a', stringT, byRef: true, variadic: true)]), 'Closure(string &...$a): mixed'];
-        yield [objectShapeT(), 'object'];
+        yield [objectShapeT(), 'object{}'];
         yield [objectShapeT(['name' => stringT]), 'object{name: string}'];
         yield [objectShapeT(['name' => optional(stringT)]), 'object{name?: string}'];
         yield [constantT('JSON_THROW_ON_ERROR'), 'const<JSON_THROW_ON_ERROR>'];
@@ -212,7 +212,7 @@ public static function provideCases(): iterable
         yield [classConstantMaskT(\stdClass::class, 'test_*'), 'stdClass::test_*'];
         yield [keyT(arrayT), 'key-of<array>'];
         yield [valueT(arrayT), 'value-of<array>'];
-        yield [offsetT(nonEmptyListT(), intT(0)), 'non-empty-list[0]'];
+        yield [offsetT(nonEmptyListT(), intT(0)), 'non-empty-list<mixed>[0]'];
         yield [ternaryT(trueT, then: intT, else: floatT), 'true ? int : float'];
         yield [isSubtypeT(trueT, mixedT), 'true is mixed'];
         yield [isSupertypeT(boolT, falseT), 'false is bool'];
@@ -222,8 +222,8 @@ public static function provideCases(): iterable
         yield [callableT([template('T', type: $T)], [$T], nullOrT($T)), 'callable<T>(T): (null|T)'];
         yield [callableT([template('T', scalarT, stringT, type: $T)], [$T], $T), 'callable<T of scalar super string>(T): T'];
         yield [objectT([template('T', type: $T)], [namedObjectT(\stdClass::class, [intT])], ['p' => $T]), 'object<T>:stdClass<int>{p: T}'];
-        yield [objectT([templateIn('I', default: intT), templateOut('O')]), 'object<in I = int, out O>'];
-        yield [objectT([template('T', type: $T), template('T2', $T)]), 'object<T, T2 of T>'];
+        yield [objectT([templateIn('I', default: intT), templateOut('O')]), 'object<in I = int, out O>{}'];
+        yield [objectT([template('T', type: $T), template('T2', $T)]), 'object<T, T2 of T>{}'];
     }
 
     #[DoesNotPerformAssertions]
@@ -231,4 +231,30 @@ public function testConstructorsCoverage(): void
     {
         iterator_to_array(self::provideCases(), preserve_keys: false);
     }
+
+    public function testItCanBeExtended(): void
+    {
+        $myStringify = new /** @extends Fallback<non-empty-string> */ class extends Fallback {
+            private readonly Stringify $stringify;
+
+            public function __construct()
+            {
+                $this->stringify = new Stringify(\WeakReference::create($this));
+            }
+
+            public function intT(IntT $type): string
+            {
+                return 'INT';
+            }
+
+            protected function fallback(Type $type): string
+            {
+                return $type->accept($this->stringify);
+            }
+        };
+
+        $string = listShapeT([listShapeT([intT])])->accept($myStringify);
+
+        self::assertSame('list{list{INT}}', $string);
+    }
 }