Add CachingParser decorator for in-memory type parsing cache

Types like "string", "DateTime<'Y-m-d'>", "array<MyClass>" are re-parsed on every serialize/deserialize call. Cache eliminates redudant lexer/parser work. Wired as default in SerializerBuilder; users calling setTypeParser() still override entirely.

Author: NikoGrano

src/SerializerBuilder.php

@@ -42,6 +42,7 @@
 use JMS\Serializer\Naming\CamelCaseNamingStrategy;
 use JMS\Serializer\Naming\PropertyNamingStrategyInterface;
 use JMS\Serializer\Naming\SerializedNameAnnotationStrategy;
+use JMS\Serializer\Type\CachingParser;
 use JMS\Serializer\Type\Parser;
 use JMS\Serializer\Type\ParserInterface;
 use JMS\Serializer\Visitor\Factory\DeserializationVisitorFactory;
@@ -198,7 +199,7 @@ public static function create(...$args): self
 
     public function __construct(?HandlerRegistryInterface $handlerRegistry = null, ?EventDispatcherInterface $eventDispatcher = null)
     {
-        $this->typeParser = new Parser();
+        $this->typeParser = new CachingParser(new Parser());
         $this->handlerRegistry = $handlerRegistry ?: new HandlerRegistry();
         $this->eventDispatcher = $eventDispatcher ?: new EventDispatcher();
         $this->serializationVisitors = [];

src/Type/CachingParser.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace JMS\Serializer\Type;
+
+/**
+ * @internal
+ */
+final class CachingParser implements ParserInterface
+{
+    /**
+     * @var ParserInterface
+     */
+    private $inner;
+
+    /**
+     * @var array<string, array>
+     */
+    private $cache = [];
+
+    public function __construct(ParserInterface $inner)
+    {
+        $this->inner = $inner;
+    }
+
+    public function parse(string $type): array
+    {
+        return $this->cache[$type] ?? $this->cache[$type] = $this->inner->parse($type);
+    }
+}

tests/Serializer/Type/CachingParserTest.php

@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+namespace JMS\Serializer\Tests\Serializer\Type;
+
+use JMS\Serializer\Type\CachingParser;
+use JMS\Serializer\Type\Parser;
+use JMS\Serializer\Type\ParserInterface;
+use PHPUnit\Framework\TestCase;
+
+class CachingParserTest extends TestCase
+{
+    /** @var CachingParser */
+    private $parser;
+
+    protected function setUp(): void
+    {
+        $this->parser = new CachingParser(new Parser());
+    }
+
+    public function testReturnsSameResultAsInnerParser(): void
+    {
+        $inner = new Parser();
+        $cached = new CachingParser($inner);
+
+        $types = [
+            'string',
+            'int',
+            'array<Foo>',
+            'array<string, int>',
+            'DateTime<\'Y-m-d\'>',
+            'Foo<Bar<Baz>>',
+        ];
+
+        foreach ($types as $type) {
+            self::assertSame($inner->parse($type), $cached->parse($type), sprintf('Mismatch for type "%s"', $type));
+        }
+    }
+
+    public function testCachesResults(): void
+    {
+        $inner = $this->createMock(ParserInterface::class);
+        $inner->expects(self::once())
+            ->method('parse')
+            ->with('string')
+            ->willReturn(['name' => 'string', 'params' => []]);
+
+        $cached = new CachingParser($inner);
+
+        $result1 = $cached->parse('string');
+        $result2 = $cached->parse('string');
+
+        self::assertSame($result1, $result2);
+    }
+
+    public function testDifferentTypesAreNotConfused(): void
+    {
+        $result1 = $this->parser->parse('string');
+        $result2 = $this->parser->parse('int');
+
+        self::assertSame(['name' => 'string', 'params' => []], $result1);
+        self::assertSame(['name' => 'int', 'params' => []], $result2);
+    }
+
+    public function testComplexTypesAreCached(): void
+    {
+        $type = 'DateTime<\'Y-m-d\', \'UTC\'>';
+        $result1 = $this->parser->parse($type);
+        $result2 = $this->parser->parse($type);
+
+        self::assertSame($result1, $result2);
+        self::assertSame('DateTime', $result1['name']);
+        self::assertCount(2, $result1['params']);
+    }
+}