Merge pull request #37 from doctrine/GH-36-BugfixTypedNullable

[GH-36] Bugfix: TypedNoDefaultReflectionProperty::setValue NULL when null allowed

.doctrine-project.json

@@ -5,14 +5,26 @@
     "docsSlug": "doctrine-reflection",
     "versions": [
         {
-            "name": "1.0",
+            "name": "1.2",
             "branchName": "master",
             "slug": "latest",
+            "upcoming": true
+        },
+        {
+            "name": "1.1",
+            "branchName": "1.1.x",
+            "slug": "1.1",
             "current": true,
             "aliases": [
                 "current",
                 "stable"
             ]
+        },
+        {
+            "name": "1.0",
+            "branchName": "1.0",
+            "slug": "1.0",
+            "maintained": false
         }
     ]
 }

.gitattributes

@@ -1,3 +1,4 @@
+/docs export-ignore
 /tests export-ignore
 /.gitattributes export-ignore
 /.gitignore export-ignore

.scrutinizer.yml

@@ -16,7 +16,7 @@ build:
                     - phpcs-run
     dependencies:
         override:
-            - composer install -noa
+            - COMPOSER_ROOT_VERSION=1.2 composer install -noa
 
 tools:
     external_code_coverage:

.travis.yml

@@ -2,6 +2,10 @@ dist: trusty
 sudo: false
 language: php
 
+env:
+  global:
+    - COMPOSER_ROOT_VERSION=1.2
+
 cache:
   directories:
     - $HOME/.composer/cache

composer.json

@@ -44,7 +44,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "1.0.x-dev"
+            "dev-master": "1.2.x-dev"
         }
     }
 }

lib/Doctrine/Common/Reflection/StaticReflectionParser.php

@@ -19,7 +19,6 @@ use const T_VAR;
 use const T_VARIABLE;
 use function array_merge;
 use function file_get_contents;
-use function is_array;
 use function ltrim;
 use function preg_match;
 use function sprintf;
@@ -190,9 +189,6 @@ class StaticReflectionParser implements ReflectionProviderInterface
                     while (($token = $tokenParser->next()) && $token[0] !== T_STRING) {
                         continue;
                     }
-                    if ($token === null) {
-                        break;
-                    }
                     $methodName                              = $token[1];
                     $this->docComment['method'][$methodName] = $docComment;
                     $docComment                              = '';
@@ -226,7 +222,7 @@ class StaticReflectionParser implements ReflectionProviderInterface
                     break;
             }
 
-            $last_token = is_array($token) ? $token[0] : false;
+            $last_token = $token[0];
         }
     }
 

lib/Doctrine/Common/Reflection/TypedNoDefaultReflectionProperty.php

@@ -13,11 +13,36 @@ 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".
+     * This is neccessary 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);
+    }
 }

tests/Doctrine/Tests_PHP74/Common/Reflection/Dummies/TokenParserAnonymousFunctionTestClass.php

@@ -1,13 +0,0 @@
-<?php
-
-namespace Doctrine\Tests_PHP74\Common\Reflection\Dummies;
-
-trait TokenParserAnonymousFunctionTestClass
-{
-    protected function method()
-    {
-        return static function ($value) {
-            return $value;
-        };
-    }
-}

tests/Doctrine/Tests_PHP74/Common/Reflection/TokenParserAnonymousFunctionTest.php

@@ -1,24 +0,0 @@
-<?php
-
-namespace Doctrine\Tests_PHP74\Common\Reflection;
-
-use Doctrine\Common\Reflection\Psr0FindFile;
-use Doctrine\Common\Reflection\StaticReflectionParser;
-use Doctrine\Tests_PHP74\Common\Reflection\Dummies\TokenParserAnonymousFunctionTestClass;
-use PHPUnit\Framework\TestCase;
-use function strlen;
-use function substr;
-
-class TokenParserAnonymousFunctionTest extends TestCase
-{
-    public function testGetValue() : void
-    {
-        $testsRoot              = substr(__DIR__, 0, -strlen(__NAMESPACE__) - 1);
-        $paths                  = [
-            'Doctrine\\Tests_PHP74' => [$testsRoot],
-        ];
-        $staticReflectionParser = new StaticReflectionParser(TokenParserAnonymousFunctionTestClass::class, new Psr0FindFile($paths));
-
-        self::assertEquals('', $staticReflectionParser->getDocComment());
-    }
-}

tests/Doctrine/Tests_PHP74/Common/Reflection/TypedNoDefaultReflectionPropertyTest.php

@@ -23,9 +23,64 @@ class TypedNoDefaultReflectionPropertyTest extends TestCase
 
         self::assertNull($reflProperty->getValue($object));
     }
+
+    public function testSetValueNull() : void
+    {
+        $reflection = new TypedNoDefaultReflectionProperty(TypedFoo::class, 'id');
+        $reflection->setAccessible(true);
+
+        $object = new TypedFoo();
+        $object->setId(1);
+
+        self::assertTrue($reflection->isInitialized($object));
+
+        $reflection->setValue($object, null);
+
+        self::assertNull($reflection->getValue($object));
+        self::assertFalse($reflection->isInitialized($object));
+    }
+
+    public function testSetValueNullOnNullableProperty() : void
+    {
+        $reflection = new TypedNoDefaultReflectionProperty(TypedNullableFoo::class, 'value');
+        $reflection->setAccessible(true);
+
+        $object = new TypedNullableFoo();
+
+        $reflection->setValue($object, null);
+
+        self::assertNull($reflection->getValue($object));
+        self::assertTrue($reflection->isInitialized($object));
+        self::assertNull($object->getValue());
+    }
 }
 
 class TypedNoDefaultReflectionPropertyTestClass
 {
     public string $test;
 }
+
+class TypedFoo
+{
+    private int $id;
+
+    public function setId($id)
+    {
+        $this->id = $id;
+    }
+}
+
+class TypedNullableFoo
+{
+    private ?string $value;
+
+    public function setValue($value)
+    {
+        $this->value = $value;
+    }
+
+    public function getValue()
+    {
+        return $this->value;
+    }
+}