Merge branch '7.2' into 7.3

nicolas-grekas · nicolas-grekas · commit ae30d7c04d24 · 2025-06-20T07:45:27.000+02:00
* 7.2:
  [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
@@ -1109,14 +1109,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
@@ -1184,13 +1184,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
@@ -33,23 +33,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(self::class), new ContainerBuilder(), 'foo');
+        LazyClosure::getCode('foo', [new \stdClass(), 'bar'], self::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
@@ -50,6 +50,7 @@
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\DependencyInjection\ServiceLocator;
 use Symfony\Component\DependencyInjection\Tests\Compiler\Foo;
+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;
@@ -532,6 +533,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
@@ -462,6 +462,11 @@ class MyCallable
     public function __invoke(): void
     {
     }
+
+    public static function theMethodImpl(): int
+    {
+        return 124;
+    }
 }
 
 class MyInlineService

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
`@@ -1184,13 +1184,13 @@ private function addNewInstance(Definition $definition, string $return = '', ?st`
`1184`	`1184`	`throw new RuntimeException(\sprintf('Cannot dump definition because of invalid factory method (%s).', $callable[1] ?: 'n/a'));`
`1185`	`1185`	`}`
`1186`	`1186`
`1187`		`- if (['...'] === $arguments && ($definition->isLazy() \|\| 'Closure' !== ($definition->getClass() ?? 'Closure')) && (`
	`1187`	`+ if (['...'] === $arguments && ('Closure' !== ($class = $definition->getClass() ?: 'Closure') \|\| $definition->isLazy() && (`
`1188`	`1188`	`$callable[0] instanceof Reference`
`1189`	`1189`	`\|\| ($callable[0] instanceof Definition && !$this->definitionVariables->contains($callable[0]))`
`1190`		`- )) {`
	`1190`	`+ ))) {`
`1191`	`1191`	`$initializer = 'fn () => '.$this->dumpValue($callable[0]);`
`1192`	`1192`
`1193`		`- return $return.LazyClosure::getCode($initializer, $callable, $definition, $this->container, $id).$tail;`
	`1193`	`+ return $return.LazyClosure::getCode($initializer, $callable, $class, $this->container, $id).$tail;`
`1194`	`1194`	`}`
`1195`	`1195`
`1196`	`1196`	`if ($callable[0] instanceof Reference`
Original file line number	Diff line number	Diff line change
`@@ -33,23 +33,23 @@ public function testThrowsWhenNotUsingInterface()`
`33`	`33`	`$this->expectException(\RuntimeException::class);`
`34`	`34`	`$this->expectExceptionMessage('Cannot create adapter for service "foo" because "Symfony\Component\DependencyInjection\Tests\Argument\LazyClosureTest" is not an interface.');`
`35`	`35`
`36`		`- LazyClosure::getCode('foo', [new \stdClass(), 'bar'], new Definition(self::class), new ContainerBuilder(), 'foo');`
	`36`	`+ LazyClosure::getCode('foo', [new \stdClass(), 'bar'], self::class, new ContainerBuilder(), 'foo');`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public function testThrowsOnNonFunctionalInterface()`
`40`	`40`	`{`
`41`	`41`	`$this->expectException(\RuntimeException::class);`
`42`	`42`	`$this->expectExceptionMessage('Cannot create adapter for service "foo" because interface "Symfony\Component\DependencyInjection\Tests\Argument\NonFunctionalInterface" doesn\'t have exactly one method.');`
`43`	`43`
`44`		`- LazyClosure::getCode('foo', [new \stdClass(), 'bar'], new Definition(NonFunctionalInterface::class), new ContainerBuilder(), 'foo');`
	`44`	`+ LazyClosure::getCode('foo', [new \stdClass(), 'bar'], NonFunctionalInterface::class, new ContainerBuilder(), 'foo');`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`public function testThrowsOnUnknownMethodInInterface()`
`48`	`48`	`{`
`49`	`49`	`$this->expectException(\RuntimeException::class);`
`50`	`50`	`$this->expectExceptionMessage('Cannot create lazy closure for service "bar" because its corresponding callable is invalid.');`
`51`	`51`
`52`		`- LazyClosure::getCode('bar', [new Definition(FunctionalInterface::class), 'bar'], new Definition(\Closure::class), new ContainerBuilder(), 'bar');`
	`52`	`+ LazyClosure::getCode('bar', [new Definition(FunctionalInterface::class), 'bar'], \Closure::class, new ContainerBuilder(), 'bar');`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
Original file line number	Diff line number	Diff line change
`@@ -462,6 +462,11 @@ class MyCallable`
`462`	`462`	`public function __invoke(): void`
`463`	`463`	`{`
`464`	`464`	`}`
	`465`	`+`
	`466`	`+ public static function theMethodImpl(): int`
	`467`	`+ {`
	`468`	`+ return 124;`
	`469`	`+ }`
`465`	`470`	`}`
`466`	`471`
`467`	`472`	`class MyInlineService`