Optimize isTooDeep() with delta scanning in DepthExclusionStrategy

Use three fast paths based on stack delta analysis to avoid full scans on every shouldSkipProperty()/shouldSkipClass() call. Same stack count retunrs cached result O(1). Stack shrunk and was not too deep O(1). Stack grew, no maxDepth on stack, not too deep, check only deltas O(delta). hasMaxDepthOnStack flag tracks if any maxDepth attributes exist on the stack. When false, growth never triggers full scan. When true or cazched result is too deep, the logic falls back to original full scan.

Author: NikoGrano

src/Exclusion/DepthExclusionStrategy.php

@@ -13,6 +13,10 @@
  */
 final class DepthExclusionStrategy implements ExclusionStrategyInterface
 {
+    private bool $cachedResult = false;
+    private int $cachedStackCount = -1;
+    private bool $hasMaxDepthOnStack = false;
+
     public function shouldSkipClass(ClassMetadata $metadata, Context $context): bool
     {
         return $this->isTooDeep($context);
@@ -25,24 +29,75 @@ public function shouldSkipProperty(PropertyMetadata $property, Context $context)
 
     private function isTooDeep(Context $context): bool
     {
+        $stack = $context->getMetadataStack();
+        $currentCount = $stack->count();
+
+        if ($currentCount === $this->cachedStackCount) {
+            return $this->cachedResult;
+        }
+
+        if ($currentCount < $this->cachedStackCount && !$this->cachedResult) {
+            $this->cachedStackCount = $currentCount;
+
+            return false;
+        }
+
+        if (!$this->hasMaxDepthOnStack && !$this->cachedResult && $currentCount > $this->cachedStackCount) {
+            $delta = $currentCount - $this->cachedStackCount;
+            $found = false;
+            $i = 0;
+            foreach ($stack as $metadata) {
+                if ($i >= $delta) {
+                    break;
+                }
+
+                if ($metadata instanceof PropertyMetadata && $metadata->maxDepth !== null) {
+                    $found = true;
+                    break;
+                }
+
+                $i++;
+            }
+
+            if (!$found) {
+                $this->cachedStackCount = $currentCount;
+
+                return false;
+            }
+        }
+
+        // Full scan
         $relativeDepth = 0;
+        $top = $currentCount > 0 ? $stack->top() : null;
+        $foundMaxDepth = false;
 
-        foreach ($context->getMetadataStack() as $metadata) {
+        foreach ($stack as $metadata) {
             if (!$metadata instanceof PropertyMetadata) {
                 continue;
             }
 
             $relativeDepth++;
 
-            if (0 === $metadata->maxDepth && $context->getMetadataStack()->top() === $metadata) {
+            if (null !== $metadata->maxDepth) {
+                $foundMaxDepth = true;
+            }
+
+            if (0 === $metadata->maxDepth && $top === $metadata) {
                 continue;
             }
 
             if (null !== $metadata->maxDepth && $relativeDepth > $metadata->maxDepth) {
+                $this->cachedResult = true;
+                $this->cachedStackCount = $currentCount;
+
                 return true;
             }
         }
 
+        $this->hasMaxDepthOnStack = $foundMaxDepth;
+        $this->cachedResult = false;
+        $this->cachedStackCount = $currentCount;
+
         return false;
     }
 }

tests/Fixtures/MaxDepth/SiblingMaxDepthChild.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace JMS\Serializer\Tests\Fixtures\MaxDepth;
+
+class SiblingMaxDepthChild
+{
+    public string $name;
+
+    public ?SiblingMaxDepthChild $child = null;
+
+    public function __construct(string $name)
+    {
+        $this->name = $name;
+    }
+}

tests/Fixtures/MaxDepth/SiblingMaxDepthParent.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace JMS\Serializer\Tests\Fixtures\MaxDepth;
+
+use JMS\Serializer\Annotation as Serializer;
+
+class SiblingMaxDepthParent
+{
+    #[Serializer\MaxDepth(depth: 3)]
+    public SiblingMaxDepthChild $deep;
+
+    #[Serializer\MaxDepth(depth: 1)]
+    public SiblingMaxDepthChild $shallow;
+
+    public function __construct()
+    {
+        $this->deep = new SiblingMaxDepthChild('deep');
+        $this->shallow = new SiblingMaxDepthChild('shallow');
+    }
+}

tests/Serializer/BaseSerializationTestCase.php

@@ -87,6 +87,8 @@
 use JMS\Serializer\Tests\Fixtures\MaxDepth\Gh1382Baz;
 use JMS\Serializer\Tests\Fixtures\MaxDepth\Gh1382Foo;
 use JMS\Serializer\Tests\Fixtures\MaxDepth\Gh236Foo;
+use JMS\Serializer\Tests\Fixtures\MaxDepth\SiblingMaxDepthChild;
+use JMS\Serializer\Tests\Fixtures\MaxDepth\SiblingMaxDepthParent;
 use JMS\Serializer\Tests\Fixtures\NamedDateTimeArraysObject;
 use JMS\Serializer\Tests\Fixtures\NamedDateTimeImmutableArraysObject;
 use JMS\Serializer\Tests\Fixtures\Node;
@@ -1853,6 +1855,20 @@ public function testMaxDepthWithOneDepthObject()
         self::assertEquals(static::getContent('maxdepth_1'), $serialized);
     }
 
+    public function testMaxDepthWithSiblingDifferentDepths()
+    {
+        $data = new SiblingMaxDepthParent();
+        $data->deep->child = new SiblingMaxDepthChild('deep_1');
+        $data->deep->child->child = new SiblingMaxDepthChild('deep_2');
+        $data->shallow->child = new SiblingMaxDepthChild('shallow_1');
+        $data->shallow->child->child = new SiblingMaxDepthChild('shallow_2');
+
+        $context = SerializationContext::create()->enableMaxDepthChecks();
+        $serialized = $this->serialize($data, $context);
+
+        self::assertEquals(static::getContent('maxdepth_sibling'), $serialized);
+    }
+
     public function testDeserializingIntoExistingObject()
     {
         if (!$this->hasDeserializer()) {

tests/Serializer/JsonSerializationTest.php

@@ -130,6 +130,7 @@ protected static function getContent($key)
             $outputs['maxdepth_skippable_object'] = '{"a":{"xxx":"yyy"}}';
             $outputs['maxdepth_0'] = '{"a":{}}';
             $outputs['maxdepth_1'] = '{"a":{"b":12345}}';
+            $outputs['maxdepth_sibling'] = '{"deep":{"name":"deep","child":{"name":"deep_1","child":{"name":"deep_2"}}},"shallow":{"name":"shallow"}}';
             $outputs['array_objects_nullable'] = '[]';
             $outputs['type_casting'] = '{"as_string":"8"}';
             $outputs['authors_inline'] = '[{"full_name":"foo"},{"full_name":"bar"}]';

tests/Serializer/xml/maxdepth_sibling.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<result>
+  <deep>
+    <name><![CDATA[deep]]></name>
+    <child>
+      <name><![CDATA[deep_1]]></name>
+      <child>
+        <name><![CDATA[deep_2]]></name>
+      </child>
+    </child>
+  </deep>
+  <shallow>
+    <name><![CDATA[shallow]]></name>
+  </shallow>
+</result>