Fix cloning entities when using lazy-ghost proxies

nicolas-grekas · nicolas-grekas · commit b6d9ce684c6c · 2023-07-06T14:28:12.000+02:00
diff --git a/lib/Doctrine/ORM/Proxy/ProxyFactory.php b/lib/Doctrine/ORM/Proxy/ProxyFactory.php
@@ -48,13 +48,12 @@ class <proxyShortClassName> extends \<className> implements \<baseProxyInterface
 {
     <useLazyGhostTrait>
 
-    /**
-     * @internal
-     */
-    public bool $__isCloning = false;
-
-    public function __construct(?\Closure $initializer = null)
+    public function __construct(?\Closure $initializer = null, ?\Closure $cloner = null)
     {
+        if ($cloner !== null) {
+            return;
+        }
+
         self::createLazyGhost($initializer, <skippedProperties>, $this);
     }
 
@@ -63,17 +62,6 @@ public function __isInitialized(): bool
         return isset($this->lazyObjectState) && $this->isLazyObjectInitialized();
     }
 
-    public function __clone()
-    {
-        $this->__isCloning = true;
-
-        try {
-            $this->__doClone();
-        } finally {
-            $this->__isCloning = false;
-        }
-    }
-
     public function __serialize(): array
     {
         <serializeImpl>
@@ -98,6 +86,9 @@ public function __serialize(): array
      */
     private $identifierFlattener;
 
+    /** @var ProxyDefinition[] */
+    private $definitions = [];
+
     /**
      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
      * connected to the given <tt>EntityManager</tt>.
@@ -131,6 +122,21 @@ public function __construct(EntityManagerInterface $em, $proxyDir, $proxyNs, $au
         $this->identifierFlattener = new IdentifierFlattener($this->uow, $em->getMetadataFactory());
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public function getProxy($className, array $identifier)
+    {
+        $proxy       = parent::getProxy($className, $identifier);
+        $initializer = $this->definitions[$className]->initializer;
+
+        $proxy->__construct(static function (Proxy $object) use ($initializer, $proxy): void {
+            $initializer($object, $proxy);
+        });
+
+        return $proxy;
+    }
+
     /**
      * {@inheritDoc}
      */
@@ -158,7 +164,7 @@ protected function createProxyDefinition($className)
             $cloner      = $this->createCloner($classMetadata, $entityPersister);
         }
 
-        return new ProxyDefinition(
+        return $this->definitions[$className] = new ProxyDefinition(
             ClassUtils::generateProxyClassName($className, $this->proxyNs),
             $classMetadata->getIdentifierFieldNames(),
             $classMetadata->getReflectionProperties(),
@@ -237,9 +243,9 @@ private function createInitializer(ClassMetadata $classMetadata, EntityPersister
      */
     private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
     {
-        return function (Proxy $proxy) use ($entityPersister, $classMetadata): void {
-            $identifier = $classMetadata->getIdentifierValues($proxy);
-            $entity     = $entityPersister->loadById($identifier, $proxy->__isCloning ? null : $proxy);
+        return function (Proxy $proxy, Proxy $original) use ($entityPersister, $classMetadata): void {
+            $identifier = $classMetadata->getIdentifierValues($original);
+            $entity     = $entityPersister->loadById($identifier, $original);
 
             if ($entity === null) {
                 throw EntityNotFoundException::fromClassNameAndIdentifier(
@@ -248,7 +254,7 @@ private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersi
                 );
             }
 
-            if (! $proxy->__isCloning) {
+            if ($proxy === $original) {
                 return;
             }
 
@@ -315,15 +321,14 @@ private function generateUseLazyGhostTrait(ClassMetadata $class): string
             isLazyObjectInitialized as private;
             createLazyGhost as private;
             resetLazyObject as private;
-            __clone as private __doClone;
         }'), $code);
 
         return $code;
     }
 
     private function generateSkippedProperties(ClassMetadata $class): string
     {
-        $skippedProperties = ['__isCloning' => true];
+        $skippedProperties = [];
         $identifiers       = array_flip($class->getIdentifierFieldNames());
         $filter            = ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED | ReflectionProperty::IS_PRIVATE;
         $reflector         = $class->getReflectionClass();
diff --git a/tests/Doctrine/Tests/ORM/Proxy/ProxyFactoryTest.php b/tests/Doctrine/Tests/ORM/Proxy/ProxyFactoryTest.php
@@ -5,7 +5,6 @@
 namespace Doctrine\Tests\ORM\Proxy;
 
 use Doctrine\Common\EventManager;
-use Doctrine\Common\Proxy\Proxy as CommonProxy;
 use Doctrine\DBAL\Connection;
 use Doctrine\DBAL\Platforms\AbstractPlatform;
 use Doctrine\ORM\EntityNotFoundException;
@@ -227,21 +226,12 @@ public function testProxyClonesParentFields(): void
             ->expects(self::atLeastOnce())
             ->method('loadById');
 
-        if ($proxy instanceof CommonProxy) {
-            $loadByIdMock->willReturn($companyEmployee);
+        $loadByIdMock->willReturn($companyEmployee);
 
-            $persister
-                ->expects(self::atLeastOnce())
-                ->method('getClassMetadata')
-                ->willReturn($classMetaData);
-        } else {
-            $loadByIdMock->willReturnCallback(static function (array $id, CompanyEmployee $companyEmployee) {
-                $companyEmployee->setSalary(1000); // A property on the CompanyEmployee
-                $companyEmployee->setName('Bob'); // A property on the parent class, CompanyPerson
-
-                return $companyEmployee;
-            });
-        }
+        $persister
+            ->expects(self::atLeastOnce())
+            ->method('getClassMetadata')
+            ->willReturn($classMetaData);
 
         $cloned = clone $proxy;
         assert($cloned instanceof CompanyEmployee);
