feature #54016 [DependencyInjection] Add #[AutowireMethodOf] attribute to autowire a method of a service as a callable (nicolas-grekas)

This PR was merged into the 7.1 branch.

Discussion
----------

[DependencyInjection] Add `#[AutowireMethodOf]` attribute to autowire a method of a service as a callable

| Q             | A
| ------------- | ---
| Branch?       | 7.1
| Bug fix?      | no
| New feature?  | yes
| Deprecations? | no
| Issues        | -
| License       | MIT

Let's take a controller for example, with one action that has this argument:
```php
        #[AutowireMethodOf(CommentRepository::class)]
        \Closure $getCommentPaginator,
```

The proposed attribute tells Symfony to create a closure that will call `CommentRepository::getCommentPaginator()`. The name of the method to be called is inferred from the name of the parameter.

This is already doable with this syntax, so that the proposed attribute is just a shortcut for this:
```php
        #[AutowireCallable(service: CommentRepository::class, method: 'getCommentPaginator')]
        \Closure $getCommentPaginator,
```

Using this style allows turning e.g. entity repositories into query functions, which are way more flexible. But because the existing syntax is quite verbose, i looked for a more concise alternative, so here we are with this proposal.

Benefits:
- Increased Flexibility: Allows developers to inject specific methods as Closures, providing greater control over what functionality is injected into
- Improved Readability: By using the attribute, the intention behind the dependency injection is made explicit, improving code clarity.
-  **Enhanced Modularity: Facilitates a more modular architecture by decoupling services from direct dependencies on specific class methods, making the codebase more maintainable and testable.**

Because we leverage the existing code infrastructure for AutowireCallable, if I declare this interface:
```php
interface GetCommentPaginatorInterface
{
    public function __invoke(Conference $conference, int $page): Paginator;
}
```

then I can also do native types (vs a closure) without doing anything else:
```php
        #[AutowireMethodOf(CommentRepository::class)]
        GetCommentPaginatorInterface $getCommentPaginator,
```

Commits
-------

df11660015 [DependencyInjection] Add `#[AutowireMethodOf]` attribute to autowire a method of a service as a callable

Author: nicolas-grekas

Attribute/AutowireMethodOf.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\DependencyInjection\Attribute;
+
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Tells which method should be turned into a Closure based on the name of the parameter it's attached to.
+ */
+#[\Attribute(\Attribute::TARGET_PARAMETER)]
+class AutowireMethodOf extends AutowireCallable
+{
+    /**
+     * @param string            $service The service containing the method to autowire
+     * @param bool|class-string $lazy    Whether to use lazy-loading for this argument
+     */
+    public function __construct(string $service, bool|string $lazy = false)
+    {
+        parent::__construct([new Reference($service)], lazy: $lazy);
+    }
+
+    public function buildDefinition(mixed $value, ?string $type, \ReflectionParameter $parameter): Definition
+    {
+        $value[1] = $parameter->name;
+
+        return parent::buildDefinition($value, $type, $parameter);
+    }
+}

CHANGELOG.md

@@ -8,6 +8,7 @@ CHANGELOG
  * Add argument `$prepend` to `ContainerConfigurator::extension()` to prepend the configuration instead of appending it
  * Have `ServiceLocator` implement `ServiceCollectionInterface`
  * Add `#[Lazy]` attribute as shortcut for `#[Autowire(lazy: [bool|string])]` and `#[Autoconfigure(lazy: [bool|string])]`
+ * Add `#[AutowireMethodOf]` attribute to autowire a method of a service as a callable
 
 7.0
 ---

Compiler/CheckExceptionOnInvalidReferenceBehaviorPass.php

@@ -47,7 +47,7 @@ protected function processValue(mixed $value, bool $isRoot = false): mixed
         if (!$value instanceof Reference) {
             return parent::processValue($value, $isRoot);
         }
-        if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE < $value->getInvalidBehavior() || $this->container->has($id = (string) $value)) {
+        if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE < $value->getInvalidBehavior() || $this->container->has((string) $value)) {
             return $value;
         }
 
@@ -83,7 +83,7 @@ protected function processValue(mixed $value, bool $isRoot = false): mixed
         $this->throwServiceNotFoundException($value, $currentId, $value);
     }
 
-    private function throwServiceNotFoundException(Reference $ref, string $sourceId, $value): void
+    private function throwServiceNotFoundException(Reference $ref, string $sourceId, mixed $value): void
     {
         $id = (string) $ref;
         $alternatives = [];

Tests/Attribute/AutowireMethodOfTest.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\DependencyInjection\Tests\Attribute;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\DependencyInjection\Attribute\AutowireMethodOf;
+use Symfony\Component\DependencyInjection\Reference;
+
+class AutowireMethodOfTest extends TestCase
+{
+    public function testConstructor()
+    {
+        $a = new AutowireMethodOf('foo');
+
+        $this->assertEquals([new Reference('foo')], $a->value);
+    }
+
+    public function testBuildDefinition(?\Closure $dummy = null)
+    {
+        $a = new AutowireMethodOf('foo');
+        $r = new \ReflectionParameter([__CLASS__, __FUNCTION__], 0);
+
+        $this->assertEquals([[new Reference('foo'), 'dummy']], $a->buildDefinition($a->value, 'Closure', $r)->getArguments());
+    }
+}