Support for non-nullable typed properties

src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/BindProxyProperties.php

@@ -6,13 +6,14 @@
 
 use Laminas\Code\Generator\ParameterGenerator;
 use Laminas\Code\Generator\PropertyGenerator;
-use ProxyManager\Exception\UnsupportedProxiedClassException;
 use ProxyManager\Generator\MethodGenerator;
 use ProxyManager\ProxyGenerator\Util\Properties;
 use ReflectionClass;
 
 use function implode;
-use function var_export;
+use function sprintf;
+
+use const PHP_EOL;
 
 /**
  * The `bindProxyProperties` method implementation for access interceptor scope localizers
@@ -42,38 +43,19 @@ public function __construct(
             . '@param \\Closure[] $suffixInterceptors method interceptors to be used before method logic'
         );
 
-        $localizedProperties        = [];
-        $properties                 = Properties::fromReflectionClass($originalClass);
-        $nonReferenceableProperties = $properties
-            ->onlyNonReferenceableProperties()
-            ->onlyInstanceProperties();
+        $properties = Properties::fromReflectionClass($originalClass);
 
-        if (! $nonReferenceableProperties->empty()) {
-            throw UnsupportedProxiedClassException::nonReferenceableLocalizedReflectionProperties(
-                $originalClass,
-                $nonReferenceableProperties
+        $bodyLines = ['$class = new \ReflectionObject($localizedObject);'];
+        foreach ($properties->getInstanceProperties() as $property) {
+            $bodyLines[] = sprintf(
+                '$this->bindProxyProperty($localizedObject, $class, \'%s\');',
+                $property->getName()
             );
         }
 
-        foreach ($properties->getAccessibleProperties() as $property) {
-            $propertyName = $property->getName();
-
-            $localizedProperties[] = '$this->' . $propertyName . ' = & $localizedObject->' . $propertyName . ';';
-        }
-
-        foreach ($properties->getPrivateProperties() as $property) {
-            $propertyName = $property->getName();
+        $bodyLines[] = sprintf('$this->%s = $prefixInterceptors;', $prefixInterceptors->getName());
+        $bodyLines[] = sprintf('$this->%s = $suffixInterceptors;', $suffixInterceptors->getName());
 
-            $localizedProperties[] = "\\Closure::bind(function () use (\$localizedObject) {\n    "
-                . '$this->' . $propertyName . ' = & $localizedObject->' . $propertyName . ";\n"
-                . '}, $this, ' . var_export($property->getDeclaringClass()->getName(), true)
-                . ')->__invoke();';
-        }
-
-        $this->setBody(
-            ($localizedProperties ? implode("\n\n", $localizedProperties) . "\n\n" : '')
-            . '$this->' . $prefixInterceptors->getName() . " = \$prefixInterceptors;\n"
-            . '$this->' . $suffixInterceptors->getName() . ' = $suffixInterceptors;'
-        );
+        $this->setBody(implode(PHP_EOL, $bodyLines));
     }
 }

src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/BindProxyProperty.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator;
+
+use Laminas\Code\Generator\ParameterGenerator;
+use ProxyManager\Exception\UnsupportedProxiedClassException;
+use ProxyManager\Generator\MethodGenerator;
+use ReflectionClass;
+
+use function strtr;
+
+class BindProxyProperty extends MethodGenerator
+{
+    public function __construct(ReflectionClass $originalClass)
+    {
+        parent::__construct(
+            'bindProxyProperty',
+            [
+                new ParameterGenerator('localizedObject', $originalClass->getName()),
+                new ParameterGenerator('class', ReflectionClass::class),
+                new ParameterGenerator('propertyName', 'string'),
+            ],
+            self::FLAG_PRIVATE
+        );
+
+        $bodyTemplate = <<<'CODE'
+        $originalClass = $class;
+        while (! $class->hasProperty($propertyName)) {
+            $class = $class->getParentClass();
+        }
+        $property = $class->getProperty($propertyName);
+        $property->setAccessible(true);
+        if (!$property->isInitialized($localizedObject)) {
+            throw new \{ EXCEPTION_CLASS }(
+                sprintf(
+                    'Cannot create reference for property $%s of class %s: property must be initialized',
+                    $property->getName(),
+                    $originalClass->getName()
+                )
+            );
+        }
+        if (!$property->isPrivate()) {
+            $this->{$propertyName} = & $localizedObject->{$propertyName};
+            return;
+        }
+
+        \Closure::bind(
+            function () use ($localizedObject, $propertyName) {
+                $this->{$propertyName} = & $localizedObject->{$propertyName};
+            },
+            $this,
+            $property->getDeclaringClass()->getName()
+        )->__invoke();
+        CODE;
+
+        $this->setBody(
+            strtr(
+                $bodyTemplate,
+                ['{ EXCEPTION_CLASS }' => UnsupportedProxiedClassException::class]
+            )
+        );
+    }
+}

src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizerGenerator.php

@@ -16,6 +16,7 @@
 use ProxyManager\ProxyGenerator\AccessInterceptor\PropertyGenerator\MethodPrefixInterceptors;
 use ProxyManager\ProxyGenerator\AccessInterceptor\PropertyGenerator\MethodSuffixInterceptors;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\BindProxyProperties;
+use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\BindProxyProperty;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\InterceptedMethod;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\MagicClone;
 use ProxyManager\ProxyGenerator\AccessInterceptorScopeLocalizer\MethodGenerator\MagicGet;
@@ -71,6 +72,7 @@ static function (MethodGenerator $generatedMethod) use ($originalClass, $classGe
                 ),
                 [
                     new StaticProxyConstructor($originalClass),
+                    new BindProxyProperty($originalClass),
                     new BindProxyProperties($originalClass, $prefixInterceptors, $suffixInterceptors),
                     new SetMethodPrefixInterceptor($prefixInterceptors),
                     new SetMethodSuffixInterceptor($suffixInterceptors),

tests/ProxyManagerTest/Functional/AccessInterceptorScopeLocalizerFunctionalTest.php

@@ -18,6 +18,7 @@
 use ProxyManagerTestAsset\ClassWithDynamicArgumentsMethod;
 use ProxyManagerTestAsset\ClassWithMethodWithByRefVariadicFunction;
 use ProxyManagerTestAsset\ClassWithMethodWithVariadicFunction;
+use ProxyManagerTestAsset\ClassWithNonNullableTypedProperties;
 use ProxyManagerTestAsset\ClassWithParentHint;
 use ProxyManagerTestAsset\ClassWithPublicArrayPropertyAccessibleViaMethod;
 use ProxyManagerTestAsset\ClassWithPublicProperties;
@@ -26,6 +27,8 @@
 use ProxyManagerTestAsset\EmptyClass;
 use ProxyManagerTestAsset\VoidCounter;
 use ReflectionClass;
+use ReflectionObject;
+use ReflectionType;
 use stdClass;
 
 use function array_values;
@@ -247,6 +250,13 @@ public function testPropertyExistence(object $instance, AccessInterceptorInterfa
         self::assertSame(isset($instance->$publicProperty), isset($proxy->$publicProperty));
         $this->assertProxySynchronized($instance, $proxy);
 
+        $class        = new ReflectionObject($instance);
+        $property     = $class->getProperty($publicProperty);
+        $propertyType = $property->getType();
+        if ($propertyType instanceof ReflectionType && ! $propertyType->allowsNull()) {
+            return;
+        }
+
         $instance->$publicProperty = null;
         self::assertFalse(isset($proxy->$publicProperty));
         $this->assertProxySynchronized($instance, $proxy);
@@ -396,6 +406,26 @@ public static function getProxyMethods(): array
                 ['parameter' => $empty],
                 $empty,
             ],
+            [
+                new ClassWithNonNullableTypedProperties(
+                    'privatePropertyValue',
+                    'protectedPropertyValue',
+                    'prublicPropertyValue'
+                ),
+                'getPrivateProperty',
+                [],
+                'privatePropertyValue',
+            ],
+            [
+                new ClassWithNonNullableTypedProperties(
+                    'privatePropertyValue',
+                    'protectedPropertyValue',
+                    'prublicPropertyValue'
+                ),
+                'getProtectedProperty',
+                [],
+                'protectedPropertyValue',
+            ],
         ];
     }
 
@@ -406,15 +436,26 @@ public static function getProxyMethods(): array
      */
     public function getPropertyAccessProxies(): array
     {
-        $instance = new BaseClass();
+        $baseClassInstance                      = new BaseClass();
+        $classWithNonNullablePropertiesInstance = new ClassWithNonNullableTypedProperties(
+            'privatePropertyValue',
+            'protectedPropertyValue',
+            'publicPropertyValue'
+        );
 
         return [
             [
-                $instance,
-                (new AccessInterceptorScopeLocalizerFactory())->createProxy($instance),
+                $baseClassInstance,
+                (new AccessInterceptorScopeLocalizerFactory())->createProxy($baseClassInstance),
                 'publicProperty',
                 'publicPropertyDefault',
             ],
+            [
+                $classWithNonNullablePropertiesInstance,
+                (new AccessInterceptorScopeLocalizerFactory())->createProxy($classWithNonNullablePropertiesInstance),
+                'publicProperty',
+                'publicPropertyValue',
+            ],
         ];
     }