bug symfony#59646 [JsonStreamer] Max depth handling and JSON errors (mtarld)

This PR was merged into the 7.3 branch.

Discussion
----------

[JsonStreamer] Max depth handling and JSON errors

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

Until now, max depth was handled like the following:
1. Creating a  `DataModelNodeInterface` that is at most 512 deep, and adding a `ExceptionNode` when this depth is reached.
1. Generating an encoder based on that tree, that adds a throw line whenever encountering an `ExceptionNode`.

But this approach creates some issues:
- When encoding an object that has a property containing a 512 deep "json encodable data" such as a very nested array, this won't throw any exception even though the encoded data is 513 deep.
- The generated encoders are very big files in case of self-referencing objects:
```php
return static function (mixed $data, \Psr\Container\ContainerInterface $normalizers, array $options): \Traversable {
    yield '{"self":';
    if (null === $data->self) {
        yield 'null';
    } else {
		yield '{"self":';
		if (null === $data->self->self) {
        	yield 'null';
	    } else {
			// 510 more times until we throw an exception
		}
  		yield '}';
	}
  	yield '}';
};
```
- The created `DataModelNodeInterface` contains useless repeated nodes and is memory-consuming in case of self-referencing objects.
---
This PR fixes these issues by using another approach:
- Creating "ghost objects" when encountering an already seen object while constructing a `DataModelNodeInterface` (like what is done for decoding). These ghosts will prevent nodes to be repeated.
- Creating "generators" callable in the encoders that are responsible to encode these ghost objects. In that way, encoder PHP files will be way lighter (and will be generated faster, for example the test suite went from `00:03.877` to `00:00.122`).
```php
return static function (mixed $data, \Psr\Container\ContainerInterface $normalizers, array $options): \Traversable {
    $generators['Foo'] = static function ($data, $depth) use ($normalizers, $options, &$generators) {
        if ($depth >= 512) {
            throw new NotEncodableValueException('Maximum stack depth exceeded');
        }
        yield '{"`@self`":';
        if ($data->self instanceof Foo) {
            yield from $generators['Foo']($data->self, $depth + 1);
        } else (null === $data->self) {
            yield 'null';
        }
        yield '}';
    };
    yield from $generators['Foo']($data, 0);
};
```
- Use these generators only for ghost objects, as calling functions costs a bit in terms of performances.
- Specify the proper depth in `json_encode` depending on the current depth:
```php
return static function (mixed $data, \Psr\Container\ContainerInterface $normalizers, array $options): \Traversable {
    yield '{"`@id`":';
    yield \json_encode($data->id, depth: 511);
    yield '}';
};
```
---
Moreover, JSON encoding errors were not gathered at all.

That's why this PR updates the `json_encode` call to use the `JSON_THROW_ON_ERROR` flag, and catches/convert the resulting exceptions to `NotEncodableValueException`:
```php
return static function (mixed $data, \Psr\Container\ContainerInterface $normalizers, array $options): \Traversable {
    try {
        yield \json_encode($data, \JSON_THROW_ON_ERROR, 512);
    } catch (\JsonException $e) {
        throw new \Symfony\Component\JsonEncoder\Exception\NotEncodableValueException($e->getMessage(), 0, $e);
    }
};
```
And the `MaxDepthException` has been converted to a `NotEncodableValueException` with the `"Maximum stack depth exceeded"` message to be the same as the native `json_encode` max depth exception.

Commits
-------

fb7fac1 [JsonEncoder] Fix max depth handling and json errors

Author: fabpot

src/Symfony/Component/JsonStreamer/DataModel/FunctionDataAccessor.php

@@ -33,6 +33,16 @@ public function __construct(
     ) {
     }
 
+    public function getObjectAccessor(): ?DataAccessorInterface
+    {
+        return $this->objectAccessor;
+    }
+
+    public function withObjectAccessor(?DataAccessorInterface $accessor): self
+    {
+        return new self($this->functionName, $this->arguments, $accessor);
+    }
+
     public function toPhpExpr(): Expr
     {
         $builder = new BuilderFactory();

src/Symfony/Component/JsonStreamer/DataModel/PropertyDataAccessor.php

@@ -29,6 +29,16 @@ public function __construct(
     ) {
     }
 
+    public function getObjectAccessor(): DataAccessorInterface
+    {
+        return $this->objectAccessor;
+    }
+
+    public function withObjectAccessor(DataAccessorInterface $accessor): self
+    {
+        return new self($accessor, $this->propertyName);
+    }
+
     public function toPhpExpr(): Expr
     {
         return (new BuilderFactory())->propertyFetch($this->objectAccessor->toPhpExpr(), $this->propertyName);

src/Symfony/Component/JsonStreamer/DataModel/Read/ObjectNode.php

@@ -30,11 +30,11 @@ final class ObjectNode implements DataModelNodeInterface
     public function __construct(
         private ObjectType $type,
         private array $properties,
-        private bool $ghost = false,
+        private bool $mock = false,
     ) {
     }
 
-    public static function createGhost(ObjectType|UnionType $type): self
+    public static function createMock(ObjectType|UnionType $type): self
     {
         return new self($type, [], true);
     }
@@ -57,8 +57,8 @@ public function getProperties(): array
         return $this->properties;
     }
 
-    public function isGhost(): bool
+    public function isMock(): bool
     {
-        return $this->ghost;
+        return $this->mock;
     }
 }

src/Symfony/Component/JsonStreamer/DataModel/Write/BackedEnumNode.php

@@ -31,6 +31,16 @@ public function __construct(
     ) {
     }
 
+    public function withAccessor(DataAccessorInterface $accessor): self
+    {
+        return new self($accessor, $this->type);
+    }
+
+    public function getIdentifier(): string
+    {
+        return (string) $this->getType();
+    }
+
     public function getAccessor(): DataAccessorInterface
     {
         return $this->accessor;

src/Symfony/Component/JsonStreamer/DataModel/Write/CollectionNode.php

@@ -30,6 +30,16 @@ public function __construct(
     ) {
     }
 
+    public function withAccessor(DataAccessorInterface $accessor): self
+    {
+        return new self($accessor, $this->type, $this->item);
+    }
+
+    public function getIdentifier(): string
+    {
+        return (string) $this->getType();
+    }
+
     public function getAccessor(): DataAccessorInterface
     {
         return $this->accessor;

src/Symfony/Component/JsonStreamer/DataModel/Write/CompositeNode.php

@@ -60,6 +60,16 @@ public function __construct(
         $this->nodes = $nodes;
     }
 
+    public function withAccessor(DataAccessorInterface $accessor): self
+    {
+        return new self($accessor, array_map(static fn (DataModelNodeInterface $n): DataModelNodeInterface => $n->withAccessor($accessor), $this->nodes));
+    }
+
+    public function getIdentifier(): string
+    {
+        return (string) $this->getType();
+    }
+
     public function getAccessor(): DataAccessorInterface
     {
         return $this->accessor;

src/Symfony/Component/JsonStreamer/DataModel/Write/DataModelNodeInterface.php

@@ -23,7 +23,11 @@
  */
 interface DataModelNodeInterface
 {
+    public function getIdentifier(): string;
+
     public function getType(): Type;
 
     public function getAccessor(): DataAccessorInterface;
+
+    public function withAccessor(DataAccessorInterface $accessor): self;
 }

src/Symfony/Component/JsonStreamer/DataModel/Write/ExceptionNode.php

@@ -12,6 +12,8 @@
 namespace Symfony\Component\JsonStreamer\DataModel\Write;
 
 use Symfony\Component\JsonStreamer\DataModel\DataAccessorInterface;
+use Symfony\Component\JsonStreamer\DataModel\FunctionDataAccessor;
+use Symfony\Component\JsonStreamer\DataModel\PropertyDataAccessor;
 use Symfony\Component\TypeInfo\Type\ObjectType;
 
 /**
@@ -30,9 +32,36 @@ public function __construct(
         private DataAccessorInterface $accessor,
         private ObjectType $type,
         private array $properties,
+        private bool $mock = false,
     ) {
     }
 
+    public static function createMock(DataAccessorInterface $accessor, ObjectType $type): self
+    {
+        return new self($accessor, $type, [], true);
+    }
+
+    public function withAccessor(DataAccessorInterface $accessor): self
+    {
+        $properties = [];
+        foreach ($this->properties as $key => $property) {
+            $propertyAccessor = $property->getAccessor();
+
+            if ($propertyAccessor instanceof PropertyDataAccessor || $propertyAccessor instanceof FunctionDataAccessor && $propertyAccessor->getObjectAccessor()) {
+                $propertyAccessor = $propertyAccessor->withObjectAccessor($accessor);
+            }
+
+            $properties[$key] = $property->withAccessor($propertyAccessor);
+        }
+
+        return new self($accessor, $this->type, $properties, $this->mock);
+    }
+
+    public function getIdentifier(): string
+    {
+        return (string) $this->getType();
+    }
+
     public function getAccessor(): DataAccessorInterface
     {
         return $this->accessor;
@@ -50,4 +79,9 @@ public function getProperties(): array
     {
         return $this->properties;
     }
+
+    public function isMock(): bool
+    {
+        return $this->mock;
+    }
 }

src/Symfony/Component/JsonStreamer/DataModel/Write/ObjectNode.php

@@ -31,6 +31,16 @@ public function __construct(
     ) {
     }
 
+    public function withAccessor(DataAccessorInterface $accessor): self
+    {
+        return new self($accessor, $this->type);
+    }
+
+    public function getIdentifier(): string
+    {
+        return (string) $this->getType();
+    }
+
     public function getAccessor(): DataAccessorInterface
     {
         return $this->accessor;