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

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