Add "fluentSafe" option to LazyLoadingValueHolderGenerator

Author: nicolas-grekas

src/ProxyManager/Factory/AbstractBaseFactory.php

@@ -17,6 +17,8 @@
 use function assert;
 use function class_exists;
 use function is_a;
+use function serialize;
+use function sha1;
 
 /**
  * Base factory common logic
@@ -29,7 +31,7 @@ abstract class AbstractBaseFactory
      * Cached checked class names
      *
      * @var array<string, string>
-     * @psalm-var array<class-string, class-string>
+     * @psalm-var array<string, class-string>
      */
     private $checkedClasses = [];
 
@@ -55,8 +57,10 @@ public function __construct(?Configuration $configuration = null)
      */
     protected function generateProxy(string $className, array $proxyOptions = []): string
     {
-        if (array_key_exists($className, $this->checkedClasses)) {
-            $generatedClassName = $this->checkedClasses[$className];
+        $cacheKey = $proxyOptions ? sha1(serialize([$className, $proxyOptions])) : $className;
+
+        if (array_key_exists($cacheKey, $this->checkedClasses)) {
+            $generatedClassName = $this->checkedClasses[$cacheKey];
 
             assert(is_a($generatedClassName, $className, true));
 
@@ -88,7 +92,7 @@ protected function generateProxy(string $className, array $proxyOptions = []): s
             ->getSignatureChecker()
             ->checkSignature(new ReflectionClass($proxyClassName), $proxyParameters);
 
-        return $this->checkedClasses[$className] = $proxyClassName;
+        return $this->checkedClasses[$cacheKey] = $proxyClassName;
     }
 
     abstract protected function getGenerator(): ProxyGeneratorInterface;

src/ProxyManager/Factory/LazyLoadingValueHolderFactory.php

@@ -38,7 +38,7 @@ public function __construct(?Configuration $configuration = null)
      *   array<string, mixed>=,
      *   ?Closure=
      * ) : bool $initializer
-     * @psalm-param array{skipDestructor?: bool} $proxyOptions
+     * @psalm-param array{skipDestructor?: bool, fluentSafe?: bool} $proxyOptions
      *
      * @psalm-return RealObjectType&ValueHolderInterface<RealObjectType>&VirtualProxyInterface
      *

src/ProxyManager/ProxyGenerator/LazyLoadingValueHolderGenerator.php

@@ -40,6 +40,8 @@
 use function array_merge;
 use function func_get_arg;
 use function func_num_args;
+use function str_replace;
+use function substr;
 
 /**
  * Generator for proxies implementing {@see \ProxyManager\Proxy\VirtualProxyInterface}
@@ -56,11 +58,11 @@ class LazyLoadingValueHolderGenerator implements ProxyGeneratorInterface
      * @throws InvalidProxiedClassException
      * @throws InvalidArgumentException
      *
-     * @psalm-param array{skipDestructor?: bool} $proxyOptions
+     * @psalm-param array{skipDestructor?: bool, fluentSafe?: bool} $proxyOptions
      */
     public function generate(ReflectionClass $originalClass, ClassGenerator $classGenerator/*, array $proxyOptions = []*/)
     {
-        /** @psalm-var array{skipDestructor?: bool} $proxyOptions */
+        /** @psalm-var array{skipDestructor?: bool, fluentSafe?: bool} $proxyOptions */
         $proxyOptions = func_num_args() >= 3 ? func_get_arg(2) : [];
 
         CanProxyAssertion::assertClassCanBeProxied($originalClass);
@@ -92,7 +94,7 @@ static function (MethodGenerator $generatedMethod) use ($originalClass, $classGe
             },
             array_merge(
                 array_map(
-                    $this->buildLazyLoadingMethodInterceptor($initializer, $valueHolder),
+                    $this->buildLazyLoadingMethodInterceptor($initializer, $valueHolder, $proxyOptions['fluentSafe'] ?? false),
                     ProxiedMethodsFilter::getProxiedMethods($originalClass, $excludedMethods)
                 ),
                 [
@@ -118,14 +120,33 @@ static function (MethodGenerator $generatedMethod) use ($originalClass, $classGe
 
     private function buildLazyLoadingMethodInterceptor(
         InitializerProperty $initializer,
-        ValueHolderProperty $valueHolder
+        ValueHolderProperty $valueHolder,
+        bool $fluentSafe
     ): callable {
-        return static function (ReflectionMethod $method) use ($initializer, $valueHolder): LazyLoadingMethodInterceptor {
-            return LazyLoadingMethodInterceptor::generateMethod(
+        return static function (ReflectionMethod $method) use ($initializer, $valueHolder, $fluentSafe): LazyLoadingMethodInterceptor {
+            $byRef  = $method->returnsReference() ? '& ' : '';
+            $method = LazyLoadingMethodInterceptor::generateMethod(
                 new MethodReflection($method->getDeclaringClass()->getName(), $method->getName()),
                 $initializer,
                 $valueHolder
             );
+
+            if ($fluentSafe) {
+                $valueHolderName = '$this->' . $valueHolder->getName();
+                $body            = $method->getBody();
+                $newBody         = str_replace('return ' . $valueHolderName, 'if (' . $valueHolderName . ' === $returnValue = ' . $byRef . $valueHolderName, $body);
+
+                if ($newBody !== $body) {
+                    $method->setBody(
+                        substr($newBody, 0, -1) . ') {' . "\n"
+                        . '    return $this;' . "\n"
+                        . '}' . "\n\n"
+                        . 'return $returnValue;'
+                    );
+                }
+            }
+
+            return $method;
         };
     }
 }

tests/language-feature-scripts/lazy-loading-value-holder-fluent-safe.phpt

@@ -0,0 +1,32 @@
+--TEST--
+Verifies that generated lazy loading value holders can be fluent-safe
+--FILE--
+<?php
+
+require_once __DIR__ . '/init.php';
+
+class FluentClass
+{
+    public function foo()
+    {
+        return $this;
+    }
+}
+
+$fluentObject = new FluentClass();
+
+$factory = new \ProxyManager\Factory\LazyLoadingValueHolderFactory($configuration);
+
+$init = function (& $wrapped, $proxy, $method, $parameters, & $initializer) use ($fluentObject) {
+    $wrapped = $fluentObject;
+    $initializer = null;
+};
+
+$proxy = $factory->createProxy(FluentClass::class, $init, ['fluentSafe' => true]);
+echo $proxy->foo() === $proxy;
+
+$proxy = $factory->createProxy(FluentClass::class, $init);
+echo $proxy->foo() === $fluentObject;
+?>
+--EXPECT--
+11