[DI] Add support for "wither" methods - for greater immutable services

nicolas-grekas · nicolas-grekas · commit 66b99ee5961a · 2019-04-03T11:14:18.000+02:00
diff --git a/Compiler/AnalyzeServiceReferencesPass.php b/Compiler/AnalyzeServiceReferencesPass.php
@@ -140,11 +140,41 @@ protected function processValue($value, $isRoot = false)
         $this->byConstructor = true;
         $this->processValue($value->getFactory());
         $this->processValue($value->getArguments());
+
+        $properties = $value->getProperties();
+        $setters = $value->getMethodCalls();
+
+        // Any references before a "wither" are part of the constructor-instantiation graph
+        $lastWitherIndex = null;
+        foreach ($setters as $k => $call) {
+            if ($call[2] ?? false) {
+                $lastWitherIndex = $k;
+            }
+        }
+
+        if (null !== $lastWitherIndex) {
+            $this->processValue($properties);
+            $setters = $properties = [];
+
+            foreach ($value->getMethodCalls() as $k => $call) {
+                if (null === $lastWitherIndex) {
+                    $setters[] = $call;
+                    continue;
+                }
+
+                if ($lastWitherIndex === $k) {
+                    $lastWitherIndex = null;
+                }
+
+                $this->processValue($call);
+            }
+        }
+
         $this->byConstructor = $byConstructor;
 
         if (!$this->onlyConstructorArguments) {
-            $this->processValue($value->getProperties());
-            $this->processValue($value->getMethodCalls());
+            $this->processValue($properties);
+            $this->processValue($setters);
             $this->processValue($value->getConfigurator());
         }
         $this->lazy = $lazy;
diff --git a/Compiler/AutowireRequiredMethodsPass.php b/Compiler/AutowireRequiredMethodsPass.php
@@ -35,6 +35,7 @@ protected function processValue($value, $isRoot = false)
         }
 
         $alreadyCalledMethods = [];
+        $withers = [];
 
         foreach ($value->getMethodCalls() as list($method)) {
             $alreadyCalledMethods[strtolower($method)] = true;
@@ -50,7 +51,11 @@ protected function processValue($value, $isRoot = false)
             while (true) {
                 if (false !== $doc = $r->getDocComment()) {
                     if (false !== stripos($doc, '@required') && preg_match('#(?:^/\*\*|\n\s*+\*)\s*+@required(?:\s|\*/$)#i', $doc)) {
-                        $value->addMethodCall($reflectionMethod->name);
+                        if (preg_match('#(?:^/\*\*|\n\s*+\*)\s*+@return\s++static[\s\*]#i', $doc)) {
+                            $withers[] = [$reflectionMethod->name, [], true];
+                        } else {
+                            $value->addMethodCall($reflectionMethod->name, []);
+                        }
                         break;
                     }
                     if (false === stripos($doc, '@inheritdoc') || !preg_match('#(?:^/\*\*|\n\s*+\*)\s*+(?:\{@inheritdoc\}|@inheritdoc)(?:\s|\*/$)#i', $doc)) {
@@ -65,6 +70,15 @@ protected function processValue($value, $isRoot = false)
             }
         }
 
+        if ($withers) {
+            // Prepend withers to prevent creating circular loops
+            $setters = $value->getMethodCalls();
+            $value->setMethodCalls($withers);
+            foreach ($setters as $call) {
+                $value->addMethodCall($call[0], $call[1], $call[2] ?? false);
+            }
+        }
+
         return $value;
     }
 }
diff --git a/ContainerBuilder.php b/ContainerBuilder.php
@@ -1139,8 +1139,15 @@ private function createService(Definition $definition, array &$inlineServices, $
             }
         }
 
-        if ($tryProxy || !$definition->isLazy()) {
-            // share only if proxying failed, or if not a proxy
+        $lastWitherIndex = null;
+        foreach ($definition->getMethodCalls() as $k => $call) {
+            if ($call[2] ?? false) {
+                $lastWitherIndex = $k;
+            }
+        }
+
+        if (null === $lastWitherIndex && ($tryProxy || !$definition->isLazy())) {
+            // share only if proxying failed, or if not a proxy, and if no withers are found
             $this->shareService($definition, $service, $id, $inlineServices);
         }
 
@@ -1149,8 +1156,13 @@ private function createService(Definition $definition, array &$inlineServices, $
             $service->$name = $value;
         }
 
-        foreach ($definition->getMethodCalls() as $call) {
-            $this->callMethod($service, $call, $inlineServices);
+        foreach ($definition->getMethodCalls() as $k => $call) {
+            $service = $this->callMethod($service, $call, $inlineServices);
+
+            if ($lastWitherIndex === $k && ($tryProxy || !$definition->isLazy())) {
+                // share only if proxying failed, or if not a proxy, and this is the last wither
+                $this->shareService($definition, $service, $id, $inlineServices);
+            }
         }
 
         if ($callable = $definition->getConfigurator()) {
@@ -1568,16 +1580,18 @@ private function callMethod($service, $call, array &$inlineServices)
     {
         foreach (self::getServiceConditionals($call[1]) as $s) {
             if (!$this->has($s)) {
-                return;
+                return $service;
             }
         }
         foreach (self::getInitializedConditionals($call[1]) as $s) {
             if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
-                return;
+                return $service;
             }
         }
 
-        $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));
+        $result = $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));
+
+        return empty($call[2]) ? $service : $result;
     }
 
     /**
diff --git a/Definition.php b/Definition.php
@@ -330,7 +330,7 @@ public function setMethodCalls(array $calls = [])
     {
         $this->calls = [];
         foreach ($calls as $call) {
-            $this->addMethodCall($call[0], $call[1]);
+            $this->addMethodCall($call[0], $call[1], $call[2] ?? false);
         }
 
         return $this;
@@ -339,19 +339,20 @@ public function setMethodCalls(array $calls = [])
     /**
      * Adds a method to call after service initialization.
      *
-     * @param string $method    The method name to call
-     * @param array  $arguments An array of arguments to pass to the method call
+     * @param string $method       The method name to call
+     * @param array  $arguments    An array of arguments to pass to the method call
+     * @param bool   $returnsClone Whether the call returns the service instance or not
      *
      * @return $this
      *
      * @throws InvalidArgumentException on empty $method param
      */
-    public function addMethodCall($method, array $arguments = [])
+    public function addMethodCall($method, array $arguments = []/*, bool $returnsClone = false*/)
     {
         if (empty($method)) {
             throw new InvalidArgumentException('Method name cannot be empty.');
         }
-        $this->calls[] = [$method, $arguments];
+        $this->calls[] = 2 < \func_num_args() && \func_get_arg(2) ? [$method, $arguments, true] : [$method, $arguments];
 
         return $this;
     }
diff --git a/Dumper/PhpDumper.php b/Dumper/PhpDumper.php
@@ -506,7 +506,14 @@ private function addServiceInstance(string $id, Definition $definition, bool $is
         $isProxyCandidate = $this->getProxyDumper()->isProxyCandidate($definition);
         $instantiation = '';
 
-        if (!$isProxyCandidate && $definition->isShared() && !isset($this->singleUsePrivateIds[$id])) {
+        $lastWitherIndex = null;
+        foreach ($definition->getMethodCalls() as $k => $call) {
+            if ($call[2] ?? false) {
+                $lastWitherIndex = $k;
+            }
+        }
+
+        if (!$isProxyCandidate && $definition->isShared() && !isset($this->singleUsePrivateIds[$id]) && null === $lastWitherIndex) {
             $instantiation = sprintf('$this->%s[\'%s\'] = %s', $this->container->getDefinition($id)->isPublic() ? 'services' : 'privates', $id, $isSimpleInstance ? '' : '$instance');
         } elseif (!$isSimpleInstance) {
             $instantiation = '$instance';
@@ -563,16 +570,32 @@ private function isTrivialInstance(Definition $definition): bool
         return true;
     }
 
-    private function addServiceMethodCalls(Definition $definition, string $variableName = 'instance'): string
+    private function addServiceMethodCalls(Definition $definition, string $variableName, ?string $sharedNonLazyId): string
     {
+        $lastWitherIndex = null;
+        foreach ($definition->getMethodCalls() as $k => $call) {
+            if ($call[2] ?? false) {
+                $lastWitherIndex = $k;
+            }
+        }
+
         $calls = '';
-        foreach ($definition->getMethodCalls() as $call) {
+        foreach ($definition->getMethodCalls() as $k => $call) {
             $arguments = [];
             foreach ($call[1] as $value) {
                 $arguments[] = $this->dumpValue($value);
             }
 
-            $calls .= $this->wrapServiceConditionals($call[1], sprintf("        \$%s->%s(%s);\n", $variableName, $call[0], implode(', ', $arguments)));
+            $witherAssignation = '';
+
+            if ($call[2] ?? false) {
+                if (null !== $sharedNonLazyId && $lastWitherIndex === $k) {
+                    $witherAssignation = sprintf('$this->%s[\'%s\'] = ', $definition->isPublic() ? 'services' : 'privates', $sharedNonLazyId);
+                }
+                $witherAssignation .= sprintf('$%s = ', $variableName);
+            }
+
+            $calls .= $this->wrapServiceConditionals($call[1], sprintf("        %s\$%s->%s(%s);\n", $witherAssignation, $variableName, $call[0], implode(', ', $arguments)));
         }
 
         return $calls;
@@ -814,7 +837,7 @@ private function addInlineService(string $id, Definition $definition, Definition
             }
 
             $code .= $this->addServiceProperties($inlineDef, $name);
-            $code .= $this->addServiceMethodCalls($inlineDef, $name);
+            $code .= $this->addServiceMethodCalls($inlineDef, $name, !$this->getProxyDumper()->isProxyCandidate($inlineDef) && $inlineDef->isShared() && !isset($this->singleUsePrivateIds[$id]) ? $id : null);
             $code .= $this->addServiceConfigurator($inlineDef, $name);
         }
 
diff --git a/Dumper/XmlDumper.php b/Dumper/XmlDumper.php
@@ -84,6 +84,9 @@ private function addMethodCalls(array $methodcalls, \DOMElement $parent)
             if (\count($methodcall[1])) {
                 $this->convertParameters($methodcall[1], 'argument', $call);
             }
+            if ($methodcall[2] ?? false) {
+                $call->setAttribute('returns-clone', 'true');
+            }
             $parent->appendChild($call);
         }
     }
diff --git a/Loader/XmlFileLoader.php b/Loader/XmlFileLoader.php
@@ -337,7 +337,7 @@ private function parseDefinition(\DOMElement $service, $file, array $defaults)
         }
 
         foreach ($this->getChildren($service, 'call') as $call) {
-            $definition->addMethodCall($call->getAttribute('method'), $this->getArgumentsAsPhp($call, 'argument', $file));
+            $definition->addMethodCall($call->getAttribute('method'), $this->getArgumentsAsPhp($call, 'argument', $file), XmlUtils::phpize($call->getAttribute('returns-clone')));
         }
 
         $tags = $this->getChildren($service, 'tag');
diff --git a/Loader/YamlFileLoader.php b/Loader/YamlFileLoader.php
@@ -463,15 +463,17 @@ private function parseDefinition($id, $service, $file, array $defaults)
                 if (isset($call['method'])) {
                     $method = $call['method'];
                     $args = isset($call['arguments']) ? $this->resolveServices($call['arguments'], $file) : [];
+                    $returnsClone = $call['returns_clone'] ?? false;
                 } else {
                     $method = $call[0];
                     $args = isset($call[1]) ? $this->resolveServices($call[1], $file) : [];
+                    $returnsClone = $call[2] ?? false;
                 }
 
                 if (!\is_array($args)) {
                     throw new InvalidArgumentException(sprintf('The second parameter for function call "%s" must be an array of its arguments for service "%s" in %s. Check your YAML syntax.', $method, $id, $file));
                 }
-                $definition->addMethodCall($method, $args);
+                $definition->addMethodCall($method, $args, $returnsClone);
             }
         }
 
diff --git a/Loader/schema/dic/services/services-1.0.xsd b/Loader/schema/dic/services/services-1.0.xsd
@@ -243,6 +243,7 @@
       <xsd:element name="argument" type="argument" maxOccurs="unbounded" />
     </xsd:choice>
     <xsd:attribute name="method" type="xsd:string" />
+    <xsd:attribute name="returns-clone" type="boolean" />
   </xsd:complexType>
 
   <xsd:simpleType name="parameter_type">
diff --git a/Tests/Compiler/AutowireRequiredMethodsPassTest.php b/Tests/Compiler/AutowireRequiredMethodsPassTest.php
@@ -77,4 +77,26 @@ public function testExplicitMethodInjection()
         );
         $this->assertEquals([], $methodCalls[0][1]);
     }
+
+    public function testWitherInjection()
+    {
+        $container = new ContainerBuilder();
+        $container->register(Foo::class);
+
+        $container
+            ->register('wither', Wither::class)
+            ->setAutowired(true);
+
+        (new ResolveClassPass())->process($container);
+        (new AutowireRequiredMethodsPass())->process($container);
+
+        $methodCalls = $container->getDefinition('wither')->getMethodCalls();
+
+        $expected = [
+            ['withFoo1', [], true],
+            ['withFoo2', [], true],
+            ['setFoo', []],
+        ];
+        $this->assertSame($expected, $methodCalls);
+    }
 }
diff --git a/Tests/ContainerBuilderTest.php b/Tests/ContainerBuilderTest.php
@@ -11,6 +11,7 @@
 
 namespace Symfony\Component\DependencyInjection\Tests;
 
+require_once __DIR__.'/Fixtures/includes/autowiring_classes.php';
 require_once __DIR__.'/Fixtures/includes/classes.php';
 require_once __DIR__.'/Fixtures/includes/ProjectExtension.php';
 
@@ -36,6 +37,8 @@
 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\DependencyInjection\ServiceLocator;
+use Symfony\Component\DependencyInjection\Tests\Compiler\Foo;
+use Symfony\Component\DependencyInjection\Tests\Compiler\Wither;
 use Symfony\Component\DependencyInjection\Tests\Fixtures\CaseSensitiveClass;
 use Symfony\Component\DependencyInjection\Tests\Fixtures\CustomDefinition;
 use Symfony\Component\DependencyInjection\Tests\Fixtures\SimilarArgumentsDummy;
@@ -1565,6 +1568,22 @@ public function testDecoratedSelfReferenceInvolvingPrivateServices()
 
         $this->assertSame(['service_container'], array_keys($container->getDefinitions()));
     }
+
+    public function testWither()
+    {
+        $container = new ContainerBuilder();
+        $container->register(Foo::class);
+
+        $container
+            ->register('wither', Wither::class)
+            ->setPublic(true)
+            ->setAutowired(true);
+
+        $container->compile();
+
+        $wither = $container->get('wither');
+        $this->assertInstanceOf(Foo::class, $wither->foo);
+    }
 }
 
 class FooClass
diff --git a/Tests/DefinitionTest.php b/Tests/DefinitionTest.php
@@ -95,10 +95,16 @@ public function testMethodCalls()
         $this->assertEquals([['foo', ['foo']]], $def->getMethodCalls(), '->getMethodCalls() returns the methods to call');
         $this->assertSame($def, $def->addMethodCall('bar', ['bar']), '->addMethodCall() implements a fluent interface');
         $this->assertEquals([['foo', ['foo']], ['bar', ['bar']]], $def->getMethodCalls(), '->addMethodCall() adds a method to call');
+        $this->assertSame($def, $def->addMethodCall('foobar', ['foobar'], true), '->addMethodCall() implements a fluent interface with third parameter');
+        $this->assertEquals([['foo', ['foo']], ['bar', ['bar']], ['foobar', ['foobar'], true]], $def->getMethodCalls(), '->addMethodCall() adds a method to call');
         $this->assertTrue($def->hasMethodCall('bar'), '->hasMethodCall() returns true if first argument is a method to call registered');
         $this->assertFalse($def->hasMethodCall('no_registered'), '->hasMethodCall() returns false if first argument is not a method to call registered');
         $this->assertSame($def, $def->removeMethodCall('bar'), '->removeMethodCall() implements a fluent interface');
+        $this->assertTrue($def->hasMethodCall('foobar'), '->hasMethodCall() returns true if first argument is a method to call registered');
+        $this->assertSame($def, $def->removeMethodCall('foobar'), '->removeMethodCall() implements a fluent interface');
         $this->assertEquals([['foo', ['foo']]], $def->getMethodCalls(), '->removeMethodCall() removes a method to call');
+        $this->assertSame($def, $def->setMethodCalls([['foobar', ['foobar'], true]]), '->setMethodCalls() implements a fluent interface with third parameter');
+        $this->assertEquals([['foobar', ['foobar'], true]], $def->getMethodCalls(), '->addMethodCall() adds a method to call');
     }
 
     /**
diff --git a/Tests/Dumper/PhpDumperTest.php b/Tests/Dumper/PhpDumperTest.php
diff --git a/Tests/Fixtures/includes/autowiring_classes.php b/Tests/Fixtures/includes/autowiring_classes.php
diff --git a/Tests/Fixtures/php/services_wither.php b/Tests/Fixtures/php/services_wither.php

Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ protected function processValue($value, $isRoot = false)`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`$alreadyCalledMethods = [];`
	`38`	`+ $withers = [];`
`38`	`39`
`39`	`40`	`foreach ($value->getMethodCalls() as list($method)) {`
`40`	`41`	`$alreadyCalledMethods[strtolower($method)] = true;`
`@@ -50,7 +51,11 @@ protected function processValue($value, $isRoot = false)`
`50`	`51`	`while (true) {`
`51`	`52`	`if (false !== $doc = $r->getDocComment()) {`
`52`	`53`	`if (false !== stripos($doc, '@required') && preg_match('#(?:^/\\\|\n\s+\)\s+@required(?:\s\|\/$)#i', $doc)) {`
`53`		`- $value->addMethodCall($reflectionMethod->name);`
	`54`	`+ if (preg_match('#(?:^/\\\|\n\s+\)\s+@return\s++static[\s\]#i', $doc)) {`
	`55`	`+ $withers[] = [$reflectionMethod->name, [], true];`
	`56`	`+ } else {`
	`57`	`+ $value->addMethodCall($reflectionMethod->name, []);`
	`58`	`+ }`
`54`	`59`	`break;`
`55`	`60`	`}`
`56`	`61`	`if (false === stripos($doc, '@inheritdoc') \|\| !preg_match('#(?:^/\\\|\n\s+\)\s+(?:\{@inheritdoc\}\|@inheritdoc)(?:\s\|\/$)#i', $doc)) {`
`@@ -65,6 +70,15 @@ protected function processValue($value, $isRoot = false)`
`65`	`70`	`}`
`66`	`71`	`}`
`67`	`72`
	`73`	`+ if ($withers) {`
	`74`	`+ // Prepend withers to prevent creating circular loops`
	`75`	`+ $setters = $value->getMethodCalls();`
	`76`	`+ $value->setMethodCalls($withers);`
	`77`	`+ foreach ($setters as $call) {`
	`78`	`+ $value->addMethodCall($call[0], $call[1], $call[2] ?? false);`
	`79`	`+ }`
	`80`	`+ }`
	`81`	`+`
`68`	`82`	`return $value;`
`69`	`83`	`}`
`70`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1139,8 +1139,15 @@ private function createService(Definition $definition, array &$inlineServices, $`
`1139`	`1139`	`}`
`1140`	`1140`	`}`
`1141`	`1141`
`1142`		`- if ($tryProxy \|\| !$definition->isLazy()) {`
`1143`		`- // share only if proxying failed, or if not a proxy`
	`1142`	`+ $lastWitherIndex = null;`
	`1143`	`+ foreach ($definition->getMethodCalls() as $k => $call) {`
	`1144`	`+ if ($call[2] ?? false) {`
	`1145`	`+ $lastWitherIndex = $k;`
	`1146`	`+ }`
	`1147`	`+ }`
	`1148`	`+`
	`1149`	`+ if (null === $lastWitherIndex && ($tryProxy \|\| !$definition->isLazy())) {`
	`1150`	`+ // share only if proxying failed, or if not a proxy, and if no withers are found`
`1144`	`1151`	`$this->shareService($definition, $service, $id, $inlineServices);`
`1145`	`1152`	`}`
`1146`	`1153`
`@@ -1149,8 +1156,13 @@ private function createService(Definition $definition, array &$inlineServices, $`
`1149`	`1156`	`$service->$name = $value;`
`1150`	`1157`	`}`
`1151`	`1158`
`1152`		`- foreach ($definition->getMethodCalls() as $call) {`
`1153`		`- $this->callMethod($service, $call, $inlineServices);`
	`1159`	`+ foreach ($definition->getMethodCalls() as $k => $call) {`
	`1160`	`+ $service = $this->callMethod($service, $call, $inlineServices);`
	`1161`	`+`
	`1162`	`+ if ($lastWitherIndex === $k && ($tryProxy \|\| !$definition->isLazy())) {`
	`1163`	`+ // share only if proxying failed, or if not a proxy, and this is the last wither`
	`1164`	`+ $this->shareService($definition, $service, $id, $inlineServices);`
	`1165`	`+ }`
`1154`	`1166`	`}`
`1155`	`1167`
`1156`	`1168`	`if ($callable = $definition->getConfigurator()) {`
`@@ -1568,16 +1580,18 @@ private function callMethod($service, $call, array &$inlineServices)`
`1568`	`1580`	`{`
`1569`	`1581`	`foreach (self::getServiceConditionals($call[1]) as $s) {`
`1570`	`1582`	`if (!$this->has($s)) {`
`1571`		`- return;`
	`1583`	`+ return $service;`
`1572`	`1584`	`}`
`1573`	`1585`	`}`
`1574`	`1586`	`foreach (self::getInitializedConditionals($call[1]) as $s) {`
`1575`	`1587`	`if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {`
`1576`		`- return;`
	`1588`	`+ return $service;`
`1577`	`1589`	`}`
`1578`	`1590`	`}`
`1579`	`1591`
`1580`		`- $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));`
	`1592`	`+ $result = $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));`
	`1593`	`+`
	`1594`	`+ return empty($call[2]) ? $service : $result;`
`1581`	`1595`	`}`
`1582`	`1596`
`1583`	`1597`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -330,7 +330,7 @@ public function setMethodCalls(array $calls = [])`
`330`	`330`	`{`
`331`	`331`	`$this->calls = [];`
`332`	`332`	`foreach ($calls as $call) {`
`333`		`- $this->addMethodCall($call[0], $call[1]);`
	`333`	`+ $this->addMethodCall($call[0], $call[1], $call[2] ?? false);`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`return $this;`
`@@ -339,19 +339,20 @@ public function setMethodCalls(array $calls = [])`
`339`	`339`	`/**`
`340`	`340`	`* Adds a method to call after service initialization.`
`341`	`341`	`*`
`342`		`- * @param string $method The method name to call`
`343`		`- * @param array $arguments An array of arguments to pass to the method call`
	`342`	`+ * @param string $method The method name to call`
	`343`	`+ * @param array $arguments An array of arguments to pass to the method call`
	`344`	`+ * @param bool $returnsClone Whether the call returns the service instance or not`
`344`	`345`	`*`
`345`	`346`	`* @return $this`
`346`	`347`	`*`
`347`	`348`	`* @throws InvalidArgumentException on empty $method param`
`348`	`349`	`*/`
`349`		`- public function addMethodCall($method, array $arguments = [])`
	`350`	`+ public function addMethodCall($method, array $arguments = []/, bool $returnsClone = false/)`
`350`	`351`	`{`
`351`	`352`	`if (empty($method)) {`
`352`	`353`	`throw new InvalidArgumentException('Method name cannot be empty.');`
`353`	`354`	`}`
`354`		`- $this->calls[] = [$method, $arguments];`
	`355`	`+ $this->calls[] = 2 < \func_num_args() && \func_get_arg(2) ? [$method, $arguments, true] : [$method, $arguments];`
`355`	`356`
`356`	`357`	`return $this;`
`357`	`358`	`}`
Original file line number	Diff line number	Diff line change
`@@ -84,6 +84,9 @@ private function addMethodCalls(array $methodcalls, \DOMElement $parent)`
`84`	`84`	`if (\count($methodcall[1])) {`
`85`	`85`	`$this->convertParameters($methodcall[1], 'argument', $call);`
`86`	`86`	`}`
	`87`	`+ if ($methodcall[2] ?? false) {`
	`88`	`+ $call->setAttribute('returns-clone', 'true');`
	`89`	`+ }`
`87`	`90`	`$parent->appendChild($call);`
`88`	`91`	`}`
`89`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -337,7 +337,7 @@ private function parseDefinition(\DOMElement $service, $file, array $defaults)`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`foreach ($this->getChildren($service, 'call') as $call) {`
`340`		`- $definition->addMethodCall($call->getAttribute('method'), $this->getArgumentsAsPhp($call, 'argument', $file));`
	`340`	`+ $definition->addMethodCall($call->getAttribute('method'), $this->getArgumentsAsPhp($call, 'argument', $file), XmlUtils::phpize($call->getAttribute('returns-clone')));`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`$tags = $this->getChildren($service, 'tag');`
Original file line number	Diff line number	Diff line change
`@@ -463,15 +463,17 @@ private function parseDefinition($id, $service, $file, array $defaults)`
`463`	`463`	`if (isset($call['method'])) {`
`464`	`464`	`$method = $call['method'];`
`465`	`465`	`$args = isset($call['arguments']) ? $this->resolveServices($call['arguments'], $file) : [];`
	`466`	`+ $returnsClone = $call['returns_clone'] ?? false;`
`466`	`467`	`} else {`
`467`	`468`	`$method = $call[0];`
`468`	`469`	`$args = isset($call[1]) ? $this->resolveServices($call[1], $file) : [];`
	`470`	`+ $returnsClone = $call[2] ?? false;`
`469`	`471`	`}`
`470`	`472`
`471`	`473`	`if (!\is_array($args)) {`
`472`	`474`	`throw new InvalidArgumentException(sprintf('The second parameter for function call "%s" must be an array of its arguments for service "%s" in %s. Check your YAML syntax.', $method, $id, $file));`
`473`	`475`	`}`
`474`		`- $definition->addMethodCall($method, $args);`
	`476`	`+ $definition->addMethodCall($method, $args, $returnsClone);`
`475`	`477`	`}`
`476`	`478`	`}`
`477`	`479`