TL;DR

We needed to use the ServiceSubscriber feature in a reusable Bundle.
The best practices for Bundles is to not use the Autowire feature.
But the way service subscriber are registered / resolved only works with autowired services at the moment.

The goal of this PR is to provide a way to easily extract the Locator for a service subscriber class / definition and use it in a custom compiler pass for example.

class MyPass implements CompilerPassInterface
{
    public function process(...)
    {
        $myServiceSubscriber = $container->getDefinition('my_service_subscriber');

        $locator = RegisterServiceSubscribersPass::registerLocator($container, 'my_service_subscriber');

        $myServiceSubscriber->addMethodCall('setContainer', [$locator]);
    }
}

More details

1. The ServiceSubscriberInterface is parsed by the RegisterServiceSubscribersPass if the service definition has the container.service_subscriber
2. It process the getSubscribedServices static method to cerate a $serviceMap
3. It registers a ServiceLocator specific for this Service
4. It adds a tag container.service_subscriber.locator with the id of the service locator
5. It automatically binds the locator on the service for anything matching PsrContainerInterface
6. later on, it goes through ResolveServiceSubscribersPass which clears tags + inject the locator

There is mo way to insert a compiler pass in between those two, they have the same priority in the same PassConfig type.

Apart from re-doing all the logic ourselves, there are no easy way to create a service locator solely based on the interface.

Why do I need to use a ServiceSubscriber in my Bundle ?

Our bundle provides extension points, allowing developers to create their own services that integrate seamlessly with the bundle's internal logic. This improves the developer experience (DX) by simplifying service wiring.

Since we can't predict in advance which services these extensions will depend on, using a ServiceSubscriber is ideal. It allows us to support dynamic dependencies without requiring developers to write a compiler pass.

For example, if a developer adds a trait like TwigAwareTrait to a class, the twig service becomes a dependency. We want to give them the flexibility to inject such additional services—beyond those provided by default in the service locator—in a clean and declarative way.