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

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 Psr\Container\ContainerInterface as PsrContainerInterface;
  15. use Symfony\Component\Config\Resource\ClassExistenceResource;
  16. use Symfony\Component\Config\Resource\ComposerResource;
  17. use Symfony\Component\Config\Resource\DirectoryResource;
  18. use Symfony\Component\Config\Resource\FileExistenceResource;
  19. use Symfony\Component\Config\Resource\FileResource;
  20. use Symfony\Component\Config\Resource\GlobResource;
  21. use Symfony\Component\Config\Resource\ReflectionClassResource;
  22. use Symfony\Component\Config\Resource\ResourceInterface;
  23. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  24. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  25. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  26. use Symfony\Component\DependencyInjection\Argument\ServiceLocator;
  27. use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
  28. use Symfony\Component\DependencyInjection\Compiler\Compiler;
  29. use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
  30. use Symfony\Component\DependencyInjection\Compiler\PassConfig;
  31. use Symfony\Component\DependencyInjection\Compiler\ResolveEnvPlaceholdersPass;
  32. use Symfony\Component\DependencyInjection\Exception\BadMethodCallException;
  33. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  34. use Symfony\Component\DependencyInjection\Exception\LogicException;
  35. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  36. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  37. use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
  38. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  39. use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\InstantiatorInterface;
  40. use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\RealServiceInstantiator;
  41. use Symfony\Component\DependencyInjection\ParameterBag\EnvPlaceholderParameterBag;
  42. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
  43. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  44. use Symfony\Component\ExpressionLanguage\Expression;
  45. use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
  47. /**
  48.  * ContainerBuilder is a DI container that provides an API to easily describe services.
  49.  *
  50.  * @author Fabien Potencier <fabien@symfony.com>
  51.  */
  52. class ContainerBuilder extends Container implements TaggedContainerInterface
  53. {
  54.     /**
  55.      * @var ExtensionInterface[]
  56.      */
  57.     private $extensions = [];
  59.     /**
  60.      * @var ExtensionInterface[]
  61.      */
  62.     private $extensionsByNs = [];
  64.     /**
  65.      * @var Definition[]
  66.      */
  67.     private $definitions = [];
  69.     /**
  70.      * @var Alias[]
  71.      */
  72.     private $aliasDefinitions = [];
  74.     /**
  75.      * @var ResourceInterface[]
  76.      */
  77.     private $resources = [];
  79.     private $extensionConfigs = [];
  81.     /**
  82.      * @var Compiler
  83.      */
  84.     private $compiler;
  86.     private $trackResources;
  88.     /**
  89.      * @var InstantiatorInterface|null
  90.      */
  91.     private $proxyInstantiator;
  93.     /**
  94.      * @var ExpressionLanguage|null
  95.      */
  96.     private $expressionLanguage;
  98.     /**
  99.      * @var ExpressionFunctionProviderInterface[]
  100.      */
  101.     private $expressionLanguageProviders = [];
  103.     /**
  104.      * @var string[] with tag names used by findTaggedServiceIds
  105.      */
  106.     private $usedTags = [];
  108.     /**
  109.      * @var string[][] a map of env var names to their placeholders
  110.      */
  111.     private $envPlaceholders = [];
  113.     /**
  114.      * @var int[] a map of env vars to their resolution counter
  115.      */
  116.     private $envCounters = [];
  118.     /**
  119.      * @var string[] the list of vendor directories
  120.      */
  121.     private $vendors;
  123.     private $autoconfiguredInstanceof = [];
  125.     private $removedIds = [];
  127.     private $removedBindingIds = [];
  129.     private static $internalTypes = [
  130.         'int' => true,
  131.         'float' => true,
  132.         'string' => true,
  133.         'bool' => true,
  134.         'resource' => true,
  135.         'object' => true,
  136.         'array' => true,
  137.         'null' => true,
  138.         'callable' => true,
  139.         'iterable' => true,
  140.         'mixed' => true,
  141.     ];
  143.     public function __construct(ParameterBagInterface $parameterBag = null)
  144.     {
  145.         parent::__construct($parameterBag);
  147.         $this->trackResources = interface_exists('Symfony\Component\Config\Resource\ResourceInterface');
  148.         $this->setDefinition('service_container', (new Definition(ContainerInterface::class))->setSynthetic(true)->setPublic(true));
  149.         $this->setAlias(PsrContainerInterface::class, new Alias('service_container', false));
  150.         $this->setAlias(ContainerInterface::class, new Alias('service_container', false));
  151.     }
  153.     /**
  154.      * @var \ReflectionClass[] a list of class reflectors
  155.      */
  156.     private $classReflectors;
  158.     /**
  159.      * Sets the track resources flag.
  160.      *
  161.      * If you are not using the loaders and therefore don't want
  162.      * to depend on the Config component, set this flag to false.
  163.      */
  164.     public function setResourceTracking(bool $track)
  165.     {
  166.         $this->trackResources = $track;
  167.     }
  169.     /**
  170.      * Checks if resources are tracked.
  171.      *
  172.      * @return bool true If resources are tracked, false otherwise
  173.      */
  174.     public function isTrackingResources()
  175.     {
  176.         return $this->trackResources;
  177.     }
  179.     /**
  180.      * Sets the instantiator to be used when fetching proxies.
  181.      */
  182.     public function setProxyInstantiator(InstantiatorInterface $proxyInstantiator)
  183.     {
  184.         $this->proxyInstantiator = $proxyInstantiator;
  185.     }
  187.     public function registerExtension(ExtensionInterface $extension)
  188.     {
  189.         $this->extensions[$extension->getAlias()] = $extension;
  191.         if (false !== $extension->getNamespace()) {
  192.             $this->extensionsByNs[$extension->getNamespace()] = $extension;
  193.         }
  194.     }
  196.     /**
  197.      * Returns an extension by alias or namespace.
  198.      *
  199.      * @return ExtensionInterface An extension instance
  200.      *
  201.      * @throws LogicException if the extension is not registered
  202.      */
  203.     public function getExtension(string $name)
  204.     {
  205.         if (isset($this->extensions[$name])) {
  206.             return $this->extensions[$name];
  207.         }
  209.         if (isset($this->extensionsByNs[$name])) {
  210.             return $this->extensionsByNs[$name];
  211.         }
  213.         throw new LogicException(sprintf('Container extension "%s" is not registered.', $name));
  214.     }
  216.     /**
  217.      * Returns all registered extensions.
  218.      *
  219.      * @return ExtensionInterface[] An array of ExtensionInterface
  220.      */
  221.     public function getExtensions()
  222.     {
  223.         return $this->extensions;
  224.     }
  226.     /**
  227.      * Checks if we have an extension.
  228.      *
  229.      * @return bool If the extension exists
  230.      */
  231.     public function hasExtension(string $name)
  232.     {
  233.         return isset($this->extensions[$name]) || isset($this->extensionsByNs[$name]);
  234.     }
  236.     /**
  237.      * Returns an array of resources loaded to build this configuration.
  238.      *
  239.      * @return ResourceInterface[] An array of resources
  240.      */
  241.     public function getResources()
  242.     {
  243.         return array_values($this->resources);
  244.     }
  246.     /**
  247.      * @return $this
  248.      */
  249.     public function addResource(ResourceInterface $resource)
  250.     {
  251.         if (!$this->trackResources) {
  252.             return $this;
  253.         }
  255.         if ($resource instanceof GlobResource && $this->inVendors($resource->getPrefix())) {
  256.             return $this;
  257.         }
  259.         $this->resources[(string) $resource] = $resource;
  261.         return $this;
  262.     }
  264.     /**
  265.      * Sets the resources for this configuration.
  266.      *
  267.      * @param ResourceInterface[] $resources An array of resources
  268.      *
  269.      * @return $this
  270.      */
  271.     public function setResources(array $resources)
  272.     {
  273.         if (!$this->trackResources) {
  274.             return $this;
  275.         }
  277.         $this->resources = $resources;
  279.         return $this;
  280.     }
  282.     /**
  283.      * Adds the object class hierarchy as resources.
  284.      *
  285.      * @param object|string $object An object instance or class name
  286.      *
  287.      * @return $this
  288.      */
  289.     public function addObjectResource($object)
  290.     {
  291.         if ($this->trackResources) {
  292.             if (\is_object($object)) {
  293.                 $object = \get_class($object);
  294.             }
  295.             if (!isset($this->classReflectors[$object])) {
  296.                 $this->classReflectors[$object] = new \ReflectionClass($object);
  297.             }
  298.             $class = $this->classReflectors[$object];
  300.             foreach ($class->getInterfaceNames() as $name) {
  301.                 if (null === $interface = &$this->classReflectors[$name]) {
  302.                     $interface = new \ReflectionClass($name);
  303.                 }
  304.                 $file = $interface->getFileName();
  305.                 if (false !== $file && file_exists($file)) {
  306.                     $this->fileExists($file);
  307.                 }
  308.             }
  309.             do {
  310.                 $file = $class->getFileName();
  311.                 if (false !== $file && file_exists($file)) {
  312.                     $this->fileExists($file);
  313.                 }
  314.                 foreach ($class->getTraitNames() as $name) {
  315.                     $this->addObjectResource($name);
  316.                 }
  317.             } while ($class = $class->getParentClass());
  318.         }
  320.         return $this;
  321.     }
  323.     /**
  324.      * Retrieves the requested reflection class and registers it for resource tracking.
  325.      *
  326.      * @throws \ReflectionException when a parent class/interface/trait is not found and $throw is true
  327.      *
  328.      * @final
  329.      */
  330.     public function getReflectionClass(?string $class, bool $throw = true): ?\ReflectionClass
  331.     {
  332.         if (!$class = $this->getParameterBag()->resolveValue($class)) {
  333.             return null;
  334.         }
  336.         if (isset(self::$internalTypes[$class])) {
  337.             return null;
  338.         }
  340.         $resource = $classReflector = null;
  342.         try {
  343.             if (isset($this->classReflectors[$class])) {
  344.                 $classReflector = $this->classReflectors[$class];
  345.             } elseif (class_exists(ClassExistenceResource::class)) {
  346.                 $resource = new ClassExistenceResource($class, false);
  347.                 $classReflector = $resource->isFresh(0) ? false : new \ReflectionClass($class);
  348.             } else {
  349.                 $classReflector = class_exists($class) ? new \ReflectionClass($class) : false;
  350.             }
  351.         } catch (\ReflectionException $e) {
  352.             if ($throw) {
  353.                 throw $e;
  354.             }
  355.         }
  357.         if ($this->trackResources) {
  358.             if (!$classReflector) {
  359.                 $this->addResource($resource ?: new ClassExistenceResource($class, false));
  360.             } elseif (!$classReflector->isInternal()) {
  361.                 $path = $classReflector->getFileName();
  363.                 if (!$this->inVendors($path)) {
  364.                     $this->addResource(new ReflectionClassResource($classReflector, $this->vendors));
  365.                 }
  366.             }
  367.             $this->classReflectors[$class] = $classReflector;
  368.         }
  370.         return $classReflector ?: null;
  371.     }
  373.     /**
  374.      * Checks whether the requested file or directory exists and registers the result for resource tracking.
  375.      *
  376.      * @param string      $path          The file or directory path for which to check the existence
  377.      * @param bool|string $trackContents Whether to track contents of the given resource. If a string is passed,
  378.      *                                   it will be used as pattern for tracking contents of the requested directory
  379.      *
  380.      * @final
  381.      */
  382.     public function fileExists(string $path, $trackContents = true): bool
  383.     {
  384.         $exists = file_exists($path);
  386.         if (!$this->trackResources || $this->inVendors($path)) {
  387.             return $exists;
  388.         }
  390.         if (!$exists) {
  391.             $this->addResource(new FileExistenceResource($path));
  393.             return $exists;
  394.         }
  396.         if (is_dir($path)) {
  397.             if ($trackContents) {
  398.                 $this->addResource(new DirectoryResource($path, \is_string($trackContents) ? $trackContents : null));
  399.             } else {
  400.                 $this->addResource(new GlobResource($path, '/*', false));
  401.             }
  402.         } elseif ($trackContents) {
  403.             $this->addResource(new FileResource($path));
  404.         }
  406.         return $exists;
  407.     }
  409.     /**
  410.      * Loads the configuration for an extension.
  411.      *
  412.      * @param string $extension The extension alias or namespace
  413.      * @param array  $values    An array of values that customizes the extension
  414.      *
  415.      * @return $this
  416.      *
  417.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  418.      * @throws \LogicException        if the extension is not registered
  419.      */
  420.     public function loadFromExtension(string $extension, array $values = null)
  421.     {
  422.         if ($this->isCompiled()) {
  423.             throw new BadMethodCallException('Cannot load from an extension on a compiled container.');
  424.         }
  426.         if (\func_num_args() < 2) {
  427.             $values = [];
  428.         }
  430.         $namespace = $this->getExtension($extension)->getAlias();
  432.         $this->extensionConfigs[$namespace][] = $values;
  434.         return $this;
  435.     }
  437.     /**
  438.      * Adds a compiler pass.
  439.      *
  440.      * @param string $type     The type of compiler pass
  441.      * @param int    $priority Used to sort the passes
  442.      *
  443.      * @return $this
  444.      */
  445.     public function addCompilerPass(CompilerPassInterface $pass, string $type = PassConfig::TYPE_BEFORE_OPTIMIZATION, int $priority = 0)
  446.     {
  447.         $this->getCompiler()->addPass($pass, $type, $priority);
  449.         $this->addObjectResource($pass);
  451.         return $this;
  452.     }
  454.     /**
  455.      * Returns the compiler pass config which can then be modified.
  456.      *
  457.      * @return PassConfig The compiler pass config
  458.      */
  459.     public function getCompilerPassConfig()
  460.     {
  461.         return $this->getCompiler()->getPassConfig();
  462.     }
  464.     /**
  465.      * Returns the compiler.
  466.      *
  467.      * @return Compiler The compiler
  468.      */
  469.     public function getCompiler()
  470.     {
  471.         if (null === $this->compiler) {
  472.             $this->compiler = new Compiler();
  473.         }
  475.         return $this->compiler;
  476.     }
  478.     /**
  479.      * Sets a service.
  480.      *
  481.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  482.      */
  483.     public function set(string $id, ?object $service)
  484.     {
  485.         if ($this->isCompiled() && (isset($this->definitions[$id]) && !$this->definitions[$id]->isSynthetic())) {
  486.             // setting a synthetic service on a compiled container is alright
  487.             throw new BadMethodCallException(sprintf('Setting service "%s" for an unknown or non-synthetic service definition on a compiled container is not allowed.', $id));
  488.         }
  490.         unset($this->definitions[$id], $this->aliasDefinitions[$id], $this->removedIds[$id]);
  492.         parent::set($id, $service);
  493.     }
  495.     /**
  496.      * Removes a service definition.
  497.      */
  498.     public function removeDefinition(string $id)
  499.     {
  500.         if (isset($this->definitions[$id])) {
  501.             unset($this->definitions[$id]);
  502.             $this->removedIds[$id] = true;
  503.         }
  504.     }
  506.     /**
  507.      * Returns true if the given service is defined.
  508.      *
  509.      * @param string $id The service identifier
  510.      *
  511.      * @return bool true if the service is defined, false otherwise
  512.      */
  513.     public function has($id)
  514.     {
  515.         $id = (string) $id;
  517.         return isset($this->definitions[$id]) || isset($this->aliasDefinitions[$id]) || parent::has($id);
  518.     }
  520.     /**
  521.      * Gets a service.
  522.      *
  523.      * @param string $id              The service identifier
  524.      * @param int    $invalidBehavior The behavior when the service does not exist
  525.      *
  526.      * @return object|null The associated service
  527.      *
  528.      * @throws InvalidArgumentException          when no definitions are available
  529.      * @throws ServiceCircularReferenceException When a circular reference is detected
  530.      * @throws ServiceNotFoundException          When the service is not defined
  531.      * @throws \Exception
  532.      *
  533.      * @see Reference
  534.      */
  535.     public function get($id, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE)
  536.     {
  537.         if ($this->isCompiled() && isset($this->removedIds[$id = (string) $id]) && ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $invalidBehavior) {
  538.             return parent::get($id);
  539.         }
  541.         return $this->doGet($id, $invalidBehavior);
  542.     }
  544.     private function doGet(string $id, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, array &$inlineServices = null, bool $isConstructorArgument = false)
  545.     {
  546.         if (isset($inlineServices[$id])) {
  547.             return $inlineServices[$id];
  548.         }
  549.         if (null === $inlineServices) {
  550.             $isConstructorArgument = true;
  551.             $inlineServices = [];
  552.         }
  553.         try {
  554.             if (ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $invalidBehavior) {
  555.                 return parent::get($id, $invalidBehavior);
  556.             }
  557.             if ($service = parent::get($id, ContainerInterface::NULL_ON_INVALID_REFERENCE)) {
  558.                 return $service;
  559.             }
  560.         } catch (ServiceCircularReferenceException $e) {
  561.             if ($isConstructorArgument) {
  562.                 throw $e;
  563.             }
  564.         }
  566.         if (!isset($this->definitions[$id]) && isset($this->aliasDefinitions[$id])) {
  567.             $alias = $this->aliasDefinitions[$id];
  569.             if ($alias->isDeprecated()) {
  570.                 @trigger_error($alias->getDeprecationMessage($id), E_USER_DEPRECATED);
  571.             }
  573.             return $this->doGet((string) $alias, $invalidBehavior, $inlineServices, $isConstructorArgument);
  574.         }
  576.         try {
  577.             $definition = $this->getDefinition($id);
  578.         } catch (ServiceNotFoundException $e) {
  579.             if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE < $invalidBehavior) {
  580.                 return null;
  581.             }
  583.             throw $e;
  584.         }
  586.         if ($definition->hasErrors() && $e = $definition->getErrors()) {
  587.             throw new RuntimeException(reset($e));
  588.         }
  590.         if ($isConstructorArgument) {
  591.             $this->loading[$id] = true;
  592.         }
  594.         try {
  595.             return $this->createService($definition, $inlineServices, $isConstructorArgument, $id);
  596.         } finally {
  597.             if ($isConstructorArgument) {
  598.                 unset($this->loading[$id]);
  599.             }
  600.         }
  601.     }
  603.     /**
  604.      * Merges a ContainerBuilder with the current ContainerBuilder configuration.
  605.      *
  606.      * Service definitions overrides the current defined ones.
  607.      *
  608.      * But for parameters, they are overridden by the current ones. It allows
  609.      * the parameters passed to the container constructor to have precedence
  610.      * over the loaded ones.
  611.      *
  612.      *     $container = new ContainerBuilder(new ParameterBag(['foo' => 'bar']));
  613.      *     $loader = new LoaderXXX($container);
  614.      *     $loader->load('resource_name');
  615.      *     $container->register('foo', 'stdClass');
  616.      *
  617.      * In the above example, even if the loaded resource defines a foo
  618.      * parameter, the value will still be 'bar' as defined in the ContainerBuilder
  619.      * constructor.
  620.      *
  621.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  622.      */
  623.     public function merge(self $container)
  624.     {
  625.         if ($this->isCompiled()) {
  626.             throw new BadMethodCallException('Cannot merge on a compiled container.');
  627.         }
  629.         $this->addDefinitions($container->getDefinitions());
  630.         $this->addAliases($container->getAliases());
  631.         $this->getParameterBag()->add($container->getParameterBag()->all());
  633.         if ($this->trackResources) {
  634.             foreach ($container->getResources() as $resource) {
  635.                 $this->addResource($resource);
  636.             }
  637.         }
  639.         foreach ($this->extensions as $name => $extension) {
  640.             if (!isset($this->extensionConfigs[$name])) {
  641.                 $this->extensionConfigs[$name] = [];
  642.             }
  644.             $this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $container->getExtensionConfig($name));
  645.         }
  647.         if ($this->getParameterBag() instanceof EnvPlaceholderParameterBag && $container->getParameterBag() instanceof EnvPlaceholderParameterBag) {
  648.             $envPlaceholders = $container->getParameterBag()->getEnvPlaceholders();
  649.             $this->getParameterBag()->mergeEnvPlaceholders($container->getParameterBag());
  650.         } else {
  651.             $envPlaceholders = [];
  652.         }
  654.         foreach ($container->envCounters as $env => $count) {
  655.             if (!$count && !isset($envPlaceholders[$env])) {
  656.                 continue;
  657.             }
  658.             if (!isset($this->envCounters[$env])) {
  659.                 $this->envCounters[$env] = $count;
  660.             } else {
  661.                 $this->envCounters[$env] += $count;
  662.             }
  663.         }
  665.         foreach ($container->getAutoconfiguredInstanceof() as $interface => $childDefinition) {
  666.             if (isset($this->autoconfiguredInstanceof[$interface])) {
  667.                 throw new InvalidArgumentException(sprintf('"%s" has already been autoconfigured and merge() does not support merging autoconfiguration for the same class/interface.', $interface));
  668.             }
  670.             $this->autoconfiguredInstanceof[$interface] = $childDefinition;
  671.         }
  672.     }
  674.     /**
  675.      * Returns the configuration array for the given extension.
  676.      *
  677.      * @return array An array of configuration
  678.      */
  679.     public function getExtensionConfig(string $name)
  680.     {
  681.         if (!isset($this->extensionConfigs[$name])) {
  682.             $this->extensionConfigs[$name] = [];
  683.         }
  685.         return $this->extensionConfigs[$name];
  686.     }
  688.     /**
  689.      * Prepends a config array to the configs of the given extension.
  690.      */
  691.     public function prependExtensionConfig(string $name, array $config)
  692.     {
  693.         if (!isset($this->extensionConfigs[$name])) {
  694.             $this->extensionConfigs[$name] = [];
  695.         }
  697.         array_unshift($this->extensionConfigs[$name], $config);
  698.     }
  700.     /**
  701.      * Compiles the container.
  702.      *
  703.      * This method passes the container to compiler
  704.      * passes whose job is to manipulate and optimize
  705.      * the container.
  706.      *
  707.      * The main compiler passes roughly do four things:
  708.      *
  709.      *  * The extension configurations are merged;
  710.      *  * Parameter values are resolved;
  711.      *  * The parameter bag is frozen;
  712.      *  * Extension loading is disabled.
  713.      *
  714.      * @param bool $resolveEnvPlaceholders Whether %env()% parameters should be resolved using the current
  715.      *                                     env vars or be replaced by uniquely identifiable placeholders.
  716.      *                                     Set to "true" when you want to use the current ContainerBuilder
  717.      *                                     directly, keep to "false" when the container is dumped instead.
  718.      */
  719.     public function compile(bool $resolveEnvPlaceholders = false)
  720.     {
  721.         $compiler = $this->getCompiler();
  723.         if ($this->trackResources) {
  724.             foreach ($compiler->getPassConfig()->getPasses() as $pass) {
  725.                 $this->addObjectResource($pass);
  726.             }
  727.         }
  728.         $bag = $this->getParameterBag();
  730.         if ($resolveEnvPlaceholders && $bag instanceof EnvPlaceholderParameterBag) {
  731.             $compiler->addPass(new ResolveEnvPlaceholdersPass(), PassConfig::TYPE_AFTER_REMOVING, -1000);
  732.         }
  734.         $compiler->compile($this);
  736.         foreach ($this->definitions as $id => $definition) {
  737.             if ($this->trackResources && $definition->isLazy()) {
  738.                 $this->getReflectionClass($definition->getClass());
  739.             }
  740.         }
  742.         $this->extensionConfigs = [];
  744.         if ($bag instanceof EnvPlaceholderParameterBag) {
  745.             if ($resolveEnvPlaceholders) {
  746.                 $this->parameterBag = new ParameterBag($this->resolveEnvPlaceholders($bag->all(), true));
  747.             }
  749.             $this->envPlaceholders = $bag->getEnvPlaceholders();
  750.         }
  752.         parent::compile();
  754.         foreach ($this->definitions + $this->aliasDefinitions as $id => $definition) {
  755.             if (!$definition->isPublic() || $definition->isPrivate()) {
  756.                 $this->removedIds[$id] = true;
  757.             }
  758.         }
  759.     }
  761.     /**
  762.      * {@inheritdoc}
  763.      */
  764.     public function getServiceIds()
  765.     {
  766.         return array_map('strval', array_unique(array_merge(array_keys($this->getDefinitions()), array_keys($this->aliasDefinitions), parent::getServiceIds())));
  767.     }
  769.     /**
  770.      * Gets removed service or alias ids.
  771.      *
  772.      * @return array
  773.      */
  774.     public function getRemovedIds()
  775.     {
  776.         return $this->removedIds;
  777.     }
  779.     /**
  780.      * Adds the service aliases.
  781.      */
  782.     public function addAliases(array $aliases)
  783.     {
  784.         foreach ($aliases as $alias => $id) {
  785.             $this->setAlias($alias, $id);
  786.         }
  787.     }
  789.     /**
  790.      * Sets the service aliases.
  791.      */
  792.     public function setAliases(array $aliases)
  793.     {
  794.         $this->aliasDefinitions = [];
  795.         $this->addAliases($aliases);
  796.     }
  798.     /**
  799.      * Sets an alias for an existing service.
  800.      *
  801.      * @param string       $alias The alias to create
  802.      * @param string|Alias $id    The service to alias
  803.      *
  804.      * @return Alias
  805.      *
  806.      * @throws InvalidArgumentException if the id is not a string or an Alias
  807.      * @throws InvalidArgumentException if the alias is for itself
  808.      */
  809.     public function setAlias(string $alias, $id)
  810.     {
  811.         if ('' === $alias || '\\' === $alias[-1] || \strlen($alias) !== strcspn($alias, "\0\r\n'")) {
  812.             throw new InvalidArgumentException(sprintf('Invalid alias id: "%s".', $alias));
  813.         }
  815.         if (\is_string($id)) {
  816.             $id = new Alias($id);
  817.         } elseif (!$id instanceof Alias) {
  818.             throw new InvalidArgumentException('$id must be a string, or an Alias object.');
  819.         }
  821.         if ($alias === (string) $id) {
  822.             throw new InvalidArgumentException(sprintf('An alias can not reference itself, got a circular reference on "%s".', $alias));
  823.         }
  825.         unset($this->definitions[$alias], $this->removedIds[$alias]);
  827.         return $this->aliasDefinitions[$alias] = $id;
  828.     }
  830.     /**
  831.      * Removes an alias.
  832.      *
  833.      * @param string $alias The alias to remove
  834.      */
  835.     public function removeAlias(string $alias)
  836.     {
  837.         if (isset($this->aliasDefinitions[$alias])) {
  838.             unset($this->aliasDefinitions[$alias]);
  839.             $this->removedIds[$alias] = true;
  840.         }
  841.     }
  843.     /**
  844.      * Returns true if an alias exists under the given identifier.
  845.      *
  846.      * @return bool true if the alias exists, false otherwise
  847.      */
  848.     public function hasAlias(string $id)
  849.     {
  850.         return isset($this->aliasDefinitions[$id]);
  851.     }
  853.     /**
  854.      * Gets all defined aliases.
  855.      *
  856.      * @return Alias[] An array of aliases
  857.      */
  858.     public function getAliases()
  859.     {
  860.         return $this->aliasDefinitions;
  861.     }
  863.     /**
  864.      * Gets an alias.
  865.      *
  866.      * @return Alias An Alias instance
  867.      *
  868.      * @throws InvalidArgumentException if the alias does not exist
  869.      */
  870.     public function getAlias(string $id)
  871.     {
  872.         if (!isset($this->aliasDefinitions[$id])) {
  873.             throw new InvalidArgumentException(sprintf('The service alias "%s" does not exist.', $id));
  874.         }
  876.         return $this->aliasDefinitions[$id];
  877.     }
  879.     /**
  880.      * Registers a service definition.
  881.      *
  882.      * This methods allows for simple registration of service definition
  883.      * with a fluid interface.
  884.      *
  885.      * @return Definition A Definition instance
  886.      */
  887.     public function register(string $id, string $class = null)
  888.     {
  889.         return $this->setDefinition($id, new Definition($class));
  890.     }
  892.     /**
  893.      * Registers an autowired service definition.
  894.      *
  895.      * This method implements a shortcut for using setDefinition() with
  896.      * an autowired definition.
  897.      *
  898.      * @return Definition The created definition
  899.      */
  900.     public function autowire(string $id, string $class = null)
  901.     {
  902.         return $this->setDefinition($id, (new Definition($class))->setAutowired(true));
  903.     }
  905.     /**
  906.      * Adds the service definitions.
  907.      *
  908.      * @param Definition[] $definitions An array of service definitions
  909.      */
  910.     public function addDefinitions(array $definitions)
  911.     {
  912.         foreach ($definitions as $id => $definition) {
  913.             $this->setDefinition($id, $definition);
  914.         }
  915.     }
  917.     /**
  918.      * Sets the service definitions.
  919.      *
  920.      * @param Definition[] $definitions An array of service definitions
  921.      */
  922.     public function setDefinitions(array $definitions)
  923.     {
  924.         $this->definitions = [];
  925.         $this->addDefinitions($definitions);
  926.     }
  928.     /**
  929.      * Gets all service definitions.
  930.      *
  931.      * @return Definition[] An array of Definition instances
  932.      */
  933.     public function getDefinitions()
  934.     {
  935.         return $this->definitions;
  936.     }
  938.     /**
  939.      * Sets a service definition.
  940.      *
  941.      * @return Definition the service definition
  942.      *
  943.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  944.      */
  945.     public function setDefinition(string $id, Definition $definition)
  946.     {
  947.         if ($this->isCompiled()) {
  948.             throw new BadMethodCallException('Adding definition to a compiled container is not allowed.');
  949.         }
  951.         if ('' === $id || '\\' === $id[-1] || \strlen($id) !== strcspn($id, "\0\r\n'")) {
  952.             throw new InvalidArgumentException(sprintf('Invalid service id: "%s".', $id));
  953.         }
  955.         unset($this->aliasDefinitions[$id], $this->removedIds[$id]);
  957.         return $this->definitions[$id] = $definition;
  958.     }
  960.     /**
  961.      * Returns true if a service definition exists under the given identifier.
  962.      *
  963.      * @return bool true if the service definition exists, false otherwise
  964.      */
  965.     public function hasDefinition(string $id)
  966.     {
  967.         return isset($this->definitions[$id]);
  968.     }
  970.     /**
  971.      * Gets a service definition.
  972.      *
  973.      * @return Definition A Definition instance
  974.      *
  975.      * @throws ServiceNotFoundException if the service definition does not exist
  976.      */
  977.     public function getDefinition(string $id)
  978.     {
  979.         if (!isset($this->definitions[$id])) {
  980.             throw new ServiceNotFoundException($id);
  981.         }
  983.         return $this->definitions[$id];
  984.     }
  986.     /**
  987.      * Gets a service definition by id or alias.
  988.      *
  989.      * The method "unaliases" recursively to return a Definition instance.
  990.      *
  991.      * @return Definition A Definition instance
  992.      *
  993.      * @throws ServiceNotFoundException if the service definition does not exist
  994.      */
  995.     public function findDefinition(string $id)
  996.     {
  997.         $seen = [];
  998.         while (isset($this->aliasDefinitions[$id])) {
  999.             $id = (string) $this->aliasDefinitions[$id];
  1001.             if (isset($seen[$id])) {
  1002.                 $seen = array_values($seen);
  1003.                 $seen = \array_slice($seen, array_search($id, $seen));
  1004.                 $seen[] = $id;
  1006.                 throw new ServiceCircularReferenceException($id, $seen);
  1007.             }
  1009.             $seen[$id] = $id;
  1010.         }
  1012.         return $this->getDefinition($id);
  1013.     }
  1015.     /**
  1016.      * Creates a service for a service definition.
  1017.      *
  1018.      * @return mixed The service described by the service definition
  1019.      *
  1020.      * @throws RuntimeException         When the factory definition is incomplete
  1021.      * @throws RuntimeException         When the service is a synthetic service
  1022.      * @throws InvalidArgumentException When configure callable is not callable
  1023.      */
  1024.     private function createService(Definition $definition, array &$inlineServices, bool $isConstructorArgument = false, string $id = null, bool $tryProxy = true)
  1025.     {
  1026.         if (null === $id && isset($inlineServices[$h = spl_object_hash($definition)])) {
  1027.             return $inlineServices[$h];
  1028.         }
  1030.         if ($definition instanceof ChildDefinition) {
  1031.             throw new RuntimeException(sprintf('Constructing service "%s" from a parent definition is not supported at build time.', $id));
  1032.         }
  1034.         if ($definition->isSynthetic()) {
  1035.             throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The DIC does not know how to construct this service.', $id));
  1036.         }
  1038.         if ($definition->isDeprecated()) {
  1039.             @trigger_error($definition->getDeprecationMessage($id), E_USER_DEPRECATED);
  1040.         }
  1042.         if ($tryProxy && $definition->isLazy() && !$tryProxy = !($proxy = $this->proxyInstantiator) || $proxy instanceof RealServiceInstantiator) {
  1043.             $proxy = $proxy->instantiateProxy(
  1044.                 $this,
  1045.                 $definition,
  1046.                 $id, function () use ($definition, &$inlineServices, $id) {
  1047.                     return $this->createService($definition, $inlineServices, true, $id, false);
  1048.                 }
  1049.             );
  1050.             $this->shareService($definition, $proxy, $id, $inlineServices);
  1052.             return $proxy;
  1053.         }
  1055.         $parameterBag = $this->getParameterBag();
  1057.         if (null !== $definition->getFile()) {
  1058.             require_once $parameterBag->resolveValue($definition->getFile());
  1059.         }
  1061.         $arguments = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getArguments())), $inlineServices, $isConstructorArgument);
  1063.         if (null !== $factory = $definition->getFactory()) {
  1064.             if (\is_array($factory)) {
  1065.                 $factory = [$this->doResolveServices($parameterBag->resolveValue($factory[0]), $inlineServices, $isConstructorArgument), $factory[1]];
  1066.             } elseif (!\is_string($factory)) {
  1067.                 throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory.', $id));
  1068.             }
  1069.         }
  1071.         if (null !== $id && $definition->isShared() && isset($this->services[$id]) && ($tryProxy || !$definition->isLazy())) {
  1072.             return $this->services[$id];
  1073.         }
  1075.         if (null !== $factory) {
  1076.             $service = $factory(...$arguments);
  1078.             if (!$definition->isDeprecated() && \is_array($factory) && \is_string($factory[0])) {
  1079.                 $r = new \ReflectionClass($factory[0]);
  1081.                 if (0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1082.                     @trigger_error(sprintf('The "%s" service relies on the deprecated "%s" factory class. It should either be deprecated or its factory upgraded.', $id, $r->name), E_USER_DEPRECATED);
  1083.                 }
  1084.             }
  1085.         } else {
  1086.             $r = new \ReflectionClass($parameterBag->resolveValue($definition->getClass()));
  1088.             $service = null === $r->getConstructor() ? $r->newInstance() : $r->newInstanceArgs($arguments);
  1090.             if (!$definition->isDeprecated() && 0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1091.                 @trigger_error(sprintf('The "%s" service relies on the deprecated "%s" class. It should either be deprecated or its implementation upgraded.', $id, $r->name), E_USER_DEPRECATED);
  1092.             }
  1093.         }
  1095.         $lastWitherIndex = null;
  1096.         foreach ($definition->getMethodCalls() as $k => $call) {
  1097.             if ($call[2] ?? false) {
  1098.                 $lastWitherIndex = $k;
  1099.             }
  1100.         }
  1102.         if (null === $lastWitherIndex && ($tryProxy || !$definition->isLazy())) {
  1103.             // share only if proxying failed, or if not a proxy, and if no withers are found
  1104.             $this->shareService($definition, $service, $id, $inlineServices);
  1105.         }
  1107.         $properties = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getProperties())), $inlineServices);
  1108.         foreach ($properties as $name => $value) {
  1109.             $service->$name = $value;
  1110.         }
  1112.         foreach ($definition->getMethodCalls() as $k => $call) {
  1113.             $service = $this->callMethod($service, $call, $inlineServices);
  1115.             if ($lastWitherIndex === $k && ($tryProxy || !$definition->isLazy())) {
  1116.                 // share only if proxying failed, or if not a proxy, and this is the last wither
  1117.                 $this->shareService($definition, $service, $id, $inlineServices);
  1118.             }
  1119.         }
  1121.         if ($callable = $definition->getConfigurator()) {
  1122.             if (\is_array($callable)) {
  1123.                 $callable[0] = $parameterBag->resolveValue($callable[0]);
  1125.                 if ($callable[0] instanceof Reference) {
  1126.                     $callable[0] = $this->doGet((string) $callable[0], $callable[0]->getInvalidBehavior(), $inlineServices);
  1127.                 } elseif ($callable[0] instanceof Definition) {
  1128.                     $callable[0] = $this->createService($callable[0], $inlineServices);
  1129.                 }
  1130.             }
  1132.             if (!\is_callable($callable)) {
  1133.                 throw new InvalidArgumentException(sprintf('The configure callable for class "%s" is not a callable.', \get_class($service)));
  1134.             }
  1136.             $callable($service);
  1137.         }
  1139.         return $service;
  1140.     }
  1142.     /**
  1143.      * Replaces service references by the real service instance and evaluates expressions.
  1144.      *
  1145.      * @param mixed $value A value
  1146.      *
  1147.      * @return mixed The same value with all service references replaced by
  1148.      *               the real service instances and all expressions evaluated
  1149.      */
  1150.     public function resolveServices($value)
  1151.     {
  1152.         return $this->doResolveServices($value);
  1153.     }
  1155.     private function doResolveServices($value, array &$inlineServices = [], bool $isConstructorArgument = false)
  1156.     {
  1157.         if (\is_array($value)) {
  1158.             foreach ($value as $k => $v) {
  1159.                 $value[$k] = $this->doResolveServices($v, $inlineServices, $isConstructorArgument);
  1160.             }
  1161.         } elseif ($value instanceof ServiceClosureArgument) {
  1162.             $reference = $value->getValues()[0];
  1163.             $value = function () use ($reference) {
  1164.                 return $this->resolveServices($reference);
  1165.             };
  1166.         } elseif ($value instanceof IteratorArgument) {
  1167.             $value = new RewindableGenerator(function () use ($value) {
  1168.                 foreach ($value->getValues() as $k => $v) {
  1169.                     foreach (self::getServiceConditionals($v) as $s) {
  1170.                         if (!$this->has($s)) {
  1171.                             continue 2;
  1172.                         }
  1173.                     }
  1174.                     foreach (self::getInitializedConditionals($v) as $s) {
  1175.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE)) {
  1176.                             continue 2;
  1177.                         }
  1178.                     }
  1180.                     yield $k => $this->resolveServices($v);
  1181.                 }
  1182.             }, function () use ($value): int {
  1183.                 $count = 0;
  1184.                 foreach ($value->getValues() as $v) {
  1185.                     foreach (self::getServiceConditionals($v) as $s) {
  1186.                         if (!$this->has($s)) {
  1187.                             continue 2;
  1188.                         }
  1189.                     }
  1190.                     foreach (self::getInitializedConditionals($v) as $s) {
  1191.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE)) {
  1192.                             continue 2;
  1193.                         }
  1194.                     }
  1196.                     ++$count;
  1197.                 }
  1199.                 return $count;
  1200.             });
  1201.         } elseif ($value instanceof ServiceLocatorArgument) {
  1202.             $refs = $types = [];
  1203.             foreach ($value->getValues() as $k => $v) {
  1204.                 if ($v) {
  1205.                     $refs[$k] = [$v];
  1206.                     $types[$k] = $v instanceof TypedReference ? $v->getType() : '?';
  1207.                 }
  1208.             }
  1209.             $value = new ServiceLocator(\Closure::fromCallable([$this, 'resolveServices']), $refs, $types);
  1210.         } elseif ($value instanceof Reference) {
  1211.             $value = $this->doGet((string) $value, $value->getInvalidBehavior(), $inlineServices, $isConstructorArgument);
  1212.         } elseif ($value instanceof Definition) {
  1213.             $value = $this->createService($value, $inlineServices, $isConstructorArgument);
  1214.         } elseif ($value instanceof Parameter) {
  1215.             $value = $this->getParameter((string) $value);
  1216.         } elseif ($value instanceof Expression) {
  1217.             $value = $this->getExpressionLanguage()->evaluate($value, ['container' => $this]);
  1218.         }
  1220.         return $value;
  1221.     }
  1223.     /**
  1224.      * Returns service ids for a given tag.
  1225.      *
  1226.      * Example:
  1227.      *
  1228.      *     $container->register('foo')->addTag('my.tag', ['hello' => 'world']);
  1229.      *
  1230.      *     $serviceIds = $container->findTaggedServiceIds('my.tag');
  1231.      *     foreach ($serviceIds as $serviceId => $tags) {
  1232.      *         foreach ($tags as $tag) {
  1233.      *             echo $tag['hello'];
  1234.      *         }
  1235.      *     }
  1236.      *
  1237.      * @return array An array of tags with the tagged service as key, holding a list of attribute arrays
  1238.      */
  1239.     public function findTaggedServiceIds(string $name, bool $throwOnAbstract = false)
  1240.     {
  1241.         $this->usedTags[] = $name;
  1242.         $tags = [];
  1243.         foreach ($this->getDefinitions() as $id => $definition) {
  1244.             if ($definition->hasTag($name)) {
  1245.                 if ($throwOnAbstract && $definition->isAbstract()) {
  1246.                     throw new InvalidArgumentException(sprintf('The service "%s" tagged "%s" must not be abstract.', $id, $name));
  1247.                 }
  1248.                 $tags[$id] = $definition->getTag($name);
  1249.             }
  1250.         }
  1252.         return $tags;
  1253.     }
  1255.     /**
  1256.      * Returns all tags the defined services use.
  1257.      *
  1258.      * @return array An array of tags
  1259.      */
  1260.     public function findTags()
  1261.     {
  1262.         $tags = [];
  1263.         foreach ($this->getDefinitions() as $id => $definition) {
  1264.             $tags = array_merge(array_keys($definition->getTags()), $tags);
  1265.         }
  1267.         return array_unique($tags);
  1268.     }
  1270.     /**
  1271.      * Returns all tags not queried by findTaggedServiceIds.
  1272.      *
  1273.      * @return string[] An array of tags
  1274.      */
  1275.     public function findUnusedTags()
  1276.     {
  1277.         return array_values(array_diff($this->findTags(), $this->usedTags));
  1278.     }
  1280.     public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
  1281.     {
  1282.         $this->expressionLanguageProviders[] = $provider;
  1283.     }
  1285.     /**
  1286.      * @return ExpressionFunctionProviderInterface[]
  1287.      */
  1288.     public function getExpressionLanguageProviders()
  1289.     {
  1290.         return $this->expressionLanguageProviders;
  1291.     }
  1293.     /**
  1294.      * Returns a ChildDefinition that will be used for autoconfiguring the interface/class.
  1295.      *
  1296.      * @return ChildDefinition
  1297.      */
  1298.     public function registerForAutoconfiguration(string $interface)
  1299.     {
  1300.         if (!isset($this->autoconfiguredInstanceof[$interface])) {
  1301.             $this->autoconfiguredInstanceof[$interface] = new ChildDefinition('');
  1302.         }
  1304.         return $this->autoconfiguredInstanceof[$interface];
  1305.     }
  1307.     /**
  1308.      * Registers an autowiring alias that only binds to a specific argument name.
  1309.      *
  1310.      * The argument name is derived from $name if provided (from $id otherwise)
  1311.      * using camel case: "foo.bar" or "foo_bar" creates an alias bound to
  1312.      * "$fooBar"-named arguments with $type as type-hint. Such arguments will
  1313.      * receive the service $id when autowiring is used.
  1314.      */
  1315.     public function registerAliasForArgument(string $id, string $type, string $name = null): Alias
  1316.     {
  1317.         $name = lcfirst(str_replace(' ', '', ucwords(preg_replace('/[^a-zA-Z0-9\x7f-\xff]++/', ' ', $name ?? $id))));
  1319.         if (!preg_match('/^[a-zA-Z_\x7f-\xff]/', $name)) {
  1320.             throw new InvalidArgumentException(sprintf('Invalid argument name "%s" for service "%s": the first character must be a letter.', $name, $id));
  1321.         }
  1323.         return $this->setAlias($type.' $'.$name, $id);
  1324.     }
  1326.     /**
  1327.      * Returns an array of ChildDefinition[] keyed by interface.
  1328.      *
  1329.      * @return ChildDefinition[]
  1330.      */
  1331.     public function getAutoconfiguredInstanceof()
  1332.     {
  1333.         return $this->autoconfiguredInstanceof;
  1334.     }
  1336.     /**
  1337.      * Resolves env parameter placeholders in a string or an array.
  1338.      *
  1339.      * @param mixed            $value     The value to resolve
  1340.      * @param string|true|null $format    A sprintf() format returning the replacement for each env var name or
  1341.      *                                    null to resolve back to the original "%env(VAR)%" format or
  1342.      *                                    true to resolve to the actual values of the referenced env vars
  1343.      * @param array            &$usedEnvs Env vars found while resolving are added to this array
  1344.      *
  1345.      * @return mixed The value with env parameters resolved if a string or an array is passed
  1346.      */
  1347.     public function resolveEnvPlaceholders($value, $format = null, array &$usedEnvs = null)
  1348.     {
  1349.         if (null === $format) {
  1350.             $format = '%%env(%s)%%';
  1351.         }
  1353.         $bag = $this->getParameterBag();
  1354.         if (true === $format) {
  1355.             $value = $bag->resolveValue($value);
  1356.         }
  1358.         if ($value instanceof Definition) {
  1359.             $value = (array) $value;
  1360.         }
  1362.         if (\is_array($value)) {
  1363.             $result = [];
  1364.             foreach ($value as $k => $v) {
  1365.                 $result[\is_string($k) ? $this->resolveEnvPlaceholders($k, $format, $usedEnvs) : $k] = $this->resolveEnvPlaceholders($v, $format, $usedEnvs);
  1366.             }
  1368.             return $result;
  1369.         }
  1371.         if (!\is_string($value) || 38 > \strlen($value)) {
  1372.             return $value;
  1373.         }
  1374.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1376.         $completed = false;
  1377.         foreach ($envPlaceholders as $env => $placeholders) {
  1378.             foreach ($placeholders as $placeholder) {
  1379.                 if (false !== stripos($value, $placeholder)) {
  1380.                     if (true === $format) {
  1381.                         $resolved = $bag->escapeValue($this->getEnv($env));
  1382.                     } else {
  1383.                         $resolved = sprintf($format, $env);
  1384.                     }
  1385.                     if ($placeholder === $value) {
  1386.                         $value = $resolved;
  1387.                         $completed = true;
  1388.                     } else {
  1389.                         if (!\is_string($resolved) && !is_numeric($resolved)) {
  1390.                             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, \gettype($resolved), $this->resolveEnvPlaceholders($value)));
  1391.                         }
  1392.                         $value = str_ireplace($placeholder, $resolved, $value);
  1393.                     }
  1394.                     $usedEnvs[$env] = $env;
  1395.                     $this->envCounters[$env] = isset($this->envCounters[$env]) ? 1 + $this->envCounters[$env] : 1;
  1397.                     if ($completed) {
  1398.                         break 2;
  1399.                     }
  1400.                 }
  1401.             }
  1402.         }
  1404.         return $value;
  1405.     }
  1407.     /**
  1408.      * Get statistics about env usage.
  1409.      *
  1410.      * @return int[] The number of time each env vars has been resolved
  1411.      */
  1412.     public function getEnvCounters()
  1413.     {
  1414.         $bag = $this->getParameterBag();
  1415.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1417.         foreach ($envPlaceholders as $env => $placeholders) {
  1418.             if (!isset($this->envCounters[$env])) {
  1419.                 $this->envCounters[$env] = 0;
  1420.             }
  1421.         }
  1423.         return $this->envCounters;
  1424.     }
  1426.     /**
  1427.      * @final
  1428.      */
  1429.     public function log(CompilerPassInterface $pass, string $message)
  1430.     {
  1431.         $this->getCompiler()->log($pass, $this->resolveEnvPlaceholders($message));
  1432.     }
  1434.     /**
  1435.      * Gets removed binding ids.
  1436.      *
  1437.      * @internal
  1438.      */
  1439.     public function getRemovedBindingIds(): array
  1440.     {
  1441.         return $this->removedBindingIds;
  1442.     }
  1444.     /**
  1445.      * Removes bindings for a service.
  1446.      *
  1447.      * @internal
  1448.      */
  1449.     public function removeBindings(string $id)
  1450.     {
  1451.         if ($this->hasDefinition($id)) {
  1452.             foreach ($this->getDefinition($id)->getBindings() as $key => $binding) {
  1453.                 list(, $bindingId) = $binding->getValues();
  1454.                 $this->removedBindingIds[(int) $bindingId] = true;
  1455.             }
  1456.         }
  1457.     }
  1459.     /**
  1460.      * Returns the Service Conditionals.
  1461.      *
  1462.      * @param mixed $value An array of conditionals to return
  1463.      *
  1464.      * @internal
  1465.      */
  1466.     public static function getServiceConditionals($value): array
  1467.     {
  1468.         $services = [];
  1470.         if (\is_array($value)) {
  1471.             foreach ($value as $v) {
  1472.                 $services = array_unique(array_merge($services, self::getServiceConditionals($v)));
  1473.             }
  1474.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  1475.             $services[] = (string) $value;
  1476.         }
  1478.         return $services;
  1479.     }
  1481.     /**
  1482.      * Returns the initialized conditionals.
  1483.      *
  1484.      * @param mixed $value An array of conditionals to return
  1485.      *
  1486.      * @internal
  1487.      */
  1488.     public static function getInitializedConditionals($value): array
  1489.     {
  1490.         $services = [];
  1492.         if (\is_array($value)) {
  1493.             foreach ($value as $v) {
  1494.                 $services = array_unique(array_merge($services, self::getInitializedConditionals($v)));
  1495.             }
  1496.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $value->getInvalidBehavior()) {
  1497.             $services[] = (string) $value;
  1498.         }
  1500.         return $services;
  1501.     }
  1503.     /**
  1504.      * Computes a reasonably unique hash of a value.
  1505.      *
  1506.      * @param mixed $value A serializable value
  1507.      *
  1508.      * @return string
  1509.      */
  1510.     public static function hash($value)
  1511.     {
  1512.         $hash = substr(base64_encode(hash('sha256', serialize($value), true)), 0, 7);
  1514.         return str_replace(['/', '+'], ['.', '_'], $hash);
  1515.     }
  1517.     /**
  1518.      * {@inheritdoc}
  1519.      */
  1520.     protected function getEnv($name)
  1521.     {
  1522.         $value = parent::getEnv($name);
  1523.         $bag = $this->getParameterBag();
  1525.         if (!\is_string($value) || !$bag instanceof EnvPlaceholderParameterBag) {
  1526.             return $value;
  1527.         }
  1529.         $envPlaceholders = $bag->getEnvPlaceholders();
  1530.         if (isset($envPlaceholders[$name][$value])) {
  1531.             $bag = new ParameterBag($bag->all());
  1533.             return $bag->unescapeValue($bag->get("env($name)"));
  1534.         }
  1535.         foreach ($envPlaceholders as $env => $placeholders) {
  1536.             if (isset($placeholders[$value])) {
  1537.                 return $this->getEnv($env);
  1538.             }
  1539.         }
  1541.         $this->resolving["env($name)"] = true;
  1542.         try {
  1543.             return $bag->unescapeValue($this->resolveEnvPlaceholders($bag->escapeValue($value), true));
  1544.         } finally {
  1545.             unset($this->resolving["env($name)"]);
  1546.         }
  1547.     }
  1549.     private function callMethod($service, array $call, array &$inlineServices)
  1550.     {
  1551.         foreach (self::getServiceConditionals($call[1]) as $s) {
  1552.             if (!$this->has($s)) {
  1553.                 return $service;
  1554.             }
  1555.         }
  1556.         foreach (self::getInitializedConditionals($call[1]) as $s) {
  1557.             if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
  1558.                 return $service;
  1559.             }
  1560.         }
  1562.         $result = $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));
  1564.         return empty($call[2]) ? $service : $result;
  1565.     }
  1567.     /**
  1568.      * Shares a given service in the container.
  1569.      *
  1570.      * @param mixed $service
  1571.      */
  1572.     private function shareService(Definition $definition, $service, ?string $id, array &$inlineServices)
  1573.     {
  1574.         $inlineServices[null !== $id ? $id : spl_object_hash($definition)] = $service;
  1576.         if (null !== $id && $definition->isShared()) {
  1577.             $this->services[$id] = $service;
  1578.             unset($this->loading[$id]);
  1579.         }
  1580.     }
  1582.     private function getExpressionLanguage(): ExpressionLanguage
  1583.     {
  1584.         if (null === $this->expressionLanguage) {
  1585.             if (!class_exists('Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
  1586.                 throw new LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  1587.             }
  1588.             $this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders);
  1589.         }
  1591.         return $this->expressionLanguage;
  1592.     }
  1594.     private function inVendors(string $path): bool
  1595.     {
  1596.         if (null === $this->vendors) {
  1597.             $resource = new ComposerResource();
  1598.             $this->vendors = $resource->getVendors();
  1599.             $this->addResource($resource);
  1600.         }
  1601.         $path = realpath($path) ?: $path;
  1603.         foreach ($this->vendors as $vendor) {
  1604.             if (0 === strpos($path, $vendor) && false !== strpbrk(substr($path, \strlen($vendor), 1), '/'.\DIRECTORY_SEPARATOR)) {
  1605.                 return true;
  1606.             }
  1607.         }
  1609.         return false;
  1610.     }
  1611. }