vendor/symfony/dependency-injection/ContainerBuilder.php line 319

Open in your IDE?
  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;
  14. use Composer\InstalledVersions;
  15. use Psr\Container\ContainerInterface as PsrContainerInterface;
  16. use Symfony\Component\Config\Resource\ClassExistenceResource;
  17. use Symfony\Component\Config\Resource\ComposerResource;
  18. use Symfony\Component\Config\Resource\DirectoryResource;
  19. use Symfony\Component\Config\Resource\FileExistenceResource;
  20. use Symfony\Component\Config\Resource\FileResource;
  21. use Symfony\Component\Config\Resource\GlobResource;
  22. use Symfony\Component\Config\Resource\ReflectionClassResource;
  23. use Symfony\Component\Config\Resource\ResourceInterface;
  24. use Symfony\Component\DependencyInjection\Argument\AbstractArgument;
  25. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  26. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  27. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  28. use Symfony\Component\DependencyInjection\Argument\ServiceLocator;
  29. use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
  30. use Symfony\Component\DependencyInjection\Attribute\Target;
  31. use Symfony\Component\DependencyInjection\Compiler\Compiler;
  32. use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
  33. use Symfony\Component\DependencyInjection\Compiler\PassConfig;
  34. use Symfony\Component\DependencyInjection\Compiler\ResolveEnvPlaceholdersPass;
  35. use Symfony\Component\DependencyInjection\Exception\BadMethodCallException;
  36. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  37. use Symfony\Component\DependencyInjection\Exception\LogicException;
  38. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  39. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  40. use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
  41. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  42. use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\InstantiatorInterface;
  43. use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\RealServiceInstantiator;
  44. use Symfony\Component\DependencyInjection\ParameterBag\EnvPlaceholderParameterBag;
  45. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
  46. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  47. use Symfony\Component\ExpressionLanguage\Expression;
  48. use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
  50. /**
  51.  * ContainerBuilder is a DI container that provides an API to easily describe services.
  52.  *
  53.  * @author Fabien Potencier <fabien@symfony.com>
  54.  */
  55. class ContainerBuilder extends Container implements TaggedContainerInterface
  56. {
  57.     /**
  58.      * @var array<string, ExtensionInterface>
  59.      */
  60.     private $extensions = [];
  62.     /**
  63.      * @var array<string, ExtensionInterface>
  64.      */
  65.     private $extensionsByNs = [];
  67.     /**
  68.      * @var array<string, Definition>
  69.      */
  70.     private $definitions = [];
  72.     /**
  73.      * @var array<string, Alias>
  74.      */
  75.     private $aliasDefinitions = [];
  77.     /**
  78.      * @var array<string, ResourceInterface>
  79.      */
  80.     private $resources = [];
  82.     /**
  83.      * @var array<string, array<array<string, mixed>>>
  84.      */
  85.     private $extensionConfigs = [];
  87.     /**
  88.      * @var Compiler
  89.      */
  90.     private $compiler;
  92.     /**
  93.      * @var bool
  94.      */
  95.     private $trackResources;
  97.     /**
  98.      * @var InstantiatorInterface|null
  99.      */
  100.     private $proxyInstantiator;
  102.     /**
  103.      * @var ExpressionLanguage|null
  104.      */
  105.     private $expressionLanguage;
  107.     /**
  108.      * @var ExpressionFunctionProviderInterface[]
  109.      */
  110.     private $expressionLanguageProviders = [];
  112.     /**
  113.      * @var string[] with tag names used by findTaggedServiceIds
  114.      */
  115.     private $usedTags = [];
  117.     /**
  118.      * @var string[][] a map of env var names to their placeholders
  119.      */
  120.     private $envPlaceholders = [];
  122.     /**
  123.      * @var int[] a map of env vars to their resolution counter
  124.      */
  125.     private $envCounters = [];
  127.     /**
  128.      * @var string[] the list of vendor directories
  129.      */
  130.     private $vendors;
  132.     /**
  133.      * @var array<string, ChildDefinition>
  134.      */
  135.     private $autoconfiguredInstanceof = [];
  137.     /**
  138.      * @var array<string, callable>
  139.      */
  140.     private $autoconfiguredAttributes = [];
  142.     /**
  143.      * @var array<string, bool>
  144.      */
  145.     private $removedIds = [];
  147.     /**
  148.      * @var array<int, bool>
  149.      */
  150.     private $removedBindingIds = [];
  152.     private const INTERNAL_TYPES = [
  153.         'int' => true,
  154.         'float' => true,
  155.         'string' => true,
  156.         'bool' => true,
  157.         'resource' => true,
  158.         'object' => true,
  159.         'array' => true,
  160.         'null' => true,
  161.         'callable' => true,
  162.         'iterable' => true,
  163.         'mixed' => true,
  164.     ];
  166.     public function __construct(ParameterBagInterface $parameterBag = null)
  167.     {
  168.         parent::__construct($parameterBag);
  170.         $this->trackResources = interface_exists(ResourceInterface::class);
  171.         $this->setDefinition('service_container', (new Definition(ContainerInterface::class))->setSynthetic(true)->setPublic(true));
  172.         $this->setAlias(PsrContainerInterface::class, new Alias('service_container', false))->setDeprecated('symfony/dependency-injection', '5.1', $deprecationMessage = 'The "%alias_id%" autowiring alias is deprecated. Define it explicitly in your app if you want to keep using it.');
  173.         $this->setAlias(ContainerInterface::class, new Alias('service_container', false))->setDeprecated('symfony/dependency-injection', '5.1', $deprecationMessage);
  174.     }
  176.     /**
  177.      * @var array<string, \ReflectionClass>
  178.      */
  179.     private $classReflectors;
  181.     /**
  182.      * Sets the track resources flag.
  183.      *
  184.      * If you are not using the loaders and therefore don't want
  185.      * to depend on the Config component, set this flag to false.
  186.      */
  187.     public function setResourceTracking(bool $track)
  188.     {
  189.         $this->trackResources = $track;
  190.     }
  192.     /**
  193.      * Checks if resources are tracked.
  194.      *
  195.      * @return bool
  196.      */
  197.     public function isTrackingResources()
  198.     {
  199.         return $this->trackResources;
  200.     }
  202.     /**
  203.      * Sets the instantiator to be used when fetching proxies.
  204.      */
  205.     public function setProxyInstantiator(InstantiatorInterface $proxyInstantiator)
  206.     {
  207.         $this->proxyInstantiator = $proxyInstantiator;
  208.     }
  210.     public function registerExtension(ExtensionInterface $extension)
  211.     {
  212.         $this->extensions[$extension->getAlias()] = $extension;
  214.         if (false !== $extension->getNamespace()) {
  215.             $this->extensionsByNs[$extension->getNamespace()] = $extension;
  216.         }
  217.     }
  219.     /**
  220.      * Returns an extension by alias or namespace.
  221.      *
  222.      * @return ExtensionInterface
  223.      *
  224.      * @throws LogicException if the extension is not registered
  225.      */
  226.     public function getExtension(string $name)
  227.     {
  228.         if (isset($this->extensions[$name])) {
  229.             return $this->extensions[$name];
  230.         }
  232.         if (isset($this->extensionsByNs[$name])) {
  233.             return $this->extensionsByNs[$name];
  234.         }
  236.         throw new LogicException(sprintf('Container extension "%s" is not registered.', $name));
  237.     }
  239.     /**
  240.      * Returns all registered extensions.
  241.      *
  242.      * @return array<string, ExtensionInterface>
  243.      */
  244.     public function getExtensions()
  245.     {
  246.         return $this->extensions;
  247.     }
  249.     /**
  250.      * Checks if we have an extension.
  251.      *
  252.      * @return bool
  253.      */
  254.     public function hasExtension(string $name)
  255.     {
  256.         return isset($this->extensions[$name]) || isset($this->extensionsByNs[$name]);
  257.     }
  259.     /**
  260.      * Returns an array of resources loaded to build this configuration.
  261.      *
  262.      * @return ResourceInterface[]
  263.      */
  264.     public function getResources()
  265.     {
  266.         return array_values($this->resources);
  267.     }
  269.     /**
  270.      * @return $this
  271.      */
  272.     public function addResource(ResourceInterface $resource)
  273.     {
  274.         if (!$this->trackResources) {
  275.             return $this;
  276.         }
  278.         if ($resource instanceof GlobResource && $this->inVendors($resource->getPrefix())) {
  279.             return $this;
  280.         }
  282.         $this->resources[(string) $resource] = $resource;
  284.         return $this;
  285.     }
  287.     /**
  288.      * Sets the resources for this configuration.
  289.      *
  290.      * @param array<string, ResourceInterface> $resources
  291.      *
  292.      * @return $this
  293.      */
  294.     public function setResources(array $resources)
  295.     {
  296.         if (!$this->trackResources) {
  297.             return $this;
  298.         }
  300.         $this->resources = $resources;
  302.         return $this;
  303.     }
  305.     /**
  306.      * Adds the object class hierarchy as resources.
  307.      *
  308.      * @param object|string $object An object instance or class name
  309.      *
  310.      * @return $this
  311.      */
  312.     public function addObjectResource($object)
  313.     {
  314.         if ($this->trackResources) {
  315.             if (\is_object($object)) {
  316.                 $object = \get_class($object);
  317.             }
  318.             if (!isset($this->classReflectors[$object])) {
  319.                 $this->classReflectors[$object] = new \ReflectionClass($object);
  320.             }
  321.             $class = $this->classReflectors[$object];
  323.             foreach ($class->getInterfaceNames() as $name) {
  324.                 if (null === $interface = &$this->classReflectors[$name]) {
  325.                     $interface = new \ReflectionClass($name);
  326.                 }
  327.                 $file = $interface->getFileName();
  328.                 if (false !== $file && file_exists($file)) {
  329.                     $this->fileExists($file);
  330.                 }
  331.             }
  332.             do {
  333.                 $file = $class->getFileName();
  334.                 if (false !== $file && file_exists($file)) {
  335.                     $this->fileExists($file);
  336.                 }
  337.                 foreach ($class->getTraitNames() as $name) {
  338.                     $this->addObjectResource($name);
  339.                 }
  340.             } while ($class = $class->getParentClass());
  341.         }
  343.         return $this;
  344.     }
  346.     /**
  347.      * Retrieves the requested reflection class and registers it for resource tracking.
  348.      *
  349.      * @throws \ReflectionException when a parent class/interface/trait is not found and $throw is true
  350.      *
  351.      * @final
  352.      */
  353.     public function getReflectionClass(?string $class, bool $throw = true): ?\ReflectionClass
  354.     {
  355.         if (!$class = $this->getParameterBag()->resolveValue($class)) {
  356.             return null;
  357.         }
  359.         if (isset(self::INTERNAL_TYPES[$class])) {
  360.             return null;
  361.         }
  363.         $resource = $classReflector = null;
  365.         try {
  366.             if (isset($this->classReflectors[$class])) {
  367.                 $classReflector = $this->classReflectors[$class];
  368.             } elseif (class_exists(ClassExistenceResource::class)) {
  369.                 $resource = new ClassExistenceResource($class, false);
  370.                 $classReflector = $resource->isFresh(0) ? false : new \ReflectionClass($class);
  371.             } else {
  372.                 $classReflector = class_exists($class) ? new \ReflectionClass($class) : false;
  373.             }
  374.         } catch (\ReflectionException $e) {
  375.             if ($throw) {
  376.                 throw $e;
  377.             }
  378.         }
  380.         if ($this->trackResources) {
  381.             if (!$classReflector) {
  382.                 $this->addResource($resource ?? new ClassExistenceResource($class, false));
  383.             } elseif (!$classReflector->isInternal()) {
  384.                 $path = $classReflector->getFileName();
  386.                 if (!$this->inVendors($path)) {
  387.                     $this->addResource(new ReflectionClassResource($classReflector, $this->vendors));
  388.                 }
  389.             }
  390.             $this->classReflectors[$class] = $classReflector;
  391.         }
  393.         return $classReflector ?: null;
  394.     }
  396.     /**
  397.      * Checks whether the requested file or directory exists and registers the result for resource tracking.
  398.      *
  399.      * @param string      $path          The file or directory path for which to check the existence
  400.      * @param bool|string $trackContents Whether to track contents of the given resource. If a string is passed,
  401.      *                                   it will be used as pattern for tracking contents of the requested directory
  402.      *
  403.      * @final
  404.      */
  405.     public function fileExists(string $path, $trackContents = true): bool
  406.     {
  407.         $exists = file_exists($path);
  409.         if (!$this->trackResources || $this->inVendors($path)) {
  410.             return $exists;
  411.         }
  413.         if (!$exists) {
  414.             $this->addResource(new FileExistenceResource($path));
  416.             return $exists;
  417.         }
  419.         if (is_dir($path)) {
  420.             if ($trackContents) {
  421.                 $this->addResource(new DirectoryResource($path, \is_string($trackContents) ? $trackContents : null));
  422.             } else {
  423.                 $this->addResource(new GlobResource($path, '/*', false));
  424.             }
  425.         } elseif ($trackContents) {
  426.             $this->addResource(new FileResource($path));
  427.         }
  429.         return $exists;
  430.     }
  432.     /**
  433.      * Loads the configuration for an extension.
  434.      *
  435.      * @param string                    $extension The extension alias or namespace
  436.      * @param array<string, mixed>|null $values    An array of values that customizes the extension
  437.      *
  438.      * @return $this
  439.      *
  440.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  441.      * @throws \LogicException        if the extension is not registered
  442.      */
  443.     public function loadFromExtension(string $extension, array $values = null)
  444.     {
  445.         if ($this->isCompiled()) {
  446.             throw new BadMethodCallException('Cannot load from an extension on a compiled container.');
  447.         }
  449.         $namespace = $this->getExtension($extension)->getAlias();
  451.         $this->extensionConfigs[$namespace][] = $values ?? [];
  453.         return $this;
  454.     }
  456.     /**
  457.      * Adds a compiler pass.
  458.      *
  459.      * @param string $type     The type of compiler pass
  460.      * @param int    $priority Used to sort the passes
  461.      *
  462.      * @return $this
  463.      */
  464.     public function addCompilerPass(CompilerPassInterface $pass, string $type = PassConfig::TYPE_BEFORE_OPTIMIZATION, int $priority = 0)
  465.     {
  466.         $this->getCompiler()->addPass($pass, $type, $priority);
  468.         $this->addObjectResource($pass);
  470.         return $this;
  471.     }
  473.     /**
  474.      * Returns the compiler pass config which can then be modified.
  475.      *
  476.      * @return PassConfig
  477.      */
  478.     public function getCompilerPassConfig()
  479.     {
  480.         return $this->getCompiler()->getPassConfig();
  481.     }
  483.     /**
  484.      * Returns the compiler.
  485.      *
  486.      * @return Compiler
  487.      */
  488.     public function getCompiler()
  489.     {
  490.         if (null === $this->compiler) {
  491.             $this->compiler = new Compiler();
  492.         }
  494.         return $this->compiler;
  495.     }
  497.     /**
  498.      * Sets a service.
  499.      *
  500.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  501.      */
  502.     public function set(string $id, ?object $service)
  503.     {
  504.         if ($this->isCompiled() && (isset($this->definitions[$id]) && !$this->definitions[$id]->isSynthetic())) {
  505.             // setting a synthetic service on a compiled container is alright
  506.             throw new BadMethodCallException(sprintf('Setting service "%s" for an unknown or non-synthetic service definition on a compiled container is not allowed.', $id));
  507.         }
  509.         unset($this->definitions[$id], $this->aliasDefinitions[$id], $this->removedIds[$id]);
  511.         parent::set($id, $service);
  512.     }
  514.     /**
  515.      * Removes a service definition.
  516.      */
  517.     public function removeDefinition(string $id)
  518.     {
  519.         if (isset($this->definitions[$id])) {
  520.             unset($this->definitions[$id]);
  521.             $this->removedIds[$id] = true;
  522.         }
  523.     }
  525.     /**
  526.      * Returns true if the given service is defined.
  527.      *
  528.      * @param string $id The service identifier
  529.      *
  530.      * @return bool
  531.      */
  532.     public function has(string $id)
  533.     {
  534.         return isset($this->definitions[$id]) || isset($this->aliasDefinitions[$id]) || parent::has($id);
  535.     }
  537.     /**
  538.      * @return object|null
  539.      *
  540.      * @throws InvalidArgumentException          when no definitions are available
  541.      * @throws ServiceCircularReferenceException When a circular reference is detected
  542.      * @throws ServiceNotFoundException          When the service is not defined
  543.      * @throws \Exception
  544.      *
  545.      * @see Reference
  546.      */
  547.     public function get(string $id, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE)
  548.     {
  549.         if ($this->isCompiled() && isset($this->removedIds[$id]) && ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $invalidBehavior) {
  550.             return parent::get($id);
  551.         }
  553.         return $this->doGet($id, $invalidBehavior);
  554.     }
  556.     private function doGet(string $id, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, array &$inlineServices = null, bool $isConstructorArgument = false)
  557.     {
  558.         if (isset($inlineServices[$id])) {
  559.             return $inlineServices[$id];
  560.         }
  561.         if (null === $inlineServices) {
  562.             $isConstructorArgument = true;
  563.             $inlineServices = [];
  564.         }
  565.         try {
  566.             if (ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $invalidBehavior) {
  567.                 return parent::get($id, $invalidBehavior);
  568.             }
  569.             if ($service = parent::get($id, ContainerInterface::NULL_ON_INVALID_REFERENCE)) {
  570.                 return $service;
  571.             }
  572.         } catch (ServiceCircularReferenceException $e) {
  573.             if ($isConstructorArgument) {
  574.                 throw $e;
  575.             }
  576.         }
  578.         if (!isset($this->definitions[$id]) && isset($this->aliasDefinitions[$id])) {
  579.             $alias = $this->aliasDefinitions[$id];
  581.             if ($alias->isDeprecated()) {
  582.                 $deprecation = $alias->getDeprecation($id);
  583.                 trigger_deprecation($deprecation['package'], $deprecation['version'], $deprecation['message']);
  584.             }
  586.             return $this->doGet((string) $alias, $invalidBehavior, $inlineServices, $isConstructorArgument);
  587.         }
  589.         try {
  590.             $definition = $this->getDefinition($id);
  591.         } catch (ServiceNotFoundException $e) {
  592.             if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE < $invalidBehavior) {
  593.                 return null;
  594.             }
  596.             throw $e;
  597.         }
  599.         if ($definition->hasErrors() && $e = $definition->getErrors()) {
  600.             throw new RuntimeException(reset($e));
  601.         }
  603.         if ($isConstructorArgument) {
  604.             $this->loading[$id] = true;
  605.         }
  607.         try {
  608.             return $this->createService($definition, $inlineServices, $isConstructorArgument, $id);
  609.         } finally {
  610.             if ($isConstructorArgument) {
  611.                 unset($this->loading[$id]);
  612.             }
  613.         }
  614.     }
  616.     /**
  617.      * Merges a ContainerBuilder with the current ContainerBuilder configuration.
  618.      *
  619.      * Service definitions overrides the current defined ones.
  620.      *
  621.      * But for parameters, they are overridden by the current ones. It allows
  622.      * the parameters passed to the container constructor to have precedence
  623.      * over the loaded ones.
  624.      *
  625.      *     $container = new ContainerBuilder(new ParameterBag(['foo' => 'bar']));
  626.      *     $loader = new LoaderXXX($container);
  627.      *     $loader->load('resource_name');
  628.      *     $container->register('foo', 'stdClass');
  629.      *
  630.      * In the above example, even if the loaded resource defines a foo
  631.      * parameter, the value will still be 'bar' as defined in the ContainerBuilder
  632.      * constructor.
  633.      *
  634.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  635.      */
  636.     public function merge(self $container)
  637.     {
  638.         if ($this->isCompiled()) {
  639.             throw new BadMethodCallException('Cannot merge on a compiled container.');
  640.         }
  642.         $this->addDefinitions($container->getDefinitions());
  643.         $this->addAliases($container->getAliases());
  644.         $this->getParameterBag()->add($container->getParameterBag()->all());
  646.         if ($this->trackResources) {
  647.             foreach ($container->getResources() as $resource) {
  648.                 $this->addResource($resource);
  649.             }
  650.         }
  652.         foreach ($this->extensions as $name => $extension) {
  653.             if (!isset($this->extensionConfigs[$name])) {
  654.                 $this->extensionConfigs[$name] = [];
  655.             }
  657.             $this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $container->getExtensionConfig($name));
  658.         }
  660.         if ($this->getParameterBag() instanceof EnvPlaceholderParameterBag && $container->getParameterBag() instanceof EnvPlaceholderParameterBag) {
  661.             $envPlaceholders = $container->getParameterBag()->getEnvPlaceholders();
  662.             $this->getParameterBag()->mergeEnvPlaceholders($container->getParameterBag());
  663.         } else {
  664.             $envPlaceholders = [];
  665.         }
  667.         foreach ($container->envCounters as $env => $count) {
  668.             if (!$count && !isset($envPlaceholders[$env])) {
  669.                 continue;
  670.             }
  671.             if (!isset($this->envCounters[$env])) {
  672.                 $this->envCounters[$env] = $count;
  673.             } else {
  674.                 $this->envCounters[$env] += $count;
  675.             }
  676.         }
  678.         foreach ($container->getAutoconfiguredInstanceof() as $interface => $childDefinition) {
  679.             if (isset($this->autoconfiguredInstanceof[$interface])) {
  680.                 throw new InvalidArgumentException(sprintf('"%s" has already been autoconfigured and merge() does not support merging autoconfiguration for the same class/interface.', $interface));
  681.             }
  683.             $this->autoconfiguredInstanceof[$interface] = $childDefinition;
  684.         }
  686.         foreach ($container->getAutoconfiguredAttributes() as $attribute => $configurator) {
  687.             if (isset($this->autoconfiguredAttributes[$attribute])) {
  688.                 throw new InvalidArgumentException(sprintf('"%s" has already been autoconfigured and merge() does not support merging autoconfiguration for the same attribute.', $attribute));
  689.             }
  691.             $this->autoconfiguredAttributes[$attribute] = $configurator;
  692.         }
  693.     }
  695.     /**
  696.      * Returns the configuration array for the given extension.
  697.      *
  698.      * @return array<array<string, mixed>>
  699.      */
  700.     public function getExtensionConfig(string $name)
  701.     {
  702.         if (!isset($this->extensionConfigs[$name])) {
  703.             $this->extensionConfigs[$name] = [];
  704.         }
  706.         return $this->extensionConfigs[$name];
  707.     }
  709.     /**
  710.      * Prepends a config array to the configs of the given extension.
  711.      *
  712.      * @param array<string, mixed> $config
  713.      */
  714.     public function prependExtensionConfig(string $name, array $config)
  715.     {
  716.         if (!isset($this->extensionConfigs[$name])) {
  717.             $this->extensionConfigs[$name] = [];
  718.         }
  720.         array_unshift($this->extensionConfigs[$name], $config);
  721.     }
  723.     /**
  724.      * Compiles the container.
  725.      *
  726.      * This method passes the container to compiler
  727.      * passes whose job is to manipulate and optimize
  728.      * the container.
  729.      *
  730.      * The main compiler passes roughly do four things:
  731.      *
  732.      *  * The extension configurations are merged;
  733.      *  * Parameter values are resolved;
  734.      *  * The parameter bag is frozen;
  735.      *  * Extension loading is disabled.
  736.      *
  737.      * @param bool $resolveEnvPlaceholders Whether %env()% parameters should be resolved using the current
  738.      *                                     env vars or be replaced by uniquely identifiable placeholders.
  739.      *                                     Set to "true" when you want to use the current ContainerBuilder
  740.      *                                     directly, keep to "false" when the container is dumped instead.
  741.      */
  742.     public function compile(bool $resolveEnvPlaceholders = false)
  743.     {
  744.         $compiler = $this->getCompiler();
  746.         if ($this->trackResources) {
  747.             foreach ($compiler->getPassConfig()->getPasses() as $pass) {
  748.                 $this->addObjectResource($pass);
  749.             }
  750.         }
  751.         $bag = $this->getParameterBag();
  753.         if ($resolveEnvPlaceholders && $bag instanceof EnvPlaceholderParameterBag) {
  754.             $compiler->addPass(new ResolveEnvPlaceholdersPass(), PassConfig::TYPE_AFTER_REMOVING, -1000);
  755.         }
  757.         $compiler->compile($this);
  759.         foreach ($this->definitions as $id => $definition) {
  760.             if ($this->trackResources && $definition->isLazy()) {
  761.                 $this->getReflectionClass($definition->getClass());
  762.             }
  763.         }
  765.         $this->extensionConfigs = [];
  767.         if ($bag instanceof EnvPlaceholderParameterBag) {
  768.             if ($resolveEnvPlaceholders) {
  769.                 $this->parameterBag = new ParameterBag($this->resolveEnvPlaceholders($bag->all(), true));
  770.             }
  772.             $this->envPlaceholders = $bag->getEnvPlaceholders();
  773.         }
  775.         parent::compile();
  777.         foreach ($this->definitions + $this->aliasDefinitions as $id => $definition) {
  778.             if (!$definition->isPublic() || $definition->isPrivate()) {
  779.                 $this->removedIds[$id] = true;
  780.             }
  781.         }
  782.     }
  784.     /**
  785.      * {@inheritdoc}
  786.      */
  787.     public function getServiceIds()
  788.     {
  789.         return array_map('strval', array_unique(array_merge(array_keys($this->getDefinitions()), array_keys($this->aliasDefinitions), parent::getServiceIds())));
  790.     }
  792.     /**
  793.      * Gets removed service or alias ids.
  794.      *
  795.      * @return array<string, bool>
  796.      */
  797.     public function getRemovedIds()
  798.     {
  799.         return $this->removedIds;
  800.     }
  802.     /**
  803.      * Adds the service aliases.
  804.      *
  805.      * @param array<string, string|Alias> $aliases
  806.      */
  807.     public function addAliases(array $aliases)
  808.     {
  809.         foreach ($aliases as $alias => $id) {
  810.             $this->setAlias($alias, $id);
  811.         }
  812.     }
  814.     /**
  815.      * Sets the service aliases.
  816.      *
  817.      * @param array<string, string|Alias> $aliases
  818.      */
  819.     public function setAliases(array $aliases)
  820.     {
  821.         $this->aliasDefinitions = [];
  822.         $this->addAliases($aliases);
  823.     }
  825.     /**
  826.      * Sets an alias for an existing service.
  827.      *
  828.      * @param string       $alias The alias to create
  829.      * @param string|Alias $id    The service to alias
  830.      *
  831.      * @return Alias
  832.      *
  833.      * @throws InvalidArgumentException if the id is not a string or an Alias
  834.      * @throws InvalidArgumentException if the alias is for itself
  835.      */
  836.     public function setAlias(string $alias, $id)
  837.     {
  838.         if ('' === $alias || '\\' === $alias[-1] || \strlen($alias) !== strcspn($alias, "\0\r\n'")) {
  839.             throw new InvalidArgumentException(sprintf('Invalid alias id: "%s".', $alias));
  840.         }
  842.         if (\is_string($id)) {
  843.             $id = new Alias($id);
  844.         } elseif (!$id instanceof Alias) {
  845.             throw new InvalidArgumentException('$id must be a string, or an Alias object.');
  846.         }
  848.         if ($alias === (string) $id) {
  849.             throw new InvalidArgumentException(sprintf('An alias cannot reference itself, got a circular reference on "%s".', $alias));
  850.         }
  852.         unset($this->definitions[$alias], $this->removedIds[$alias]);
  854.         return $this->aliasDefinitions[$alias] = $id;
  855.     }
  857.     public function removeAlias(string $alias)
  858.     {
  859.         if (isset($this->aliasDefinitions[$alias])) {
  860.             unset($this->aliasDefinitions[$alias]);
  861.             $this->removedIds[$alias] = true;
  862.         }
  863.     }
  865.     /**
  866.      * @return bool
  867.      */
  868.     public function hasAlias(string $id)
  869.     {
  870.         return isset($this->aliasDefinitions[$id]);
  871.     }
  873.     /**
  874.      * @return array<string, Alias>
  875.      */
  876.     public function getAliases()
  877.     {
  878.         return $this->aliasDefinitions;
  879.     }
  881.     /**
  882.      * @return Alias
  883.      *
  884.      * @throws InvalidArgumentException if the alias does not exist
  885.      */
  886.     public function getAlias(string $id)
  887.     {
  888.         if (!isset($this->aliasDefinitions[$id])) {
  889.             throw new InvalidArgumentException(sprintf('The service alias "%s" does not exist.', $id));
  890.         }
  892.         return $this->aliasDefinitions[$id];
  893.     }
  895.     /**
  896.      * Registers a service definition.
  897.      *
  898.      * This methods allows for simple registration of service definition
  899.      * with a fluid interface.
  900.      *
  901.      * @return Definition
  902.      */
  903.     public function register(string $id, string $class = null)
  904.     {
  905.         return $this->setDefinition($id, new Definition($class));
  906.     }
  908.     /**
  909.      * Registers an autowired service definition.
  910.      *
  911.      * This method implements a shortcut for using setDefinition() with
  912.      * an autowired definition.
  913.      *
  914.      * @return Definition
  915.      */
  916.     public function autowire(string $id, string $class = null)
  917.     {
  918.         return $this->setDefinition($id, (new Definition($class))->setAutowired(true));
  919.     }
  921.     /**
  922.      * Adds the service definitions.
  923.      *
  924.      * @param array<string, Definition> $definitions
  925.      */
  926.     public function addDefinitions(array $definitions)
  927.     {
  928.         foreach ($definitions as $id => $definition) {
  929.             $this->setDefinition($id, $definition);
  930.         }
  931.     }
  933.     /**
  934.      * Sets the service definitions.
  935.      *
  936.      * @param array<string, Definition> $definitions
  937.      */
  938.     public function setDefinitions(array $definitions)
  939.     {
  940.         $this->definitions = [];
  941.         $this->addDefinitions($definitions);
  942.     }
  944.     /**
  945.      * Gets all service definitions.
  946.      *
  947.      * @return array<string, Definition>
  948.      */
  949.     public function getDefinitions()
  950.     {
  951.         return $this->definitions;
  952.     }
  954.     /**
  955.      * Sets a service definition.
  956.      *
  957.      * @return Definition
  958.      *
  959.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  960.      */
  961.     public function setDefinition(string $id, Definition $definition)
  962.     {
  963.         if ($this->isCompiled()) {
  964.             throw new BadMethodCallException('Adding definition to a compiled container is not allowed.');
  965.         }
  967.         if ('' === $id || '\\' === $id[-1] || \strlen($id) !== strcspn($id, "\0\r\n'")) {
  968.             throw new InvalidArgumentException(sprintf('Invalid service id: "%s".', $id));
  969.         }
  971.         unset($this->aliasDefinitions[$id], $this->removedIds[$id]);
  973.         return $this->definitions[$id] = $definition;
  974.     }
  976.     /**
  977.      * Returns true if a service definition exists under the given identifier.
  978.      *
  979.      * @return bool
  980.      */
  981.     public function hasDefinition(string $id)
  982.     {
  983.         return isset($this->definitions[$id]);
  984.     }
  986.     /**
  987.      * Gets a service definition.
  988.      *
  989.      * @return Definition
  990.      *
  991.      * @throws ServiceNotFoundException if the service definition does not exist
  992.      */
  993.     public function getDefinition(string $id)
  994.     {
  995.         if (!isset($this->definitions[$id])) {
  996.             throw new ServiceNotFoundException($id);
  997.         }
  999.         return $this->definitions[$id];
  1000.     }
  1002.     /**
  1003.      * Gets a service definition by id or alias.
  1004.      *
  1005.      * The method "unaliases" recursively to return a Definition instance.
  1006.      *
  1007.      * @return Definition
  1008.      *
  1009.      * @throws ServiceNotFoundException if the service definition does not exist
  1010.      */
  1011.     public function findDefinition(string $id)
  1012.     {
  1013.         $seen = [];
  1014.         while (isset($this->aliasDefinitions[$id])) {
  1015.             $id = (string) $this->aliasDefinitions[$id];
  1017.             if (isset($seen[$id])) {
  1018.                 $seen = array_values($seen);
  1019.                 $seen = \array_slice($seen, array_search($id, $seen));
  1020.                 $seen[] = $id;
  1022.                 throw new ServiceCircularReferenceException($id, $seen);
  1023.             }
  1025.             $seen[$id] = $id;
  1026.         }
  1028.         return $this->getDefinition($id);
  1029.     }
  1031.     /**
  1032.      * Creates a service for a service definition.
  1033.      *
  1034.      * @return mixed
  1035.      *
  1036.      * @throws RuntimeException         When the factory definition is incomplete
  1037.      * @throws RuntimeException         When the service is a synthetic service
  1038.      * @throws InvalidArgumentException When configure callable is not callable
  1039.      */
  1040.     private function createService(Definition $definition, array &$inlineServices, bool $isConstructorArgument = false, string $id = null, bool $tryProxy = true)
  1041.     {
  1042.         if (null === $id && isset($inlineServices[$h = spl_object_hash($definition)])) {
  1043.             return $inlineServices[$h];
  1044.         }
  1046.         if ($definition instanceof ChildDefinition) {
  1047.             throw new RuntimeException(sprintf('Constructing service "%s" from a parent definition is not supported at build time.', $id));
  1048.         }
  1050.         if ($definition->isSynthetic()) {
  1051.             throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The DIC does not know how to construct this service.', $id));
  1052.         }
  1054.         if ($definition->isDeprecated()) {
  1055.             $deprecation = $definition->getDeprecation($id);
  1056.             trigger_deprecation($deprecation['package'], $deprecation['version'], $deprecation['message']);
  1057.         }
  1059.         if ($tryProxy && $definition->isLazy() && !$tryProxy = !($proxy = $this->proxyInstantiator) || $proxy instanceof RealServiceInstantiator) {
  1060.             $proxy = $proxy->instantiateProxy(
  1061.                 $this,
  1062.                 $definition,
  1063.                 $id, function () use ($definition, &$inlineServices, $id) {
  1064.                     return $this->createService($definition, $inlineServices, true, $id, false);
  1065.                 }
  1066.             );
  1067.             $this->shareService($definition, $proxy, $id, $inlineServices);
  1069.             return $proxy;
  1070.         }
  1072.         $parameterBag = $this->getParameterBag();
  1074.         if (null !== $definition->getFile()) {
  1075.             require_once $parameterBag->resolveValue($definition->getFile());
  1076.         }
  1078.         $arguments = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getArguments())), $inlineServices, $isConstructorArgument);
  1080.         if (null !== $factory = $definition->getFactory()) {
  1081.             if (\is_array($factory)) {
  1082.                 $factory = [$this->doResolveServices($parameterBag->resolveValue($factory[0]), $inlineServices, $isConstructorArgument), $factory[1]];
  1083.             } elseif (!\is_string($factory)) {
  1084.                 throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory.', $id));
  1085.             }
  1086.         }
  1088.         if (null !== $id && $definition->isShared() && isset($this->services[$id]) && ($tryProxy || !$definition->isLazy())) {
  1089.             return $this->services[$id];
  1090.         }
  1092.         if (null !== $factory) {
  1093.             $service = $factory(...$arguments);
  1095.             if (!$definition->isDeprecated() && \is_array($factory) && \is_string($factory[0])) {
  1096.                 $r = new \ReflectionClass($factory[0]);
  1098.                 if (0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1099.                     trigger_deprecation('', '', 'The "%s" service relies on the deprecated "%s" factory class. It should either be deprecated or its factory upgraded.', $id, $r->name);
  1100.                 }
  1101.             }
  1102.         } else {
  1103.             $r = new \ReflectionClass($parameterBag->resolveValue($definition->getClass()));
  1105.             $service = null === $r->getConstructor() ? $r->newInstance() : $r->newInstanceArgs(array_values($arguments));
  1107.             if (!$definition->isDeprecated() && 0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1108.                 trigger_deprecation('', '', 'The "%s" service relies on the deprecated "%s" class. It should either be deprecated or its implementation upgraded.', $id, $r->name);
  1109.             }
  1110.         }
  1112.         $lastWitherIndex = null;
  1113.         foreach ($definition->getMethodCalls() as $k => $call) {
  1114.             if ($call[2] ?? false) {
  1115.                 $lastWitherIndex = $k;
  1116.             }
  1117.         }
  1119.         if (null === $lastWitherIndex && ($tryProxy || !$definition->isLazy())) {
  1120.             // share only if proxying failed, or if not a proxy, and if no withers are found
  1121.             $this->shareService($definition, $service, $id, $inlineServices);
  1122.         }
  1124.         $properties = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getProperties())), $inlineServices);
  1125.         foreach ($properties as $name => $value) {
  1126.             $service->$name = $value;
  1127.         }
  1129.         foreach ($definition->getMethodCalls() as $k => $call) {
  1130.             $service = $this->callMethod($service, $call, $inlineServices);
  1132.             if ($lastWitherIndex === $k && ($tryProxy || !$definition->isLazy())) {
  1133.                 // share only if proxying failed, or if not a proxy, and this is the last wither
  1134.                 $this->shareService($definition, $service, $id, $inlineServices);
  1135.             }
  1136.         }
  1138.         if ($callable = $definition->getConfigurator()) {
  1139.             if (\is_array($callable)) {
  1140.                 $callable[0] = $parameterBag->resolveValue($callable[0]);
  1142.                 if ($callable[0] instanceof Reference) {
  1143.                     $callable[0] = $this->doGet((string) $callable[0], $callable[0]->getInvalidBehavior(), $inlineServices);
  1144.                 } elseif ($callable[0] instanceof Definition) {
  1145.                     $callable[0] = $this->createService($callable[0], $inlineServices);
  1146.                 }
  1147.             }
  1149.             if (!\is_callable($callable)) {
  1150.                 throw new InvalidArgumentException(sprintf('The configure callable for class "%s" is not a callable.', get_debug_type($service)));
  1151.             }
  1153.             $callable($service);
  1154.         }
  1156.         return $service;
  1157.     }
  1159.     /**
  1160.      * Replaces service references by the real service instance and evaluates expressions.
  1161.      *
  1162.      * @param mixed $value
  1163.      *
  1164.      * @return mixed The same value with all service references replaced by
  1165.      *               the real service instances and all expressions evaluated
  1166.      */
  1167.     public function resolveServices($value)
  1168.     {
  1169.         return $this->doResolveServices($value);
  1170.     }
  1172.     private function doResolveServices($value, array &$inlineServices = [], bool $isConstructorArgument = false)
  1173.     {
  1174.         if (\is_array($value)) {
  1175.             foreach ($value as $k => $v) {
  1176.                 $value[$k] = $this->doResolveServices($v, $inlineServices, $isConstructorArgument);
  1177.             }
  1178.         } elseif ($value instanceof ServiceClosureArgument) {
  1179.             $reference = $value->getValues()[0];
  1180.             $value = function () use ($reference) {
  1181.                 return $this->resolveServices($reference);
  1182.             };
  1183.         } elseif ($value instanceof IteratorArgument) {
  1184.             $value = new RewindableGenerator(function () use ($value, &$inlineServices) {
  1185.                 foreach ($value->getValues() as $k => $v) {
  1186.                     foreach (self::getServiceConditionals($v) as $s) {
  1187.                         if (!$this->has($s)) {
  1188.                             continue 2;
  1189.                         }
  1190.                     }
  1191.                     foreach (self::getInitializedConditionals($v) as $s) {
  1192.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
  1193.                             continue 2;
  1194.                         }
  1195.                     }
  1197.                     yield $k => $this->doResolveServices($v, $inlineServices);
  1198.                 }
  1199.             }, function () use ($value): int {
  1200.                 $count = 0;
  1201.                 foreach ($value->getValues() as $v) {
  1202.                     foreach (self::getServiceConditionals($v) as $s) {
  1203.                         if (!$this->has($s)) {
  1204.                             continue 2;
  1205.                         }
  1206.                     }
  1207.                     foreach (self::getInitializedConditionals($v) as $s) {
  1208.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE)) {
  1209.                             continue 2;
  1210.                         }
  1211.                     }
  1213.                     ++$count;
  1214.                 }
  1216.                 return $count;
  1217.             });
  1218.         } elseif ($value instanceof ServiceLocatorArgument) {
  1219.             $refs = $types = [];
  1220.             foreach ($value->getValues() as $k => $v) {
  1221.                 if ($v) {
  1222.                     $refs[$k] = [$v];
  1223.                     $types[$k] = $v instanceof TypedReference ? $v->getType() : '?';
  1224.                 }
  1225.             }
  1226.             $value = new ServiceLocator(\Closure::fromCallable([$this, 'resolveServices']), $refs, $types);
  1227.         } elseif ($value instanceof Reference) {
  1228.             $value = $this->doGet((string) $value, $value->getInvalidBehavior(), $inlineServices, $isConstructorArgument);
  1229.         } elseif ($value instanceof Definition) {
  1230.             $value = $this->createService($value, $inlineServices, $isConstructorArgument);
  1231.         } elseif ($value instanceof Parameter) {
  1232.             $value = $this->getParameter((string) $value);
  1233.         } elseif ($value instanceof Expression) {
  1234.             $value = $this->getExpressionLanguage()->evaluate($value, ['container' => $this]);
  1235.         } elseif ($value instanceof AbstractArgument) {
  1236.             throw new RuntimeException($value->getTextWithContext());
  1237.         }
  1239.         return $value;
  1240.     }
  1242.     /**
  1243.      * Returns service ids for a given tag.
  1244.      *
  1245.      * Example:
  1246.      *
  1247.      *     $container->register('foo')->addTag('my.tag', ['hello' => 'world']);
  1248.      *
  1249.      *     $serviceIds = $container->findTaggedServiceIds('my.tag');
  1250.      *     foreach ($serviceIds as $serviceId => $tags) {
  1251.      *         foreach ($tags as $tag) {
  1252.      *             echo $tag['hello'];
  1253.      *         }
  1254.      *     }
  1255.      *
  1256.      * @return array<string, array> An array of tags with the tagged service as key, holding a list of attribute arrays
  1257.      */
  1258.     public function findTaggedServiceIds(string $name, bool $throwOnAbstract = false)
  1259.     {
  1260.         $this->usedTags[] = $name;
  1261.         $tags = [];
  1262.         foreach ($this->getDefinitions() as $id => $definition) {
  1263.             if ($definition->hasTag($name)) {
  1264.                 if ($throwOnAbstract && $definition->isAbstract()) {
  1265.                     throw new InvalidArgumentException(sprintf('The service "%s" tagged "%s" must not be abstract.', $id, $name));
  1266.                 }
  1267.                 $tags[$id] = $definition->getTag($name);
  1268.             }
  1269.         }
  1271.         return $tags;
  1272.     }
  1274.     /**
  1275.      * Returns all tags the defined services use.
  1276.      *
  1277.      * @return string[]
  1278.      */
  1279.     public function findTags()
  1280.     {
  1281.         $tags = [];
  1282.         foreach ($this->getDefinitions() as $id => $definition) {
  1283.             $tags[] = array_keys($definition->getTags());
  1284.         }
  1286.         return array_unique(array_merge([], ...$tags));
  1287.     }
  1289.     /**
  1290.      * Returns all tags not queried by findTaggedServiceIds.
  1291.      *
  1292.      * @return string[]
  1293.      */
  1294.     public function findUnusedTags()
  1295.     {
  1296.         return array_values(array_diff($this->findTags(), $this->usedTags));
  1297.     }
  1299.     public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
  1300.     {
  1301.         $this->expressionLanguageProviders[] = $provider;
  1302.     }
  1304.     /**
  1305.      * @return ExpressionFunctionProviderInterface[]
  1306.      */
  1307.     public function getExpressionLanguageProviders()
  1308.     {
  1309.         return $this->expressionLanguageProviders;
  1310.     }
  1312.     /**
  1313.      * Returns a ChildDefinition that will be used for autoconfiguring the interface/class.
  1314.      *
  1315.      * @return ChildDefinition
  1316.      */
  1317.     public function registerForAutoconfiguration(string $interface)
  1318.     {
  1319.         if (!isset($this->autoconfiguredInstanceof[$interface])) {
  1320.             $this->autoconfiguredInstanceof[$interface] = new ChildDefinition('');
  1321.         }
  1323.         return $this->autoconfiguredInstanceof[$interface];
  1324.     }
  1326.     /**
  1327.      * Registers an attribute that will be used for autoconfiguring annotated classes.
  1328.      *
  1329.      * The third argument passed to the callable is the reflector of the
  1330.      * class/method/property/parameter that the attribute targets. Using one or many of
  1331.      * \ReflectionClass|\ReflectionMethod|\ReflectionProperty|\ReflectionParameter as a type-hint
  1332.      * for this argument allows filtering which attributes should be passed to the callable.
  1333.      *
  1334.      * @template T
  1335.      *
  1336.      * @param class-string<T>                                $attributeClass
  1337.      * @param callable(ChildDefinition, T, \Reflector): void $configurator
  1338.      */
  1339.     public function registerAttributeForAutoconfiguration(string $attributeClass, callable $configurator): void
  1340.     {
  1341.         $this->autoconfiguredAttributes[$attributeClass] = $configurator;
  1342.     }
  1344.     /**
  1345.      * Registers an autowiring alias that only binds to a specific argument name.
  1346.      *
  1347.      * The argument name is derived from $name if provided (from $id otherwise)
  1348.      * using camel case: "foo.bar" or "foo_bar" creates an alias bound to
  1349.      * "$fooBar"-named arguments with $type as type-hint. Such arguments will
  1350.      * receive the service $id when autowiring is used.
  1351.      */
  1352.     public function registerAliasForArgument(string $id, string $type, string $name = null): Alias
  1353.     {
  1354.         $name = (new Target($name ?? $id))->name;
  1356.         if (!preg_match('/^[a-zA-Z_\x7f-\xff]/', $name)) {
  1357.             throw new InvalidArgumentException(sprintf('Invalid argument name "%s" for service "%s": the first character must be a letter.', $name, $id));
  1358.         }
  1360.         return $this->setAlias($type.' $'.$name, $id);
  1361.     }
  1363.     /**
  1364.      * Returns an array of ChildDefinition[] keyed by interface.
  1365.      *
  1366.      * @return array<string, ChildDefinition>
  1367.      */
  1368.     public function getAutoconfiguredInstanceof()
  1369.     {
  1370.         return $this->autoconfiguredInstanceof;
  1371.     }
  1373.     /**
  1374.      * @return array<string, callable>
  1375.      */
  1376.     public function getAutoconfiguredAttributes(): array
  1377.     {
  1378.         return $this->autoconfiguredAttributes;
  1379.     }
  1381.     /**
  1382.      * Resolves env parameter placeholders in a string or an array.
  1383.      *
  1384.      * @param mixed            $value     The value to resolve
  1385.      * @param string|true|null $format    A sprintf() format returning the replacement for each env var name or
  1386.      *                                    null to resolve back to the original "%env(VAR)%" format or
  1387.      *                                    true to resolve to the actual values of the referenced env vars
  1388.      * @param array            &$usedEnvs Env vars found while resolving are added to this array
  1389.      *
  1390.      * @return mixed The value with env parameters resolved if a string or an array is passed
  1391.      */
  1392.     public function resolveEnvPlaceholders($value, $format = null, array &$usedEnvs = null)
  1393.     {
  1394.         if (null === $format) {
  1395.             $format = '%%env(%s)%%';
  1396.         }
  1398.         $bag = $this->getParameterBag();
  1399.         if (true === $format) {
  1400.             $value = $bag->resolveValue($value);
  1401.         }
  1403.         if ($value instanceof Definition) {
  1404.             $value = (array) $value;
  1405.         }
  1407.         if (\is_array($value)) {
  1408.             $result = [];
  1409.             foreach ($value as $k => $v) {
  1410.                 $result[\is_string($k) ? $this->resolveEnvPlaceholders($k, $format, $usedEnvs) : $k] = $this->resolveEnvPlaceholders($v, $format, $usedEnvs);
  1411.             }
  1413.             return $result;
  1414.         }
  1416.         if (!\is_string($value) || 38 > \strlen($value) || !preg_match('/env[_(]/i', $value)) {
  1417.             return $value;
  1418.         }
  1419.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1421.         $completed = false;
  1422.         foreach ($envPlaceholders as $env => $placeholders) {
  1423.             foreach ($placeholders as $placeholder) {
  1424.                 if (false !== stripos($value, $placeholder)) {
  1425.                     if (true === $format) {
  1426.                         $resolved = $bag->escapeValue($this->getEnv($env));
  1427.                     } else {
  1428.                         $resolved = sprintf($format, $env);
  1429.                     }
  1430.                     if ($placeholder === $value) {
  1431.                         $value = $resolved;
  1432.                         $completed = true;
  1433.                     } else {
  1434.                         if (!\is_string($resolved) && !is_numeric($resolved)) {
  1435.                             throw new RuntimeException(sprintf('A string value must be composed of strings and/or numbers, but found parameter "env(%s)" of type "%s" inside string value "%s".', $env, get_debug_type($resolved), $this->resolveEnvPlaceholders($value)));
  1436.                         }
  1437.                         $value = str_ireplace($placeholder, $resolved, $value);
  1438.                     }
  1439.                     $usedEnvs[$env] = $env;
  1440.                     $this->envCounters[$env] = isset($this->envCounters[$env]) ? 1 + $this->envCounters[$env] : 1;
  1442.                     if ($completed) {
  1443.                         break 2;
  1444.                     }
  1445.                 }
  1446.             }
  1447.         }
  1449.         return $value;
  1450.     }
  1452.     /**
  1453.      * Get statistics about env usage.
  1454.      *
  1455.      * @return int[] The number of time each env vars has been resolved
  1456.      */
  1457.     public function getEnvCounters()
  1458.     {
  1459.         $bag = $this->getParameterBag();
  1460.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1462.         foreach ($envPlaceholders as $env => $placeholders) {
  1463.             if (!isset($this->envCounters[$env])) {
  1464.                 $this->envCounters[$env] = 0;
  1465.             }
  1466.         }
  1468.         return $this->envCounters;
  1469.     }
  1471.     /**
  1472.      * @final
  1473.      */
  1474.     public function log(CompilerPassInterface $pass, string $message)
  1475.     {
  1476.         $this->getCompiler()->log($pass, $this->resolveEnvPlaceholders($message));
  1477.     }
  1479.     /**
  1480.      * Checks whether a class is available and will remain available in the "no-dev" mode of Composer.
  1481.      *
  1482.      * When parent packages are provided and if any of them is in dev-only mode,
  1483.      * the class will be considered available even if it is also in dev-only mode.
  1484.      */
  1485.     final public static function willBeAvailable(string $package, string $class, array $parentPackages): bool
  1486.     {
  1487.         $skipDeprecation = 3 < \func_num_args() && func_get_arg(3);
  1488.         $hasRuntimeApi = class_exists(InstalledVersions::class);
  1490.         if (!$hasRuntimeApi && !$skipDeprecation) {
  1491.             trigger_deprecation('symfony/dependency-injection', '5.4', 'Calling "%s" when dependencies have been installed with Composer 1 is deprecated. Consider upgrading to Composer 2.', __METHOD__);
  1492.         }
  1494.         if (!class_exists($class) && !interface_exists($class, false) && !trait_exists($class, false)) {
  1495.             return false;
  1496.         }
  1498.         if (!$hasRuntimeApi || !InstalledVersions::isInstalled($package) || InstalledVersions::isInstalled($package, false)) {
  1499.             return true;
  1500.         }
  1502.         // the package is installed but in dev-mode only, check if this applies to one of the parent packages too
  1504.         $rootPackage = InstalledVersions::getRootPackage()['name'] ?? '';
  1506.         if ('symfony/symfony' === $rootPackage) {
  1507.             return true;
  1508.         }
  1510.         foreach ($parentPackages as $parentPackage) {
  1511.             if ($rootPackage === $parentPackage || (InstalledVersions::isInstalled($parentPackage) && !InstalledVersions::isInstalled($parentPackage, false))) {
  1512.                 return true;
  1513.             }
  1514.         }
  1516.         return false;
  1517.     }
  1519.     /**
  1520.      * Gets removed binding ids.
  1521.      *
  1522.      * @return array<int, bool>
  1523.      *
  1524.      * @internal
  1525.      */
  1526.     public function getRemovedBindingIds(): array
  1527.     {
  1528.         return $this->removedBindingIds;
  1529.     }
  1531.     /**
  1532.      * Removes bindings for a service.
  1533.      *
  1534.      * @internal
  1535.      */
  1536.     public function removeBindings(string $id)
  1537.     {
  1538.         if ($this->hasDefinition($id)) {
  1539.             foreach ($this->getDefinition($id)->getBindings() as $key => $binding) {
  1540.                 [, $bindingId] = $binding->getValues();
  1541.                 $this->removedBindingIds[(int) $bindingId] = true;
  1542.             }
  1543.         }
  1544.     }
  1546.     /**
  1547.      * Returns the Service Conditionals.
  1548.      *
  1549.      * @param mixed $value An array of conditionals to return
  1550.      *
  1551.      * @return string[]
  1552.      *
  1553.      * @internal
  1554.      */
  1555.     public static function getServiceConditionals($value): array
  1556.     {
  1557.         $services = [];
  1559.         if (\is_array($value)) {
  1560.             foreach ($value as $v) {
  1561.                 $services = array_unique(array_merge($services, self::getServiceConditionals($v)));
  1562.             }
  1563.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  1564.             $services[] = (string) $value;
  1565.         }
  1567.         return $services;
  1568.     }
  1570.     /**
  1571.      * Returns the initialized conditionals.
  1572.      *
  1573.      * @param mixed $value An array of conditionals to return
  1574.      *
  1575.      * @return string[]
  1576.      *
  1577.      * @internal
  1578.      */
  1579.     public static function getInitializedConditionals($value): array
  1580.     {
  1581.         $services = [];
  1583.         if (\is_array($value)) {
  1584.             foreach ($value as $v) {
  1585.                 $services = array_unique(array_merge($services, self::getInitializedConditionals($v)));
  1586.             }
  1587.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $value->getInvalidBehavior()) {
  1588.             $services[] = (string) $value;
  1589.         }
  1591.         return $services;
  1592.     }
  1594.     /**
  1595.      * Computes a reasonably unique hash of a value.
  1596.      *
  1597.      * @param mixed $value A serializable value
  1598.      *
  1599.      * @return string
  1600.      */
  1601.     public static function hash($value)
  1602.     {
  1603.         $hash = substr(base64_encode(hash('sha256', serialize($value), true)), 0, 7);
  1605.         return str_replace(['/', '+'], ['.', '_'], $hash);
  1606.     }
  1608.     /**
  1609.      * {@inheritdoc}
  1610.      */
  1611.     protected function getEnv(string $name)
  1612.     {
  1613.         $value = parent::getEnv($name);
  1614.         $bag = $this->getParameterBag();
  1616.         if (!\is_string($value) || !$bag instanceof EnvPlaceholderParameterBag) {
  1617.             return $value;
  1618.         }
  1620.         $envPlaceholders = $bag->getEnvPlaceholders();
  1621.         if (isset($envPlaceholders[$name][$value])) {
  1622.             $bag = new ParameterBag($bag->all());
  1624.             return $bag->unescapeValue($bag->get("env($name)"));
  1625.         }
  1626.         foreach ($envPlaceholders as $env => $placeholders) {
  1627.             if (isset($placeholders[$value])) {
  1628.                 return $this->getEnv($env);
  1629.             }
  1630.         }
  1632.         $this->resolving["env($name)"] = true;
  1633.         try {
  1634.             return $bag->unescapeValue($this->resolveEnvPlaceholders($bag->escapeValue($value), true));
  1635.         } finally {
  1636.             unset($this->resolving["env($name)"]);
  1637.         }
  1638.     }
  1640.     private function callMethod(object $service, array $call, array &$inlineServices)
  1641.     {
  1642.         foreach (self::getServiceConditionals($call[1]) as $s) {
  1643.             if (!$this->has($s)) {
  1644.                 return $service;
  1645.             }
  1646.         }
  1647.         foreach (self::getInitializedConditionals($call[1]) as $s) {
  1648.             if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
  1649.                 return $service;
  1650.             }
  1651.         }
  1653.         $result = $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));
  1655.         return empty($call[2]) ? $service : $result;
  1656.     }
  1658.     /**
  1659.      * Shares a given service in the container.
  1660.      *
  1661.      * @param mixed $service
  1662.      */
  1663.     private function shareService(Definition $definition, $service, ?string $id, array &$inlineServices)
  1664.     {
  1665.         $inlineServices[$id ?? spl_object_hash($definition)] = $service;
  1667.         if (null !== $id && $definition->isShared()) {
  1668.             $this->services[$id] = $service;
  1669.             unset($this->loading[$id]);
  1670.         }
  1671.     }
  1673.     private function getExpressionLanguage(): ExpressionLanguage
  1674.     {
  1675.         if (null === $this->expressionLanguage) {
  1676.             if (!class_exists(\Symfony\Component\ExpressionLanguage\ExpressionLanguage::class)) {
  1677.                 throw new LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  1678.             }
  1679.             $this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders);
  1680.         }
  1682.         return $this->expressionLanguage;
  1683.     }
  1685.     private function inVendors(string $path): bool
  1686.     {
  1687.         if (null === $this->vendors) {
  1688.             $this->vendors = (new ComposerResource())->getVendors();
  1689.         }
  1690.         $path = realpath($path) ?: $path;
  1692.         foreach ($this->vendors as $vendor) {
  1693.             if (str_starts_with($path, $vendor) && false !== strpbrk(substr($path, \strlen($vendor), 1), '/'.\DIRECTORY_SEPARATOR)) {
  1694.                 $this->addResource(new FileResource($vendor.'/composer/installed.json'));
  1696.                 return true;
  1697.             }
  1698.         }
  1700.         return false;
  1701.     }
  1702. }