Import useful reflection classes

.github/workflows/continuous-integration.yml

@@ -32,7 +32,7 @@ jobs:
           restore-keys: "php-${{ matrix.php-version }}-composer-locked-"
 
       - name: "Install dependencies with composer"
-        run: "composer install --no-interaction --no-progress"
+        run: " COMPOSER_ROOT_VERSION=2.0 composer install --no-interaction --no-progress"
 
       - name: "Run a static analysis with vimeo/psalm"
         run: "vendor/bin/psalm --show-info=false --stats --output-format=github --threads=$(nproc)"

composer.json

@@ -24,12 +24,12 @@
         "doctrine/annotations": "^1.0",
         "doctrine/cache": "^1.0",
         "doctrine/collections": "^1.0",
-        "doctrine/event-manager": "^1.0",
-        "doctrine/reflection": "^1.2"
+        "doctrine/event-manager": "^1.0"
     },
     "require-dev": {
         "phpstan/phpstan": "^0.11",
         "doctrine/coding-standard": "^6.0",
+        "doctrine/common": "^3.0",
         "phpunit/phpunit": "^7.0 || ^8.0 || ^9.0",
         "vimeo/psalm": "^3.11"
     },

lib/Doctrine/Persistence/Mapping/RuntimeReflectionService.php

@@ -2,8 +2,8 @@
 
 namespace Doctrine\Persistence\Mapping;
 
-use Doctrine\Common\Reflection\RuntimePublicReflectionProperty;
-use Doctrine\Common\Reflection\TypedNoDefaultReflectionProperty;
+use Doctrine\Persistence\Reflection\RuntimePublicReflectionProperty;
+use Doctrine\Persistence\Reflection\TypedNoDefaultReflectionProperty;
 use ReflectionClass;
 use ReflectionException;
 use ReflectionMethod;

lib/Doctrine/Persistence/Reflection/RuntimePublicReflectionProperty.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Doctrine\Persistence\Reflection;
+
+use Doctrine\Common\Proxy\Proxy;
+use ReflectionProperty;
+
+/**
+ * PHP Runtime Reflection Public Property - special overrides for public properties.
+ */
+class RuntimePublicReflectionProperty extends ReflectionProperty
+{
+    /**
+     * {@inheritDoc}
+     *
+     * Checks is the value actually exist before fetching it.
+     * This is to avoid calling `__get` on the provided $object if it
+     * is a {@see \Doctrine\Common\Proxy\Proxy}.
+     */
+    public function getValue($object = null)
+    {
+        $name = $this->getName();
+
+        if ($object instanceof Proxy && ! $object->__isInitialized()) {
+            $originalInitializer = $object->__getInitializer();
+            $object->__setInitializer(null);
+            $val = $object->$name ?? null;
+            $object->__setInitializer($originalInitializer);
+
+            return $val;
+        }
+
+        return isset($object->$name) ? parent::getValue($object) : null;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Avoids triggering lazy loading via `__set` if the provided object
+     * is a {@see \Doctrine\Common\Proxy\Proxy}.
+     *
+     * @link https://bugs.php.net/bug.php?id=63463
+     */
+    public function setValue($object, $value = null)
+    {
+        if (! ($object instanceof Proxy && ! $object->__isInitialized())) {
+            parent::setValue($object, $value);
+
+            return;
+        }
+
+        $originalInitializer = $object->__getInitializer();
+        $object->__setInitializer(null);
+        parent::setValue($object, $value);
+        $object->__setInitializer($originalInitializer);
+    }
+}

lib/Doctrine/Persistence/Reflection/TypedNoDefaultReflectionProperty.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Doctrine\Persistence\Reflection;
+
+use ReflectionProperty;
+
+/**
+ * PHP Typed No Default Reflection Property - special override for typed properties without a default value.
+ */
+class TypedNoDefaultReflectionProperty extends ReflectionProperty
+{
+    /**
+     * {@inheritDoc}
+     *
+     * Checks that a typed property is initialized before accessing its value.
+     * This is necessary to avoid PHP error "Error: Typed property must not be accessed before initialization".
+     * Should be used only for reflecting typed properties without a default value.
+     */
+    public function getValue($object = null)
+    {
+        return $object !== null && $this->isInitialized($object) ? parent::getValue($object) : null;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Works around the problem with setting typed no default properties to
+     * NULL which is not supported, instead unset() to uninitialize.
+     *
+     * @link https://github.com/doctrine/orm/issues/7999
+     */
+    public function setValue($object, $value = null)
+    {
+        if ($value === null && $this->hasType() && ! $this->getType()->allowsNull()) {
+            $propertyName = $this->getName();
+
+            $unsetter = function () use ($propertyName) {
+                unset($this->$propertyName);
+            };
+            $unsetter = $unsetter->bindTo($object, $this->getDeclaringClass()->getName());
+            $unsetter();
+
+            return;
+        }
+
+        parent::setValue($object, $value);
+    }
+}

psalm.xml

@@ -13,4 +13,12 @@
             <directory name="vendor" />
         </ignoreFiles>
     </projectFiles>
+    <issueHandlers>
+        <RedundantCondition>
+            <errorLevel type="suppress">
+                <!-- see https://github.com/JetBrains/phpstorm-stubs/pull/877 -->
+                <file name="lib/Doctrine/Persistence/Reflection/TypedNoDefaultReflectionProperty.php"/>
+            </errorLevel>
+        </RedundantCondition>
+    </issueHandlers>
 </psalm>

tests/Doctrine/Tests/Persistence/Mapping/RuntimeReflectionServiceTest.php

@@ -2,9 +2,9 @@
 
 namespace Doctrine\Tests\Persistence\Mapping;
 
-use Doctrine\Common\Reflection\RuntimePublicReflectionProperty;
 use Doctrine\Persistence\Mapping\MappingException;
 use Doctrine\Persistence\Mapping\RuntimeReflectionService;
+use Doctrine\Persistence\Reflection\RuntimePublicReflectionProperty;
 use PHPUnit\Framework\TestCase;
 use ReflectionProperty;
 use function count;