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

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