bug #60842 [DependencyInjection] Fix generating adapters of functional interfaces (nicolas-grekas)

nicolas-grekas · nicolas-grekas · commit 26e3fc7887ea · 2025-06-20T07:44:23.000+02:00
This PR was merged into the 6.4 branch. Discussion ---------- [DependencyInjection] Fix generating adapters of functional interfaces | Q | A | ------------- | --- | Branch? | 6.4 | Bug fix? | yes | New feature? | no | Deprecations? | no | Issues | - | License | MIT Fixes support for generating adapters from static method, and also from inline services when they're put in a temporary variable. Commits ------- 86a4445 [DependencyInjection] Fix generating adapters of functional interfaces
diff --git a/src/Symfony/Component/DependencyInjection/Argument/LazyClosure.php b/src/Symfony/Component/DependencyInjection/Argument/LazyClosure.php
@@ -40,22 +40,22 @@ public function __get(mixed $name): mixed
         }
 
         if (isset($this->initializer)) {
-            $this->service = ($this->initializer)();
+            if (\is_string($service = ($this->initializer)())) {
+                $service = (new \ReflectionClass($service))->newInstanceWithoutConstructor();
+            }
+            $this->service = $service;
             unset($this->initializer);
         }
 
         return $this->service;
     }
 
-    public static function getCode(string $initializer, array $callable, Definition $definition, ContainerBuilder $container, ?string $id): string
+    public static function getCode(string $initializer, array $callable, string $class, ContainerBuilder $container, ?string $id): string
     {
         $method = $callable[1];
-        $asClosure = 'Closure' === ($definition->getClass() ?: 'Closure');
 
-        if ($asClosure) {
+        if ($asClosure = 'Closure' === $class) {
             $class = ($callable[0] instanceof Reference ? $container->findDefinition($callable[0]) : $callable[0])->getClass();
-        } else {
-            $class = $definition->getClass();
         }
 
         $r = $container->getReflectionClass($class);
diff --git a/src/Symfony/Component/DependencyInjection/ContainerBuilder.php b/src/Symfony/Component/DependencyInjection/ContainerBuilder.php
@@ -1060,14 +1060,15 @@ private function createService(Definition $definition, array &$inlineServices, b
             }
 
             if (\is_array($callable) && (
-                $callable[0] instanceof Reference
+                'Closure' !== $class
+                || $callable[0] instanceof Reference
                 || $callable[0] instanceof Definition && !isset($inlineServices[spl_object_hash($callable[0])])
             )) {
                 $initializer = function () use ($callable, &$inlineServices) {
                     return $this->doResolveServices($callable[0], $inlineServices);
                 };
 
-                $proxy = eval('return '.LazyClosure::getCode('$initializer', $callable, $definition, $this, $id).';');
+                $proxy = eval('return '.LazyClosure::getCode('$initializer', $callable, $class, $this, $id).';');
                 $this->shareService($definition, $proxy, $id, $inlineServices);
 
                 return $proxy;
diff --git a/src/Symfony/Component/DependencyInjection/Dumper/PhpDumper.php b/src/Symfony/Component/DependencyInjection/Dumper/PhpDumper.php
@@ -1202,13 +1202,13 @@ private function addNewInstance(Definition $definition, string $return = '', ?st
                 throw new RuntimeException(sprintf('Cannot dump definition because of invalid factory method (%s).', $callable[1] ?: 'n/a'));
             }
 
-            if (['...'] === $arguments && ($definition->isLazy() || 'Closure' !== ($definition->getClass() ?? 'Closure')) && (
+            if (['...'] === $arguments && ('Closure' !== ($class = $definition->getClass() ?: 'Closure') || $definition->isLazy() && (
                 $callable[0] instanceof Reference
                 || ($callable[0] instanceof Definition && !$this->definitionVariables->contains($callable[0]))
-            )) {
+            ))) {
                 $initializer = 'fn () => '.$this->dumpValue($callable[0]);
 
-                return $return.LazyClosure::getCode($initializer, $callable, $definition, $this->container, $id).$tail;
+                return $return.LazyClosure::getCode($initializer, $callable, $class, $this->container, $id).$tail;
             }
 
             if ($callable[0] instanceof Reference
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Argument/LazyClosureTest.php b/src/Symfony/Component/DependencyInjection/Tests/Argument/LazyClosureTest.php
@@ -34,23 +34,23 @@ public function testThrowsWhenNotUsingInterface()
         $this->expectException(\RuntimeException::class);
         $this->expectExceptionMessage('Cannot create adapter for service "foo" because "Symfony\Component\DependencyInjection\Tests\Argument\LazyClosureTest" is not an interface.');
 
-        LazyClosure::getCode('foo', [new \stdClass(), 'bar'], new Definition(LazyClosureTest::class), new ContainerBuilder(), 'foo');
+        LazyClosure::getCode('foo', [new \stdClass(), 'bar'], LazyClosureTest::class, new ContainerBuilder(), 'foo');
     }
 
     public function testThrowsOnNonFunctionalInterface()
     {
         $this->expectException(\RuntimeException::class);
         $this->expectExceptionMessage('Cannot create adapter for service "foo" because interface "Symfony\Component\DependencyInjection\Tests\Argument\NonFunctionalInterface" doesn\'t have exactly one method.');
 
-        LazyClosure::getCode('foo', [new \stdClass(), 'bar'], new Definition(NonFunctionalInterface::class), new ContainerBuilder(), 'foo');
+        LazyClosure::getCode('foo', [new \stdClass(), 'bar'], NonFunctionalInterface::class, new ContainerBuilder(), 'foo');
     }
 
     public function testThrowsOnUnknownMethodInInterface()
     {
         $this->expectException(\RuntimeException::class);
         $this->expectExceptionMessage('Cannot create lazy closure for service "bar" because its corresponding callable is invalid.');
 
-        LazyClosure::getCode('bar', [new Definition(FunctionalInterface::class), 'bar'], new Definition(\Closure::class), new ContainerBuilder(), 'bar');
+        LazyClosure::getCode('bar', [new Definition(FunctionalInterface::class), 'bar'], \Closure::class, new ContainerBuilder(), 'bar');
     }
 }
 
diff --git a/src/Symfony/Component/DependencyInjection/Tests/ContainerBuilderTest.php b/src/Symfony/Component/DependencyInjection/Tests/ContainerBuilderTest.php
@@ -49,6 +49,7 @@
 use Symfony\Component\DependencyInjection\ServiceLocator;
 use Symfony\Component\DependencyInjection\Tests\Compiler\Foo;
 use Symfony\Component\DependencyInjection\Tests\Compiler\FooAnnotation;
+use Symfony\Component\DependencyInjection\Tests\Compiler\MyCallable;
 use Symfony\Component\DependencyInjection\Tests\Compiler\SingleMethodInterface;
 use Symfony\Component\DependencyInjection\Tests\Compiler\Wither;
 use Symfony\Component\DependencyInjection\Tests\Fixtures\CaseSensitiveClass;
@@ -522,6 +523,19 @@ public function testClosureProxy()
         $this->assertInstanceOf(Foo::class, $container->get('closure_proxy')->theMethod());
     }
 
+    public function testClosureProxyWithStaticMethod()
+    {
+        $container = new ContainerBuilder();
+        $container->register('closure_proxy', SingleMethodInterface::class)
+            ->setPublic('true')
+            ->setFactory(['Closure', 'fromCallable'])
+            ->setArguments([[MyCallable::class, 'theMethodImpl']]);
+        $container->compile();
+
+        $this->assertInstanceOf(SingleMethodInterface::class, $container->get('closure_proxy'));
+        $this->assertSame(124, $container->get('closure_proxy')->theMethod());
+    }
+
     public function testCreateServiceClass()
     {
         $builder = new ContainerBuilder();
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/includes/autowiring_classes.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/includes/autowiring_classes.php
@@ -582,4 +582,9 @@ class MyCallable
     public function __invoke(): void
     {
     }
+
+    public static function theMethodImpl(): int
+    {
+        return 124;
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -40,22 +40,22 @@ public function __get(mixed $name): mixed`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`if (isset($this->initializer)) {`
`43`		`- $this->service = ($this->initializer)();`
	`43`	`+ if (\is_string($service = ($this->initializer)())) {`
	`44`	`+ $service = (new \ReflectionClass($service))->newInstanceWithoutConstructor();`
	`45`	`+ }`
	`46`	`+ $this->service = $service;`
`44`	`47`	`unset($this->initializer);`
`45`	`48`	`}`
`46`	`49`
`47`	`50`	`return $this->service;`
`48`	`51`	`}`
`49`	`52`
`50`		`- public static function getCode(string $initializer, array $callable, Definition $definition, ContainerBuilder $container, ?string $id): string`
	`53`	`+ public static function getCode(string $initializer, array $callable, string $class, ContainerBuilder $container, ?string $id): string`
`51`	`54`	`{`
`52`	`55`	`$method = $callable[1];`
`53`		`- $asClosure = 'Closure' === ($definition->getClass() ?: 'Closure');`
`54`	`56`
`55`		`- if ($asClosure) {`
	`57`	`+ if ($asClosure = 'Closure' === $class) {`
`56`	`58`	`$class = ($callable[0] instanceof Reference ? $container->findDefinition($callable[0]) : $callable[0])->getClass();`
`57`		`- } else {`
`58`		`- $class = $definition->getClass();`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`$r = $container->getReflectionClass($class);`
Original file line number	Diff line number	Diff line change
`@@ -1202,13 +1202,13 @@ private function addNewInstance(Definition $definition, string $return = '', ?st`
`1202`	`1202`	`throw new RuntimeException(sprintf('Cannot dump definition because of invalid factory method (%s).', $callable[1] ?: 'n/a'));`
`1203`	`1203`	`}`
`1204`	`1204`
`1205`		`- if (['...'] === $arguments && ($definition->isLazy() \|\| 'Closure' !== ($definition->getClass() ?? 'Closure')) && (`
	`1205`	`+ if (['...'] === $arguments && ('Closure' !== ($class = $definition->getClass() ?: 'Closure') \|\| $definition->isLazy() && (`
`1206`	`1206`	`$callable[0] instanceof Reference`
`1207`	`1207`	`\|\| ($callable[0] instanceof Definition && !$this->definitionVariables->contains($callable[0]))`
`1208`		`- )) {`
	`1208`	`+ ))) {`
`1209`	`1209`	`$initializer = 'fn () => '.$this->dumpValue($callable[0]);`
`1210`	`1210`
`1211`		`- return $return.LazyClosure::getCode($initializer, $callable, $definition, $this->container, $id).$tail;`
	`1211`	`+ return $return.LazyClosure::getCode($initializer, $callable, $class, $this->container, $id).$tail;`
`1212`	`1212`	`}`
`1213`	`1213`
`1214`	`1214`	`if ($callable[0] instanceof Reference`
Original file line number	Diff line number	Diff line change
`@@ -34,23 +34,23 @@ public function testThrowsWhenNotUsingInterface()`
`34`	`34`	`$this->expectException(\RuntimeException::class);`
`35`	`35`	`$this->expectExceptionMessage('Cannot create adapter for service "foo" because "Symfony\Component\DependencyInjection\Tests\Argument\LazyClosureTest" is not an interface.');`
`36`	`36`
`37`		`- LazyClosure::getCode('foo', [new \stdClass(), 'bar'], new Definition(LazyClosureTest::class), new ContainerBuilder(), 'foo');`
	`37`	`+ LazyClosure::getCode('foo', [new \stdClass(), 'bar'], LazyClosureTest::class, new ContainerBuilder(), 'foo');`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`public function testThrowsOnNonFunctionalInterface()`
`41`	`41`	`{`
`42`	`42`	`$this->expectException(\RuntimeException::class);`
`43`	`43`	`$this->expectExceptionMessage('Cannot create adapter for service "foo" because interface "Symfony\Component\DependencyInjection\Tests\Argument\NonFunctionalInterface" doesn\'t have exactly one method.');`
`44`	`44`
`45`		`- LazyClosure::getCode('foo', [new \stdClass(), 'bar'], new Definition(NonFunctionalInterface::class), new ContainerBuilder(), 'foo');`
	`45`	`+ LazyClosure::getCode('foo', [new \stdClass(), 'bar'], NonFunctionalInterface::class, new ContainerBuilder(), 'foo');`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`public function testThrowsOnUnknownMethodInInterface()`
`49`	`49`	`{`
`50`	`50`	`$this->expectException(\RuntimeException::class);`
`51`	`51`	`$this->expectExceptionMessage('Cannot create lazy closure for service "bar" because its corresponding callable is invalid.');`
`52`	`52`
`53`		`- LazyClosure::getCode('bar', [new Definition(FunctionalInterface::class), 'bar'], new Definition(\Closure::class), new ContainerBuilder(), 'bar');`
	`53`	`+ LazyClosure::getCode('bar', [new Definition(FunctionalInterface::class), 'bar'], \Closure::class, new ContainerBuilder(), 'bar');`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
Original file line number	Diff line number	Diff line change
`@@ -582,4 +582,9 @@ class MyCallable`
`582`	`582`	`public function __invoke(): void`
`583`	`583`	`{`
`584`	`584`	`}`
	`585`	`+`
	`586`	`+ public static function theMethodImpl(): int`
	`587`	`+ {`
	`588`	`+ return 124;`
	`589`	`+ }`
`585`	`590`	`}`