Best case would be to allow interface usage instead of string-based tag names:

class MyService
{
    public function __construct(
        #[TaggedInterface(FormTypeInterface::class)] private ServiceLocator $tagged
    ) {}
    
    /**
    * @param class-string<FormTypeInterface> $className
    */
    public function get(string $className): FormTypeInterface
    {
        return $this->tagged->get($className);
    }
}

$formType = $myService->get(EntityType::class);

A feature like this could be useful for a day we get generics; tools like rector might provide automigration:

public function __construct(private ServiceLocator<FormTypeInterface> $tagged)

#[Tagged(name: 'form.type')]

This looks like just one step after #39897 - could happen in 5.3 :)

#[TaggedInterface(FormTypeInterface::class)]

I would clearly advise against this. It's a shortcut that forgets that tags are absolutely required as intermediaries to create collections of services in a decoupled way.

But fortunately, together with #39804, you might end up being able to provide a very similar DX.

I would clearly advise against this.

That is OK. My tagged services have same name as interface i.e.

$container->registerForAutoconfiguration(ExporterInterface::class)->addTag(ExporterInterface::class);

so I thought to maybe even remove this one line. But yes, it might be too much, sorry.

PR welcome @zmitic

@nicolas-grekas For #[TaggedInterface]?

If so; would I be allowed to create another class instead of ServiceLocator, and add stubs like in the first comment?

For #[Tagged(name: 'form.type')] (see above about #[TaggedInterface])

@nicolas-grekas

I am sorry I didn't have time for this before.

Before I start, just to confirm:

• unless indexAttribute is defined, keys should be class names instead of integers; correct?

I.e. instead of this way to get class-name based index:

class MyMainService
{
    public function __construct(
        #[TaggedLocator(tag: ViewFactoryInterface::class, indexAttribute: 'default')] 
        private ServiceLocator $tagged,
    )
    {
    }
}

abstract class AbstractViewFactory implements ViewFactoryInterface
{
    public static function getDefaultName(): string
    {
        return self::class;
    }
}

it should work this way when indexAttribute is null. Is this correct?

With latest @fractalzombie patch, everything works perfectly.

Thank you all.