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

nicolas-grekas · nicolas-grekas · commit 0f5a1c8bff91 · 2019-02-12T19:42:29.000+01:00
diff --git a/src/Symfony/Bundle/FrameworkBundle/Console/Descriptor/XmlDescriptor.php b/src/Symfony/Bundle/FrameworkBundle/Console/Descriptor/XmlDescriptor.php
@@ -343,6 +343,9 @@ private function getContainerDefinitionDocument(Definition $definition, string $
             foreach ($calls as $callData) {
                 $callsXML->appendChild($callXML = $dom->createElement('call'));
                 $callXML->setAttribute('method', $callData[0]);
+                if ($callData[2] ?? false) {
+                    $callXML->setAttribute('use-result', 'true');
+                }
             }
         }
 
diff --git a/src/Symfony/Component/DependencyInjection/Compiler/AnalyzeServiceReferencesPass.php b/src/Symfony/Component/DependencyInjection/Compiler/AnalyzeServiceReferencesPass.php
@@ -140,11 +140,21 @@ protected function processValue($value, $isRoot = false)
         $this->byConstructor = true;
         $this->processValue($value->getFactory());
         $this->processValue($value->getArguments());
+
+        // "wither" calls are part of the constructor-instantiation graph
+        $setterCalls = [];
+        foreach ($value->getMethodCalls() as $call) {
+            if ($call[2] ?? false) {
+                $this->processValue($call);
+            } else {
+                $setterCalls[] = $call;
+            }
+        }
         $this->byConstructor = $byConstructor;
 
         if (!$this->onlyConstructorArguments) {
             $this->processValue($value->getProperties());
-            $this->processValue($value->getMethodCalls());
+            $this->processValue($setterCalls);
             $this->processValue($value->getConfigurator());
         }
         $this->lazy = $lazy;
diff --git a/src/Symfony/Component/DependencyInjection/Compiler/AutowireRequiredMethodsPass.php b/src/Symfony/Component/DependencyInjection/Compiler/AutowireRequiredMethodsPass.php
@@ -50,7 +50,7 @@ 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);
+                        $value->addMethodCall($reflectionMethod->name, [], preg_match('#(?:^/\*\*|\n\s*+\*)\s*+@return\s++static[\s\*]#i', $doc));
                         break;
                     }
                     if (false === stripos($doc, '@inheritdoc') || !preg_match('#(?:^/\*\*|\n\s*+\*)\s*+(?:\{@inheritdoc\}|@inheritdoc)(?:\s|\*/$)#i', $doc)) {
diff --git a/src/Symfony/Component/DependencyInjection/ContainerBuilder.php b/src/Symfony/Component/DependencyInjection/ContainerBuilder.php
@@ -1150,7 +1150,7 @@ private function createService(Definition $definition, array &$inlineServices, $
         }
 
         foreach ($definition->getMethodCalls() as $call) {
-            $this->callMethod($service, $call, $inlineServices);
+            $service = $this->callMethod($service, $call, $inlineServices);
         }
 
         if ($callable = $definition->getConfigurator()) {
@@ -1568,16 +1568,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/src/Symfony/Component/DependencyInjection/Definition.php b/src/Symfony/Component/DependencyInjection/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;
@@ -341,17 +341,18 @@ public function setMethodCalls(array $calls = [])
      *
      * @param string $method    The method name to call
      * @param array  $arguments An array of arguments to pass to the method call
+     * @param bool   $useResult 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 $useResult = 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/src/Symfony/Component/DependencyInjection/Dumper/PhpDumper.php b/src/Symfony/Component/DependencyInjection/Dumper/PhpDumper.php
@@ -572,7 +572,7 @@ private function addServiceMethodCalls(Definition $definition, string $variableN
                 $arguments[] = $this->dumpValue($value);
             }
 
-            $calls .= $this->wrapServiceConditionals($call[1], sprintf("        \$%s->%s(%s);\n", $variableName, $call[0], implode(', ', $arguments)));
+            $calls .= $this->wrapServiceConditionals($call[1], sprintf("        %s\$%s->%s(%s);\n", empty($call[2]) ? '' : "\${$variableName} = ", $variableName, $call[0], implode(', ', $arguments)));
         }
 
         return $calls;
@@ -820,6 +820,17 @@ private function addInlineService(string $id, Definition $definition, Definition
 
         if ($isRootInstance && !$isSimpleInstance) {
             $code .= "\n        return \$instance;\n";
+
+            foreach ($definition->getMethodCalls() as $call) {
+                if (!($call[2] ?? false)) {
+                    continue;
+                }
+
+                if (!$this->getProxyDumper()->isProxyCandidate($definition) && $definition->isShared() && !isset($this->singleUsePrivateIds[$id])) {
+                    $code = substr_replace($code, sprintf('$this->%s[\'%s\'] = ', $definition->isPublic() ? 'services' : 'privates', $id), -11, 0);
+                    break;
+                }
+            }
         }
 
         return $code;
diff --git a/src/Symfony/Component/DependencyInjection/Dumper/XmlDumper.php b/src/Symfony/Component/DependencyInjection/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('use-result', 'true');
+            }
             $parent->appendChild($call);
         }
     }
diff --git a/src/Symfony/Component/DependencyInjection/Loader/XmlFileLoader.php b/src/Symfony/Component/DependencyInjection/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), $call->getAttribute('use-result'));
         }
 
         $tags = $this->getChildren($service, 'tag');
diff --git a/src/Symfony/Component/DependencyInjection/Loader/YamlFileLoader.php b/src/Symfony/Component/DependencyInjection/Loader/YamlFileLoader.php
@@ -471,7 +471,7 @@ private function parseDefinition($id, $service, $file, array $defaults)
                 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, $call['use_result'] ?? false);
             }
         }
 
diff --git a/src/Symfony/Component/DependencyInjection/Loader/schema/dic/services/services-1.0.xsd b/src/Symfony/Component/DependencyInjection/Loader/schema/dic/services/services-1.0.xsd
@@ -241,6 +241,7 @@
       <xsd:element name="argument" type="argument" maxOccurs="unbounded" />
     </xsd:choice>
     <xsd:attribute name="method" type="xsd:string" />
+    <xsd:attribute name="use-result" type="boolean" />
   </xsd:complexType>
 
   <xsd:simpleType name="parameter_type">
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Compiler/AutowireRequiredMethodsPassTest.php b/src/Symfony/Component/DependencyInjection/Tests/Compiler/AutowireRequiredMethodsPassTest.php
@@ -77,4 +77,21 @@ 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();
+
+        $this->assertSame([['withFoo', [], true]], $methodCalls);
+    }
 }
diff --git a/src/Symfony/Component/DependencyInjection/Tests/ContainerBuilderTest.php b/src/Symfony/Component/DependencyInjection/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/src/Symfony/Component/DependencyInjection/Tests/DefinitionTest.php b/src/Symfony/Component/DependencyInjection/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/src/Symfony/Component/DependencyInjection/Tests/Dumper/PhpDumperTest.php b/src/Symfony/Component/DependencyInjection/Tests/Dumper/PhpDumperTest.php
@@ -30,13 +30,16 @@
 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\CustomDefinition;
 use Symfony\Component\DependencyInjection\Tests\Fixtures\StubbedTranslator;
 use Symfony\Component\DependencyInjection\Tests\Fixtures\TestServiceSubscriber;
 use Symfony\Component\DependencyInjection\TypedReference;
 use Symfony\Component\DependencyInjection\Variable;
 use Symfony\Component\ExpressionLanguage\Expression;
 
+require_once __DIR__.'/../Fixtures/includes/autowiring_classes.php';
 require_once __DIR__.'/../Fixtures/includes/classes.php';
 
 class PhpDumperTest extends TestCase
@@ -1170,6 +1173,28 @@ public function testServiceLocatorArgument()
         $container->set('foo5', $foo5 = new \stdClass());
         $this->assertSame($foo5, $locator->get('foo5'));
     }
+
+    public function testWither()
+    {
+        $container = new ContainerBuilder();
+        $container->register(Foo::class);
+
+        $container
+            ->register('wither', Wither::class)
+            ->setPublic(true)
+            ->setAutowired(true);
+
+        $container->compile();
+        $dumper = new PhpDumper($container);
+        $dump = $dumper->dump(['class' => 'Symfony_DI_PhpDumper_Service_Wither']);
+        $this->assertStringEqualsFile(self::$fixturesPath.'/php/services_wither.php', $dump);
+        eval('?>'.$dump);
+
+        $container = new \Symfony_DI_PhpDumper_Service_Wither();
+
+        $wither = $container->get('wither');
+        $this->assertInstanceOf(Foo::class, $wither->foo);
+    }
 }
 
 class Rot13EnvVarProcessor implements EnvVarProcessorInterface
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/includes/autowiring_classes.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/includes/autowiring_classes.php
@@ -278,6 +278,21 @@ public function setChildMethodWithoutDocBlock(A $a)
     }
 }
 
+class Wither
+{
+    /**
+     * @required
+     * @return static
+     */
+    public function withFoo(Foo $foo)
+    {
+        $new = clone $this;
+        $new->foo = $foo;
+
+        return $new;
+    }
+}
+
 class SetterInjectionParent
 {
     /** @required*/
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/php/services_wither.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/php/services_wither.php
@@ -0,0 +1,64 @@
+<?php
+
+use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Container;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag;
+
+/**
+ * This class has been auto-generated
+ * by the Symfony Dependency Injection Component.
+ *
+ * @final since Symfony 3.3
+ */
+class Symfony_DI_PhpDumper_Service_Wither extends Container
+{
+    private $parameters;
+    private $targetDirs = [];
+
+    public function __construct()
+    {
+        $this->services = $this->privates = [];
+        $this->methodMap = [
+            'wither' => 'getWitherService',
+        ];
+
+        $this->aliases = [];
+    }
+
+    public function compile()
+    {
+        throw new LogicException('You cannot compile a dumped container that was already compiled.');
+    }
+
+    public function isCompiled()
+    {
+        return true;
+    }
+
+    public function getRemovedIds()
+    {
+        return [
+            'Psr\\Container\\ContainerInterface' => true,
+            'Symfony\\Component\\DependencyInjection\\ContainerInterface' => true,
+            'Symfony\\Component\\DependencyInjection\\Tests\\Compiler\\Foo' => true,
+        ];
+    }
+
+    /**
+     * Gets the public 'wither' shared autowired service.
+     *
+     * @return \Symfony\Component\DependencyInjection\Tests\Compiler\Wither
+     */
+    protected function getWitherService()
+    {
+        $this->services['wither'] = $instance = new \Symfony\Component\DependencyInjection\Tests\Compiler\Wither();
+
+        $instance = $instance->withFoo(new \Symfony\Component\DependencyInjection\Tests\Compiler\Foo());
+
+        return $this->services['wither'] = $instance;
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -343,6 +343,9 @@ private function getContainerDefinitionDocument(Definition $definition, string $`
`343`	`343`	`foreach ($calls as $callData) {`
`344`	`344`	`$callsXML->appendChild($callXML = $dom->createElement('call'));`
`345`	`345`	`$callXML->setAttribute('method', $callData[0]);`
	`346`	`+ if ($callData[2] ?? false) {`
	`347`	`+ $callXML->setAttribute('use-result', 'true');`
	`348`	`+ }`
`346`	`349`	`}`
`347`	`350`	`}`
`348`	`351`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ protected function processValue($value, $isRoot = false)`
`50`	`50`	`while (true) {`
`51`	`51`	`if (false !== $doc = $r->getDocComment()) {`
`52`	`52`	`if (false !== stripos($doc, '@required') && preg_match('#(?:^/\\\|\n\s+\)\s+@required(?:\s\|\/$)#i', $doc)) {`
`53`		`- $value->addMethodCall($reflectionMethod->name);`
	`53`	`+ $value->addMethodCall($reflectionMethod->name, [], preg_match('#(?:^/\\\|\n\s+\)\s+@return\s++static[\s\]#i', $doc));`
`54`	`54`	`break;`
`55`	`55`	`}`
`56`	`56`	`if (false === stripos($doc, '@inheritdoc') \|\| !preg_match('#(?:^/\\\|\n\s+\)\s+(?:\{@inheritdoc\}\|@inheritdoc)(?:\s\|\/$)#i', $doc)) {`
Original file line number	Diff line number	Diff line change
`@@ -1150,7 +1150,7 @@ private function createService(Definition $definition, array &$inlineServices, $`
`1150`	`1150`	`}`
`1151`	`1151`
`1152`	`1152`	`foreach ($definition->getMethodCalls() as $call) {`
`1153`		`- $this->callMethod($service, $call, $inlineServices);`
	`1153`	`+ $service = $this->callMethod($service, $call, $inlineServices);`
`1154`	`1154`	`}`
`1155`	`1155`
`1156`	`1156`	`if ($callable = $definition->getConfigurator()) {`
`@@ -1568,16 +1568,18 @@ private function callMethod($service, $call, array &$inlineServices)`
`1568`	`1568`	`{`
`1569`	`1569`	`foreach (self::getServiceConditionals($call[1]) as $s) {`
`1570`	`1570`	`if (!$this->has($s)) {`
`1571`		`- return;`
	`1571`	`+ return $service;`
`1572`	`1572`	`}`
`1573`	`1573`	`}`
`1574`	`1574`	`foreach (self::getInitializedConditionals($call[1]) as $s) {`
`1575`	`1575`	`if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {`
`1576`		`- return;`
	`1576`	`+ return $service;`
`1577`	`1577`	`}`
`1578`	`1578`	`}`
`1579`	`1579`
`1580`		`- $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));`
	`1580`	`+ $result = $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));`
	`1581`	`+`
	`1582`	`+ return empty($call[2]) ? $service : $result;`
`1581`	`1583`	`}`
`1582`	`1584`
`1583`	`1585`	`/**`
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;`
`@@ -341,17 +341,18 @@ public function setMethodCalls(array $calls = [])`
`341`	`341`	`*`
`342`	`342`	`* @param string $method The method name to call`
`343`	`343`	`* @param array $arguments An array of arguments to pass to the method call`
	`344`	`+ * @param bool $useResult 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 $useResult = 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('use-result', '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), $call->getAttribute('use-result'));`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`$tags = $this->getChildren($service, 'tag');`
Original file line number	Diff line number	Diff line change
`@@ -471,7 +471,7 @@ private function parseDefinition($id, $service, $file, array $defaults)`
`471`	`471`	`if (!\is_array($args)) {`
`472`	`472`	`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`	`473`	`}`
`474`		`- $definition->addMethodCall($method, $args);`
	`474`	`+ $definition->addMethodCall($method, $args, $call['use_result'] ?? false);`
`475`	`475`	`}`
`476`	`476`	`}`
`477`	`477`