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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\DependencyInjection;
  14. use Composer\InstalledVersions;
  15. use 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\Attribute\Target;
  30. use Symfony\Component\DependencyInjection\Compiler\Compiler;
  31. use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
  32. use Symfony\Component\DependencyInjection\Compiler\PassConfig;
  33. use Symfony\Component\DependencyInjection\Compiler\ResolveEnvPlaceholdersPass;
  34. use Symfony\Component\DependencyInjection\Exception\BadMethodCallException;
  35. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  36. use Symfony\Component\DependencyInjection\Exception\LogicException;
  37. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  38. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  39. use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
  40. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  41. use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\InstantiatorInterface;
  42. use Symfony\Component\DependencyInjection\LazyProxy\Instantiator\RealServiceInstantiator;
  43. use Symfony\Component\DependencyInjection\ParameterBag\EnvPlaceholderParameterBag;
  44. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
  45. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  46. use Symfony\Component\ExpressionLanguage\Expression;
  47. use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
  49. /**
  50.  * ContainerBuilder is a DI container that provides an API to easily describe services.
  51.  *
  52.  * @author Fabien Potencier <fabien@symfony.com>
  53.  */
  54. class ContainerBuilder extends Container implements TaggedContainerInterface
  55. {
  56.     /**
  57.      * @var array<string, ExtensionInterface>
  58.      */
  59.     private array $extensions = [];
  61.     /**
  62.      * @var array<string, ExtensionInterface>
  63.      */
  64.     private array $extensionsByNs = [];
  66.     /**
  67.      * @var array<string, Definition>
  68.      */
  69.     private array $definitions = [];
  71.     /**
  72.      * @var array<string, Alias>
  73.      */
  74.     private array $aliasDefinitions = [];
  76.     /**
  77.      * @var array<string, ResourceInterface>
  78.      */
  79.     private array $resources = [];
  81.     /**
  82.      * @var array<string, array<array<string, mixed>>>
  83.      */
  84.     private array $extensionConfigs = [];
  86.     private Compiler $compiler;
  87.     private bool $trackResources;
  88.     private ?InstantiatorInterface $proxyInstantiator = null;
  89.     private ExpressionLanguage $expressionLanguage;
  91.     /**
  92.      * @var ExpressionFunctionProviderInterface[]
  93.      */
  94.     private array $expressionLanguageProviders = [];
  96.     /**
  97.      * @var string[] with tag names used by findTaggedServiceIds
  98.      */
  99.     private array $usedTags = [];
  101.     /**
  102.      * @var string[][] a map of env var names to their placeholders
  103.      */
  104.     private array $envPlaceholders = [];
  106.     /**
  107.      * @var int[] a map of env vars to their resolution counter
  108.      */
  109.     private array $envCounters = [];
  111.     /**
  112.      * @var string[] the list of vendor directories
  113.      */
  114.     private array $vendors;
  116.     /**
  117.      * @var array<string, ChildDefinition>
  118.      */
  119.     private array $autoconfiguredInstanceof = [];
  121.     /**
  122.      * @var array<string, callable>
  123.      */
  124.     private array $autoconfiguredAttributes = [];
  126.     /**
  127.      * @var array<string, bool>
  128.      */
  129.     private array $removedIds = [];
  131.     /**
  132.      * @var array<int, bool>
  133.      */
  134.     private array $removedBindingIds = [];
  136.     private const INTERNAL_TYPES = [
  137.         'int' => true,
  138.         'float' => true,
  139.         'string' => true,
  140.         'bool' => true,
  141.         'resource' => true,
  142.         'object' => true,
  143.         'array' => true,
  144.         'null' => true,
  145.         'callable' => true,
  146.         'iterable' => true,
  147.         'mixed' => true,
  148.     ];
  150.     public function __construct(ParameterBagInterface $parameterBag = null)
  151.     {
  152.         parent::__construct($parameterBag);
  154.         $this->trackResources = interface_exists(ResourceInterface::class);
  155.         $this->setDefinition('service_container', (new Definition(ContainerInterface::class))->setSynthetic(true)->setPublic(true));
  156.     }
  158.     /**
  159.      * @var array<string, \ReflectionClass>
  160.      */
  161.     private array $classReflectors;
  163.     /**
  164.      * Sets the track resources flag.
  165.      *
  166.      * If you are not using the loaders and therefore don't want
  167.      * to depend on the Config component, set this flag to false.
  168.      */
  169.     public function setResourceTracking(bool $track)
  170.     {
  171.         $this->trackResources = $track;
  172.     }
  174.     /**
  175.      * Checks if resources are tracked.
  176.      */
  177.     public function isTrackingResources(): bool
  178.     {
  179.         return $this->trackResources;
  180.     }
  182.     /**
  183.      * Sets the instantiator to be used when fetching proxies.
  184.      */
  185.     public function setProxyInstantiator(InstantiatorInterface $proxyInstantiator)
  186.     {
  187.         $this->proxyInstantiator = $proxyInstantiator;
  188.     }
  190.     public function registerExtension(ExtensionInterface $extension)
  191.     {
  192.         $this->extensions[$extension->getAlias()] = $extension;
  194.         if (false !== $extension->getNamespace()) {
  195.             $this->extensionsByNs[$extension->getNamespace()] = $extension;
  196.         }
  197.     }
  199.     /**
  200.      * Returns an extension by alias or namespace.
  201.      *
  202.      * @throws LogicException if the extension is not registered
  203.      */
  204.     public function getExtension(string $name): ExtensionInterface
  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 array<string, ExtensionInterface>
  221.      */
  222.     public function getExtensions(): array
  223.     {
  224.         return $this->extensions;
  225.     }
  227.     /**
  228.      * Checks if we have an extension.
  229.      */
  230.     public function hasExtension(string $name): bool
  231.     {
  232.         return isset($this->extensions[$name]) || isset($this->extensionsByNs[$name]);
  233.     }
  235.     /**
  236.      * Returns an array of resources loaded to build this configuration.
  237.      *
  238.      * @return ResourceInterface[]
  239.      */
  240.     public function getResources(): array
  241.     {
  242.         return array_values($this->resources);
  243.     }
  245.     /**
  246.      * @return $this
  247.      */
  248.     public function addResource(ResourceInterface $resource): static
  249.     {
  250.         if (!$this->trackResources) {
  251.             return $this;
  252.         }
  254.         if ($resource instanceof GlobResource && $this->inVendors($resource->getPrefix())) {
  255.             return $this;
  256.         }
  258.         $this->resources[(string) $resource] = $resource;
  260.         return $this;
  261.     }
  263.     /**
  264.      * Sets the resources for this configuration.
  265.      *
  266.      * @param array<string, ResourceInterface> $resources
  267.      *
  268.      * @return $this
  269.      */
  270.     public function setResources(array $resources): static
  271.     {
  272.         if (!$this->trackResources) {
  273.             return $this;
  274.         }
  276.         $this->resources = $resources;
  278.         return $this;
  279.     }
  281.     /**
  282.      * Adds the object class hierarchy as resources.
  283.      *
  284.      * @param object|string $object An object instance or class name
  285.      *
  286.      * @return $this
  287.      */
  288.     public function addObjectResource(object|string $object): static
  289.     {
  290.         if ($this->trackResources) {
  291.             if (\is_object($object)) {
  292.                 $object = \get_class($object);
  293.             }
  294.             if (!isset($this->classReflectors[$object])) {
  295.                 $this->classReflectors[$object] = new \ReflectionClass($object);
  296.             }
  297.             $class = $this->classReflectors[$object];
  299.             foreach ($class->getInterfaceNames() as $name) {
  300.                 if (null === $interface = &$this->classReflectors[$name]) {
  301.                     $interface = new \ReflectionClass($name);
  302.                 }
  303.                 $file = $interface->getFileName();
  304.                 if (false !== $file && file_exists($file)) {
  305.                     $this->fileExists($file);
  306.                 }
  307.             }
  308.             do {
  309.                 $file = $class->getFileName();
  310.                 if (false !== $file && file_exists($file)) {
  311.                     $this->fileExists($file);
  312.                 }
  313.                 foreach ($class->getTraitNames() as $name) {
  314.                     $this->addObjectResource($name);
  315.                 }
  316.             } while ($class = $class->getParentClass());
  317.         }
  319.         return $this;
  320.     }
  322.     /**
  323.      * Retrieves the requested reflection class and registers it for resource tracking.
  324.      *
  325.      * @throws \ReflectionException when a parent class/interface/trait is not found and $throw is true
  326.      *
  327.      * @final
  328.      */
  329.     public function getReflectionClass(?string $class, bool $throw = true): ?\ReflectionClass
  330.     {
  331.         if (!$class = $this->getParameterBag()->resolveValue($class)) {
  332.             return null;
  333.         }
  335.         if (isset(self::INTERNAL_TYPES[$class])) {
  336.             return null;
  337.         }
  339.         $resource = $classReflector = null;
  341.         try {
  342.             if (isset($this->classReflectors[$class])) {
  343.                 $classReflector = $this->classReflectors[$class];
  344.             } elseif (class_exists(ClassExistenceResource::class)) {
  345.                 $resource = new ClassExistenceResource($class, false);
  346.                 $classReflector = $resource->isFresh(0) ? false : new \ReflectionClass($class);
  347.             } else {
  348.                 $classReflector = class_exists($class) ? new \ReflectionClass($class) : false;
  349.             }
  350.         } catch (\ReflectionException $e) {
  351.             if ($throw) {
  352.                 throw $e;
  353.             }
  354.         }
  356.         if ($this->trackResources) {
  357.             if (!$classReflector) {
  358.                 $this->addResource($resource ?? new ClassExistenceResource($class, false));
  359.             } elseif (!$classReflector->isInternal()) {
  360.                 $path = $classReflector->getFileName();
  362.                 if (!$this->inVendors($path)) {
  363.                     $this->addResource(new ReflectionClassResource($classReflector, $this->vendors));
  364.                 }
  365.             }
  366.             $this->classReflectors[$class] = $classReflector;
  367.         }
  369.         return $classReflector ?: null;
  370.     }
  372.     /**
  373.      * Checks whether the requested file or directory exists and registers the result for resource tracking.
  374.      *
  375.      * @param string      $path          The file or directory path for which to check the existence
  376.      * @param bool|string $trackContents Whether to track contents of the given resource. If a string is passed,
  377.      *                                   it will be used as pattern for tracking contents of the requested directory
  378.      *
  379.      * @final
  380.      */
  381.     public function fileExists(string $path, bool|string $trackContents = true): bool
  382.     {
  383.         $exists = file_exists($path);
  385.         if (!$this->trackResources || $this->inVendors($path)) {
  386.             return $exists;
  387.         }
  389.         if (!$exists) {
  390.             $this->addResource(new FileExistenceResource($path));
  392.             return $exists;
  393.         }
  395.         if (is_dir($path)) {
  396.             if ($trackContents) {
  397.                 $this->addResource(new DirectoryResource($path, \is_string($trackContents) ? $trackContents : null));
  398.             } else {
  399.                 $this->addResource(new GlobResource($path, '/*', false));
  400.             }
  401.         } elseif ($trackContents) {
  402.             $this->addResource(new FileResource($path));
  403.         }
  405.         return $exists;
  406.     }
  408.     /**
  409.      * Loads the configuration for an extension.
  410.      *
  411.      * @param string                    $extension The extension alias or namespace
  412.      * @param array<string, mixed>|null $values    An array of values that customizes the extension
  413.      *
  414.      * @return $this
  415.      *
  416.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  417.      * @throws \LogicException        if the extension is not registered
  418.      */
  419.     public function loadFromExtension(string $extension, array $values = null): static
  420.     {
  421.         if ($this->isCompiled()) {
  422.             throw new BadMethodCallException('Cannot load from an extension on a compiled container.');
  423.         }
  425.         $namespace = $this->getExtension($extension)->getAlias();
  427.         $this->extensionConfigs[$namespace][] = $values ?? [];
  429.         return $this;
  430.     }
  432.     /**
  433.      * Adds a compiler pass.
  434.      *
  435.      * @param string $type     The type of compiler pass
  436.      * @param int    $priority Used to sort the passes
  437.      *
  438.      * @return $this
  439.      */
  440.     public function addCompilerPass(CompilerPassInterface $pass, string $type = PassConfig::TYPE_BEFORE_OPTIMIZATION, int $priority = 0): static
  441.     {
  442.         $this->getCompiler()->addPass($pass, $type, $priority);
  444.         $this->addObjectResource($pass);
  446.         return $this;
  447.     }
  449.     /**
  450.      * Returns the compiler pass config which can then be modified.
  451.      */
  452.     public function getCompilerPassConfig(): PassConfig
  453.     {
  454.         return $this->getCompiler()->getPassConfig();
  455.     }
  457.     /**
  458.      * Returns the compiler.
  459.      */
  460.     public function getCompiler(): Compiler
  461.     {
  462.         return $this->compiler ??= new Compiler();
  463.     }
  465.     /**
  466.      * Sets a service.
  467.      *
  468.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  469.      */
  470.     public function set(string $id, ?object $service)
  471.     {
  472.         if ($this->isCompiled() && (isset($this->definitions[$id]) && !$this->definitions[$id]->isSynthetic())) {
  473.             // setting a synthetic service on a compiled container is alright
  474.             throw new BadMethodCallException(sprintf('Setting service "%s" for an unknown or non-synthetic service definition on a compiled container is not allowed.', $id));
  475.         }
  477.         unset($this->definitions[$id], $this->aliasDefinitions[$id], $this->removedIds[$id]);
  479.         parent::set($id, $service);
  480.     }
  482.     /**
  483.      * Removes a service definition.
  484.      */
  485.     public function removeDefinition(string $id)
  486.     {
  487.         if (isset($this->definitions[$id])) {
  488.             unset($this->definitions[$id]);
  489.             $this->removedIds[$id] = true;
  490.         }
  491.     }
  493.     public function has(string $id): bool
  494.     {
  495.         return isset($this->definitions[$id]) || isset($this->aliasDefinitions[$id]) || parent::has($id);
  496.     }
  498.     /**
  499.      * @throws InvalidArgumentException          when no definitions are available
  500.      * @throws ServiceCircularReferenceException When a circular reference is detected
  501.      * @throws ServiceNotFoundException          When the service is not defined
  502.      * @throws \Exception
  503.      *
  504.      * @see Reference
  505.      */
  506.     public function get(string $id, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE): ?object
  507.     {
  508.         if ($this->isCompiled() && isset($this->removedIds[$id]) && ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $invalidBehavior) {
  509.             return parent::get($id);
  510.         }
  512.         return $this->doGet($id, $invalidBehavior);
  513.     }
  515.     private function doGet(string $id, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, array &$inlineServices = null, bool $isConstructorArgument = false): mixed
  516.     {
  517.         if (isset($inlineServices[$id])) {
  518.             return $inlineServices[$id];
  519.         }
  520.         if (null === $inlineServices) {
  521.             $isConstructorArgument = true;
  522.             $inlineServices = [];
  523.         }
  524.         try {
  525.             if (ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $invalidBehavior) {
  526.                 return parent::get($id, $invalidBehavior);
  527.             }
  528.             if ($service = parent::get($id, ContainerInterface::NULL_ON_INVALID_REFERENCE)) {
  529.                 return $service;
  530.             }
  531.         } catch (ServiceCircularReferenceException $e) {
  532.             if ($isConstructorArgument) {
  533.                 throw $e;
  534.             }
  535.         }
  537.         if (!isset($this->definitions[$id]) && isset($this->aliasDefinitions[$id])) {
  538.             $alias = $this->aliasDefinitions[$id];
  540.             if ($alias->isDeprecated()) {
  541.                 $deprecation = $alias->getDeprecation($id);
  542.                 trigger_deprecation($deprecation['package'], $deprecation['version'], $deprecation['message']);
  543.             }
  545.             return $this->doGet((string) $alias, $invalidBehavior, $inlineServices, $isConstructorArgument);
  546.         }
  548.         try {
  549.             $definition = $this->getDefinition($id);
  550.         } catch (ServiceNotFoundException $e) {
  551.             if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE < $invalidBehavior) {
  552.                 return null;
  553.             }
  555.             throw $e;
  556.         }
  558.         if ($definition->hasErrors() && $e = $definition->getErrors()) {
  559.             throw new RuntimeException(reset($e));
  560.         }
  562.         if ($isConstructorArgument) {
  563.             $this->loading[$id] = true;
  564.         }
  566.         try {
  567.             return $this->createService($definition, $inlineServices, $isConstructorArgument, $id);
  568.         } finally {
  569.             if ($isConstructorArgument) {
  570.                 unset($this->loading[$id]);
  571.             }
  572.         }
  573.     }
  575.     /**
  576.      * Merges a ContainerBuilder with the current ContainerBuilder configuration.
  577.      *
  578.      * Service definitions overrides the current defined ones.
  579.      *
  580.      * But for parameters, they are overridden by the current ones. It allows
  581.      * the parameters passed to the container constructor to have precedence
  582.      * over the loaded ones.
  583.      *
  584.      *     $container = new ContainerBuilder(new ParameterBag(['foo' => 'bar']));
  585.      *     $loader = new LoaderXXX($container);
  586.      *     $loader->load('resource_name');
  587.      *     $container->register('foo', 'stdClass');
  588.      *
  589.      * In the above example, even if the loaded resource defines a foo
  590.      * parameter, the value will still be 'bar' as defined in the ContainerBuilder
  591.      * constructor.
  592.      *
  593.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  594.      */
  595.     public function merge(self $container)
  596.     {
  597.         if ($this->isCompiled()) {
  598.             throw new BadMethodCallException('Cannot merge on a compiled container.');
  599.         }
  601.         $this->addDefinitions($container->getDefinitions());
  602.         $this->addAliases($container->getAliases());
  603.         $this->getParameterBag()->add($container->getParameterBag()->all());
  605.         if ($this->trackResources) {
  606.             foreach ($container->getResources() as $resource) {
  607.                 $this->addResource($resource);
  608.             }
  609.         }
  611.         foreach ($this->extensions as $name => $extension) {
  612.             if (!isset($this->extensionConfigs[$name])) {
  613.                 $this->extensionConfigs[$name] = [];
  614.             }
  616.             $this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $container->getExtensionConfig($name));
  617.         }
  619.         if ($this->getParameterBag() instanceof EnvPlaceholderParameterBag && $container->getParameterBag() instanceof EnvPlaceholderParameterBag) {
  620.             $envPlaceholders = $container->getParameterBag()->getEnvPlaceholders();
  621.             $this->getParameterBag()->mergeEnvPlaceholders($container->getParameterBag());
  622.         } else {
  623.             $envPlaceholders = [];
  624.         }
  626.         foreach ($container->envCounters as $env => $count) {
  627.             if (!$count && !isset($envPlaceholders[$env])) {
  628.                 continue;
  629.             }
  630.             if (!isset($this->envCounters[$env])) {
  631.                 $this->envCounters[$env] = $count;
  632.             } else {
  633.                 $this->envCounters[$env] += $count;
  634.             }
  635.         }
  637.         foreach ($container->getAutoconfiguredInstanceof() as $interface => $childDefinition) {
  638.             if (isset($this->autoconfiguredInstanceof[$interface])) {
  639.                 throw new InvalidArgumentException(sprintf('"%s" has already been autoconfigured and merge() does not support merging autoconfiguration for the same class/interface.', $interface));
  640.             }
  642.             $this->autoconfiguredInstanceof[$interface] = $childDefinition;
  643.         }
  645.         foreach ($container->getAutoconfiguredAttributes() as $attribute => $configurator) {
  646.             if (isset($this->autoconfiguredAttributes[$attribute])) {
  647.                 throw new InvalidArgumentException(sprintf('"%s" has already been autoconfigured and merge() does not support merging autoconfiguration for the same attribute.', $attribute));
  648.             }
  650.             $this->autoconfiguredAttributes[$attribute] = $configurator;
  651.         }
  652.     }
  654.     /**
  655.      * Returns the configuration array for the given extension.
  656.      *
  657.      * @return array<array<string, mixed>>
  658.      */
  659.     public function getExtensionConfig(string $name): array
  660.     {
  661.         if (!isset($this->extensionConfigs[$name])) {
  662.             $this->extensionConfigs[$name] = [];
  663.         }
  665.         return $this->extensionConfigs[$name];
  666.     }
  668.     /**
  669.      * Prepends a config array to the configs of the given extension.
  670.      *
  671.      * @param array<string, mixed> $config
  672.      */
  673.     public function prependExtensionConfig(string $name, array $config)
  674.     {
  675.         if (!isset($this->extensionConfigs[$name])) {
  676.             $this->extensionConfigs[$name] = [];
  677.         }
  679.         array_unshift($this->extensionConfigs[$name], $config);
  680.     }
  682.     /**
  683.      * Compiles the container.
  684.      *
  685.      * This method passes the container to compiler
  686.      * passes whose job is to manipulate and optimize
  687.      * the container.
  688.      *
  689.      * The main compiler passes roughly do four things:
  690.      *
  691.      *  * The extension configurations are merged;
  692.      *  * Parameter values are resolved;
  693.      *  * The parameter bag is frozen;
  694.      *  * Extension loading is disabled.
  695.      *
  696.      * @param bool $resolveEnvPlaceholders Whether %env()% parameters should be resolved using the current
  697.      *                                     env vars or be replaced by uniquely identifiable placeholders.
  698.      *                                     Set to "true" when you want to use the current ContainerBuilder
  699.      *                                     directly, keep to "false" when the container is dumped instead.
  700.      */
  701.     public function compile(bool $resolveEnvPlaceholders = false)
  702.     {
  703.         $compiler = $this->getCompiler();
  705.         if ($this->trackResources) {
  706.             foreach ($compiler->getPassConfig()->getPasses() as $pass) {
  707.                 $this->addObjectResource($pass);
  708.             }
  709.         }
  710.         $bag = $this->getParameterBag();
  712.         if ($resolveEnvPlaceholders && $bag instanceof EnvPlaceholderParameterBag) {
  713.             $compiler->addPass(new ResolveEnvPlaceholdersPass(), PassConfig::TYPE_AFTER_REMOVING, -1000);
  714.         }
  716.         $compiler->compile($this);
  718.         foreach ($this->definitions as $id => $definition) {
  719.             if ($this->trackResources && $definition->isLazy()) {
  720.                 $this->getReflectionClass($definition->getClass());
  721.             }
  722.         }
  724.         $this->extensionConfigs = [];
  726.         if ($bag instanceof EnvPlaceholderParameterBag) {
  727.             if ($resolveEnvPlaceholders) {
  728.                 $this->parameterBag = new ParameterBag($this->resolveEnvPlaceholders($bag->all(), true));
  729.             }
  731.             $this->envPlaceholders = $bag->getEnvPlaceholders();
  732.         }
  734.         parent::compile();
  736.         foreach ($this->definitions + $this->aliasDefinitions as $id => $definition) {
  737.             if (!$definition->isPublic() || $definition->isPrivate()) {
  738.                 $this->removedIds[$id] = true;
  739.             }
  740.         }
  741.     }
  743.     /**
  744.      * {@inheritdoc}
  745.      */
  746.     public function getServiceIds(): array
  747.     {
  748.         return array_map('strval', array_unique(array_merge(array_keys($this->getDefinitions()), array_keys($this->aliasDefinitions), parent::getServiceIds())));
  749.     }
  751.     /**
  752.      * Gets removed service or alias ids.
  753.      *
  754.      * @return array<string, bool>
  755.      */
  756.     public function getRemovedIds(): array
  757.     {
  758.         return $this->removedIds;
  759.     }
  761.     /**
  762.      * Adds the service aliases.
  763.      *
  764.      * @param array<string, string|Alias> $aliases
  765.      */
  766.     public function addAliases(array $aliases)
  767.     {
  768.         foreach ($aliases as $alias => $id) {
  769.             $this->setAlias($alias, $id);
  770.         }
  771.     }
  773.     /**
  774.      * Sets the service aliases.
  775.      *
  776.      * @param array<string, string|Alias> $aliases
  777.      */
  778.     public function setAliases(array $aliases)
  779.     {
  780.         $this->aliasDefinitions = [];
  781.         $this->addAliases($aliases);
  782.     }
  784.     /**
  785.      * Sets an alias for an existing service.
  786.      *
  787.      * @throws InvalidArgumentException if the id is not a string or an Alias
  788.      * @throws InvalidArgumentException if the alias is for itself
  789.      */
  790.     public function setAlias(string $alias, string|Alias $id): Alias
  791.     {
  792.         if ('' === $alias || '\\' === $alias[-1] || \strlen($alias) !== strcspn($alias, "\0\r\n'")) {
  793.             throw new InvalidArgumentException(sprintf('Invalid alias id: "%s".', $alias));
  794.         }
  796.         if (\is_string($id)) {
  797.             $id = new Alias($id);
  798.         }
  800.         if ($alias === (string) $id) {
  801.             throw new InvalidArgumentException(sprintf('An alias cannot reference itself, got a circular reference on "%s".', $alias));
  802.         }
  804.         unset($this->definitions[$alias], $this->removedIds[$alias]);
  806.         return $this->aliasDefinitions[$alias] = $id;
  807.     }
  809.     public function removeAlias(string $alias)
  810.     {
  811.         if (isset($this->aliasDefinitions[$alias])) {
  812.             unset($this->aliasDefinitions[$alias]);
  813.             $this->removedIds[$alias] = true;
  814.         }
  815.     }
  817.     public function hasAlias(string $id): bool
  818.     {
  819.         return isset($this->aliasDefinitions[$id]);
  820.     }
  822.     /**
  823.      * @return array<string, Alias>
  824.      */
  825.     public function getAliases(): array
  826.     {
  827.         return $this->aliasDefinitions;
  828.     }
  830.     /**
  831.      * @throws InvalidArgumentException if the alias does not exist
  832.      */
  833.     public function getAlias(string $id): Alias
  834.     {
  835.         if (!isset($this->aliasDefinitions[$id])) {
  836.             throw new InvalidArgumentException(sprintf('The service alias "%s" does not exist.', $id));
  837.         }
  839.         return $this->aliasDefinitions[$id];
  840.     }
  842.     /**
  843.      * Registers a service definition.
  844.      *
  845.      * This methods allows for simple registration of service definition
  846.      * with a fluid interface.
  847.      */
  848.     public function register(string $id, string $class = null): Definition
  849.     {
  850.         return $this->setDefinition($id, new Definition($class));
  851.     }
  853.     /**
  854.      * Registers an autowired service definition.
  855.      *
  856.      * This method implements a shortcut for using setDefinition() with
  857.      * an autowired definition.
  858.      */
  859.     public function autowire(string $id, string $class = null): Definition
  860.     {
  861.         return $this->setDefinition($id, (new Definition($class))->setAutowired(true));
  862.     }
  864.     /**
  865.      * Adds the service definitions.
  866.      *
  867.      * @param array<string, Definition> $definitions
  868.      */
  869.     public function addDefinitions(array $definitions)
  870.     {
  871.         foreach ($definitions as $id => $definition) {
  872.             $this->setDefinition($id, $definition);
  873.         }
  874.     }
  876.     /**
  877.      * Sets the service definitions.
  878.      *
  879.      * @param array<string, Definition> $definitions
  880.      */
  881.     public function setDefinitions(array $definitions)
  882.     {
  883.         $this->definitions = [];
  884.         $this->addDefinitions($definitions);
  885.     }
  887.     /**
  888.      * Gets all service definitions.
  889.      *
  890.      * @return array<string, Definition>
  891.      */
  892.     public function getDefinitions(): array
  893.     {
  894.         return $this->definitions;
  895.     }
  897.     /**
  898.      * Sets a service definition.
  899.      *
  900.      * @throws BadMethodCallException When this ContainerBuilder is compiled
  901.      */
  902.     public function setDefinition(string $id, Definition $definition): Definition
  903.     {
  904.         if ($this->isCompiled()) {
  905.             throw new BadMethodCallException('Adding definition to a compiled container is not allowed.');
  906.         }
  908.         if ('' === $id || '\\' === $id[-1] || \strlen($id) !== strcspn($id, "\0\r\n'")) {
  909.             throw new InvalidArgumentException(sprintf('Invalid service id: "%s".', $id));
  910.         }
  912.         unset($this->aliasDefinitions[$id], $this->removedIds[$id]);
  914.         return $this->definitions[$id] = $definition;
  915.     }
  917.     /**
  918.      * Returns true if a service definition exists under the given identifier.
  919.      */
  920.     public function hasDefinition(string $id): bool
  921.     {
  922.         return isset($this->definitions[$id]);
  923.     }
  925.     /**
  926.      * Gets a service definition.
  927.      *
  928.      * @throws ServiceNotFoundException if the service definition does not exist
  929.      */
  930.     public function getDefinition(string $id): Definition
  931.     {
  932.         if (!isset($this->definitions[$id])) {
  933.             throw new ServiceNotFoundException($id);
  934.         }
  936.         return $this->definitions[$id];
  937.     }
  939.     /**
  940.      * Gets a service definition by id or alias.
  941.      *
  942.      * The method "unaliases" recursively to return a Definition instance.
  943.      *
  944.      * @throws ServiceNotFoundException if the service definition does not exist
  945.      */
  946.     public function findDefinition(string $id): Definition
  947.     {
  948.         $seen = [];
  949.         while (isset($this->aliasDefinitions[$id])) {
  950.             $id = (string) $this->aliasDefinitions[$id];
  952.             if (isset($seen[$id])) {
  953.                 $seen = array_values($seen);
  954.                 $seen = \array_slice($seen, array_search($id, $seen));
  955.                 $seen[] = $id;
  957.                 throw new ServiceCircularReferenceException($id, $seen);
  958.             }
  960.             $seen[$id] = $id;
  961.         }
  963.         return $this->getDefinition($id);
  964.     }
  966.     /**
  967.      * Creates a service for a service definition.
  968.      *
  969.      * @throws RuntimeException         When the factory definition is incomplete
  970.      * @throws RuntimeException         When the service is a synthetic service
  971.      * @throws InvalidArgumentException When configure callable is not callable
  972.      */
  973.     private function createService(Definition $definition, array &$inlineServices, bool $isConstructorArgument = false, string $id = null, bool $tryProxy = true): mixed
  974.     {
  975.         if (null === $id && isset($inlineServices[$h = spl_object_hash($definition)])) {
  976.             return $inlineServices[$h];
  977.         }
  979.         if ($definition instanceof ChildDefinition) {
  980.             throw new RuntimeException(sprintf('Constructing service "%s" from a parent definition is not supported at build time.', $id));
  981.         }
  983.         if ($definition->isSynthetic()) {
  984.             throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The DIC does not know how to construct this service.', $id));
  985.         }
  987.         if ($definition->isDeprecated()) {
  988.             $deprecation = $definition->getDeprecation($id);
  989.             trigger_deprecation($deprecation['package'], $deprecation['version'], $deprecation['message']);
  990.         }
  992.         if ($tryProxy && $definition->isLazy() && !$tryProxy = !($proxy = $this->proxyInstantiator) || $proxy instanceof RealServiceInstantiator) {
  993.             $proxy = $proxy->instantiateProxy(
  994.                 $this,
  995.                 $definition,
  996.                 $id, function () use ($definition, &$inlineServices, $id) {
  997.                     return $this->createService($definition, $inlineServices, true, $id, false);
  998.                 }
  999.             );
  1000.             $this->shareService($definition, $proxy, $id, $inlineServices);
  1002.             return $proxy;
  1003.         }
  1005.         $parameterBag = $this->getParameterBag();
  1007.         if (null !== $definition->getFile()) {
  1008.             require_once $parameterBag->resolveValue($definition->getFile());
  1009.         }
  1011.         $arguments = $definition->getArguments();
  1013.         if (null !== $factory = $definition->getFactory()) {
  1014.             if (\is_array($factory)) {
  1015.                 $factory = [$this->doResolveServices($parameterBag->resolveValue($factory[0]), $inlineServices, $isConstructorArgument), $factory[1]];
  1016.             } elseif (!\is_string($factory)) {
  1017.                 throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory.', $id));
  1018.             } elseif (str_starts_with($factory, '@=')) {
  1019.                 $factory = function (ServiceLocator $arguments) use ($factory) {
  1020.                     return $this->getExpressionLanguage()->evaluate(substr($factory, 2), ['container' => $this, 'args' => $arguments]);
  1021.                 };
  1022.                 $arguments = [new ServiceLocatorArgument($arguments)];
  1023.             }
  1024.         }
  1026.         $arguments = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($arguments)), $inlineServices, $isConstructorArgument);
  1028.         if (null !== $id && $definition->isShared() && isset($this->services[$id]) && ($tryProxy || !$definition->isLazy())) {
  1029.             return $this->services[$id];
  1030.         }
  1032.         if (null !== $factory) {
  1033.             $service = $factory(...$arguments);
  1035.             if (!$definition->isDeprecated() && \is_array($factory) && \is_string($factory[0])) {
  1036.                 $r = new \ReflectionClass($factory[0]);
  1038.                 if (0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1039.                     trigger_deprecation('', '', 'The "%s" service relies on the deprecated "%s" factory class. It should either be deprecated or its factory upgraded.', $id, $r->name);
  1040.                 }
  1041.             }
  1042.         } else {
  1043.             $r = new \ReflectionClass($parameterBag->resolveValue($definition->getClass()));
  1045.             $service = null === $r->getConstructor() ? $r->newInstance() : $r->newInstanceArgs(array_values($arguments));
  1047.             if (!$definition->isDeprecated() && 0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
  1048.                 trigger_deprecation('', '', 'The "%s" service relies on the deprecated "%s" class. It should either be deprecated or its implementation upgraded.', $id, $r->name);
  1049.             }
  1050.         }
  1052.         $lastWitherIndex = null;
  1053.         foreach ($definition->getMethodCalls() as $k => $call) {
  1054.             if ($call[2] ?? false) {
  1055.                 $lastWitherIndex = $k;
  1056.             }
  1057.         }
  1059.         if (null === $lastWitherIndex && ($tryProxy || !$definition->isLazy())) {
  1060.             // share only if proxying failed, or if not a proxy, and if no withers are found
  1061.             $this->shareService($definition, $service, $id, $inlineServices);
  1062.         }
  1064.         $properties = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getProperties())), $inlineServices);
  1065.         foreach ($properties as $name => $value) {
  1066.             $service->$name = $value;
  1067.         }
  1069.         foreach ($definition->getMethodCalls() as $k => $call) {
  1070.             $service = $this->callMethod($service, $call, $inlineServices);
  1072.             if ($lastWitherIndex === $k && ($tryProxy || !$definition->isLazy())) {
  1073.                 // share only if proxying failed, or if not a proxy, and this is the last wither
  1074.                 $this->shareService($definition, $service, $id, $inlineServices);
  1075.             }
  1076.         }
  1078.         if ($callable = $definition->getConfigurator()) {
  1079.             if (\is_array($callable)) {
  1080.                 $callable[0] = $parameterBag->resolveValue($callable[0]);
  1082.                 if ($callable[0] instanceof Reference) {
  1083.                     $callable[0] = $this->doGet((string) $callable[0], $callable[0]->getInvalidBehavior(), $inlineServices);
  1084.                 } elseif ($callable[0] instanceof Definition) {
  1085.                     $callable[0] = $this->createService($callable[0], $inlineServices);
  1086.                 }
  1087.             }
  1089.             if (!\is_callable($callable)) {
  1090.                 throw new InvalidArgumentException(sprintf('The configure callable for class "%s" is not a callable.', get_debug_type($service)));
  1091.             }
  1093.             $callable($service);
  1094.         }
  1096.         return $service;
  1097.     }
  1099.     /**
  1100.      * Replaces service references by the real service instance and evaluates expressions.
  1101.      *
  1102.      * @return mixed The same value with all service references replaced by
  1103.      *               the real service instances and all expressions evaluated
  1104.      */
  1105.     public function resolveServices(mixed $value): mixed
  1106.     {
  1107.         return $this->doResolveServices($value);
  1108.     }
  1110.     private function doResolveServices(mixed $value, array &$inlineServices = [], bool $isConstructorArgument = false): mixed
  1111.     {
  1112.         if (\is_array($value)) {
  1113.             foreach ($value as $k => $v) {
  1114.                 $value[$k] = $this->doResolveServices($v, $inlineServices, $isConstructorArgument);
  1115.             }
  1116.         } elseif ($value instanceof ServiceClosureArgument) {
  1117.             $reference = $value->getValues()[0];
  1118.             $value = function () use ($reference) {
  1119.                 return $this->resolveServices($reference);
  1120.             };
  1121.         } elseif ($value instanceof IteratorArgument) {
  1122.             $value = new RewindableGenerator(function () use ($value, &$inlineServices) {
  1123.                 foreach ($value->getValues() as $k => $v) {
  1124.                     foreach (self::getServiceConditionals($v) as $s) {
  1125.                         if (!$this->has($s)) {
  1126.                             continue 2;
  1127.                         }
  1128.                     }
  1129.                     foreach (self::getInitializedConditionals($v) as $s) {
  1130.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
  1131.                             continue 2;
  1132.                         }
  1133.                     }
  1135.                     yield $k => $this->doResolveServices($v, $inlineServices);
  1136.                 }
  1137.             }, function () use ($value): int {
  1138.                 $count = 0;
  1139.                 foreach ($value->getValues() as $v) {
  1140.                     foreach (self::getServiceConditionals($v) as $s) {
  1141.                         if (!$this->has($s)) {
  1142.                             continue 2;
  1143.                         }
  1144.                     }
  1145.                     foreach (self::getInitializedConditionals($v) as $s) {
  1146.                         if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE)) {
  1147.                             continue 2;
  1148.                         }
  1149.                     }
  1151.                     ++$count;
  1152.                 }
  1154.                 return $count;
  1155.             });
  1156.         } elseif ($value instanceof ServiceLocatorArgument) {
  1157.             $refs = $types = [];
  1158.             foreach ($value->getValues() as $k => $v) {
  1159.                 $refs[$k] = [$v, null];
  1160.                 $types[$k] = $v instanceof TypedReference ? $v->getType() : '?';
  1161.             }
  1162.             $value = new ServiceLocator($this->resolveServices(...), $refs, $types);
  1163.         } elseif ($value instanceof Reference) {
  1164.             $value = $this->doGet((string) $value, $value->getInvalidBehavior(), $inlineServices, $isConstructorArgument);
  1165.         } elseif ($value instanceof Definition) {
  1166.             $value = $this->createService($value, $inlineServices, $isConstructorArgument);
  1167.         } elseif ($value instanceof Parameter) {
  1168.             $value = $this->getParameter((string) $value);
  1169.         } elseif ($value instanceof Expression) {
  1170.             $value = $this->getExpressionLanguage()->evaluate($value, ['container' => $this]);
  1171.         } elseif ($value instanceof AbstractArgument) {
  1172.             throw new RuntimeException($value->getTextWithContext());
  1173.         }
  1175.         return $value;
  1176.     }
  1178.     /**
  1179.      * Returns service ids for a given tag.
  1180.      *
  1181.      * Example:
  1182.      *
  1183.      *     $container->register('foo')->addTag('my.tag', ['hello' => 'world']);
  1184.      *
  1185.      *     $serviceIds = $container->findTaggedServiceIds('my.tag');
  1186.      *     foreach ($serviceIds as $serviceId => $tags) {
  1187.      *         foreach ($tags as $tag) {
  1188.      *             echo $tag['hello'];
  1189.      *         }
  1190.      *     }
  1191.      *
  1192.      * @return array<string, array> An array of tags with the tagged service as key, holding a list of attribute arrays
  1193.      */
  1194.     public function findTaggedServiceIds(string $name, bool $throwOnAbstract = false): array
  1195.     {
  1196.         $this->usedTags[] = $name;
  1197.         $tags = [];
  1198.         foreach ($this->getDefinitions() as $id => $definition) {
  1199.             if ($definition->hasTag($name)) {
  1200.                 if ($throwOnAbstract && $definition->isAbstract()) {
  1201.                     throw new InvalidArgumentException(sprintf('The service "%s" tagged "%s" must not be abstract.', $id, $name));
  1202.                 }
  1203.                 $tags[$id] = $definition->getTag($name);
  1204.             }
  1205.         }
  1207.         return $tags;
  1208.     }
  1210.     /**
  1211.      * Returns all tags the defined services use.
  1212.      *
  1213.      * @return string[]
  1214.      */
  1215.     public function findTags(): array
  1216.     {
  1217.         $tags = [];
  1218.         foreach ($this->getDefinitions() as $id => $definition) {
  1219.             $tags[] = array_keys($definition->getTags());
  1220.         }
  1222.         return array_unique(array_merge([], ...$tags));
  1223.     }
  1225.     /**
  1226.      * Returns all tags not queried by findTaggedServiceIds.
  1227.      *
  1228.      * @return string[]
  1229.      */
  1230.     public function findUnusedTags(): array
  1231.     {
  1232.         return array_values(array_diff($this->findTags(), $this->usedTags));
  1233.     }
  1235.     public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
  1236.     {
  1237.         $this->expressionLanguageProviders[] = $provider;
  1238.     }
  1240.     /**
  1241.      * @return ExpressionFunctionProviderInterface[]
  1242.      */
  1243.     public function getExpressionLanguageProviders(): array
  1244.     {
  1245.         return $this->expressionLanguageProviders;
  1246.     }
  1248.     /**
  1249.      * Returns a ChildDefinition that will be used for autoconfiguring the interface/class.
  1250.      */
  1251.     public function registerForAutoconfiguration(string $interface): ChildDefinition
  1252.     {
  1253.         if (!isset($this->autoconfiguredInstanceof[$interface])) {
  1254.             $this->autoconfiguredInstanceof[$interface] = new ChildDefinition('');
  1255.         }
  1257.         return $this->autoconfiguredInstanceof[$interface];
  1258.     }
  1260.     /**
  1261.      * Registers an attribute that will be used for autoconfiguring annotated classes.
  1262.      *
  1263.      * The third argument passed to the callable is the reflector of the
  1264.      * class/method/property/parameter that the attribute targets. Using one or many of
  1265.      * \ReflectionClass|\ReflectionMethod|\ReflectionProperty|\ReflectionParameter as a type-hint
  1266.      * for this argument allows filtering which attributes should be passed to the callable.
  1267.      *
  1268.      * @template T
  1269.      *
  1270.      * @param class-string<T>                                $attributeClass
  1271.      * @param callable(ChildDefinition, T, \Reflector): void $configurator
  1272.      */
  1273.     public function registerAttributeForAutoconfiguration(string $attributeClass, callable $configurator): void
  1274.     {
  1275.         $this->autoconfiguredAttributes[$attributeClass] = $configurator;
  1276.     }
  1278.     /**
  1279.      * Registers an autowiring alias that only binds to a specific argument name.
  1280.      *
  1281.      * The argument name is derived from $name if provided (from $id otherwise)
  1282.      * using camel case: "foo.bar" or "foo_bar" creates an alias bound to
  1283.      * "$fooBar"-named arguments with $type as type-hint. Such arguments will
  1284.      * receive the service $id when autowiring is used.
  1285.      */
  1286.     public function registerAliasForArgument(string $id, string $type, string $name = null): Alias
  1287.     {
  1288.         $name = (new Target($name ?? $id))->name;
  1290.         if (!preg_match('/^[a-zA-Z_\x7f-\xff]/', $name)) {
  1291.             throw new InvalidArgumentException(sprintf('Invalid argument name "%s" for service "%s": the first character must be a letter.', $name, $id));
  1292.         }
  1294.         return $this->setAlias($type.' $'.$name, $id);
  1295.     }
  1297.     /**
  1298.      * Returns an array of ChildDefinition[] keyed by interface.
  1299.      *
  1300.      * @return array<string, ChildDefinition>
  1301.      */
  1302.     public function getAutoconfiguredInstanceof(): array
  1303.     {
  1304.         return $this->autoconfiguredInstanceof;
  1305.     }
  1307.     /**
  1308.      * @return array<string, callable>
  1309.      */
  1310.     public function getAutoconfiguredAttributes(): array
  1311.     {
  1312.         return $this->autoconfiguredAttributes;
  1313.     }
  1315.     /**
  1316.      * Resolves env parameter placeholders in a string or an array.
  1317.      *
  1318.      * @param string|true|null $format    A sprintf() format returning the replacement for each env var name or
  1319.      *                                    null to resolve back to the original "%env(VAR)%" format or
  1320.      *                                    true to resolve to the actual values of the referenced env vars
  1321.      * @param array            &$usedEnvs Env vars found while resolving are added to this array
  1322.      *
  1323.      * @return mixed The value with env parameters resolved if a string or an array is passed
  1324.      */
  1325.     public function resolveEnvPlaceholders(mixed $value, string|bool $format = null, array &$usedEnvs = null): mixed
  1326.     {
  1327.         if (null === $format) {
  1328.             $format = '%%env(%s)%%';
  1329.         }
  1331.         $bag = $this->getParameterBag();
  1332.         if (true === $format) {
  1333.             $value = $bag->resolveValue($value);
  1334.         }
  1336.         if ($value instanceof Definition) {
  1337.             $value = (array) $value;
  1338.         }
  1340.         if (\is_array($value)) {
  1341.             $result = [];
  1342.             foreach ($value as $k => $v) {
  1343.                 $result[\is_string($k) ? $this->resolveEnvPlaceholders($k, $format, $usedEnvs) : $k] = $this->resolveEnvPlaceholders($v, $format, $usedEnvs);
  1344.             }
  1346.             return $result;
  1347.         }
  1349.         if (!\is_string($value) || 38 > \strlen($value) || !preg_match('/env[_(]/i', $value)) {
  1350.             return $value;
  1351.         }
  1352.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1354.         $completed = false;
  1355.         foreach ($envPlaceholders as $env => $placeholders) {
  1356.             foreach ($placeholders as $placeholder) {
  1357.                 if (false !== stripos($value, $placeholder)) {
  1358.                     if (true === $format) {
  1359.                         $resolved = $bag->escapeValue($this->getEnv($env));
  1360.                     } else {
  1361.                         $resolved = sprintf($format, $env);
  1362.                     }
  1363.                     if ($placeholder === $value) {
  1364.                         $value = $resolved;
  1365.                         $completed = true;
  1366.                     } else {
  1367.                         if (!\is_string($resolved) && !is_numeric($resolved)) {
  1368.                             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)));
  1369.                         }
  1370.                         $value = str_ireplace($placeholder, $resolved, $value);
  1371.                     }
  1372.                     $usedEnvs[$env] = $env;
  1373.                     $this->envCounters[$env] = isset($this->envCounters[$env]) ? 1 + $this->envCounters[$env] : 1;
  1375.                     if ($completed) {
  1376.                         break 2;
  1377.                     }
  1378.                 }
  1379.             }
  1380.         }
  1382.         return $value;
  1383.     }
  1385.     /**
  1386.      * Get statistics about env usage.
  1387.      *
  1388.      * @return int[] The number of time each env vars has been resolved
  1389.      */
  1390.     public function getEnvCounters(): array
  1391.     {
  1392.         $bag = $this->getParameterBag();
  1393.         $envPlaceholders = $bag instanceof EnvPlaceholderParameterBag ? $bag->getEnvPlaceholders() : $this->envPlaceholders;
  1395.         foreach ($envPlaceholders as $env => $placeholders) {
  1396.             if (!isset($this->envCounters[$env])) {
  1397.                 $this->envCounters[$env] = 0;
  1398.             }
  1399.         }
  1401.         return $this->envCounters;
  1402.     }
  1404.     /**
  1405.      * @final
  1406.      */
  1407.     public function log(CompilerPassInterface $pass, string $message)
  1408.     {
  1409.         $this->getCompiler()->log($pass, $this->resolveEnvPlaceholders($message));
  1410.     }
  1412.     /**
  1413.      * Checks whether a class is available and will remain available in the "no-dev" mode of Composer.
  1414.      *
  1415.      * When parent packages are provided and if any of them is in dev-only mode,
  1416.      * the class will be considered available even if it is also in dev-only mode.
  1417.      *
  1418.      * @throws \LogicException If dependencies have been installed with Composer 1
  1419.      */
  1420.     final public static function willBeAvailable(string $package, string $class, array $parentPackages): bool
  1421.     {
  1422.         if (!class_exists(InstalledVersions::class)) {
  1423.             throw new \LogicException(sprintf('Calling "%s" when dependencies have been installed with Composer 1 is not supported. Consider upgrading to Composer 2.', __METHOD__));
  1424.         }
  1426.         if (!class_exists($class) && !interface_exists($class, false) && !trait_exists($class, false)) {
  1427.             return false;
  1428.         }
  1430.         if (!InstalledVersions::isInstalled($package) || InstalledVersions::isInstalled($package, false)) {
  1431.             return true;
  1432.         }
  1434.         // the package is installed but in dev-mode only, check if this applies to one of the parent packages too
  1436.         $rootPackage = InstalledVersions::getRootPackage()['name'] ?? '';
  1438.         if ('symfony/symfony' === $rootPackage) {
  1439.             return true;
  1440.         }
  1442.         foreach ($parentPackages as $parentPackage) {
  1443.             if ($rootPackage === $parentPackage || (InstalledVersions::isInstalled($parentPackage) && !InstalledVersions::isInstalled($parentPackage, false))) {
  1444.                 return true;
  1445.             }
  1446.         }
  1448.         return false;
  1449.     }
  1451.     /**
  1452.      * Gets removed binding ids.
  1453.      *
  1454.      * @return array<int, bool>
  1455.      *
  1456.      * @internal
  1457.      */
  1458.     public function getRemovedBindingIds(): array
  1459.     {
  1460.         return $this->removedBindingIds;
  1461.     }
  1463.     /**
  1464.      * Removes bindings for a service.
  1465.      *
  1466.      * @internal
  1467.      */
  1468.     public function removeBindings(string $id)
  1469.     {
  1470.         if ($this->hasDefinition($id)) {
  1471.             foreach ($this->getDefinition($id)->getBindings() as $key => $binding) {
  1472.                 [, $bindingId] = $binding->getValues();
  1473.                 $this->removedBindingIds[(int) $bindingId] = true;
  1474.             }
  1475.         }
  1476.     }
  1478.     /**
  1479.      * @return string[]
  1480.      *
  1481.      * @internal
  1482.      */
  1483.     public static function getServiceConditionals(mixed $value): array
  1484.     {
  1485.         $services = [];
  1487.         if (\is_array($value)) {
  1488.             foreach ($value as $v) {
  1489.                 $services = array_unique(array_merge($services, self::getServiceConditionals($v)));
  1490.             }
  1491.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  1492.             $services[] = (string) $value;
  1493.         }
  1495.         return $services;
  1496.     }
  1498.     /**
  1499.      * @return string[]
  1500.      *
  1501.      * @internal
  1502.      */
  1503.     public static function getInitializedConditionals(mixed $value): array
  1504.     {
  1505.         $services = [];
  1507.         if (\is_array($value)) {
  1508.             foreach ($value as $v) {
  1509.                 $services = array_unique(array_merge($services, self::getInitializedConditionals($v)));
  1510.             }
  1511.         } elseif ($value instanceof Reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $value->getInvalidBehavior()) {
  1512.             $services[] = (string) $value;
  1513.         }
  1515.         return $services;
  1516.     }
  1518.     /**
  1519.      * Computes a reasonably unique hash of a serializable value.
  1520.      */
  1521.     public static function hash(mixed $value): string
  1522.     {
  1523.         $hash = substr(base64_encode(hash('sha256', serialize($value), true)), 0, 7);
  1525.         return str_replace(['/', '+'], ['.', '_'], $hash);
  1526.     }
  1528.     /**
  1529.      * {@inheritdoc}
  1530.      */
  1531.     protected function getEnv(string $name): mixed
  1532.     {
  1533.         $value = parent::getEnv($name);
  1534.         $bag = $this->getParameterBag();
  1536.         if (!\is_string($value) || !$bag instanceof EnvPlaceholderParameterBag) {
  1537.             return $value;
  1538.         }
  1540.         $envPlaceholders = $bag->getEnvPlaceholders();
  1541.         if (isset($envPlaceholders[$name][$value])) {
  1542.             $bag = new ParameterBag($bag->all());
  1544.             return $bag->unescapeValue($bag->get("env($name)"));
  1545.         }
  1546.         foreach ($envPlaceholders as $env => $placeholders) {
  1547.             if (isset($placeholders[$value])) {
  1548.                 return $this->getEnv($env);
  1549.             }
  1550.         }
  1552.         $this->resolving["env($name)"] = true;
  1553.         try {
  1554.             return $bag->unescapeValue($this->resolveEnvPlaceholders($bag->escapeValue($value), true));
  1555.         } finally {
  1556.             unset($this->resolving["env($name)"]);
  1557.         }
  1558.     }
  1560.     private function callMethod(object $service, array $call, array &$inlineServices): mixed
  1561.     {
  1562.         foreach (self::getServiceConditionals($call[1]) as $s) {
  1563.             if (!$this->has($s)) {
  1564.                 return $service;
  1565.             }
  1566.         }
  1567.         foreach (self::getInitializedConditionals($call[1]) as $s) {
  1568.             if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
  1569.                 return $service;
  1570.             }
  1571.         }
  1573.         $result = $service->{$call[0]}(...$this->doResolveServices($this->getParameterBag()->unescapeValue($this->getParameterBag()->resolveValue($call[1])), $inlineServices));
  1575.         return empty($call[2]) ? $service : $result;
  1576.     }
  1578.     private function shareService(Definition $definition, mixed $service, ?string $id, array &$inlineServices)
  1579.     {
  1580.         $inlineServices[$id ?? spl_object_hash($definition)] = $service;
  1582.         if (null !== $id && $definition->isShared()) {
  1583.             $this->services[$id] = $service;
  1584.             unset($this->loading[$id]);
  1585.         }
  1586.     }
  1588.     private function getExpressionLanguage(): ExpressionLanguage
  1589.     {
  1590.         if (!isset($this->expressionLanguage)) {
  1591.             if (!class_exists(Expression::class)) {
  1592.                 throw new LogicException('Expressions cannot be used without the ExpressionLanguage component. Try running "composer require symfony/expression-language".');
  1593.             }
  1594.             $this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders, null, $this->getEnv(...));
  1595.         }
  1597.         return $this->expressionLanguage;
  1598.     }
  1600.     private function inVendors(string $path): bool
  1601.     {
  1602.         $this->vendors ??= (new ComposerResource())->getVendors();
  1603.         $path = realpath($path) ?: $path;
  1605.         foreach ($this->vendors as $vendor) {
  1606.             if (str_starts_with($path, $vendor) && false !== strpbrk(substr($path, \strlen($vendor), 1), '/'.\DIRECTORY_SEPARATOR)) {
  1607.                 $this->addResource(new FileResource($vendor.'/composer/installed.json'));
  1609.                 return true;
  1610.             }
  1611.         }
  1613.         return false;
  1614.     }
  1615. }