Injecting all tagged services in a service by variadic constructor

[jmediatechnology]

Description

Injecting all tagged services to a service is possible by declaring an iterable within the constructor.
Example:

namespace App;

class HandlerCollection
{
    public function __construct(iterable $handlers)
    {
    }
}

The services.yaml might look like this:

services:
    App\Handler\One:
        tags: ['app.handler']

    App\Handler\Two:
        tags: ['app.handler']

    App\HandlerCollection:
        # inject all services tagged with app.handler as first argument
        arguments:
            - !tagged_iterator app.handler

Example code found here:
https://symfony.com/doc/current/service_container/tags.html#reference-tagged-services

---

In practise my code will look like this:

namespace App;

class ChainService
{
    /**
     * @param iterable<AwesomeService> $awesomeServices
     */
    public function __construct(private iterable $awesomeServices) {}

    public function doSomething(string $string): string
    {
        foreach ($this->awesomeServices as $awesomeService) {
            if ($awesomeService->supports($string)) {
                return $awesomeService->doSomething($string);
            }
        }

        throw new InvalidArgumentException(
            sprintf(
                'Failed to do something with "%s".',
                $string,
            )
        );
    }
}

To extinguish the need of the @param annotation in this case I would like to use a typed variable-length argument lists in the constructor instead of an iterable, like this:

namespace App;

class ChainService
{
    private array $awesomeServices;

    public function __construct(AwesomeService ...$awesomeServices) {}

    public function doSomething(string $string): string
    {
        foreach ($this->awesomeServices as $awesomeService) {
            if ($awesomeService->supports($string)) {
                return $awesomeService->doSomething($string);
            }
        }

        throw new InvalidArgumentException(
            sprintf(
                'Failed to do something with "%s".',
                $string,
            )
        );
    }
}

The tagged_iterator is not able to deal with this code because the Dependency Injection component will try to inject an RewindableGenerator to ChainService which implements an IteratorAggregate, thus triggering a type error.

The usage of variadics in a typed constructor argument is possible when services are wired manually in services.yaml.
For example:

services:
    App\ChainService:
        arguments:
            - '@App\AwesomeService1'
            - '@App\AwesomeService2'
            - '@App\AwesomeService3'

Can you make the tagged_iterator operational for typed variadic constructor arguments?
Or can you introduce something else to make the typed variadic constructor arguments possible?

Example

services:
    App\ChainService:
        arguments:
            - !variadic app.handler

[lyrixx]

If I remember correctly, I already opened a PR that has been refused

See #33722

[nicolas-grekas]

There's a critical difference between both implementations: the non-variadic variant will not instantiate services that are listed after the one that "supports" the thing, while the variadic variant will consume the full iterator.

Personally, this style using variadics is a hack and doesn't need to be supported as such. See how the argument "removing an @param" can lead to effective and nasty runtime side effects.

[nicolas-grekas]

Closing for the reason given in my last comment.