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

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.      * @param bool $track True if you want to track resources, false otherwise
  165.      */
  166.     public function setResourceTracking($track)
  167.     {
  168.         $this->trackResources = (bool) $track;
  169.     }
  171.     /**
  172.      * Checks if resources are tracked.
  173.      *
  174.      * @return bool true If resources are tracked, false otherwise
  175.      */
  176.     public function isTrackingResources()
  177.     {
  178.         return $this->trackResources;
  179.     }
  181.     /**
  182.      * Sets the instantiator to be used when fetching proxies.
  183.      */
  184.     public function setProxyInstantiator(InstantiatorInterface $proxyInstantiator)
  185.     {
  186.         $this->proxyInstantiator = $proxyInstantiator;
  187.     }
  189.     public function registerExtension(ExtensionInterface $extension)
  190.     {
  191.         $this->extensions[$extension->getAlias()] = $extension;
  193.         if (false !== $extension->getNamespace()) {
  194.             $this->extensionsByNs[$extension->getNamespace()] = $extension;
  195.         }
  196.     }
  198.     /**
  199.      * Returns an extension by alias or namespace.
  200.      *
  201.      * @param string $name An alias or a namespace
  202.      *
  203.      * @return ExtensionInterface An extension instance
  204.      *
  205.      * @throws LogicException if the extension is not registered
  206.      */
  207.     public function getExtension($name)
  208.     {
  209.         if (isset($this->extensions[$name])) {
  210.             return $this->extensions[$name];
  211.         }
  213.         if (isset($this->extensionsByNs[$name])) {
  214.             return $this->extensionsByNs[$name];
  215.         }
  217.         throw new LogicException(sprintf('Container extension "%s" is not registered.', $name));
  218.     }
  220.     /**
  221.      * Returns all registered extensions.
  222.      *
  223.      * @return ExtensionInterface[] An array of ExtensionInterface
  224.      */
  225.     public function getExtensions()
  226.     {
  227.         return $this->extensions;
  228.     }
  230.     /**
  231.      * Checks if we have an extension.
  232.      *
  233.      * @param string $name The name of the extension
  234.      *
  235.      * @return bool If the extension exists
  236.      */
  237.     public function hasExtension($name)
  238.     {
  239.         return isset($this->extensions[$name]) || isset($this->extensionsByNs[$name]);
  240.     }
  242.     /**
  243.      * Returns an array of resources loaded to build this configuration.
  244.      *
  245.      * @return ResourceInterface[] An array of resources
  246.      */
  247.     public function getResources()
  248.     {
  249.         return array_values($this->resources);
  250.     }
  252.     /**
  253.      * @return $this
  254.      */
  255.     public function addResource(ResourceInterface $resource)
  256.     {
  257.         if (!$this->trackResources) {
  258.             return $this;
  259.         }
  261.         if ($resource instanceof GlobResource && $this->inVendors($resource->getPrefix())) {
  262.             return $this;
  263.         }
  265.         $this->resources[(string) $resource] = $resource;
  267.         return $this;
  268.     }
  270.     /**
  271.      * Sets the resources for this configuration.
  272.      *
  273.      * @param ResourceInterface[] $resources An array of resources
  274.      *
  275.      * @return $this
  276.      */
  277.     public function setResources(array $resources)
  278.     {
  279.         if (!$this->trackResources) {
  280.             return $this;
  281.         }
  283.         $this->resources = $resources;
  285.         return $this;
  286.     }
  288.     /**
  289.      * Adds the object class hierarchy as resources.
  290.      *
  291.      * @param object|string $object An object instance or class name
  292.      *
  293.      * @return $this
  294.      */
  295.     public function addObjectResource($object)
  296.     {
  297.         if ($this->trackResources) {
  298.             if (\is_object($object)) {
  299.                 $object = \get_class($object);
  300.             }
  301.             if (!isset($this->classReflectors[$object])) {
  302.                 $this->classReflectors[$object] = new \ReflectionClass($object);
  303.             }
  304.             $class = $this->classReflectors[$object];
  306.             foreach ($class->getInterfaceNames() as $name) {
  307.                 if (null === $interface = &$this->classReflectors[$name]) {
  308.                     $interface = new \ReflectionClass($name);
  309.                 }
  310.                 $file = $interface->getFileName();
  311.                 if (false !== $file && file_exists($file)) {
  312.                     $this->fileExists($file);
  313.                 }
  314.             }
  315.             do {
  316.                 $file = $class->getFileName();
  317.                 if (false !== $file && file_exists($file)) {
  318.                     $this->fileExists($file);
  319.                 }
  320.                 foreach ($class->getTraitNames() as $name) {
  321.                     $this->addObjectResource($name);
  322.                 }
  323.             } while ($class = $class->getParentClass());
  324.         }
  326.         return $this;
  327.     }
  329.     /**
  330.      * Retrieves the requested reflection class and registers it for resource tracking.
  331.      *
  332.      * @throws \ReflectionException when a parent class/interface/trait is not found and $throw is true
  333.      *
  334.      * @final
  335.      */
  336.     public function getReflectionClass(?string $class, bool $throw = true): ?\ReflectionClass
  337.     {
  338.         if (!$class = $this->getParameterBag()->resolveValue($class)) {
  339.             return null;
  340.         }
  342.         if (isset(self::$internalTypes[$class])) {
  343.             return null;
  344.         }
  346.         $resource = $classReflector = null;
  348.         try {
  349.             if (isset($this->classReflectors[$class])) {
  350.                 $classReflector = $this->classReflectors[$class];
  351.             } elseif (class_exists(ClassExistenceResource::class)) {
  352.                 $resource = new ClassExistenceResource($class, false);
  353.                 $classReflector = $resource->isFresh(0) ? false : new \ReflectionClass($class);
  354.             } else {
  355.                 $classReflector = class_exists($class) ? new \ReflectionClass($class) : false;
  356.             }
  357.         } catch (\ReflectionException $e) {
  358.             if ($throw) {
  359.                 throw $e;
  360.             }
  361.         }
  363.         if ($this->trackResources) {
  364.             if (!$classReflector) {
  365.                 $this->addResource($resource ?: new ClassExistenceResource($class, false));
  366.             } elseif (!$classReflector->isInternal()) {
  367.                 $path = $classReflector->getFileName();
  369.                 if (!$this->inVendors($path)) {
  370.                     $this->addResource(new ReflectionClassResource($classReflector, $this->vendors));
  371.                 }
  372.             }
  373.             $this->classReflectors[$class] = $classReflector;
  374.         }
  376.         return $classReflector ?: null;
  377.     }
  379.     /**
  380.      * Checks whether the requested file or directory exists and registers the result for resource tracking.
  381.      *
  382.      * @param string      $path          The file or directory path for which to check the existence
  383.      * @param bool|string $trackContents Whether to track contents of the given resource. If a string is passed,
  384.      *                                   it will be used as pattern for tracking contents of the requested directory
  385.      *
  386.      * @final
  387.      */
  388.     public function fileExists(string $path, $trackContents = true): bool
  389.     {
  390.         $exists = file_exists($path);
  392.         if (!$this->trackResources || $this->inVendors($path)) {
  393.             return $exists;
  394.         }
  396.         if (!$exists) {
  397.             $this->addResource(new FileExistenceResource($path));
  399.             return $exists;
  400.         }
  402.         if (is_dir($path)) {
  403.             if ($trackContents) {
  404.                 $this->addResource(new DirectoryResource($path, \is_string($trackContents) ? $trackContents : null));
  405.             } else {
  406.                 $this->addResource(new GlobResource($path, '/*', false));
  407.             }
  408.         } elseif ($trackContents) {
  409.             $this->addResource(new FileResource($path));
  410.         }
  412.         return $exists;
  413.     }
  415.     /**
  416.      * Loads the configuration for an extension.
  417.      *
  418.      * @param string $extension The extension alias or namespace
  419.      * @param array  $values    An array of values that customizes the extension
  420.      *
  421.      * @return $this
  422.      *
  423.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  424.      * @throws \LogicException        if the extension is not registered
  425.      */
  426.     public function loadFromExtension($extension, array $values = null)
  427.     {
  428.         if ($this->isCompiled()) {
  429.             throw new BadMethodCallException('Cannot load from an extension on a compiled container.');
  430.         }
  432.         if (\func_num_args() < 2) {
  433.             $values = [];
  434.         }
  436.         $namespace = $this->getExtension($extension)->getAlias();
  438.         $this->extensionConfigs[$namespace][] = $values;
  440.         return $this;
  441.     }
  443.     /**
  444.      * Adds a compiler pass.
  445.      *
  446.      * @param string $type     The type of compiler pass
  447.      * @param int    $priority Used to sort the passes
  448.      *
  449.      * @return $this
  450.      */
  451.     public function addCompilerPass(CompilerPassInterface $pass, $type = PassConfig::TYPE_BEFORE_OPTIMIZATION, int $priority = 0)
  452.     {
  453.         $this->getCompiler()->addPass($pass, $type, $priority);
  455.         $this->addObjectResource($pass);
  457.         return $this;
  458.     }
  460.     /**
  461.      * Returns the compiler pass config which can then be modified.
  462.      *
  463.      * @return PassConfig The compiler pass config
  464.      */
  465.     public function getCompilerPassConfig()
  466.     {
  467.         return $this->getCompiler()->getPassConfig();
  468.     }
  470.     /**
  471.      * Returns the compiler.
  472.      *
  473.      * @return Compiler The compiler
  474.      */
  475.     public function getCompiler()
  476.     {
  477.         if (null === $this->compiler) {
  478.             $this->compiler = new Compiler();
  479.         }
  481.         return $this->compiler;
  482.     }
  484.     /**
  485.      * Sets a service.
  486.      *
  487.      * @param string      $id      The service identifier
  488.      * @param object|null $service The service instance
  489.      *
  490.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  491.      */
  492.     public function set($id, $service)
  493.     {
  494.         if (!\is_object($service) && null !== $service) {
  495.             @trigger_error(sprintf('Non-object services are deprecated since Symfony 4.4, setting the "%s" service to a value of type "%s" should be avoided.', $id, \gettype($service)), \E_USER_DEPRECATED);
  496.         }
  498.         $id = (string) $id;
  500.         if ($this->isCompiled() && (isset($this->definitions[$id]) && !$this->definitions[$id]->isSynthetic())) {
  501.             // setting a synthetic service on a compiled container is alright
  502.             throw new BadMethodCallException(sprintf('Setting service "%s" for an unknown or non-synthetic service definition on a compiled container is not allowed.', $id));
  503.         }
  505.         unset($this->definitions[$id], $this->aliasDefinitions[$id], $this->removedIds[$id]);
  507.         parent::set($id, $service);
  508.     }
  510.     /**
  511.      * Removes a service definition.
  512.      *
  513.      * @param string $id The service identifier
  514.      */
  515.     public function removeDefinition($id)
  516.     {
  517.         if (isset($this->definitions[$id = (string) $id])) {
  518.             unset($this->definitions[$id]);
  519.             $this->removedIds[$id] = true;
  520.         }
  521.     }
  523.     /**
  524.      * Returns true if the given service is defined.
  525.      *
  526.      * @param string $id The service identifier
  527.      *
  528.      * @return bool true if the service is defined, false otherwise
  529.      */
  530.     public function has($id)
  531.     {
  532.         $id = (string) $id;
  534.         return isset($this->definitions[$id]) || isset($this->aliasDefinitions[$id]) || parent::has($id);
  535.     }
  537.     /**
  538.      * Gets a service.
  539.      *
  540.      * @param string $id              The service identifier
  541.      * @param int    $invalidBehavior The behavior when the service does not exist
  542.      *
  543.      * @return object|null The associated service
  544.      *
  545.      * @throws InvalidArgumentException          when no definitions are available
  546.      * @throws ServiceCircularReferenceException When a circular reference is detected
  547.      * @throws ServiceNotFoundException          When the service is not defined
  548.      * @throws \Exception
  549.      *
  550.      * @see Reference
  551.      */
  552.     public function get($id, $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE)
  553.     {
  554.         if ($this->isCompiled() && isset($this->removedIds[$id = (string) $id]) && ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $invalidBehavior) {
  555.             return parent::get($id);
  556.         }
  558.         $service = $this->doGet($id, $invalidBehavior);
  560.         if (!\is_object($service) && null !== $service) {
  561.             @trigger_error(sprintf('Non-object services are deprecated since Symfony 4.4, please fix the "%s" service which is of type "%s" right now.', $id, \gettype($service)), \E_USER_DEPRECATED);
  562.         }
  564.         return $service;
  565.     }
  567.     private function doGet(string $id, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, array &$inlineServices = null, bool $isConstructorArgument = false)
  568.     {
  569.         if (isset($inlineServices[$id])) {
  570.             return $inlineServices[$id];
  571.         }
  572.         if (null === $inlineServices) {
  573.             $isConstructorArgument = true;
  574.             $inlineServices = [];
  575.         }
  576.         try {
  577.             if (ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $invalidBehavior) {
  578.                 return parent::get($id, $invalidBehavior);
  579.             }
  580.             if ($service = parent::get($id, ContainerInterface::NULL_ON_INVALID_REFERENCE)) {
  581.                 return $service;
  582.             }
  583.         } catch (ServiceCircularReferenceException $e) {
  584.             if ($isConstructorArgument) {
  585.                 throw $e;
  586.             }
  587.         }
  589.         if (!isset($this->definitions[$id]) && isset($this->aliasDefinitions[$id])) {
  590.             $alias = $this->aliasDefinitions[$id];
  592.             if ($alias->isDeprecated()) {
  593.                 @trigger_error($alias->getDeprecationMessage($id), \E_USER_DEPRECATED);
  594.             }
  596.             return $this->doGet((string) $alias, $invalidBehavior, $inlineServices, $isConstructorArgument);
  597.         }
  599.         try {
  600.             $definition = $this->getDefinition($id);
  601.         } catch (ServiceNotFoundException $e) {
  602.             if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE < $invalidBehavior) {
  603.                 return null;
  604.             }
  606.             throw $e;
  607.         }
  609.         if ($definition->hasErrors() && $e = $definition->getErrors()) {
  610.             throw new RuntimeException(reset($e));
  611.         }
  613.         if ($isConstructorArgument) {
  614.             $this->loading[$id] = true;
  615.         }
  617.         try {
  618.             return $this->createService($definition, $inlineServices, $isConstructorArgument, $id);
  619.         } finally {
  620.             if ($isConstructorArgument) {
  621.                 unset($this->loading[$id]);
  622.             }
  623.         }
  624.     }
  626.     /**
  627.      * Merges a ContainerBuilder with the current ContainerBuilder configuration.
  628.      *
  629.      * Service definitions overrides the current defined ones.
  630.      *
  631.      * But for parameters, they are overridden by the current ones. It allows
  632.      * the parameters passed to the container constructor to have precedence
  633.      * over the loaded ones.
  634.      *
  635.      *     $container = new ContainerBuilder(new ParameterBag(['foo' => 'bar']));
  636.      *     $loader = new LoaderXXX($container);
  637.      *     $loader->load('resource_name');
  638.      *     $container->register('foo', 'stdClass');
  639.      *
  640.      * In the above example, even if the loaded resource defines a foo
  641.      * parameter, the value will still be 'bar' as defined in the ContainerBuilder
  642.      * constructor.
  643.      *
  644.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  645.      */
  646.     public function merge(self $container)
  647.     {
  648.         if ($this->isCompiled()) {
  649.             throw new BadMethodCallException('Cannot merge on a compiled container.');
  650.         }
  652.         $this->addDefinitions($container->getDefinitions());
  653.         $this->addAliases($container->getAliases());
  654.         $this->getParameterBag()->add($container->getParameterBag()->all());
  656.         if ($this->trackResources) {
  657.             foreach ($container->getResources() as $resource) {
  658.                 $this->addResource($resource);
  659.             }
  660.         }
  662.         foreach ($this->extensions as $name => $extension) {
  663.             if (!isset($this->extensionConfigs[$name])) {
  664.                 $this->extensionConfigs[$name] = [];
  665.             }
  667.             $this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $container->getExtensionConfig($name));
  668.         }
  670.         if ($this->getParameterBag() instanceof EnvPlaceholderParameterBag && $container->getParameterBag() instanceof EnvPlaceholderParameterBag) {
  671.             $envPlaceholders = $container->getParameterBag()->getEnvPlaceholders();
  672.             $this->getParameterBag()->mergeEnvPlaceholders($container->getParameterBag());
  673.         } else {
  674.             $envPlaceholders = [];
  675.         }
  677.         foreach ($container->envCounters as $env => $count) {
  678.             if (!$count && !isset($envPlaceholders[$env])) {
  679.                 continue;
  680.             }
  681.             if (!isset($this->envCounters[$env])) {
  682.                 $this->envCounters[$env] = $count;
  683.             } else {
  684.                 $this->envCounters[$env] += $count;
  685.             }
  686.         }
  688.         foreach ($container->getAutoconfiguredInstanceof() as $interface => $childDefinition) {
  689.             if (isset($this->autoconfiguredInstanceof[$interface])) {
  690.                 throw new InvalidArgumentException(sprintf('"%s" has already been autoconfigured and merge() does not support merging autoconfiguration for the same class/interface.', $interface));
  691.             }
  693.             $this->autoconfiguredInstanceof[$interface] = $childDefinition;
  694.         }
  695.     }
  697.     /**
  698.      * Returns the configuration array for the given extension.
  699.      *
  700.      * @param string $name The name of the extension
  701.      *
  702.      * @return array An array of configuration
  703.      */
  704.     public function getExtensionConfig($name)
  705.     {
  706.         if (!isset($this->extensionConfigs[$name])) {
  707.             $this->extensionConfigs[$name] = [];
  708.         }
  710.         return $this->extensionConfigs[$name];
  711.     }
  713.     /**
  714.      * Prepends a config array to the configs of the given extension.
  715.      *
  716.      * @param string $name   The name of the extension
  717.      * @param array  $config The config to set
  718.      */
  719.     public function prependExtensionConfig($name, array $config)
  720.     {
  721.         if (!isset($this->extensionConfigs[$name])) {
  722.             $this->extensionConfigs[$name] = [];
  723.         }
  725.         array_unshift($this->extensionConfigs[$name], $config);
  726.     }
  728.     /**
  729.      * Compiles the container.
  730.      *
  731.      * This method passes the container to compiler
  732.      * passes whose job is to manipulate and optimize
  733.      * the container.
  734.      *
  735.      * The main compiler passes roughly do four things:
  736.      *
  737.      *  * The extension configurations are merged;
  738.      *  * Parameter values are resolved;
  739.      *  * The parameter bag is frozen;
  740.      *  * Extension loading is disabled.
  741.      *
  742.      * @param bool $resolveEnvPlaceholders Whether %env()% parameters should be resolved using the current
  743.      *                                     env vars or be replaced by uniquely identifiable placeholders.
  744.      *                                     Set to "true" when you want to use the current ContainerBuilder
  745.      *                                     directly, keep to "false" when the container is dumped instead.
  746.      */
  747.     public function compile(bool $resolveEnvPlaceholders = false)
  748.     {
  749.         $compiler = $this->getCompiler();
  751.         if ($this->trackResources) {
  752.             foreach ($compiler->getPassConfig()->getPasses() as $pass) {
  753.                 $this->addObjectResource($pass);
  754.             }
  755.         }
  756.         $bag = $this->getParameterBag();
  758.         if ($resolveEnvPlaceholders && $bag instanceof EnvPlaceholderParameterBag) {
  759.             $compiler->addPass(new ResolveEnvPlaceholdersPass(), PassConfig::TYPE_AFTER_REMOVING, -1000);
  760.         }
  762.         $compiler->compile($this);
  764.         foreach ($this->definitions as $id => $definition) {
  765.             if ($this->trackResources && $definition->isLazy()) {
  766.                 $this->getReflectionClass($definition->getClass());
  767.             }
  768.         }
  770.         $this->extensionConfigs = [];
  772.         if ($bag instanceof EnvPlaceholderParameterBag) {
  773.             if ($resolveEnvPlaceholders) {
  774.                 $this->parameterBag = new ParameterBag($this->resolveEnvPlaceholders($bag->all(), true));
  775.             }
  777.             $this->envPlaceholders = $bag->getEnvPlaceholders();
  778.         }
  780.         parent::compile();
  782.         foreach ($this->definitions + $this->aliasDefinitions as $id => $definition) {
  783.             if (!$definition->isPublic() || $definition->isPrivate()) {
  784.                 $this->removedIds[$id] = true;
  785.             }
  786.         }
  787.     }
  789.     /**
  790.      * {@inheritdoc}
  791.      */
  792.     public function getServiceIds()
  793.     {
  794.         return array_map('strval', array_unique(array_merge(array_keys($this->getDefinitions()), array_keys($this->aliasDefinitions), parent::getServiceIds())));
  795.     }
  797.     /**
  798.      * Gets removed service or alias ids.
  799.      *
  800.      * @return array
  801.      */
  802.     public function getRemovedIds()
  803.     {
  804.         return $this->removedIds;
  805.     }
  807.     /**
  808.      * Adds the service aliases.
  809.      */
  810.     public function addAliases(array $aliases)
  811.     {
  812.         foreach ($aliases as $alias => $id) {
  813.             $this->setAlias($alias, $id);
  814.         }
  815.     }
  817.     /**
  818.      * Sets the service aliases.
  819.      */
  820.     public function setAliases(array $aliases)
  821.     {
  822.         $this->aliasDefinitions = [];
  823.         $this->addAliases($aliases);
  824.     }
  826.     /**
  827.      * Sets an alias for an existing service.
  828.      *
  829.      * @param string       $alias The alias to create
  830.      * @param string|Alias $id    The service to alias
  831.      *
  832.      * @return Alias
  833.      *
  834.      * @throws InvalidArgumentException if the id is not a string or an Alias
  835.      * @throws InvalidArgumentException if the alias is for itself
  836.      */
  837.     public function setAlias($alias, $id)
  838.     {
  839.         $alias = (string) $alias;
  841.         if ('' === $alias || '\\' === $alias[-1] || \strlen($alias) !== strcspn($alias, "\0\r\n'")) {
  842.             throw new InvalidArgumentException(sprintf('Invalid alias id: "%s".', $alias));
  843.         }
  845.         if (\is_string($id)) {
  846.             $id = new Alias($id);
  847.         } elseif (!$id instanceof Alias) {
  848.             throw new InvalidArgumentException('$id must be a string, or an Alias object.');
  849.         }
  851.         if ($alias === (string) $id) {
  852.             throw new InvalidArgumentException(sprintf('An alias can not reference itself, got a circular reference on "%s".', $alias));
  853.         }
  855.         unset($this->definitions[$alias], $this->removedIds[$alias]);
  857.         return $this->aliasDefinitions[$alias] = $id;
  858.     }
  860.     /**
  861.      * Removes an alias.
  862.      *
  863.      * @param string $alias The alias to remove
  864.      */
  865.     public function removeAlias($alias)
  866.     {
  867.         if (isset($this->aliasDefinitions[$alias = (string) $alias])) {
  868.             unset($this->aliasDefinitions[$alias]);
  869.             $this->removedIds[$alias] = true;
  870.         }
  871.     }
  873.     /**
  874.      * Returns true if an alias exists under the given identifier.
  875.      *
  876.      * @param string $id The service identifier
  877.      *
  878.      * @return bool true if the alias exists, false otherwise
  879.      */
  880.     public function hasAlias($id)
  881.     {
  882.         return isset($this->aliasDefinitions[$id = (string) $id]);
  883.     }
  885.     /**
  886.      * Gets all defined aliases.
  887.      *
  888.      * @return Alias[] An array of aliases
  889.      */
  890.     public function getAliases()
  891.     {
  892.         return $this->aliasDefinitions;
  893.     }
  895.     /**
  896.      * Gets an alias.
  897.      *
  898.      * @param string $id The service identifier
  899.      *
  900.      * @return Alias An Alias instance
  901.      *
  902.      * @throws InvalidArgumentException if the alias does not exist
  903.      */
  904.     public function getAlias($id)
  905.     {
  906.         $id = (string) $id;
  908.         if (!isset($this->aliasDefinitions[$id])) {
  909.             throw new InvalidArgumentException(sprintf('The service alias "%s" does not exist.', $id));
  910.         }
  912.         return $this->aliasDefinitions[$id];
  913.     }
  915.     /**
  916.      * Registers a service definition.
  917.      *
  918.      * This methods allows for simple registration of service definition
  919.      * with a fluid interface.
  920.      *
  921.      * @param string      $id    The service identifier
  922.      * @param string|null $class The service class
  923.      *
  924.      * @return Definition A Definition instance
  925.      */
  926.     public function register($id, $class = null)
  927.     {
  928.         return $this->setDefinition($id, new Definition($class));
  929.     }
  931.     /**
  932.      * Registers an autowired service definition.
  933.      *
  934.      * This method implements a shortcut for using setDefinition() with
  935.      * an autowired definition.
  936.      *
  937.      * @param string      $id    The service identifier
  938.      * @param string|null $class The service class
  939.      *
  940.      * @return Definition The created definition
  941.      */
  942.     public function autowire($id, $class = null)
  943.     {
  944.         return $this->setDefinition($id, (new Definition($class))->setAutowired(true));
  945.     }
  947.     /**
  948.      * Adds the service definitions.
  949.      *
  950.      * @param Definition[] $definitions An array of service definitions
  951.      */
  952.     public function addDefinitions(array $definitions)
  953.     {
  954.         foreach ($definitions as $id => $definition) {
  955.             $this->setDefinition($id, $definition);
  956.         }
  957.     }
  959.     /**
  960.      * Sets the service definitions.
  961.      *
  962.      * @param Definition[] $definitions An array of service definitions
  963.      */
  964.     public function setDefinitions(array $definitions)
  965.     {
  966.         $this->definitions = [];
  967.         $this->addDefinitions($definitions);
  968.     }
  970.     /**
  971.      * Gets all service definitions.
  972.      *
  973.      * @return Definition[] An array of Definition instances
  974.      */
  975.     public function getDefinitions()
  976.     {
  977.         return $this->definitions;
  978.     }
  980.     /**
  981.      * Sets a service definition.
  982.      *
  983.      * @param string $id The service identifier
  984.      *
  985.      * @return Definition the service definition
  986.      *
  987.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  988.      */
  989.     public function setDefinition($id, Definition $definition)
  990.     {
  991.         if ($this->isCompiled()) {
  992.             throw new BadMethodCallException('Adding definition to a compiled container is not allowed.');
  993.         }
  995.         $id = (string) $id;
  997.         if ('' === $id || '\\' === $id[-1] || \strlen($id) !== strcspn($id, "\0\r\n'")) {
  998.             throw new InvalidArgumentException(sprintf('Invalid service id: "%s".', $id));
  999.         }
  1001.         unset($this->aliasDefinitions[$id], $this->removedIds[$id]);
  1003.         return $this->definitions[$id] = $definition;
  1004.     }
  1006.     /**
  1007.      * Returns true if a service definition exists under the given identifier.
  1008.      *
  1009.      * @param string $id The service identifier
  1010.      *
  1011.      * @return bool true if the service definition exists, false otherwise
  1012.      */
  1013.     public function hasDefinition($id)
  1014.     {
  1015.         return isset($this->definitions[(string) $id]);
  1016.     }
  1018.     /**
  1019.      * Gets a service definition.
  1020.      *
  1021.      * @param string $id The service identifier
  1022.      *
  1023.      * @return Definition A Definition instance
  1024.      *
  1025.      * @throws ServiceNotFoundException if the service definition does not exist
  1026.      */
  1027.     public function getDefinition($id)
  1028.     {
  1029.         $id = (string) $id;
  1031.         if (!isset($this->definitions[$id])) {
  1032.             throw new ServiceNotFoundException($id);
  1033.         }
  1035.         return $this->definitions[$id];
  1036.     }
  1038.     /**
  1039.      * Gets a service definition by id or alias.
  1040.      *
  1041.      * The method "unaliases" recursively to return a Definition instance.
  1042.      *
  1043.      * @param string $id The service identifier or alias
  1044.      *
  1045.      * @return Definition A Definition instance
  1046.      *
  1047.      * @throws ServiceNotFoundException if the service definition does not exist
  1048.      */
  1049.     public function findDefinition($id)
  1050.     {
  1051.         $id = (string) $id;
  1053.         $seen = [];
  1054.         while (isset($this->aliasDefinitions[$id])) {
  1055.             $id = (string) $this->aliasDefinitions[$id];
  1057.             if (isset($seen[$id])) {
  1058.                 $seen = array_values($seen);
  1059.                 $seen = \array_slice($seen, array_search($id, $seen));
  1060.                 $seen[] = $id;
  1062.                 throw new ServiceCircularReferenceException($id, $seen);
  1063.             }
  1065.             $seen[$id] = $id;
  1066.         }
  1068.         return $this->getDefinition($id);
  1069.     }
  1071.     /**
  1072.      * Creates a service for a service definition.
  1073.      *
  1074.      * @return mixed The service described by the service definition
  1075.      *
  1076.      * @throws RuntimeException         When the factory definition is incomplete
  1077.      * @throws RuntimeException         When the service is a synthetic service
  1078.      * @throws InvalidArgumentException When configure callable is not callable
  1079.      */
  1080.     private function createService(Definition $definition, array &$inlineServices, bool $isConstructorArgument = false, string $id = null, bool $tryProxy = true)
  1081.     {
  1082.         if (null === $id && isset($inlineServices[$h = spl_object_hash($definition)])) {
  1083.             return $inlineServices[$h];
  1084.         }
  1086.         if ($definition instanceof ChildDefinition) {
  1087.             throw new RuntimeException(sprintf('Constructing service "%s" from a parent definition is not supported at build time.', $id));
  1088.         }
  1090.         if ($definition->isSynthetic()) {
  1091.             throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The DIC does not know how to construct this service.', $id));
  1092.         }
  1094.         if ($definition->isDeprecated()) {
  1095.             @trigger_error($definition->getDeprecationMessage($id), \E_USER_DEPRECATED);
  1096.         }
  1098.         if ($tryProxy && $definition->isLazy() && !$tryProxy = !($proxy = $this->proxyInstantiator) || $proxy instanceof RealServiceInstantiator) {
  1099.             $proxy = $proxy->instantiateProxy(
  1100.                 $this,
  1101.                 $definition,
  1102.                 $id, function () use ($definition, &$inlineServices, $id) {
  1103.                     return $this->createService($definition, $inlineServices, true, $id, false);
  1104.                 }
  1105.             );
  1106.             $this->shareService($definition, $proxy, $id, $inlineServices);
  1108.             return $proxy;
  1109.         }
  1111.         $parameterBag = $this->getParameterBag();
  1113.         if (null !== $definition->getFile()) {
  1114.             require_once $parameterBag->resolveValue($definition->getFile());
  1115.         }
  1117.         $arguments = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getArguments())), $inlineServices, $isConstructorArgument);
  1119.         if (null !== $factory = $definition->getFactory()) {
  1120.             if (\is_array($factory)) {
  1121.                 $factory = [$this->doResolveServices($parameterBag->resolveValue($factory[0]), $inlineServices, $isConstructorArgument), $factory[1]];
  1122.             } elseif (!\is_string($factory)) {
  1123.                 throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory.', $id));
  1124.             }
  1125.         }
  1127.         if (null !== $id && $definition->isShared() && isset($this->services[$id]) && ($tryProxy || !$definition->isLazy())) {
  1128.             return $this->services[$id];
  1129.         }
  1131.         if (null !== $factory) {
  1132.             $service = $factory(...$arguments);
  1134.             if (!$definition->isDeprecated() && \is_array($factory) && \is_string($factory[0])) {
  1135.                 $r = new \ReflectionClass($factory[0]);
  1137.                 if (0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1138.                     @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);
  1139.                 }
  1140.             }
  1141.         } else {
  1142.             $r = new \ReflectionClass($parameterBag->resolveValue($definition->getClass()));
  1144.             $service = null === $r->getConstructor() ? $r->newInstance() : $r->newInstanceArgs(array_values($arguments));
  1146.             if (!$definition->isDeprecated() && 0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1147.                 @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);
  1148.             }
  1149.         }
  1151.         $lastWitherIndex = null;
  1152.         foreach ($definition->getMethodCalls() as $k => $call) {
  1153.             if ($call[2] ?? false) {
  1154.                 $lastWitherIndex = $k;
  1155.             }
  1156.         }
  1158.         if (null === $lastWitherIndex && ($tryProxy || !$definition->isLazy())) {
  1159.             // share only if proxying failed, or if not a proxy, and if no withers are found
  1160.             $this->shareService($definition, $service, $id, $inlineServices);
  1161.         }
  1163.         $properties = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getProperties())), $inlineServices);
  1164.         foreach ($properties as $name => $value) {
  1165.             $service->$name = $value;
  1166.         }
  1168.         foreach ($definition->getMethodCalls() as $k => $call) {
  1169.             $service = $this->callMethod($service, $call, $inlineServices);
  1171.             if ($lastWitherIndex === $k && ($tryProxy || !$definition->isLazy())) {
  1172.                 // share only if proxying failed, or if not a proxy, and this is the last wither
  1173.                 $this->shareService($definition, $service, $id, $inlineServices);
  1174.             }
  1175.         }
  1177.         if ($callable = $definition->getConfigurator()) {
  1178.             if (\is_array($callable)) {
  1179.                 $callable[0] = $parameterBag->resolveValue($callable[0]);
  1181.                 if ($callable[0] instanceof Reference) {
  1182.                     $callable[0] = $this->doGet((string) $callable[0], $callable[0]->getInvalidBehavior(), $inlineServices);
  1183.                 } elseif ($callable[0] instanceof Definition) {
  1184.                     $callable[0] = $this->createService($callable[0], $inlineServices);
  1185.                 }
  1186.             }
  1188.             if (!\is_callable($callable)) {
  1189.                 throw new InvalidArgumentException(sprintf('The configure callable for class "%s" is not a callable.', \get_class($service)));
  1190.             }
  1192.             $callable($service);
  1193.         }
  1195.         return $service;
  1196.     }
  1198.     /**
  1199.      * Replaces service references by the real service instance and evaluates expressions.
  1200.      *
  1201.      * @param mixed $value A value
  1202.      *
  1203.      * @return mixed The same value with all service references replaced by
  1204.      *               the real service instances and all expressions evaluated
  1205.      */
  1206.     public function resolveServices($value)
  1207.     {
  1208.         return $this->doResolveServices($value);
  1209.     }
  1211.     private function doResolveServices($value, array &$inlineServices = [], bool $isConstructorArgument = false)
  1212.     {
  1213.         if (\is_array($value)) {
  1214.             foreach ($value as $k => $v) {
  1215.                 $value[$k] = $this->doResolveServices($v, $inlineServices, $isConstructorArgument);
  1216.             }
  1217.         } elseif ($value instanceof ServiceClosureArgument) {
  1218.             $reference = $value->getValues()[0];
  1219.             $value = function () use ($reference) {
  1220.                 return $this->resolveServices($reference);
  1221.             };
  1222.         } elseif ($value instanceof IteratorArgument) {
  1223.             $value = new RewindableGenerator(function () use ($value) {
  1224.                 foreach ($value->getValues() as $k => $v) {
  1225.                     foreach (self::getServiceConditionals($v) as $s) {
  1226.                         if (!$this->has($s)) {
  1227.                             continue 2;
  1228.                         }
  1229.                     }
  1230.                     foreach (self::getInitializedConditionals($v) as $s) {
  1231.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE)) {
  1232.                             continue 2;
  1233.                         }
  1234.                     }
  1236.                     yield $k => $this->resolveServices($v);
  1237.                 }
  1238.             }, function () use ($value): int {
  1239.                 $count = 0;
  1240.                 foreach ($value->getValues() as $v) {
  1241.                     foreach (self::getServiceConditionals($v) as $s) {
  1242.                         if (!$this->has($s)) {
  1243.                             continue 2;
  1244.                         }
  1245.                     }
  1246.                     foreach (self::getInitializedConditionals($v) as $s) {
  1247.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE)) {
  1248.                             continue 2;
  1249.                         }
  1250.                     }
  1252.                     ++$count;
  1253.                 }
  1255.                 return $count;
  1256.             });
  1257.         } elseif ($value instanceof ServiceLocatorArgument) {
  1258.             $refs = $types = [];
  1259.             foreach ($value->getValues() as $k => $v) {
  1260.                 if ($v) {
  1261.                     $refs[$k] = [$v];
  1262.                     $types[$k] = $v instanceof TypedReference ? $v->getType() : '?';
  1263.                 }
  1264.             }
  1265.             $value = new ServiceLocator(\Closure::fromCallable([$this, 'resolveServices']), $refs, $types);
  1266.         } elseif ($value instanceof Reference) {
  1267.             $value = $this->doGet((string) $value, $value->getInvalidBehavior(), $inlineServices, $isConstructorArgument);
  1268.         } elseif ($value instanceof Definition) {
  1269.             $value = $this->createService($value, $inlineServices, $isConstructorArgument);
  1270.         } elseif ($value instanceof Parameter) {
  1271.             $value = $this->getParameter((string) $value);
  1272.         } elseif ($value instanceof Expression) {
  1273.             $value = $this->getExpressionLanguage()->evaluate($value, ['container' => $this]);
  1274.         }
  1276.         return $value;
  1277.     }
  1279.     /**
  1280.      * Returns service ids for a given tag.
  1281.      *
  1282.      * Example:
  1283.      *
  1284.      *     $container->register('foo')->addTag('my.tag', ['hello' => 'world']);
  1285.      *
  1286.      *     $serviceIds = $container->findTaggedServiceIds('my.tag');
  1287.      *     foreach ($serviceIds as $serviceId => $tags) {
  1288.      *         foreach ($tags as $tag) {
  1289.      *             echo $tag['hello'];
  1290.      *         }
  1291.      *     }
  1292.      *
  1293.      * @param string $name
  1294.      * @param bool   $throwOnAbstract
  1295.      *
  1296.      * @return array An array of tags with the tagged service as key, holding a list of attribute arrays
  1297.      */
  1298.     public function findTaggedServiceIds($name, $throwOnAbstract = false)
  1299.     {
  1300.         $this->usedTags[] = $name;
  1301.         $tags = [];
  1302.         foreach ($this->getDefinitions() as $id => $definition) {
  1303.             if ($definition->hasTag($name)) {
  1304.                 if ($throwOnAbstract && $definition->isAbstract()) {
  1305.                     throw new InvalidArgumentException(sprintf('The service "%s" tagged "%s" must not be abstract.', $id, $name));
  1306.                 }
  1307.                 $tags[$id] = $definition->getTag($name);
  1308.             }
  1309.         }
  1311.         return $tags;
  1312.     }
  1314.     /**
  1315.      * Returns all tags the defined services use.
  1316.      *
  1317.      * @return array An array of tags
  1318.      */
  1319.     public function findTags()
  1320.     {
  1321.         $tags = [];
  1322.         foreach ($this->getDefinitions() as $id => $definition) {
  1323.             $tags = array_merge(array_keys($definition->getTags()), $tags);
  1324.         }
  1326.         return array_unique($tags);
  1327.     }
  1329.     /**
  1330.      * Returns all tags not queried by findTaggedServiceIds.
  1331.      *
  1332.      * @return string[] An array of tags
  1333.      */
  1334.     public function findUnusedTags()
  1335.     {
  1336.         return array_values(array_diff($this->findTags(), $this->usedTags));
  1337.     }
  1339.     public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
  1340.     {
  1341.         $this->expressionLanguageProviders[] = $provider;
  1342.     }
  1344.     /**
  1345.      * @return ExpressionFunctionProviderInterface[]
  1346.      */
  1347.     public function getExpressionLanguageProviders()
  1348.     {
  1349.         return $this->expressionLanguageProviders;
  1350.     }
  1352.     /**
  1353.      * Returns a ChildDefinition that will be used for autoconfiguring the interface/class.
  1354.      *
  1355.      * @param string $interface The class or interface to match
  1356.      *
  1357.      * @return ChildDefinition
  1358.      */
  1359.     public function registerForAutoconfiguration($interface)
  1360.     {
  1361.         if (!isset($this->autoconfiguredInstanceof[$interface])) {
  1362.             $this->autoconfiguredInstanceof[$interface] = new ChildDefinition('');
  1363.         }
  1365.         return $this->autoconfiguredInstanceof[$interface];
  1366.     }
  1368.     /**
  1369.      * Registers an autowiring alias that only binds to a specific argument name.
  1370.      *
  1371.      * The argument name is derived from $name if provided (from $id otherwise)
  1372.      * using camel case: "foo.bar" or "foo_bar" creates an alias bound to
  1373.      * "$fooBar"-named arguments with $type as type-hint. Such arguments will
  1374.      * receive the service $id when autowiring is used.
  1375.      */
  1376.     public function registerAliasForArgument(string $id, string $type, string $name = null): Alias
  1377.     {
  1378.         $name = lcfirst(str_replace(' ', '', ucwords(preg_replace('/[^a-zA-Z0-9\x7f-\xff]++/', ' ', $name ?? $id))));
  1380.         if (!preg_match('/^[a-zA-Z_\x7f-\xff]/', $name)) {
  1381.             throw new InvalidArgumentException(sprintf('Invalid argument name "%s" for service "%s": the first character must be a letter.', $name, $id));
  1382.         }
  1384.         return $this->setAlias($type.' $'.$name, $id);
  1385.     }
  1387.     /**
  1388.      * Returns an array of ChildDefinition[] keyed by interface.
  1389.      *
  1390.      * @return ChildDefinition[]
  1391.      */
  1392.     public function getAutoconfiguredInstanceof()
  1393.     {
  1394.         return $this->autoconfiguredInstanceof;
  1395.     }
  1397.     /**
  1398.      * Resolves env parameter placeholders in a string or an array.
  1399.      *
  1400.      * @param mixed            $value     The value to resolve
  1401.      * @param string|true|null $format    A sprintf() format returning the replacement for each env var name or
  1402.      *                                    null to resolve back to the original "%env(VAR)%" format or
  1403.      *                                    true to resolve to the actual values of the referenced env vars
  1404.      * @param array            &$usedEnvs Env vars found while resolving are added to this array
  1405.      *
  1406.      * @return mixed The value with env parameters resolved if a string or an array is passed
  1407.      */
  1408.     public function resolveEnvPlaceholders($value, $format = null, array &$usedEnvs = null)
  1409.     {
  1410.         if (null === $format) {
  1411.             $format = '%%env(%s)%%';
  1412.         }
  1414.         $bag = $this->getParameterBag();
  1415.         if (true === $format) {
  1416.             $value = $bag->resolveValue($value);
  1417.         }
  1419.         if ($value instanceof Definition) {
  1420.             $value = (array) $value;
  1421.         }
  1423.         if (\is_array($value)) {
  1424.             $result = [];
  1425.             foreach ($value as $k => $v) {
  1426.                 $result[\is_string($k) ? $this->resolveEnvPlaceholders($k, $format, $usedEnvs) : $k] = $this->resolveEnvPlaceholders($v, $format, $usedEnvs);
  1427.             }
  1429.             return $result;
  1430.         }
  1432.         if (!\is_string($value) || 38 > \strlen($value)) {
  1433.             return $value;
  1434.         }
  1435.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1437.         $completed = false;
  1438.         foreach ($envPlaceholders as $env => $placeholders) {
  1439.             foreach ($placeholders as $placeholder) {
  1440.                 if (false !== stripos($value, $placeholder)) {
  1441.                     if (true === $format) {
  1442.                         $resolved = $bag->escapeValue($this->getEnv($env));
  1443.                     } else {
  1444.                         $resolved = sprintf($format, $env);
  1445.                     }
  1446.                     if ($placeholder === $value) {
  1447.                         $value = $resolved;
  1448.                         $completed = true;
  1449.                     } else {
  1450.                         if (!\is_string($resolved) && !is_numeric($resolved)) {
  1451.                             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)));
  1452.                         }
  1453.                         $value = str_ireplace($placeholder, $resolved, $value);
  1454.                     }
  1455.                     $usedEnvs[$env] = $env;
  1456.                     $this->envCounters[$env] = isset($this->envCounters[$env]) ? 1 + $this->envCounters[$env] : 1;
  1458.                     if ($completed) {
  1459.                         break 2;
  1460.                     }
  1461.                 }
  1462.             }
  1463.         }
  1465.         return $value;
  1466.     }
  1468.     /**
  1469.      * Get statistics about env usage.
  1470.      *
  1471.      * @return int[] The number of time each env vars has been resolved
  1472.      */
  1473.     public function getEnvCounters()
  1474.     {
  1475.         $bag = $this->getParameterBag();
  1476.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1478.         foreach ($envPlaceholders as $env => $placeholders) {
  1479.             if (!isset($this->envCounters[$env])) {
  1480.                 $this->envCounters[$env] = 0;
  1481.             }
  1482.         }
  1484.         return $this->envCounters;
  1485.     }
  1487.     /**
  1488.      * @final
  1489.      */
  1490.     public function log(CompilerPassInterface $pass, string $message)
  1491.     {
  1492.         $this->getCompiler()->log($pass, $this->resolveEnvPlaceholders($message));
  1493.     }
  1495.     /**
  1496.      * Gets removed binding ids.
  1497.      *
  1498.      * @internal
  1499.      */
  1500.     public function getRemovedBindingIds(): array
  1501.     {
  1502.         return $this->removedBindingIds;
  1503.     }
  1505.     /**
  1506.      * Removes bindings for a service.
  1507.      *
  1508.      * @internal
  1509.      */
  1510.     public function removeBindings(string $id)
  1511.     {
  1512.         if ($this->hasDefinition($id)) {
  1513.             foreach ($this->getDefinition($id)->getBindings() as $key => $binding) {
  1514.                 list(, $bindingId) = $binding->getValues();
  1515.                 $this->removedBindingIds[(int) $bindingId] = true;
  1516.             }
  1517.         }
  1518.     }
  1520.     /**
  1521.      * Returns the Service Conditionals.
  1522.      *
  1523.      * @param mixed $value An array of conditionals to return
  1524.      *
  1525.      * @internal
  1526.      */
  1527.     public static function getServiceConditionals($value): array
  1528.     {
  1529.         $services = [];
  1531.         if (\is_array($value)) {
  1532.             foreach ($value as $v) {
  1533.                 $services = array_unique(array_merge($services, self::getServiceConditionals($v)));
  1534.             }
  1535.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  1536.             $services[] = (string) $value;
  1537.         }
  1539.         return $services;
  1540.     }
  1542.     /**
  1543.      * Returns the initialized conditionals.
  1544.      *
  1545.      * @param mixed $value An array of conditionals to return
  1546.      *
  1547.      * @internal
  1548.      */
  1549.     public static function getInitializedConditionals($value): array
  1550.     {
  1551.         $services = [];
  1553.         if (\is_array($value)) {
  1554.             foreach ($value as $v) {
  1555.                 $services = array_unique(array_merge($services, self::getInitializedConditionals($v)));
  1556.             }
  1557.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $value->getInvalidBehavior()) {
  1558.             $services[] = (string) $value;
  1559.         }
  1561.         return $services;
  1562.     }
  1564.     /**
  1565.      * Computes a reasonably unique hash of a value.
  1566.      *
  1567.      * @param mixed $value A serializable value
  1568.      *
  1569.      * @return string
  1570.      */
  1571.     public static function hash($value)
  1572.     {
  1573.         $hash = substr(base64_encode(hash('sha256', serialize($value), true)), 0, 7);
  1575.         return str_replace(['/', '+'], ['.', '_'], $hash);
  1576.     }
  1578.     /**
  1579.      * {@inheritdoc}
  1580.      */
  1581.     protected function getEnv($name)
  1582.     {
  1583.         $value = parent::getEnv($name);
  1584.         $bag = $this->getParameterBag();
  1586.         if (!\is_string($value) || !$bag instanceof EnvPlaceholderParameterBag) {
  1587.             return $value;
  1588.         }
  1590.         $envPlaceholders = $bag->getEnvPlaceholders();
  1591.         if (isset($envPlaceholders[$name][$value])) {
  1592.             $bag = new ParameterBag($bag->all());
  1594.             return $bag->unescapeValue($bag->get("env($name)"));
  1595.         }
  1596.         foreach ($envPlaceholders as $env => $placeholders) {
  1597.             if (isset($placeholders[$value])) {
  1598.                 return $this->getEnv($env);
  1599.             }
  1600.         }
  1602.         $this->resolving["env($name)"] = true;
  1603.         try {
  1604.             return $bag->unescapeValue($this->resolveEnvPlaceholders($bag->escapeValue($value), true));
  1605.         } finally {
  1606.             unset($this->resolving["env($name)"]);
  1607.         }
  1608.     }
  1610.     private function callMethod($service, array $call, array &$inlineServices)
  1611.     {
  1612.         foreach (self::getServiceConditionals($call[1]) as $s) {
  1613.             if (!$this->has($s)) {
  1614.                 return $service;
  1615.             }
  1616.         }
  1617.         foreach (self::getInitializedConditionals($call[1]) as $s) {
  1618.             if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
  1619.                 return $service;
  1620.             }
  1621.         }
  1623.         $result = $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));
  1625.         return empty($call[2]) ? $service : $result;
  1626.     }
  1628.     /**
  1629.      * Shares a given service in the container.
  1630.      *
  1631.      * @param mixed $service
  1632.      */
  1633.     private function shareService(Definition $definition, $service, ?string $id, array &$inlineServices)
  1634.     {
  1635.         $inlineServices[null !== $id ? $id : spl_object_hash($definition)] = $service;
  1637.         if (null !== $id && $definition->isShared()) {
  1638.             $this->services[$id] = $service;
  1639.             unset($this->loading[$id]);
  1640.         }
  1641.     }
  1643.     private function getExpressionLanguage(): ExpressionLanguage
  1644.     {
  1645.         if (null === $this->expressionLanguage) {
  1646.             if (!class_exists('Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
  1647.                 throw new LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  1648.             }
  1649.             $this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders);
  1650.         }
  1652.         return $this->expressionLanguage;
  1653.     }
  1655.     private function inVendors(string $path): bool
  1656.     {
  1657.         if (null === $this->vendors) {
  1658.             $resource = new ComposerResource();
  1659.             $this->vendors = $resource->getVendors();
  1660.             $this->addResource($resource);
  1661.         }
  1662.         $path = realpath($path) ?: $path;
  1664.         foreach ($this->vendors as $vendor) {
  1665.             if (0 === strpos($path, $vendor) && false !== strpbrk(substr($path, \strlen($vendor), 1), '/'.\DIRECTORY_SEPARATOR)) {
  1666.                 return true;
  1667.             }
  1668.         }
  1670.         return false;
  1671.     }
  1672. }