vendor/symfony/dependency-injection/Compiler/ServiceLocatorTagPass.php line 103

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\DependencyInjection\Compiler;
  14. use Symfony\Component\DependencyInjection\Alias;
  15. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  16. use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
  17. use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
  18. use Symfony\Component\DependencyInjection\ContainerBuilder;
  19. use Symfony\Component\DependencyInjection\Definition;
  20. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  21. use Symfony\Component\DependencyInjection\Reference;
  22. use Symfony\Component\DependencyInjection\ServiceLocator;
  24. /**
  25.  * Applies the "container.service_locator" tag by wrapping references into ServiceClosureArgument instances.
  26.  *
  27.  * @author Nicolas Grekas <p@tchwork.com>
  28.  */
  29. final class ServiceLocatorTagPass extends AbstractRecursivePass
  30. {
  31.     use PriorityTaggedServiceTrait;
  33.     protected function processValue(mixed $value, bool $isRoot = false): mixed
  34.     {
  35.         if ($value instanceof ServiceLocatorArgument) {
  36.             if ($value->getTaggedIteratorArgument()) {
  37.                 $value->setValues($this->findAndSortTaggedServices($value->getTaggedIteratorArgument(), $this->container));
  38.             }
  40.             return self::register($this->container, $value->getValues());
  41.         }
  43.         if ($value instanceof Definition) {
  44.             $value->setBindings(parent::processValue($value->getBindings()));
  45.         }
  47.         if (!$value instanceof Definition || !$value->hasTag('container.service_locator')) {
  48.             return parent::processValue($value, $isRoot);
  49.         }
  51.         if (!$value->getClass()) {
  52.             $value->setClass(ServiceLocator::class);
  53.         }
  55.         $services = $value->getArguments()[0] ?? null;
  57.         if ($services instanceof TaggedIteratorArgument) {
  58.             $services = $this->findAndSortTaggedServices($services, $this->container);
  59.         }
  61.         if (!\is_array($services)) {
  62.             throw new InvalidArgumentException(sprintf('Invalid definition for service "%s": an array of references is expected as first argument when the "container.service_locator" tag is set.', $this->currentId));
  63.         }
  65.         $i = 0;
  67.         foreach ($services as $k => $v) {
  68.             if ($v instanceof ServiceClosureArgument) {
  69.                 continue;
  70.             }
  72.             if ($i === $k) {
  73.                 if ($v instanceof Reference) {
  74.                     unset($services[$k]);
  75.                     $k = (string) $v;
  76.                 }
  77.                 ++$i;
  78.             } elseif (\is_int($k)) {
  79.                 $i = null;
  80.             }
  82.             $services[$k] = new ServiceClosureArgument($v);
  83.         }
  84.         ksort($services);
  86.         $value->setArgument(0, $services);
  88.         $id = '.service_locator.'.ContainerBuilder::hash($value);
  90.         if ($isRoot) {
  91.             if ($id !== $this->currentId) {
  92.                 $this->container->setAlias($id, new Alias($this->currentId, false));
  93.             }
  95.             return $value;
  96.         }
  98.         $this->container->setDefinition($id, $value->setPublic(false));
  100.         return new Reference($id);
  101.     }
  103.     public static function register(ContainerBuilder $container, array $map, string $callerId = null): Reference
  104.     {
  105.         foreach ($map as $k => $v) {
  106.             $map[$k] = new ServiceClosureArgument($v);
  107.         }
  109.         $locator = (new Definition(ServiceLocator::class))
  110.             ->addArgument($map)
  111.             ->addTag('container.service_locator');
  113.         if (null !== $callerId && $container->hasDefinition($callerId)) {
  114.             $locator->setBindings($container->getDefinition($callerId)->getBindings());
  115.         }
  117.         if (!$container->hasDefinition($id = '.service_locator.'.ContainerBuilder::hash($locator))) {
  118.             $container->setDefinition($id, $locator);
  119.         }
  121.         if (null !== $callerId) {
  122.             $locatorId = $id;
  123.             // Locators are shared when they hold the exact same list of factories;
  124.             // to have them specialized per consumer service, we use a cloning factory
  125.             // to derivate customized instances from the prototype one.
  126.             $container->register($id .= '.'.$callerId, ServiceLocator::class)
  127.                 ->setFactory([new Reference($locatorId), 'withContext'])
  128.                 ->addTag('container.service_locator_context', ['id' => $callerId])
  129.                 ->addArgument($callerId)
  130.                 ->addArgument(new Reference('service_container'));
  131.         }
  133.         return new Reference($id);
  134.     }
  135. }