Corrected by-ref parameters also for scope-localizer interceptor proxies

Author: Ocramius

src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/Util/InterceptorGenerator.php

@@ -67,7 +67,11 @@ public static function createInterceptedMethodBody(
             '{{$suffixInterceptorsName}}'      => $suffixInterceptors->getName(),
             '{{$suffixEarlyReturnExpression}}' => ProxiedMethodReturnExpression::generate('$suffixReturnValue', $originalMethod),
             '{{$returnExpression}}'            => ProxiedMethodReturnExpression::generate('$returnValue', $originalMethod),
-            '{{$paramsString}}'                => 'array(' . implode(', ', array_map(static fn (ParameterGenerator $parameter): string => var_export($parameter->getName(), true) . ' => $' . $parameter->getName(), $method->getParameters())) . ')',
+            '{{$paramsString}}'                => 'array(' . implode(', ', array_map(
+                static fn (ParameterGenerator $parameter): string => var_export($parameter->getName(), true) . ' => ' . ($parameter->getPassedByReference() ? '&$' : '$') . $parameter->getName(),
+                $method->getParameters()
+            ))
+                . ')',
         ];
 
         return str_replace(

tests/ProxyManagerTest/Functional/AccessInterceptorScopeLocalizerFunctionalTest.php

@@ -24,6 +24,7 @@
 use ProxyManagerTestAsset\ClassWithPublicStringNullableTypedProperty;
 use ProxyManagerTestAsset\ClassWithSelfHint;
 use ProxyManagerTestAsset\EmptyClass;
+use ProxyManagerTestAsset\ReferenceIncrementDecrementClass;
 use ProxyManagerTestAsset\VoidCounter;
 use ReflectionClass;
 use stdClass;
@@ -562,6 +563,79 @@ public function testWillRefuseToGenerateReferencesToTypedPropertiesWithoutDefaul
         $factory->createProxy($instance);
     }
 
+    public function testByReferencePassedArgumentsAreGivenAsReferenceToInterceptorCallbacks(): void
+    {
+        $proxy = (new AccessInterceptorScopeLocalizerFactory())->createProxy(
+            new ReferenceIncrementDecrementClass(),
+            [
+                'incrementReference' => static function (
+                    object $proxy,
+                    ReferenceIncrementDecrementClass $instance,
+                    string $method,
+                    array $args,
+                    bool &$returnEarly
+                ): void {
+                    self::assertSame(0, $args['reference']);
+
+                    $returnEarly       = true;
+                    $args['reference'] = 5;
+                },
+            ]
+        );
+
+        $number = 0;
+
+        $proxy->incrementReference($number);
+
+        self::assertSame(5, $number, 'Number was changed by interceptor');
+    }
+
+    public function testByReferenceArgumentsAreForwardedThroughInterceptorsAndSubject(): void
+    {
+        $proxy = (new AccessInterceptorScopeLocalizerFactory())->createProxy(
+            new ReferenceIncrementDecrementClass(),
+            [
+                'incrementReference' => static function (
+                    object $proxy,
+                    ReferenceIncrementDecrementClass $instance,
+                    string $method,
+                    array $args,
+                    bool &$returnEarly
+                ): void {
+                    self::assertSame(0, $args['reference']);
+
+                    $returnEarly       = false;
+                    $args['reference'] = 5;
+                },
+            ],
+            [
+                'incrementReference' => static function (
+                    object $proxy,
+                    ReferenceIncrementDecrementClass $instance,
+                    string $method,
+                    array $args,
+                    mixed $returnValue,
+                    bool &$returnEarly
+                ): void {
+                    self::assertIsInt($args['reference']);
+
+                    $returnEarly        = false;
+                    $args['reference'] *= 2;
+                },
+            ]
+        );
+
+        $number = 0;
+
+        $proxy->incrementReference($number);
+
+        self::assertSame(
+            12,
+            $number,
+            'Number was changed by prefix interceptor, then incremented, then doubled by suffix interceptor'
+        );
+    }
+
     /**
      * @psalm-param ExpectedType $expected
      *

tests/ProxyManagerTest/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/Util/InterceptorGeneratorTest.php

@@ -167,6 +167,61 @@ public function testInterceptorGeneratorWithExistingNonVoidMethod(): void
     }
 }
 
+return $returnValue;
+PHP;
+        // @codingStandardsIgnoreEnd
+
+        self::assertSame(
+            $expected,
+            InterceptorGenerator::createInterceptedMethodBody(
+                '$returnValue = "foo";',
+                $method,
+                $prefixInterceptors,
+                $suffixInterceptors,
+                new ReflectionMethod(BaseClass::class, 'publicMethod')
+            )
+        );
+    }
+
+    public function testInterceptorGeneratorWithReferences(): void
+    {
+        $method             = $this->createMock(MethodGenerator::class);
+        $bar                = $this->createMock(ParameterGenerator::class);
+        $baz                = $this->createMock(ParameterGenerator::class);
+        $prefixInterceptors = $this->createMock(PropertyGenerator::class);
+        $suffixInterceptors = $this->createMock(PropertyGenerator::class);
+
+        $bar->method('getName')->willReturn('bar');
+        $bar->method('getPassedByReference')->willReturn(false);
+        $baz->method('getName')->willReturn('baz');
+        $baz->method('getPassedByReference')->willReturn(true);
+        $method->method('getName')->willReturn('fooMethod');
+        $method->method('getParameters')->will(self::returnValue([$bar, $baz]));
+        $prefixInterceptors->method('getName')->willReturn('pre');
+        $suffixInterceptors->method('getName')->willReturn('post');
+
+        // @codingStandardsIgnoreStart
+        $expected = <<<'PHP'
+if (isset($this->pre['fooMethod'])) {
+    $returnEarly       = false;
+    $prefixReturnValue = $this->pre['fooMethod']->__invoke($this, $this, 'fooMethod', array('bar' => $bar, 'baz' => &$baz), $returnEarly);
+
+    if ($returnEarly) {
+        return $prefixReturnValue;
+    }
+}
+
+$returnValue = "foo";
+
+if (isset($this->post['fooMethod'])) {
+    $returnEarly       = false;
+    $suffixReturnValue = $this->post['fooMethod']->__invoke($this, $this, 'fooMethod', array('bar' => $bar, 'baz' => &$baz), $returnValue, $returnEarly);
+
+    if ($returnEarly) {
+        return $suffixReturnValue;
+    }
+}
+
 return $returnValue;
 PHP;
         // @codingStandardsIgnoreEnd