vendor/symfony/dependency-injection/Dumper/PhpDumper.php line 1462

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\Dumper;
  14. use Composer\Autoload\ClassLoader;
  15. use Symfony\Component\Debug\DebugClassLoader as LegacyDebugClassLoader;
  16. use Symfony\Component\DependencyInjection\Argument\AbstractArgument;
  17. use Symfony\Component\DependencyInjection\Argument\ArgumentInterface;
  18. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  19. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  20. use Symfony\Component\DependencyInjection\Argument\ServiceLocator;
  21. use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
  22. use Symfony\Component\DependencyInjection\Compiler\AnalyzeServiceReferencesPass;
  23. use Symfony\Component\DependencyInjection\Compiler\CheckCircularReferencesPass;
  24. use Symfony\Component\DependencyInjection\Compiler\ServiceReferenceGraphNode;
  25. use Symfony\Component\DependencyInjection\Container;
  26. use Symfony\Component\DependencyInjection\ContainerBuilder;
  27. use Symfony\Component\DependencyInjection\ContainerInterface;
  28. use Symfony\Component\DependencyInjection\Definition;
  29. use Symfony\Component\DependencyInjection\Exception\EnvParameterException;
  30. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  31. use Symfony\Component\DependencyInjection\Exception\LogicException;
  32. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  33. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  34. use Symfony\Component\DependencyInjection\ExpressionLanguage;
  35. use Symfony\Component\DependencyInjection\LazyProxy\PhpDumper\DumperInterface;
  36. use Symfony\Component\DependencyInjection\LazyProxy\PhpDumper\NullDumper;
  37. use Symfony\Component\DependencyInjection\Loader\FileLoader;
  38. use Symfony\Component\DependencyInjection\Parameter;
  39. use Symfony\Component\DependencyInjection\Reference;
  40. use Symfony\Component\DependencyInjection\ServiceLocator as BaseServiceLocator;
  41. use Symfony\Component\DependencyInjection\TypedReference;
  42. use Symfony\Component\DependencyInjection\Variable;
  43. use Symfony\Component\ErrorHandler\DebugClassLoader;
  44. use Symfony\Component\ExpressionLanguage\Expression;
  45. use Symfony\Component\HttpKernel\Kernel;
  47. /**
  48.  * PhpDumper dumps a service container as a PHP class.
  49.  *
  50.  * @author Fabien Potencier <fabien@symfony.com>
  51.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  52.  */
  53. class PhpDumper extends Dumper
  54. {
  55.     /**
  56.      * Characters that might appear in the generated variable name as first character.
  57.      */
  58.     public const FIRST_CHARS = 'abcdefghijklmnopqrstuvwxyz';
  60.     /**
  61.      * Characters that might appear in the generated variable name as any but the first character.
  62.      */
  63.     public const NON_FIRST_CHARS = 'abcdefghijklmnopqrstuvwxyz0123456789_';
  65.     /** @var \SplObjectStorage<Definition, Variable>|null */
  66.     private ?\SplObjectStorage $definitionVariables = null;
  67.     private ?array $referenceVariables = null;
  68.     private int $variableCount;
  69.     private ?\SplObjectStorage $inlinedDefinitions = null;
  70.     private ?array $serviceCalls = null;
  71.     private array $reservedVariables = ['instance', 'class', 'this', 'container'];
  72.     private ExpressionLanguage $expressionLanguage;
  73.     private ?string $targetDirRegex = null;
  74.     private int $targetDirMaxMatches;
  75.     private string $docStar;
  76.     private array $serviceIdToMethodNameMap;
  77.     private array $usedMethodNames;
  78.     private string $namespace;
  79.     private bool $asFiles;
  80.     private string $hotPathTag;
  81.     private array $preloadTags;
  82.     private bool $inlineFactories;
  83.     private bool $inlineRequires;
  84.     private array $inlinedRequires = [];
  85.     private array $circularReferences = [];
  86.     private array $singleUsePrivateIds = [];
  87.     private array $preload = [];
  88.     private bool $addGetService = false;
  89.     private array $locatedIds = [];
  90.     private string $serviceLocatorTag;
  91.     private array $exportedVariables = [];
  92.     private string $baseClass;
  93.     private DumperInterface $proxyDumper;
  94.     private bool $hasProxyDumper = false;
  96.     /**
  97.      * {@inheritdoc}
  98.      */
  99.     public function __construct(ContainerBuilder $container)
  100.     {
  101.         if (!$container->isCompiled()) {
  102.             throw new LogicException('Cannot dump an uncompiled container.');
  103.         }
  105.         parent::__construct($container);
  106.     }
  108.     /**
  109.      * Sets the dumper to be used when dumping proxies in the generated container.
  110.      */
  111.     public function setProxyDumper(DumperInterface $proxyDumper)
  112.     {
  113.         $this->proxyDumper = $proxyDumper;
  114.         $this->hasProxyDumper = !$proxyDumper instanceof NullDumper;
  115.     }
  117.     /**
  118.      * Dumps the service container as a PHP class.
  119.      *
  120.      * Available options:
  121.      *
  122.      *  * class:      The class name
  123.      *  * base_class: The base class name
  124.      *  * namespace:  The class namespace
  125.      *  * as_files:   To split the container in several files
  126.      *
  127.      * @return string|array A PHP class representing the service container or an array of PHP files if the "as_files" option is set
  128.      *
  129.      * @throws EnvParameterException When an env var exists but has not been dumped
  130.      */
  131.     public function dump(array $options = []): string|array
  132.     {
  133.         $this->locatedIds = [];
  134.         $this->targetDirRegex = null;
  135.         $this->inlinedRequires = [];
  136.         $this->exportedVariables = [];
  137.         $options = array_merge([
  138.             'class' => 'ProjectServiceContainer',
  139.             'base_class' => 'Container',
  140.             'namespace' => '',
  141.             'as_files' => false,
  142.             'debug' => true,
  143.             'hot_path_tag' => 'container.hot_path',
  144.             'preload_tags' => ['container.preload', 'container.no_preload'],
  145.             'inline_factories_parameter' => 'container.dumper.inline_factories',
  146.             'inline_class_loader_parameter' => 'container.dumper.inline_class_loader',
  147.             'preload_classes' => [],
  148.             'service_locator_tag' => 'container.service_locator',
  149.             'build_time' => time(),
  150.         ], $options);
  152.         $this->addGetService = false;
  153.         $this->namespace = $options['namespace'];
  154.         $this->asFiles = $options['as_files'];
  155.         $this->hotPathTag = $options['hot_path_tag'];
  156.         $this->preloadTags = $options['preload_tags'];
  157.         $this->inlineFactories = $this->asFiles && $options['inline_factories_parameter'] && $this->container->hasParameter($options['inline_factories_parameter']) && $this->container->getParameter($options['inline_factories_parameter']);
  158.         $this->inlineRequires = $options['inline_class_loader_parameter'] && ($this->container->hasParameter($options['inline_class_loader_parameter']) ? $this->container->getParameter($options['inline_class_loader_parameter']) : $options['debug']);
  159.         $this->serviceLocatorTag = $options['service_locator_tag'];
  161.         if (!str_starts_with($baseClass = $options['base_class'], '\\') && 'Container' !== $baseClass) {
  162.             $baseClass = sprintf('%s\%s', $options['namespace'] ? '\\'.$options['namespace'] : '', $baseClass);
  163.             $this->baseClass = $baseClass;
  164.         } elseif ('Container' === $baseClass) {
  165.             $this->baseClass = Container::class;
  166.         } else {
  167.             $this->baseClass = $baseClass;
  168.         }
  170.         $this->initializeMethodNamesMap('Container' === $baseClass ? Container::class : $baseClass);
  172.         if (!$this->hasProxyDumper) {
  173.             (new AnalyzeServiceReferencesPass(true, false))->process($this->container);
  174.             try {
  175.                 (new CheckCircularReferencesPass())->process($this->container);
  176.             } catch (ServiceCircularReferenceException $e) {
  177.                 $path = $e->getPath();
  178.                 end($path);
  179.                 $path[key($path)] .= '". Try running "composer require symfony/proxy-manager-bridge';
  181.                 throw new ServiceCircularReferenceException($e->getServiceId(), $path);
  182.             }
  183.         }
  185.         $this->analyzeReferences();
  186.         $this->docStar = $options['debug'] ? '*' : '';
  188.         if (!empty($options['file']) && is_dir($dir = \dirname($options['file']))) {
  189.             // Build a regexp where the first root dirs are mandatory,
  190.             // but every other sub-dir is optional up to the full path in $dir
  191.             // Mandate at least 1 root dir and not more than 5 optional dirs.
  193.             $dir = explode(\DIRECTORY_SEPARATOR, realpath($dir));
  194.             $i = \count($dir);
  196.             if (2 + (int) ('\\' === \DIRECTORY_SEPARATOR) <= $i) {
  197.                 $regex = '';
  198.                 $lastOptionalDir = $i > 8 ? $i - 5 : (2 + (int) ('\\' === \DIRECTORY_SEPARATOR));
  199.                 $this->targetDirMaxMatches = $i - $lastOptionalDir;
  201.                 while (--$i >= $lastOptionalDir) {
  202.                     $regex = sprintf('(%s%s)?', preg_quote(\DIRECTORY_SEPARATOR.$dir[$i], '#'), $regex);
  203.                 }
  205.                 do {
  206.                     $regex = preg_quote(\DIRECTORY_SEPARATOR.$dir[$i], '#').$regex;
  207.                 } while (0 < --$i);
  209.                 $this->targetDirRegex = '#(^|file://|[:;, \|\r\n])'.preg_quote($dir[0], '#').$regex.'#';
  210.             }
  211.         }
  213.         $proxyClasses = $this->inlineFactories ? $this->generateProxyClasses() : null;
  215.         if ($options['preload_classes']) {
  216.             $this->preload = array_combine($options['preload_classes'], $options['preload_classes']);
  217.         }
  219.         $code =
  220.             $this->startClass($options['class'], $baseClass, $this->inlineFactories && $proxyClasses).
  221.             $this->addServices($services).
  222.             $this->addDeprecatedAliases().
  223.             $this->addDefaultParametersMethod()
  224.         ;
  226.         $proxyClasses ??= $this->generateProxyClasses();
  228.         if ($this->addGetService) {
  229.             $code = preg_replace(
  230.                 "/(\r?\n\r?\n    public function __construct.+?\\{\r?\n)/s",
  231.                 "\n    protected \Closure \$getService;$1        \$this->getService = \$this->getService(...);\n",
  232.                 $code,
  233.                 1
  234.             );
  235.         }
  237.         if ($this->asFiles) {
  238.             $fileTemplate = <<<EOF
  239. <?php
  241. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  242. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  244. /*{$this->docStar}
  245.  * @internal This class has been auto-generated by the Symfony Dependency Injection Component.
  246.  */
  247. class %s extends {$options['class']}
  248. {%s}
  250. EOF;
  251.             $files = [];
  252.             $preloadedFiles = [];
  253.             $ids = $this->container->getRemovedIds();
  254.             foreach ($this->container->getDefinitions() as $id => $definition) {
  255.                 if (!$definition->isPublic()) {
  256.                     $ids[$id] = true;
  257.                 }
  258.             }
  259.             if ($ids = array_keys($ids)) {
  260.                 sort($ids);
  261.                 $c = "<?php\n\nreturn [\n";
  262.                 foreach ($ids as $id) {
  263.                     $c .= '    '.$this->doExport($id)." => true,\n";
  264.                 }
  265.                 $files['removed-ids.php'] = $c."];\n";
  266.             }
  268.             if (!$this->inlineFactories) {
  269.                 foreach ($this->generateServiceFiles($services) as $file => [$c, $preload]) {
  270.                     $files[$file] = sprintf($fileTemplate, substr($file, 0, -4), $c);
  272.                     if ($preload) {
  273.                         $preloadedFiles[$file] = $file;
  274.                     }
  275.                 }
  276.                 foreach ($proxyClasses as $file => $c) {
  277.                     $files[$file] = "<?php\n".$c;
  278.                     $preloadedFiles[$file] = $file;
  279.                 }
  280.             }
  282.             $code .= $this->endClass();
  284.             if ($this->inlineFactories && $proxyClasses) {
  285.                 $files['proxy-classes.php'] = "<?php\n\n";
  287.                 foreach ($proxyClasses as $c) {
  288.                     $files['proxy-classes.php'] .= $c;
  289.                 }
  290.             }
  292.             $files[$options['class'].'.php'] = $code;
  293.             $hash = ucfirst(strtr(ContainerBuilder::hash($files), '._', 'xx'));
  294.             $code = [];
  296.             foreach ($files as $file => $c) {
  297.                 $code["Container{$hash}/{$file}"] = substr_replace($c, "<?php\n\nnamespace Container{$hash};\n", 0, 6);
  299.                 if (isset($preloadedFiles[$file])) {
  300.                     $preloadedFiles[$file] = "Container{$hash}/{$file}";
  301.                 }
  302.             }
  303.             $namespaceLine = $this->namespace ? "\nnamespace {$this->namespace};\n" : '';
  304.             $time = $options['build_time'];
  305.             $id = hash('crc32', $hash.$time);
  306.             $this->asFiles = false;
  308.             if ($this->preload && null !== $autoloadFile = $this->getAutoloadFile()) {
  309.                 $autoloadFile = trim($this->export($autoloadFile), '()\\');
  311.                 $preloadedFiles = array_reverse($preloadedFiles);
  312.                 if ('' !== $preloadedFiles = implode("';\nrequire __DIR__.'/", $preloadedFiles)) {
  313.                     $preloadedFiles = "require __DIR__.'/$preloadedFiles';\n";
  314.                 }
  316.                 $code[$options['class'].'.preload.php'] = <<<EOF
  317. <?php
  319. // This file has been auto-generated by the Symfony Dependency Injection Component
  320. // You can reference it in the "opcache.preload" php.ini setting on PHP >= 7.4 when preloading is desired
  322. use Symfony\Component\DependencyInjection\Dumper\Preloader;
  324. if (in_array(PHP_SAPI, ['cli', 'phpdbg'], true)) {
  325.     return;
  326. }
  328. require $autoloadFile;
  329. (require __DIR__.'/{$options['class']}.php')->set(\\Container{$hash}\\{$options['class']}::class, null);
  330. $preloadedFiles
  331. \$classes = [];
  333. EOF;
  335.                 foreach ($this->preload as $class) {
  336.                     if (!$class || str_contains($class, '$') || \in_array($class, ['int', 'float', 'string', 'bool', 'resource', 'object', 'array', 'null', 'callable', 'iterable', 'mixed', 'void'], true)) {
  337.                         continue;
  338.                     }
  339.                     if (!(class_exists($class, false) || interface_exists($class, false) || trait_exists($class, false)) || (new \ReflectionClass($class))->isUserDefined()) {
  340.                         $code[$options['class'].'.preload.php'] .= sprintf("\$classes[] = '%s';\n", $class);
  341.                     }
  342.                 }
  344.                 $code[$options['class'].'.preload.php'] .= <<<'EOF'
  346. $preloaded = Preloader::preload($classes);
  348. EOF;
  349.             }
  351.             $code[$options['class'].'.php'] = <<<EOF
  352. <?php
  353. {$namespaceLine}
  354. // This file has been auto-generated by the Symfony Dependency Injection Component for internal use.
  356. if (\\class_exists(\\Container{$hash}\\{$options['class']}::class, false)) {
  357.     // no-op
  358. } elseif (!include __DIR__.'/Container{$hash}/{$options['class']}.php') {
  359.     touch(__DIR__.'/Container{$hash}.legacy');
  361.     return;
  362. }
  364. if (!\\class_exists({$options['class']}::class, false)) {
  365.     \\class_alias(\\Container{$hash}\\{$options['class']}::class, {$options['class']}::class, false);
  366. }
  368. return new \\Container{$hash}\\{$options['class']}([
  369.     'container.build_hash' => '$hash',
  370.     'container.build_id' => '$id',
  371.     'container.build_time' => $time,
  372. ], __DIR__.\\DIRECTORY_SEPARATOR.'Container{$hash}');
  374. EOF;
  375.         } else {
  376.             $code .= $this->endClass();
  377.             foreach ($proxyClasses as $c) {
  378.                 $code .= $c;
  379.             }
  380.         }
  382.         $this->targetDirRegex = null;
  383.         $this->inlinedRequires = [];
  384.         $this->circularReferences = [];
  385.         $this->locatedIds = [];
  386.         $this->exportedVariables = [];
  387.         $this->preload = [];
  389.         $unusedEnvs = [];
  390.         foreach ($this->container->getEnvCounters() as $env => $use) {
  391.             if (!$use) {
  392.                 $unusedEnvs[] = $env;
  393.             }
  394.         }
  395.         if ($unusedEnvs) {
  396.             throw new EnvParameterException($unusedEnvs, null, 'Environment variables "%s" are never used. Please, check your container\'s configuration.');
  397.         }
  399.         return $code;
  400.     }
  402.     /**
  403.      * Retrieves the currently set proxy dumper or instantiates one.
  404.      */
  405.     private function getProxyDumper(): DumperInterface
  406.     {
  407.         return $this->proxyDumper ??= new NullDumper();
  408.     }
  410.     private function analyzeReferences()
  411.     {
  412.         (new AnalyzeServiceReferencesPass(false, $this->hasProxyDumper))->process($this->container);
  413.         $checkedNodes = [];
  414.         $this->circularReferences = [];
  415.         $this->singleUsePrivateIds = [];
  416.         foreach ($this->container->getCompiler()->getServiceReferenceGraph()->getNodes() as $id => $node) {
  417.             if (!$node->getValue() instanceof Definition) {
  418.                 continue;
  419.             }
  421.             if ($this->isSingleUsePrivateNode($node)) {
  422.                 $this->singleUsePrivateIds[$id] = $id;
  423.             }
  425.             $this->collectCircularReferences($id, $node->getOutEdges(), $checkedNodes);
  426.         }
  428.         $this->container->getCompiler()->getServiceReferenceGraph()->clear();
  429.         $this->singleUsePrivateIds = array_diff_key($this->singleUsePrivateIds, $this->circularReferences);
  430.     }
  432.     private function collectCircularReferences(string $sourceId, array $edges, array &$checkedNodes, array &$loops = [], array $path = [], bool $byConstructor = true): void
  433.     {
  434.         $path[$sourceId] = $byConstructor;
  435.         $checkedNodes[$sourceId] = true;
  436.         foreach ($edges as $edge) {
  437.             $node = $edge->getDestNode();
  438.             $id = $node->getId();
  439.             if ($sourceId === $id || !$node->getValue() instanceof Definition || $edge->isWeak()) {
  440.                 continue;
  441.             }
  443.             if (isset($path[$id])) {
  444.                 $loop = null;
  445.                 $loopByConstructor = $edge->isReferencedByConstructor() && !$edge->isLazy();
  446.                 $pathInLoop = [$id, []];
  447.                 foreach ($path as $k => $pathByConstructor) {
  448.                     if (null !== $loop) {
  449.                         $loop[] = $k;
  450.                         $pathInLoop[1][$k] = $pathByConstructor;
  451.                         $loops[$k][] = &$pathInLoop;
  452.                         $loopByConstructor = $loopByConstructor && $pathByConstructor;
  453.                     } elseif ($k === $id) {
  454.                         $loop = [];
  455.                     }
  456.                 }
  457.                 $this->addCircularReferences($id, $loop, $loopByConstructor);
  458.             } elseif (!isset($checkedNodes[$id])) {
  459.                 $this->collectCircularReferences($id, $node->getOutEdges(), $checkedNodes, $loops, $path, $edge->isReferencedByConstructor() && !$edge->isLazy());
  460.             } elseif (isset($loops[$id])) {
  461.                 // we already had detected loops for this edge
  462.                 // let's check if we have a common ancestor in one of the detected loops
  463.                 foreach ($loops[$id] as [$first, $loopPath]) {
  464.                     if (!isset($path[$first])) {
  465.                         continue;
  466.                     }
  467.                     // We have a common ancestor, let's fill the current path
  468.                     $fillPath = null;
  469.                     foreach ($loopPath as $k => $pathByConstructor) {
  470.                         if (null !== $fillPath) {
  471.                             $fillPath[$k] = $pathByConstructor;
  472.                         } elseif ($k === $id) {
  473.                             $fillPath = $path;
  474.                             $fillPath[$k] = $pathByConstructor;
  475.                         }
  476.                     }
  478.                     // we can now build the loop
  479.                     $loop = null;
  480.                     $loopByConstructor = $edge->isReferencedByConstructor() && !$edge->isLazy();
  481.                     foreach ($fillPath as $k => $pathByConstructor) {
  482.                         if (null !== $loop) {
  483.                             $loop[] = $k;
  484.                             $loopByConstructor = $loopByConstructor && $pathByConstructor;
  485.                         } elseif ($k === $first) {
  486.                             $loop = [];
  487.                         }
  488.                     }
  489.                     $this->addCircularReferences($first, $loop, $loopByConstructor);
  490.                     break;
  491.                 }
  492.             }
  493.         }
  494.         unset($path[$sourceId]);
  495.     }
  497.     private function addCircularReferences(string $sourceId, array $currentPath, bool $byConstructor)
  498.     {
  499.         $currentId = $sourceId;
  500.         $currentPath = array_reverse($currentPath);
  501.         $currentPath[] = $currentId;
  502.         foreach ($currentPath as $parentId) {
  503.             if (empty($this->circularReferences[$parentId][$currentId])) {
  504.                 $this->circularReferences[$parentId][$currentId] = $byConstructor;
  505.             }
  507.             $currentId = $parentId;
  508.         }
  509.     }
  511.     private function collectLineage(string $class, array &$lineage)
  512.     {
  513.         if (isset($lineage[$class])) {
  514.             return;
  515.         }
  516.         if (!$r = $this->container->getReflectionClass($class, false)) {
  517.             return;
  518.         }
  519.         if (is_a($class, $this->baseClass, true)) {
  520.             return;
  521.         }
  522.         $file = $r->getFileName();
  523.         if (str_ends_with($file, ') : eval()\'d code')) {
  524.             $file = substr($file, 0, strrpos($file, '(', -17));
  525.         }
  526.         if (!$file || $this->doExport($file) === $exportedFile = $this->export($file)) {
  527.             return;
  528.         }
  530.         $lineage[$class] = substr($exportedFile, 1, -1);
  532.         if ($parent = $r->getParentClass()) {
  533.             $this->collectLineage($parent->name, $lineage);
  534.         }
  536.         foreach ($r->getInterfaces() as $parent) {
  537.             $this->collectLineage($parent->name, $lineage);
  538.         }
  540.         foreach ($r->getTraits() as $parent) {
  541.             $this->collectLineage($parent->name, $lineage);
  542.         }
  544.         unset($lineage[$class]);
  545.         $lineage[$class] = substr($exportedFile, 1, -1);
  546.     }
  548.     private function generateProxyClasses(): array
  549.     {
  550.         $proxyClasses = [];
  551.         $alreadyGenerated = [];
  552.         $definitions = $this->container->getDefinitions();
  553.         $strip = '' === $this->docStar && method_exists(Kernel::class, 'stripComments');
  554.         $proxyDumper = $this->getProxyDumper();
  555.         ksort($definitions);
  556.         foreach ($definitions as $definition) {
  557.             if (!$proxyDumper->isProxyCandidate($definition)) {
  558.                 continue;
  559.             }
  560.             if (isset($alreadyGenerated[$class = $definition->getClass()])) {
  561.                 continue;
  562.             }
  563.             $alreadyGenerated[$class] = true;
  564.             // register class' reflector for resource tracking
  565.             $this->container->getReflectionClass($class);
  566.             if ("\n" === $proxyCode = "\n".$proxyDumper->getProxyCode($definition)) {
  567.                 continue;
  568.             }
  570.             if ($this->inlineRequires) {
  571.                 $lineage = [];
  572.                 $this->collectLineage($class, $lineage);
  574.                 $code = '';
  575.                 foreach (array_diff_key(array_flip($lineage), $this->inlinedRequires) as $file => $class) {
  576.                     if ($this->inlineFactories) {
  577.                         $this->inlinedRequires[$file] = true;
  578.                     }
  579.                     $code .= sprintf("include_once %s;\n", $file);
  580.                 }
  582.                 $proxyCode = $code.$proxyCode;
  583.             }
  585.             if ($strip) {
  586.                 $proxyCode = "<?php\n".$proxyCode;
  587.                 $proxyCode = substr(Kernel::stripComments($proxyCode), 5);
  588.             }
  590.             $proxyClass = explode(' ', $this->inlineRequires ? substr($proxyCode, \strlen($code)) : $proxyCode, 3)[1];
  592.             if ($this->asFiles || $this->namespace) {
  593.                 $proxyCode .= "\nif (!\\class_exists('$proxyClass', false)) {\n    \\class_alias(__NAMESPACE__.'\\\\$proxyClass', '$proxyClass', false);\n}\n";
  594.             }
  596.             $proxyClasses[$proxyClass.'.php'] = $proxyCode;
  597.         }
  599.         return $proxyClasses;
  600.     }
  602.     private function addServiceInclude(string $cId, Definition $definition): string
  603.     {
  604.         $code = '';
  606.         if ($this->inlineRequires && (!$this->isHotPath($definition) || $this->getProxyDumper()->isProxyCandidate($definition))) {
  607.             $lineage = [];
  608.             foreach ($this->inlinedDefinitions as $def) {
  609.                 if (!$def->isDeprecated()) {
  610.                     foreach ($this->getClasses($def, $cId) as $class) {
  611.                         $this->collectLineage($class, $lineage);
  612.                     }
  613.                 }
  614.             }
  616.             foreach ($this->serviceCalls as $id => [$callCount, $behavior]) {
  617.                 if ('service_container' !== $id && $id !== $cId
  618.                     && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE !== $behavior
  619.                     && $this->container->has($id)
  620.                     && $this->isTrivialInstance($def = $this->container->findDefinition($id))
  621.                 ) {
  622.                     foreach ($this->getClasses($def, $cId) as $class) {
  623.                         $this->collectLineage($class, $lineage);
  624.                     }
  625.                 }
  626.             }
  628.             foreach (array_diff_key(array_flip($lineage), $this->inlinedRequires) as $file => $class) {
  629.                 $code .= sprintf("        include_once %s;\n", $file);
  630.             }
  631.         }
  633.         foreach ($this->inlinedDefinitions as $def) {
  634.             if ($file = $def->getFile()) {
  635.                 $file = $this->dumpValue($file);
  636.                 $file = '(' === $file[0] ? substr($file, 1, -1) : $file;
  637.                 $code .= sprintf("        include_once %s;\n", $file);
  638.             }
  639.         }
  641.         if ('' !== $code) {
  642.             $code .= "\n";
  643.         }
  645.         return $code;
  646.     }
  648.     /**
  649.      * @throws InvalidArgumentException
  650.      * @throws RuntimeException
  651.      */
  652.     private function addServiceInstance(string $id, Definition $definition, bool $isSimpleInstance): string
  653.     {
  654.         $class = $this->dumpValue($definition->getClass());
  656.         if (str_starts_with($class, "'") && !str_contains($class, '$') && !preg_match('/^\'(?:\\\{2})?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*(?:\\\{2}[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)*\'$/', $class)) {
  657.             throw new InvalidArgumentException(sprintf('"%s" is not a valid class name for the "%s" service.', $class, $id));
  658.         }
  660.         $isProxyCandidate = $this->getProxyDumper()->isProxyCandidate($definition);
  661.         $instantiation = '';
  663.         $lastWitherIndex = null;
  664.         foreach ($definition->getMethodCalls() as $k => $call) {
  665.             if ($call[2] ?? false) {
  666.                 $lastWitherIndex = $k;
  667.             }
  668.         }
  670.         if (!$isProxyCandidate && $definition->isShared() && !isset($this->singleUsePrivateIds[$id]) && null === $lastWitherIndex) {
  671.             $instantiation = sprintf('$this->%s[%s] = %s', $this->container->getDefinition($id)->isPublic() ? 'services' : 'privates', $this->doExport($id), $isSimpleInstance ? '' : '$instance');
  672.         } elseif (!$isSimpleInstance) {
  673.             $instantiation = '$instance';
  674.         }
  676.         $return = '';
  677.         if ($isSimpleInstance) {
  678.             $return = 'return ';
  679.         } else {
  680.             $instantiation .= ' = ';
  681.         }
  683.         return $this->addNewInstance($definition, '        '.$return.$instantiation, $id);
  684.     }
  686.     private function isTrivialInstance(Definition $definition): bool
  687.     {
  688.         if ($definition->hasErrors()) {
  689.             return true;
  690.         }
  691.         if ($definition->isSynthetic() || $definition->getFile() || $definition->getMethodCalls() || $definition->getProperties() || $definition->getConfigurator()) {
  692.             return false;
  693.         }
  694.         if ($definition->isDeprecated() || $definition->isLazy() || $definition->getFactory() || 3 < \count($definition->getArguments())) {
  695.             return false;
  696.         }
  698.         foreach ($definition->getArguments() as $arg) {
  699.             if (!$arg || $arg instanceof Parameter) {
  700.                 continue;
  701.             }
  702.             if (\is_array($arg) && 3 >= \count($arg)) {
  703.                 foreach ($arg as $k => $v) {
  704.                     if ($this->dumpValue($k) !== $this->dumpValue($k, false)) {
  705.                         return false;
  706.                     }
  707.                     if (!$v || $v instanceof Parameter) {
  708.                         continue;
  709.                     }
  710.                     if ($v instanceof Reference && $this->container->has($id = (string) $v) && $this->container->findDefinition($id)->isSynthetic()) {
  711.                         continue;
  712.                     }
  713.                     if (!\is_scalar($v) || $this->dumpValue($v) !== $this->dumpValue($v, false)) {
  714.                         return false;
  715.                     }
  716.                 }
  717.             } elseif ($arg instanceof Reference && $this->container->has($id = (string) $arg) && $this->container->findDefinition($id)->isSynthetic()) {
  718.                 continue;
  719.             } elseif (!\is_scalar($arg) || $this->dumpValue($arg) !== $this->dumpValue($arg, false)) {
  720.                 return false;
  721.             }
  722.         }
  724.         return true;
  725.     }
  727.     private function addServiceMethodCalls(Definition $definition, string $variableName, ?string $sharedNonLazyId): string
  728.     {
  729.         $lastWitherIndex = null;
  730.         foreach ($definition->getMethodCalls() as $k => $call) {
  731.             if ($call[2] ?? false) {
  732.                 $lastWitherIndex = $k;
  733.             }
  734.         }
  736.         $calls = '';
  737.         foreach ($definition->getMethodCalls() as $k => $call) {
  738.             $arguments = [];
  739.             foreach ($call[1] as $i => $value) {
  740.                 $arguments[] = (\is_string($i) ? $i.': ' : '').$this->dumpValue($value);
  741.             }
  743.             $witherAssignation = '';
  745.             if ($call[2] ?? false) {
  746.                 if (null !== $sharedNonLazyId && $lastWitherIndex === $k && 'instance' === $variableName) {
  747.                     $witherAssignation = sprintf('$this->%s[\'%s\'] = ', $definition->isPublic() ? 'services' : 'privates', $sharedNonLazyId);
  748.                 }
  749.                 $witherAssignation .= sprintf('$%s = ', $variableName);
  750.             }
  752.             $calls .= $this->wrapServiceConditionals($call[1], sprintf("        %s\$%s->%s(%s);\n", $witherAssignation, $variableName, $call[0], implode(', ', $arguments)));
  753.         }
  755.         return $calls;
  756.     }
  758.     private function addServiceProperties(Definition $definition, string $variableName = 'instance'): string
  759.     {
  760.         $code = '';
  761.         foreach ($definition->getProperties() as $name => $value) {
  762.             $code .= sprintf("        \$%s->%s = %s;\n", $variableName, $name, $this->dumpValue($value));
  763.         }
  765.         return $code;
  766.     }
  768.     private function addServiceConfigurator(Definition $definition, string $variableName = 'instance'): string
  769.     {
  770.         if (!$callable = $definition->getConfigurator()) {
  771.             return '';
  772.         }
  774.         if (\is_array($callable)) {
  775.             if ($callable[0] instanceof Reference
  776.                 || ($callable[0] instanceof Definition && $this->definitionVariables->contains($callable[0]))
  777.             ) {
  778.                 return sprintf("        %s->%s(\$%s);\n", $this->dumpValue($callable[0]), $callable[1], $variableName);
  779.             }
  781.             $class = $this->dumpValue($callable[0]);
  782.             // If the class is a string we can optimize away
  783.             if (str_starts_with($class, "'") && !str_contains($class, '$')) {
  784.                 return sprintf("        %s::%s(\$%s);\n", $this->dumpLiteralClass($class), $callable[1], $variableName);
  785.             }
  787.             if (str_starts_with($class, 'new ')) {
  788.                 return sprintf("        (%s)->%s(\$%s);\n", $this->dumpValue($callable[0]), $callable[1], $variableName);
  789.             }
  791.             return sprintf("        [%s, '%s'](\$%s);\n", $this->dumpValue($callable[0]), $callable[1], $variableName);
  792.         }
  794.         return sprintf("        %s(\$%s);\n", $callable, $variableName);
  795.     }
  797.     private function addService(string $id, Definition $definition): array
  798.     {
  799.         $this->definitionVariables = new \SplObjectStorage();
  800.         $this->referenceVariables = [];
  801.         $this->variableCount = 0;
  802.         $this->referenceVariables[$id] = new Variable('instance');
  804.         $return = [];
  806.         if ($class = $definition->getClass()) {
  807.             $class = $class instanceof Parameter ? '%'.$class.'%' : $this->container->resolveEnvPlaceholders($class);
  808.             $return[] = sprintf(str_starts_with($class, '%') ? '@return object A %1$s instance' : '@return \%s', ltrim($class, '\\'));
  809.         } elseif ($definition->getFactory()) {
  810.             $factory = $definition->getFactory();
  811.             if (\is_string($factory) && !str_starts_with($factory, '@=')) {
  812.                 $return[] = sprintf('@return object An instance returned by %s()', $factory);
  813.             } elseif (\is_array($factory) && (\is_string($factory[0]) || $factory[0] instanceof Definition || $factory[0] instanceof Reference)) {
  814.                 $class = $factory[0] instanceof Definition ? $factory[0]->getClass() : (string) $factory[0];
  815.                 $class = $class instanceof Parameter ? '%'.$class.'%' : $this->container->resolveEnvPlaceholders($class);
  816.                 $return[] = sprintf('@return object An instance returned by %s::%s()', $class, $factory[1]);
  817.             }
  818.         }
  820.         if ($definition->isDeprecated()) {
  821.             if ($return && str_starts_with($return[\count($return) - 1], '@return')) {
  822.                 $return[] = '';
  823.             }
  825.             $deprecation = $definition->getDeprecation($id);
  826.             $return[] = sprintf('@deprecated %s', ($deprecation['package'] || $deprecation['version'] ? "Since {$deprecation['package']} {$deprecation['version']}: " : '').$deprecation['message']);
  827.         }
  829.         $return = str_replace("\n     * \n", "\n     *\n", implode("\n     * ", $return));
  830.         $return = $this->container->resolveEnvPlaceholders($return);
  832.         $shared = $definition->isShared() ? ' shared' : '';
  833.         $public = $definition->isPublic() ? 'public' : 'private';
  834.         $autowired = $definition->isAutowired() ? ' autowired' : '';
  835.         $asFile = $this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition);
  836.         $methodName = $this->generateMethodName($id);
  838.         if ($asFile || $definition->isLazy()) {
  839.             $lazyInitialization = '$lazyLoad = true';
  840.         } else {
  841.             $lazyInitialization = '';
  842.         }
  844.         $code = <<<EOF
  846.     /*{$this->docStar}
  847.      * Gets the $public '$id'$shared$autowired service.
  848.      *
  849.      * $return
  850. EOF;
  851.         $code = str_replace('*/', ' ', $code).<<<EOF
  853.      */
  854.     protected function {$methodName}($lazyInitialization)
  855.     {
  857. EOF;
  859.         if ($asFile) {
  860.             $file = $methodName.'.php';
  861.             $code = str_replace("protected function {$methodName}(", 'public static function do($container, ', $code);
  862.         } else {
  863.             $file = null;
  864.         }
  866.         if ($definition->hasErrors() && $e = $definition->getErrors()) {
  867.             $code .= sprintf("        throw new RuntimeException(%s);\n", $this->export(reset($e)));
  868.         } else {
  869.             $this->serviceCalls = [];
  870.             $this->inlinedDefinitions = $this->getDefinitionsFromArguments([$definition], null, $this->serviceCalls);
  872.             if ($definition->isDeprecated()) {
  873.                 $deprecation = $definition->getDeprecation($id);
  874.                 $code .= sprintf("        trigger_deprecation(%s, %s, %s);\n\n", $this->export($deprecation['package']), $this->export($deprecation['version']), $this->export($deprecation['message']));
  875.             } elseif ($definition->hasTag($this->hotPathTag) || !$definition->hasTag($this->preloadTags[1])) {
  876.                 foreach ($this->inlinedDefinitions as $def) {
  877.                     foreach ($this->getClasses($def, $id) as $class) {
  878.                         $this->preload[$class] = $class;
  879.                     }
  880.                 }
  881.             }
  883.             if (!$definition->isShared()) {
  884.                 $factory = sprintf('$this->factories%s[%s]', $definition->isPublic() ? '' : "['service_container']", $this->doExport($id));
  885.             }
  887.             if ($isProxyCandidate = $this->getProxyDumper()->isProxyCandidate($definition)) {
  888.                 if (!$definition->isShared()) {
  889.                     $code .= sprintf('        %s = %1$s ?? ', $factory);
  891.                     if ($asFile) {
  892.                         $code .= "function () {\n";
  893.                         $code .= "            return self::do(\$container);\n";
  894.                         $code .= "        };\n\n";
  895.                     } else {
  896.                         $code .= sprintf("\$this->%s(...);\n\n", $methodName);
  897.                     }
  898.                 }
  900.                 $factoryCode = $asFile ? 'self::do($container, false)' : sprintf('$this->%s(false)', $methodName);
  901.                 $factoryCode = $this->getProxyDumper()->getProxyFactoryCode($definition, $id, $factoryCode);
  902.                 $code .= $asFile ? preg_replace('/function \(([^)]*+)\)( {|:)/', 'function (\1) use ($container)\2', $factoryCode) : $factoryCode;
  903.             }
  905.             $c = $this->addServiceInclude($id, $definition);
  907.             if ('' !== $c && $isProxyCandidate && !$definition->isShared()) {
  908.                 $c = implode("\n", array_map(function ($line) { return $line ? '    '.$line : $line; }, explode("\n", $c)));
  909.                 $code .= "        static \$include = true;\n\n";
  910.                 $code .= "        if (\$include) {\n";
  911.                 $code .= $c;
  912.                 $code .= "            \$include = false;\n";
  913.                 $code .= "        }\n\n";
  914.             } else {
  915.                 $code .= $c;
  916.             }
  918.             $c = $this->addInlineService($id, $definition);
  920.             if (!$isProxyCandidate && !$definition->isShared()) {
  921.                 $c = implode("\n", array_map(function ($line) { return $line ? '    '.$line : $line; }, explode("\n", $c)));
  922.                 $lazyloadInitialization = $definition->isLazy() ? '$lazyLoad = true' : '';
  924.                 $c = sprintf("        %s = function (%s) {\n%s        };\n\n        return %1\$s();\n", $factory, $lazyloadInitialization, $c);
  925.             }
  927.             $code .= $c;
  928.         }
  930.         if ($asFile) {
  931.             $code = str_replace('$this', '$container', $code);
  932.             $code = preg_replace('/function \(([^)]*+)\)( {|:)/', 'function (\1) use ($container)\2', $code);
  933.         }
  935.         $code .= "    }\n";
  937.         $this->definitionVariables = $this->inlinedDefinitions = null;
  938.         $this->referenceVariables = $this->serviceCalls = null;
  940.         return [$file, $code];
  941.     }
  943.     private function addInlineVariables(string $id, Definition $definition, array $arguments, bool $forConstructor): string
  944.     {
  945.         $code = '';
  947.         foreach ($arguments as $argument) {
  948.             if (\is_array($argument)) {
  949.                 $code .= $this->addInlineVariables($id, $definition, $argument, $forConstructor);
  950.             } elseif ($argument instanceof Reference) {
  951.                 $code .= $this->addInlineReference($id, $definition, $argument, $forConstructor);
  952.             } elseif ($argument instanceof Definition) {
  953.                 $code .= $this->addInlineService($id, $definition, $argument, $forConstructor);
  954.             }
  955.         }
  957.         return $code;
  958.     }
  960.     private function addInlineReference(string $id, Definition $definition, string $targetId, bool $forConstructor): string
  961.     {
  962.         while ($this->container->hasAlias($targetId)) {
  963.             $targetId = (string) $this->container->getAlias($targetId);
  964.         }
  966.         [$callCount, $behavior] = $this->serviceCalls[$targetId];
  968.         if ($id === $targetId) {
  969.             return $this->addInlineService($id, $definition, $definition);
  970.         }
  972.         if ('service_container' === $targetId || isset($this->referenceVariables[$targetId])) {
  973.             return '';
  974.         }
  976.         if ($this->container->hasDefinition($targetId) && ($def = $this->container->getDefinition($targetId)) && !$def->isShared()) {
  977.             return '';
  978.         }
  980.         $hasSelfRef = isset($this->circularReferences[$id][$targetId]) && !isset($this->definitionVariables[$definition]) && !($this->hasProxyDumper && $definition->isLazy());
  982.         if ($hasSelfRef && !$forConstructor && !$forConstructor = !$this->circularReferences[$id][$targetId]) {
  983.             $code = $this->addInlineService($id, $definition, $definition);
  984.         } else {
  985.             $code = '';
  986.         }
  988.         if (isset($this->referenceVariables[$targetId]) || (2 > $callCount && (!$hasSelfRef || !$forConstructor))) {
  989.             return $code;
  990.         }
  992.         $name = $this->getNextVariableName();
  993.         $this->referenceVariables[$targetId] = new Variable($name);
  995.         $reference = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $behavior ? new Reference($targetId, $behavior) : null;
  996.         $code .= sprintf("        \$%s = %s;\n", $name, $this->getServiceCall($targetId, $reference));
  998.         if (!$hasSelfRef || !$forConstructor) {
  999.             return $code;
  1000.         }
  1002.         $code .= sprintf(<<<'EOTXT'
  1004.         if (isset($this->%s[%s])) {
  1005.             return $this->%1$s[%2$s];
  1006.         }
  1008. EOTXT
  1009.             ,
  1010.             $this->container->getDefinition($id)->isPublic() ? 'services' : 'privates',
  1011.             $this->doExport($id)
  1012.         );
  1014.         return $code;
  1015.     }
  1017.     private function addInlineService(string $id, Definition $definition, Definition $inlineDef = null, bool $forConstructor = true): string
  1018.     {
  1019.         $code = '';
  1021.         if ($isSimpleInstance = $isRootInstance = null === $inlineDef) {
  1022.             foreach ($this->serviceCalls as $targetId => [$callCount, $behavior, $byConstructor]) {
  1023.                 if ($byConstructor && isset($this->circularReferences[$id][$targetId]) && !$this->circularReferences[$id][$targetId] && !($this->hasProxyDumper && $definition->isLazy())) {
  1024.                     $code .= $this->addInlineReference($id, $definition, $targetId, $forConstructor);
  1025.                 }
  1026.             }
  1027.         }
  1029.         if (isset($this->definitionVariables[$inlineDef = $inlineDef ?: $definition])) {
  1030.             return $code;
  1031.         }
  1033.         $arguments = [$inlineDef->getArguments(), $inlineDef->getFactory()];
  1035.         $code .= $this->addInlineVariables($id, $definition, $arguments, $forConstructor);
  1037.         if ($arguments = array_filter([$inlineDef->getProperties(), $inlineDef->getMethodCalls(), $inlineDef->getConfigurator()])) {
  1038.             $isSimpleInstance = false;
  1039.         } elseif ($definition !== $inlineDef && 2 > $this->inlinedDefinitions[$inlineDef]) {
  1040.             return $code;
  1041.         }
  1043.         if (isset($this->definitionVariables[$inlineDef])) {
  1044.             $isSimpleInstance = false;
  1045.         } else {
  1046.             $name = $definition === $inlineDef ? 'instance' : $this->getNextVariableName();
  1047.             $this->definitionVariables[$inlineDef] = new Variable($name);
  1048.             $code .= '' !== $code ? "\n" : '';
  1050.             if ('instance' === $name) {
  1051.                 $code .= $this->addServiceInstance($id, $definition, $isSimpleInstance);
  1052.             } else {
  1053.                 $code .= $this->addNewInstance($inlineDef, '        $'.$name.' = ', $id);
  1054.             }
  1056.             if ('' !== $inline = $this->addInlineVariables($id, $definition, $arguments, false)) {
  1057.                 $code .= "\n".$inline."\n";
  1058.             } elseif ($arguments && 'instance' === $name) {
  1059.                 $code .= "\n";
  1060.             }
  1062.             $code .= $this->addServiceProperties($inlineDef, $name);
  1063.             $code .= $this->addServiceMethodCalls($inlineDef, $name, !$this->getProxyDumper()->isProxyCandidate($inlineDef) && $inlineDef->isShared() && !isset($this->singleUsePrivateIds[$id]) ? $id : null);
  1064.             $code .= $this->addServiceConfigurator($inlineDef, $name);
  1065.         }
  1067.         if ($isRootInstance && !$isSimpleInstance) {
  1068.             $code .= "\n        return \$instance;\n";
  1069.         }
  1071.         return $code;
  1072.     }
  1074.     private function addServices(array &$services = null): string
  1075.     {
  1076.         $publicServices = $privateServices = '';
  1077.         $definitions = $this->container->getDefinitions();
  1078.         ksort($definitions);
  1079.         foreach ($definitions as $id => $definition) {
  1080.             if (!$definition->isSynthetic()) {
  1081.                 $services[$id] = $this->addService($id, $definition);
  1082.             } elseif ($definition->hasTag($this->hotPathTag) || !$definition->hasTag($this->preloadTags[1])) {
  1083.                 $services[$id] = null;
  1085.                 foreach ($this->getClasses($definition, $id) as $class) {
  1086.                     $this->preload[$class] = $class;
  1087.                 }
  1088.             }
  1089.         }
  1091.         foreach ($definitions as $id => $definition) {
  1092.             if (!([$file, $code] = $services[$id]) || null !== $file) {
  1093.                 continue;
  1094.             }
  1095.             if ($definition->isPublic()) {
  1096.                 $publicServices .= $code;
  1097.             } elseif (!$this->isTrivialInstance($definition) || isset($this->locatedIds[$id])) {
  1098.                 $privateServices .= $code;
  1099.             }
  1100.         }
  1102.         return $publicServices.$privateServices;
  1103.     }
  1105.     private function generateServiceFiles(array $services): iterable
  1106.     {
  1107.         $definitions = $this->container->getDefinitions();
  1108.         ksort($definitions);
  1109.         foreach ($definitions as $id => $definition) {
  1110.             if (([$file, $code] = $services[$id]) && null !== $file && ($definition->isPublic() || !$this->isTrivialInstance($definition) || isset($this->locatedIds[$id]))) {
  1111.                 yield $file => [$code, $definition->hasTag($this->hotPathTag) || !$definition->hasTag($this->preloadTags[1]) && !$definition->isDeprecated() && !$definition->hasErrors()];
  1112.             }
  1113.         }
  1114.     }
  1116.     private function addNewInstance(Definition $definition, string $return = '', string $id = null): string
  1117.     {
  1118.         $tail = $return ? ";\n" : '';
  1120.         if (BaseServiceLocator::class === $definition->getClass() && $definition->hasTag($this->serviceLocatorTag)) {
  1121.             $arguments = [];
  1122.             foreach ($definition->getArgument(0) as $k => $argument) {
  1123.                 $arguments[$k] = $argument->getValues()[0];
  1124.             }
  1126.             return $return.$this->dumpValue(new ServiceLocatorArgument($arguments)).$tail;
  1127.         }
  1129.         $arguments = [];
  1130.         foreach ($definition->getArguments() as $i => $value) {
  1131.             $arguments[] = (\is_string($i) ? $i.': ' : '').$this->dumpValue($value);
  1132.         }
  1134.         if (null !== $definition->getFactory()) {
  1135.             $callable = $definition->getFactory();
  1137.             if (['Closure', 'fromCallable'] === $callable && [0] === array_keys($definition->getArguments())) {
  1138.                 $callable = $definition->getArgument(0);
  1139.                 $arguments = ['...'];
  1141.                 if ($callable instanceof Reference || $callable instanceof Definition) {
  1142.                     $callable = [$callable, '__invoke'];
  1143.                 }
  1144.             }
  1146.             if (\is_array($callable)) {
  1147.                 if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $callable[1])) {
  1148.                     throw new RuntimeException(sprintf('Cannot dump definition because of invalid factory method (%s).', $callable[1] ?: 'n/a'));
  1149.                 }
  1151.                 if ($callable[0] instanceof Reference
  1152.                     || ($callable[0] instanceof Definition && $this->definitionVariables->contains($callable[0]))) {
  1153.                     return $return.sprintf('%s->%s(%s)', $this->dumpValue($callable[0]), $callable[1], $arguments ? implode(', ', $arguments) : '').$tail;
  1154.                 }
  1156.                 $class = $this->dumpValue($callable[0]);
  1157.                 // If the class is a string we can optimize away
  1158.                 if (str_starts_with($class, "'") && !str_contains($class, '$')) {
  1159.                     if ("''" === $class) {
  1160.                         throw new RuntimeException(sprintf('Cannot dump definition: "%s" service is defined to be created by a factory but is missing the service reference, did you forget to define the factory service id or class?', $id ? 'The "'.$id.'"' : 'inline'));
  1161.                     }
  1163.                     return $return.sprintf('%s::%s(%s)', $this->dumpLiteralClass($class), $callable[1], $arguments ? implode(', ', $arguments) : '').$tail;
  1164.                 }
  1166.                 if (str_starts_with($class, 'new ')) {
  1167.                     return $return.sprintf('(%s)->%s(%s)', $class, $callable[1], $arguments ? implode(', ', $arguments) : '').$tail;
  1168.                 }
  1170.                 return $return.sprintf("[%s, '%s'](%s)", $class, $callable[1], $arguments ? implode(', ', $arguments) : '').$tail;
  1171.             }
  1173.             if (\is_string($callable) && str_starts_with($callable, '@=')) {
  1174.                 return $return.sprintf('(($args = %s) ? (%s) : null)',
  1175.                     $this->dumpValue(new ServiceLocatorArgument($definition->getArguments())),
  1176.                     $this->getExpressionLanguage()->compile(substr($callable, 2), ['this' => 'container', 'args' => 'args'])
  1177.                 ).$tail;
  1178.             }
  1180.             return $return.sprintf('%s(%s)', $this->dumpLiteralClass($this->dumpValue($callable)), $arguments ? implode(', ', $arguments) : '').$tail;
  1181.         }
  1183.         if (null === $class = $definition->getClass()) {
  1184.             throw new RuntimeException('Cannot dump definitions which have no class nor factory.');
  1185.         }
  1187.         return $return.sprintf('new %s(%s)', $this->dumpLiteralClass($this->dumpValue($class)), implode(', ', $arguments)).$tail;
  1188.     }
  1190.     private function startClass(string $class, string $baseClass, bool $hasProxyClasses): string
  1191.     {
  1192.         $namespaceLine = !$this->asFiles && $this->namespace ? "\nnamespace {$this->namespace};\n" : '';
  1194.         $code = <<<EOF
  1195. <?php
  1196. $namespaceLine
  1197. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  1198. use Symfony\Component\DependencyInjection\ContainerInterface;
  1199. use Symfony\Component\DependencyInjection\Container;
  1200. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  1201. use Symfony\Component\DependencyInjection\Exception\LogicException;
  1202. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  1203. use Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag;
  1204. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  1206. /*{$this->docStar}
  1207.  * @internal This class has been auto-generated by the Symfony Dependency Injection Component.
  1208.  */
  1209. class $class extends $baseClass
  1210. {
  1211.     protected \$parameters = [];
  1213.     public function __construct()
  1214.     {
  1216. EOF;
  1217.         if ($this->asFiles) {
  1218.             $code = str_replace('$parameters = []', "\$containerDir;\n    protected \$parameters = [];\n    private \$buildParameters", $code);
  1219.             $code = str_replace('__construct()', '__construct(array $buildParameters = [], $containerDir = __DIR__)', $code);
  1220.             $code .= "        \$this->buildParameters = \$buildParameters;\n";
  1221.             $code .= "        \$this->containerDir = \$containerDir;\n";
  1223.             if (null !== $this->targetDirRegex) {
  1224.                 $code = str_replace('$parameters = []', "\$targetDir;\n    protected \$parameters = []", $code);
  1225.                 $code .= '        $this->targetDir = \\dirname($containerDir);'."\n";
  1226.             }
  1227.         }
  1229.         if (Container::class !== $this->baseClass) {
  1230.             $r = $this->container->getReflectionClass($this->baseClass, false);
  1231.             if (null !== $r
  1232.                 && (null !== $constructor = $r->getConstructor())
  1233.                 && 0 === $constructor->getNumberOfRequiredParameters()
  1234.                 && Container::class !== $constructor->getDeclaringClass()->name
  1235.             ) {
  1236.                 $code .= "        parent::__construct();\n";
  1237.                 $code .= "        \$this->parameterBag = null;\n\n";
  1238.             }
  1239.         }
  1241.         if ($this->container->getParameterBag()->all()) {
  1242.             $code .= "        \$this->parameters = \$this->getDefaultParameters();\n\n";
  1243.         }
  1244.         $code .= "        \$this->services = \$this->privates = [];\n";
  1246.         $code .= $this->addSyntheticIds();
  1247.         $code .= $this->addMethodMap();
  1248.         $code .= $this->asFiles && !$this->inlineFactories ? $this->addFileMap() : '';
  1249.         $code .= $this->addAliases();
  1250.         $code .= $this->addInlineRequires($hasProxyClasses);
  1251.         $code .= <<<EOF
  1252.     }
  1254.     public function compile(): void
  1255.     {
  1256.         throw new LogicException('You cannot compile a dumped container that was already compiled.');
  1257.     }
  1259.     public function isCompiled(): bool
  1260.     {
  1261.         return true;
  1262.     }
  1264. EOF;
  1265.         $code .= $this->addRemovedIds();
  1267.         if ($this->asFiles && !$this->inlineFactories) {
  1268.             $code .= <<<'EOF'
  1270.     protected function load($file, $lazyLoad = true)
  1271.     {
  1272.         if (class_exists($class = __NAMESPACE__.'\\'.$file, false)) {
  1273.             return $class::do($this, $lazyLoad);
  1274.         }
  1276.         if ('.' === $file[-4]) {
  1277.             $class = substr($class, 0, -4);
  1278.         } else {
  1279.             $file .= '.php';
  1280.         }
  1282.         $service = require $this->containerDir.\DIRECTORY_SEPARATOR.$file;
  1284.         return class_exists($class, false) ? $class::do($this, $lazyLoad) : $service;
  1285.     }
  1287. EOF;
  1288.         }
  1290.         $proxyDumper = $this->getProxyDumper();
  1291.         foreach ($this->container->getDefinitions() as $definition) {
  1292.             if (!$proxyDumper->isProxyCandidate($definition)) {
  1293.                 continue;
  1294.             }
  1296.             if ($this->asFiles && !$this->inlineFactories) {
  1297.                 $proxyLoader = "class_exists(\$class, false) || require __DIR__.'/'.\$class.'.php';\n\n        ";
  1298.             } else {
  1299.                 $proxyLoader = '';
  1300.             }
  1302.             $code .= <<<EOF
  1304.     protected function createProxy(\$class, \Closure \$factory)
  1305.     {
  1306.         {$proxyLoader}return \$factory();
  1307.     }
  1309. EOF;
  1310.             break;
  1311.         }
  1313.         return $code;
  1314.     }
  1316.     private function addSyntheticIds(): string
  1317.     {
  1318.         $code = '';
  1319.         $definitions = $this->container->getDefinitions();
  1320.         ksort($definitions);
  1321.         foreach ($definitions as $id => $definition) {
  1322.             if ($definition->isSynthetic() && 'service_container' !== $id) {
  1323.                 $code .= '            '.$this->doExport($id)." => true,\n";
  1324.             }
  1325.         }
  1327.         return $code ? "        \$this->syntheticIds = [\n{$code}        ];\n" : '';
  1328.     }
  1330.     private function addRemovedIds(): string
  1331.     {
  1332.         $ids = $this->container->getRemovedIds();
  1333.         foreach ($this->container->getDefinitions() as $id => $definition) {
  1334.             if (!$definition->isPublic()) {
  1335.                 $ids[$id] = true;
  1336.             }
  1337.         }
  1338.         if (!$ids) {
  1339.             return '';
  1340.         }
  1341.         if ($this->asFiles) {
  1342.             $code = "require \$this->containerDir.\\DIRECTORY_SEPARATOR.'removed-ids.php'";
  1343.         } else {
  1344.             $code = '';
  1345.             $ids = array_keys($ids);
  1346.             sort($ids);
  1347.             foreach ($ids as $id) {
  1348.                 if (preg_match(FileLoader::ANONYMOUS_ID_REGEXP, $id)) {
  1349.                     continue;
  1350.                 }
  1351.                 $code .= '            '.$this->doExport($id)." => true,\n";
  1352.             }
  1354.             $code = "[\n{$code}        ]";
  1355.         }
  1357.         return <<<EOF
  1359.     public function getRemovedIds(): array
  1360.     {
  1361.         return {$code};
  1362.     }
  1364. EOF;
  1365.     }
  1367.     private function addMethodMap(): string
  1368.     {
  1369.         $code = '';
  1370.         $definitions = $this->container->getDefinitions();
  1371.         ksort($definitions);
  1372.         foreach ($definitions as $id => $definition) {
  1373.             if (!$definition->isSynthetic() && $definition->isPublic() && (!$this->asFiles || $this->inlineFactories || $this->isHotPath($definition))) {
  1374.                 $code .= '            '.$this->doExport($id).' => '.$this->doExport($this->generateMethodName($id)).",\n";
  1375.             }
  1376.         }
  1378.         $aliases = $this->container->getAliases();
  1379.         foreach ($aliases as $alias => $id) {
  1380.             if (!$id->isDeprecated()) {
  1381.                 continue;
  1382.             }
  1383.             $code .= '            '.$this->doExport($alias).' => '.$this->doExport($this->generateMethodName($alias)).",\n";
  1384.         }
  1386.         return $code ? "        \$this->methodMap = [\n{$code}        ];\n" : '';
  1387.     }
  1389.     private function addFileMap(): string
  1390.     {
  1391.         $code = '';
  1392.         $definitions = $this->container->getDefinitions();
  1393.         ksort($definitions);
  1394.         foreach ($definitions as $id => $definition) {
  1395.             if (!$definition->isSynthetic() && $definition->isPublic() && !$this->isHotPath($definition)) {
  1396.                 $code .= sprintf("            %s => '%s',\n", $this->doExport($id), $this->generateMethodName($id));
  1397.             }
  1398.         }
  1400.         return $code ? "        \$this->fileMap = [\n{$code}        ];\n" : '';
  1401.     }
  1403.     private function addAliases(): string
  1404.     {
  1405.         if (!$aliases = $this->container->getAliases()) {
  1406.             return "\n        \$this->aliases = [];\n";
  1407.         }
  1409.         $code = "        \$this->aliases = [\n";
  1410.         ksort($aliases);
  1411.         foreach ($aliases as $alias => $id) {
  1412.             if ($id->isDeprecated()) {
  1413.                 continue;
  1414.             }
  1416.             $id = (string) $id;
  1417.             while (isset($aliases[$id])) {
  1418.                 $id = (string) $aliases[$id];
  1419.             }
  1420.             $code .= '            '.$this->doExport($alias).' => '.$this->doExport($id).",\n";
  1421.         }
  1423.         return $code."        ];\n";
  1424.     }
  1426.     private function addDeprecatedAliases(): string
  1427.     {
  1428.         $code = '';
  1429.         $aliases = $this->container->getAliases();
  1430.         foreach ($aliases as $alias => $definition) {
  1431.             if (!$definition->isDeprecated()) {
  1432.                 continue;
  1433.             }
  1434.             $public = $definition->isPublic() ? 'public' : 'private';
  1435.             $id = (string) $definition;
  1436.             $methodNameAlias = $this->generateMethodName($alias);
  1437.             $idExported = $this->export($id);
  1438.             $deprecation = $definition->getDeprecation($alias);
  1439.             $packageExported = $this->export($deprecation['package']);
  1440.             $versionExported = $this->export($deprecation['version']);
  1441.             $messageExported = $this->export($deprecation['message']);
  1442.             $code .= <<<EOF
  1444.     /*{$this->docStar}
  1445.      * Gets the $public '$alias' alias.
  1446.      *
  1447.      * @return object The "$id" service.
  1448.      */
  1449.     protected function {$methodNameAlias}()
  1450.     {
  1451.         trigger_deprecation($packageExported, $versionExported, $messageExported);
  1453.         return \$this->get($idExported);
  1454.     }
  1456. EOF;
  1457.         }
  1459.         return $code;
  1460.     }
  1462.     private function addInlineRequires(bool $hasProxyClasses): string
  1463.     {
  1464.         $lineage = [];
  1465.         $hotPathServices = $this->hotPathTag && $this->inlineRequires ? $this->container->findTaggedServiceIds($this->hotPathTag) : [];
  1467.         foreach ($hotPathServices as $id => $tags) {
  1468.             $definition = $this->container->getDefinition($id);
  1470.             if ($this->getProxyDumper()->isProxyCandidate($definition)) {
  1471.                 continue;
  1472.             }
  1474.             $inlinedDefinitions = $this->getDefinitionsFromArguments([$definition]);
  1476.             foreach ($inlinedDefinitions as $def) {
  1477.                 foreach ($this->getClasses($def, $id) as $class) {
  1478.                     $this->collectLineage($class, $lineage);
  1479.                 }
  1480.             }
  1481.         }
  1483.         $code = '';
  1485.         foreach ($lineage as $file) {
  1486.             if (!isset($this->inlinedRequires[$file])) {
  1487.                 $this->inlinedRequires[$file] = true;
  1488.                 $code .= sprintf("\n            include_once %s;", $file);
  1489.             }
  1490.         }
  1492.         if ($hasProxyClasses) {
  1493.             $code .= "\n            include_once __DIR__.'/proxy-classes.php';";
  1494.         }
  1496.         return $code ? sprintf("\n        \$this->privates['service_container'] = function () {%s\n        };\n", $code) : '';
  1497.     }
  1499.     private function addDefaultParametersMethod(): string
  1500.     {
  1501.         if (!$this->container->getParameterBag()->all()) {
  1502.             return '';
  1503.         }
  1505.         $php = [];
  1506.         $dynamicPhp = [];
  1508.         foreach ($this->container->getParameterBag()->all() as $key => $value) {
  1509.             if ($key !== $resolvedKey = $this->container->resolveEnvPlaceholders($key)) {
  1510.                 throw new InvalidArgumentException(sprintf('Parameter name cannot use env parameters: "%s".', $resolvedKey));
  1511.             }
  1512.             $hasEnum = false;
  1513.             $export = $this->exportParameters([$value], '', 12, $hasEnum);
  1514.             $export = explode('0 => ', substr(rtrim($export, " ]\n"), 2, -1), 2);
  1516.             if ($hasEnum || preg_match("/\\\$this->(?:getEnv\('(?:[-.\w]*+:)*+\w++'\)|targetDir\.'')/", $export[1])) {
  1517.                 $dynamicPhp[$key] = sprintf('%s%s => %s,', $export[0], $this->export($key), $export[1]);
  1518.             } else {
  1519.                 $php[] = sprintf('%s%s => %s,', $export[0], $this->export($key), $export[1]);
  1520.             }
  1521.         }
  1522.         $parameters = sprintf("[\n%s\n%s]", implode("\n", $php), str_repeat(' ', 8));
  1524.         $code = <<<'EOF'
  1526.     public function getParameter(string $name): array|bool|string|int|float|\UnitEnum|null
  1527.     {
  1528.         if (isset($this->buildParameters[$name])) {
  1529.             return $this->buildParameters[$name];
  1530.         }
  1532.         if (!(isset($this->parameters[$name]) || isset($this->loadedDynamicParameters[$name]) || \array_key_exists($name, $this->parameters))) {
  1533.             throw new InvalidArgumentException(sprintf('The parameter "%s" must be defined.', $name));
  1534.         }
  1535.         if (isset($this->loadedDynamicParameters[$name])) {
  1536.             return $this->loadedDynamicParameters[$name] ? $this->dynamicParameters[$name] : $this->getDynamicParameter($name);
  1537.         }
  1539.         return $this->parameters[$name];
  1540.     }
  1542.     public function hasParameter(string $name): bool
  1543.     {
  1544.         if (isset($this->buildParameters[$name])) {
  1545.             return true;
  1546.         }
  1548.         return isset($this->parameters[$name]) || isset($this->loadedDynamicParameters[$name]) || \array_key_exists($name, $this->parameters);
  1549.     }
  1551.     public function setParameter(string $name, $value): void
  1552.     {
  1553.         throw new LogicException('Impossible to call set() on a frozen ParameterBag.');
  1554.     }
  1556.     public function getParameterBag(): ParameterBagInterface
  1557.     {
  1558.         if (null === $this->parameterBag) {
  1559.             $parameters = $this->parameters;
  1560.             foreach ($this->loadedDynamicParameters as $name => $loaded) {
  1561.                 $parameters[$name] = $loaded ? $this->dynamicParameters[$name] : $this->getDynamicParameter($name);
  1562.             }
  1563.             foreach ($this->buildParameters as $name => $value) {
  1564.                 $parameters[$name] = $value;
  1565.             }
  1566.             $this->parameterBag = new FrozenParameterBag($parameters);
  1567.         }
  1569.         return $this->parameterBag;
  1570.     }
  1572. EOF;
  1573.         if (!$this->asFiles) {
  1574.             $code = preg_replace('/^.*buildParameters.*\n.*\n.*\n\n?/m', '', $code);
  1575.         }
  1577.         if ($dynamicPhp) {
  1578.             $loadedDynamicParameters = $this->exportParameters(array_combine(array_keys($dynamicPhp), array_fill(0, \count($dynamicPhp), false)), '', 8);
  1579.             $getDynamicParameter = <<<'EOF'
  1580.         $value = match ($name) {
  1581. %s
  1582.             default => throw new InvalidArgumentException(sprintf('The dynamic parameter "%%s" must be defined.', $name)),
  1583.         };
  1584.         $this->loadedDynamicParameters[$name] = true;
  1586.         return $this->dynamicParameters[$name] = $value;
  1587. EOF;
  1588.             $getDynamicParameter = sprintf($getDynamicParameter, implode("\n", $dynamicPhp));
  1589.         } else {
  1590.             $loadedDynamicParameters = '[]';
  1591.             $getDynamicParameter = str_repeat(' ', 8).'throw new InvalidArgumentException(sprintf(\'The dynamic parameter "%s" must be defined.\', $name));';
  1592.         }
  1594.         $code .= <<<EOF
  1596.     private \$loadedDynamicParameters = {$loadedDynamicParameters};
  1597.     private \$dynamicParameters = [];
  1599.     private function getDynamicParameter(string \$name)
  1600.     {
  1601. {$getDynamicParameter}
  1602.     }
  1604.     protected function getDefaultParameters(): array
  1605.     {
  1606.         return $parameters;
  1607.     }
  1609. EOF;
  1611.         return $code;
  1612.     }
  1614.     /**
  1615.      * @throws InvalidArgumentException
  1616.      */
  1617.     private function exportParameters(array $parameters, string $path = '', int $indent = 12, bool &$hasEnum = false): string
  1618.     {
  1619.         $php = [];
  1620.         foreach ($parameters as $key => $value) {
  1621.             if (\is_array($value)) {
  1622.                 $value = $this->exportParameters($value, $path.'/'.$key, $indent + 4, $hasEnum);
  1623.             } elseif ($value instanceof ArgumentInterface) {
  1624.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain special arguments. "%s" found in "%s".', get_debug_type($value), $path.'/'.$key));
  1625.             } elseif ($value instanceof Variable) {
  1626.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain variable references. Variable "%s" found in "%s".', $value, $path.'/'.$key));
  1627.             } elseif ($value instanceof Definition) {
  1628.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain service definitions. Definition for "%s" found in "%s".', $value->getClass(), $path.'/'.$key));
  1629.             } elseif ($value instanceof Reference) {
  1630.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain references to other services (reference to service "%s" found in "%s").', $value, $path.'/'.$key));
  1631.             } elseif ($value instanceof Expression) {
  1632.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain expressions. Expression "%s" found in "%s".', $value, $path.'/'.$key));
  1633.             } elseif ($value instanceof \UnitEnum) {
  1634.                 $hasEnum = true;
  1635.                 $value = sprintf('\%s::%s', \get_class($value), $value->name);
  1636.             } else {
  1637.                 $value = $this->export($value);
  1638.             }
  1640.             $php[] = sprintf('%s%s => %s,', str_repeat(' ', $indent), $this->export($key), $value);
  1641.         }
  1643.         return sprintf("[\n%s\n%s]", implode("\n", $php), str_repeat(' ', $indent - 4));
  1644.     }
  1646.     private function endClass(): string
  1647.     {
  1648.         return <<<'EOF'
  1649. }
  1651. EOF;
  1652.     }
  1654.     private function wrapServiceConditionals(mixed $value, string $code): string
  1655.     {
  1656.         if (!$condition = $this->getServiceConditionals($value)) {
  1657.             return $code;
  1658.         }
  1660.         // re-indent the wrapped code
  1661.         $code = implode("\n", array_map(function ($line) { return $line ? '    '.$line : $line; }, explode("\n", $code)));
  1663.         return sprintf("        if (%s) {\n%s        }\n", $condition, $code);
  1664.     }
  1666.     private function getServiceConditionals(mixed $value): string
  1667.     {
  1668.         $conditions = [];
  1669.         foreach (ContainerBuilder::getInitializedConditionals($value) as $service) {
  1670.             if (!$this->container->hasDefinition($service)) {
  1671.                 return 'false';
  1672.             }
  1673.             $conditions[] = sprintf('isset($this->%s[%s])', $this->container->getDefinition($service)->isPublic() ? 'services' : 'privates', $this->doExport($service));
  1674.         }
  1675.         foreach (ContainerBuilder::getServiceConditionals($value) as $service) {
  1676.             if ($this->container->hasDefinition($service) && !$this->container->getDefinition($service)->isPublic()) {
  1677.                 continue;
  1678.             }
  1680.             $conditions[] = sprintf('$this->has(%s)', $this->doExport($service));
  1681.         }
  1683.         if (!$conditions) {
  1684.             return '';
  1685.         }
  1687.         return implode(' && ', $conditions);
  1688.     }
  1690.     private function getDefinitionsFromArguments(array $arguments, \SplObjectStorage $definitions = null, array &$calls = [], bool $byConstructor = null): \SplObjectStorage
  1691.     {
  1692.         if (null === $definitions) {
  1693.             $definitions = new \SplObjectStorage();
  1694.         }
  1696.         foreach ($arguments as $argument) {
  1697.             if (\is_array($argument)) {
  1698.                 $this->getDefinitionsFromArguments($argument, $definitions, $calls, $byConstructor);
  1699.             } elseif ($argument instanceof Reference) {
  1700.                 $id = (string) $argument;
  1702.                 while ($this->container->hasAlias($id)) {
  1703.                     $id = (string) $this->container->getAlias($id);
  1704.                 }
  1706.                 if (!isset($calls[$id])) {
  1707.                     $calls[$id] = [0, $argument->getInvalidBehavior(), $byConstructor];
  1708.                 } else {
  1709.                     $calls[$id][1] = min($calls[$id][1], $argument->getInvalidBehavior());
  1710.                 }
  1712.                 ++$calls[$id][0];
  1713.             } elseif (!$argument instanceof Definition) {
  1714.                 // no-op
  1715.             } elseif (isset($definitions[$argument])) {
  1716.                 $definitions[$argument] = 1 + $definitions[$argument];
  1717.             } else {
  1718.                 $definitions[$argument] = 1;
  1719.                 $arguments = [$argument->getArguments(), $argument->getFactory()];
  1720.                 $this->getDefinitionsFromArguments($arguments, $definitions, $calls, null === $byConstructor || $byConstructor);
  1721.                 $arguments = [$argument->getProperties(), $argument->getMethodCalls(), $argument->getConfigurator()];
  1722.                 $this->getDefinitionsFromArguments($arguments, $definitions, $calls, null !== $byConstructor && $byConstructor);
  1723.             }
  1724.         }
  1726.         return $definitions;
  1727.     }
  1729.     /**
  1730.      * @throws RuntimeException
  1731.      */
  1732.     private function dumpValue(mixed $value, bool $interpolate = true): string
  1733.     {
  1734.         if (\is_array($value)) {
  1735.             if ($value && $interpolate && false !== $param = array_search($value, $this->container->getParameterBag()->all(), true)) {
  1736.                 return $this->dumpValue("%$param%");
  1737.             }
  1738.             $code = [];
  1739.             foreach ($value as $k => $v) {
  1740.                 $code[] = sprintf('%s => %s', $this->dumpValue($k, $interpolate), $this->dumpValue($v, $interpolate));
  1741.             }
  1743.             return sprintf('[%s]', implode(', ', $code));
  1744.         } elseif ($value instanceof ArgumentInterface) {
  1745.             $scope = [$this->definitionVariables, $this->referenceVariables];
  1746.             $this->definitionVariables = $this->referenceVariables = null;
  1748.             try {
  1749.                 if ($value instanceof ServiceClosureArgument) {
  1750.                     $value = $value->getValues()[0];
  1751.                     $code = $this->dumpValue($value, $interpolate);
  1753.                     $returnedType = '';
  1754.                     if ($value instanceof TypedReference) {
  1755.                         $returnedType = sprintf(': %s\%s', ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $value->getInvalidBehavior() ? '' : '?', str_replace(['|', '&'], ['|\\', '&\\'], $value->getType()));
  1756.                     }
  1758.                     $code = sprintf('return %s;', $code);
  1760.                     $attribute = '';
  1761.                     if ($value instanceof Reference) {
  1762.                         $attribute = 'name: '.$this->dumpValue((string) $value, $interpolate);
  1764.                         if ($this->container->hasDefinition($value) && ($class = $this->container->findDefinition($value)->getClass()) && $class !== (string) $value) {
  1765.                             $attribute .= ', class: '.$this->dumpValue($class, $interpolate);
  1766.                         }
  1768.                         $attribute = sprintf('#[\Closure(%s)] ', $attribute);
  1769.                     }
  1771.                     return sprintf("%sfunction ()%s {\n            %s\n        }", $attribute, $returnedType, $code);
  1772.                 }
  1774.                 if ($value instanceof IteratorArgument) {
  1775.                     $operands = [0];
  1776.                     $code = [];
  1777.                     $code[] = 'new RewindableGenerator(function () {';
  1779.                     if (!$values = $value->getValues()) {
  1780.                         $code[] = '            return new \EmptyIterator();';
  1781.                     } else {
  1782.                         $countCode = [];
  1783.                         $countCode[] = 'function () {';
  1785.                         foreach ($values as $k => $v) {
  1786.                             ($c = $this->getServiceConditionals($v)) ? $operands[] = "(int) ($c)" : ++$operands[0];
  1787.                             $v = $this->wrapServiceConditionals($v, sprintf("        yield %s => %s;\n", $this->dumpValue($k, $interpolate), $this->dumpValue($v, $interpolate)));
  1788.                             foreach (explode("\n", $v) as $v) {
  1789.                                 if ($v) {
  1790.                                     $code[] = '    '.$v;
  1791.                                 }
  1792.                             }
  1793.                         }
  1795.                         $countCode[] = sprintf('            return %s;', implode(' + ', $operands));
  1796.                         $countCode[] = '        }';
  1797.                     }
  1799.                     $code[] = sprintf('        }, %s)', \count($operands) > 1 ? implode("\n", $countCode) : $operands[0]);
  1801.                     return implode("\n", $code);
  1802.                 }
  1804.                 if ($value instanceof ServiceLocatorArgument) {
  1805.                     $serviceMap = '';
  1806.                     $serviceTypes = '';
  1807.                     foreach ($value->getValues() as $k => $v) {
  1808.                         if (!$v instanceof Reference) {
  1809.                             $serviceMap .= sprintf("\n            %s => [%s],", $this->export($k), $this->dumpValue($v));
  1810.                             $serviceTypes .= sprintf("\n            %s => '?',", $this->export($k));
  1811.                             continue;
  1812.                         }
  1813.                         $id = (string) $v;
  1814.                         while ($this->container->hasAlias($id)) {
  1815.                             $id = (string) $this->container->getAlias($id);
  1816.                         }
  1817.                         $definition = $this->container->getDefinition($id);
  1818.                         $load = !($definition->hasErrors() && $e = $definition->getErrors()) ? $this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition) : reset($e);
  1819.                         $serviceMap .= sprintf("\n            %s => [%s, %s, %s, %s],",
  1820.                             $this->export($k),
  1821.                             $this->export($definition->isShared() ? ($definition->isPublic() ? 'services' : 'privates') : false),
  1822.                             $this->doExport($id),
  1823.                             $this->export(ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE !== $v->getInvalidBehavior() && !\is_string($load) ? $this->generateMethodName($id) : null),
  1824.                             $this->export($load)
  1825.                         );
  1826.                         $serviceTypes .= sprintf("\n            %s => %s,", $this->export($k), $this->export($v instanceof TypedReference ? $v->getType() : '?'));
  1827.                         $this->locatedIds[$id] = true;
  1828.                     }
  1829.                     $this->addGetService = true;
  1831.                     return sprintf('new \%s($this->getService, [%s%s], [%s%s])', ServiceLocator::class, $serviceMap, $serviceMap ? "\n        " : '', $serviceTypes, $serviceTypes ? "\n        " : '');
  1832.                 }
  1833.             } finally {
  1834.                 [$this->definitionVariables, $this->referenceVariables] = $scope;
  1835.             }
  1836.         } elseif ($value instanceof Definition) {
  1837.             if ($value->hasErrors() && $e = $value->getErrors()) {
  1838.                 return sprintf('throw new RuntimeException(%s)', $this->export(reset($e)));
  1839.             }
  1840.             if ($this->definitionVariables?->contains($value)) {
  1841.                 return $this->dumpValue($this->definitionVariables[$value], $interpolate);
  1842.             }
  1843.             if ($value->getMethodCalls()) {
  1844.                 throw new RuntimeException('Cannot dump definitions which have method calls.');
  1845.             }
  1846.             if ($value->getProperties()) {
  1847.                 throw new RuntimeException('Cannot dump definitions which have properties.');
  1848.             }
  1849.             if (null !== $value->getConfigurator()) {
  1850.                 throw new RuntimeException('Cannot dump definitions which have a configurator.');
  1851.             }
  1853.             return $this->addNewInstance($value);
  1854.         } elseif ($value instanceof Variable) {
  1855.             return '$'.$value;
  1856.         } elseif ($value instanceof Reference) {
  1857.             $id = (string) $value;
  1859.             while ($this->container->hasAlias($id)) {
  1860.                 $id = (string) $this->container->getAlias($id);
  1861.             }
  1863.             if (null !== $this->referenceVariables && isset($this->referenceVariables[$id])) {
  1864.                 return $this->dumpValue($this->referenceVariables[$id], $interpolate);
  1865.             }
  1867.             return $this->getServiceCall($id, $value);
  1868.         } elseif ($value instanceof Expression) {
  1869.             return $this->getExpressionLanguage()->compile((string) $value, ['this' => 'container']);
  1870.         } elseif ($value instanceof Parameter) {
  1871.             return $this->dumpParameter($value);
  1872.         } elseif (true === $interpolate && \is_string($value)) {
  1873.             if (preg_match('/^%([^%]+)%$/', $value, $match)) {
  1874.                 // we do this to deal with non string values (Boolean, integer, ...)
  1875.                 // the preg_replace_callback converts them to strings
  1876.                 return $this->dumpParameter($match[1]);
  1877.             } else {
  1878.                 $replaceParameters = function ($match) {
  1879.                     return "'.".$this->dumpParameter($match[2]).".'";
  1880.                 };
  1882.                 $code = str_replace('%%', '%', preg_replace_callback('/(?<!%)(%)([^%]+)\1/', $replaceParameters, $this->export($value)));
  1884.                 return $code;
  1885.             }
  1886.         } elseif ($value instanceof \UnitEnum) {
  1887.             return sprintf('\%s::%s', \get_class($value), $value->name);
  1888.         } elseif ($value instanceof AbstractArgument) {
  1889.             throw new RuntimeException($value->getTextWithContext());
  1890.         } elseif (\is_object($value) || \is_resource($value)) {
  1891.             throw new RuntimeException('Unable to dump a service container if a parameter is an object or a resource.');
  1892.         }
  1894.         return $this->export($value);
  1895.     }
  1897.     /**
  1898.      * Dumps a string to a literal (aka PHP Code) class value.
  1899.      *
  1900.      * @throws RuntimeException
  1901.      */
  1902.     private function dumpLiteralClass(string $class): string
  1903.     {
  1904.         if (str_contains($class, '$')) {
  1905.             return sprintf('${($_ = %s) && false ?: "_"}', $class);
  1906.         }
  1907.         if (!str_starts_with($class, "'") || !preg_match('/^\'(?:\\\{2})?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*(?:\\\{2}[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)*\'$/', $class)) {
  1908.             throw new RuntimeException(sprintf('Cannot dump definition because of invalid class name (%s).', $class ?: 'n/a'));
  1909.         }
  1911.         $class = substr(str_replace('\\\\', '\\', $class), 1, -1);
  1913.         return str_starts_with($class, '\\') ? $class : '\\'.$class;
  1914.     }
  1916.     private function dumpParameter(string $name): string
  1917.     {
  1918.         if ($this->container->hasParameter($name)) {
  1919.             $value = $this->container->getParameter($name);
  1920.             $dumpedValue = $this->dumpValue($value, false);
  1922.             if (!$value || !\is_array($value)) {
  1923.                 return $dumpedValue;
  1924.             }
  1926.             if (!preg_match("/\\\$this->(?:getEnv\('(?:[-.\w]*+:)*+\w++'\)|targetDir\.'')/", $dumpedValue)) {
  1927.                 return sprintf('$this->parameters[%s]', $this->doExport($name));
  1928.             }
  1929.         }
  1931.         return sprintf('$this->getParameter(%s)', $this->doExport($name));
  1932.     }
  1934.     private function getServiceCall(string $id, Reference $reference = null): string
  1935.     {
  1936.         while ($this->container->hasAlias($id)) {
  1937.             $id = (string) $this->container->getAlias($id);
  1938.         }
  1940.         if ('service_container' === $id) {
  1941.             return '$this';
  1942.         }
  1944.         if ($this->container->hasDefinition($id) && $definition = $this->container->getDefinition($id)) {
  1945.             if ($definition->isSynthetic()) {
  1946.                 $code = sprintf('$this->get(%s%s)', $this->doExport($id), null !== $reference ? ', '.$reference->getInvalidBehavior() : '');
  1947.             } elseif (null !== $reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $reference->getInvalidBehavior()) {
  1948.                 $code = 'null';
  1949.                 if (!$definition->isShared()) {
  1950.                     return $code;
  1951.                 }
  1952.             } elseif ($this->isTrivialInstance($definition)) {
  1953.                 if ($definition->hasErrors() && $e = $definition->getErrors()) {
  1954.                     return sprintf('throw new RuntimeException(%s)', $this->export(reset($e)));
  1955.                 }
  1956.                 $code = $this->addNewInstance($definition, '', $id);
  1957.                 if ($definition->isShared() && !isset($this->singleUsePrivateIds[$id])) {
  1958.                     $code = sprintf('$this->%s[%s] = %s', $definition->isPublic() ? 'services' : 'privates', $this->doExport($id), $code);
  1959.                 }
  1960.                 $code = "($code)";
  1961.             } else {
  1962.                 $code = $this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition) ? "\$this->load('%s')" : '$this->%s()';
  1963.                 $code = sprintf($code, $this->generateMethodName($id));
  1965.                 if (!$definition->isShared()) {
  1966.                     $factory = sprintf('$this->factories%s[%s]', $definition->isPublic() ? '' : "['service_container']", $this->doExport($id));
  1967.                     $code = sprintf('(isset(%s) ? %1$s() : %s)', $factory, $code);
  1968.                 }
  1969.             }
  1970.             if ($definition->isShared() && !isset($this->singleUsePrivateIds[$id])) {
  1971.                 $code = sprintf('($this->%s[%s] ?? %s)', $definition->isPublic() ? 'services' : 'privates', $this->doExport($id), $code);
  1972.             }
  1974.             return $code;
  1975.         }
  1976.         if (null !== $reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $reference->getInvalidBehavior()) {
  1977.             return 'null';
  1978.         }
  1979.         if (null !== $reference && ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE < $reference->getInvalidBehavior()) {
  1980.             $code = sprintf('$this->get(%s, ContainerInterface::NULL_ON_INVALID_REFERENCE)', $this->doExport($id));
  1981.         } else {
  1982.             $code = sprintf('$this->get(%s)', $this->doExport($id));
  1983.         }
  1985.         return sprintf('($this->services[%s] ?? %s)', $this->doExport($id), $code);
  1986.     }
  1988.     /**
  1989.      * Initializes the method names map to avoid conflicts with the Container methods.
  1990.      */
  1991.     private function initializeMethodNamesMap(string $class)
  1992.     {
  1993.         $this->serviceIdToMethodNameMap = [];
  1994.         $this->usedMethodNames = [];
  1996.         if ($reflectionClass = $this->container->getReflectionClass($class)) {
  1997.             foreach ($reflectionClass->getMethods() as $method) {
  1998.                 $this->usedMethodNames[strtolower($method->getName())] = true;
  1999.             }
  2000.         }
  2001.     }
  2003.     /**
  2004.      * @throws InvalidArgumentException
  2005.      */
  2006.     private function generateMethodName(string $id): string
  2007.     {
  2008.         if (isset($this->serviceIdToMethodNameMap[$id])) {
  2009.             return $this->serviceIdToMethodNameMap[$id];
  2010.         }
  2012.         $i = strrpos($id, '\\');
  2013.         $name = Container::camelize(false !== $i && isset($id[1 + $i]) ? substr($id, 1 + $i) : $id);
  2014.         $name = preg_replace('/[^a-zA-Z0-9_\x7f-\xff]/', '', $name);
  2015.         $methodName = 'get'.$name.'Service';
  2016.         $suffix = 1;
  2018.         while (isset($this->usedMethodNames[strtolower($methodName)])) {
  2019.             ++$suffix;
  2020.             $methodName = 'get'.$name.$suffix.'Service';
  2021.         }
  2023.         $this->serviceIdToMethodNameMap[$id] = $methodName;
  2024.         $this->usedMethodNames[strtolower($methodName)] = true;
  2026.         return $methodName;
  2027.     }
  2029.     private function getNextVariableName(): string
  2030.     {
  2031.         $firstChars = self::FIRST_CHARS;
  2032.         $firstCharsLength = \strlen($firstChars);
  2033.         $nonFirstChars = self::NON_FIRST_CHARS;
  2034.         $nonFirstCharsLength = \strlen($nonFirstChars);
  2036.         while (true) {
  2037.             $name = '';
  2038.             $i = $this->variableCount;
  2040.             if ('' === $name) {
  2041.                 $name .= $firstChars[$i % $firstCharsLength];
  2042.                 $i = (int) ($i / $firstCharsLength);
  2043.             }
  2045.             while ($i > 0) {
  2046.                 --$i;
  2047.                 $name .= $nonFirstChars[$i % $nonFirstCharsLength];
  2048.                 $i = (int) ($i / $nonFirstCharsLength);
  2049.             }
  2051.             ++$this->variableCount;
  2053.             // check that the name is not reserved
  2054.             if (\in_array($name, $this->reservedVariables, true)) {
  2055.                 continue;
  2056.             }
  2058.             return $name;
  2059.         }
  2060.     }
  2062.     private function getExpressionLanguage(): ExpressionLanguage
  2063.     {
  2064.         if (!isset($this->expressionLanguage)) {
  2065.             if (!class_exists(\Symfony\Component\ExpressionLanguage\ExpressionLanguage::class)) {
  2066.                 throw new LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  2067.             }
  2068.             $providers = $this->container->getExpressionLanguageProviders();
  2069.             $this->expressionLanguage = new ExpressionLanguage(null, $providers, function ($arg) {
  2070.                 $id = '""' === substr_replace($arg, '', 1, -1) ? stripcslashes(substr($arg, 1, -1)) : null;
  2072.                 if (null !== $id && ($this->container->hasAlias($id) || $this->container->hasDefinition($id))) {
  2073.                     return $this->getServiceCall($id);
  2074.                 }
  2076.                 return sprintf('$this->get(%s)', $arg);
  2077.             });
  2079.             if ($this->container->isTrackingResources()) {
  2080.                 foreach ($providers as $provider) {
  2081.                     $this->container->addObjectResource($provider);
  2082.                 }
  2083.             }
  2084.         }
  2086.         return $this->expressionLanguage;
  2087.     }
  2089.     private function isHotPath(Definition $definition): bool
  2090.     {
  2091.         return $this->hotPathTag && $definition->hasTag($this->hotPathTag) && !$definition->isDeprecated();
  2092.     }
  2094.     private function isSingleUsePrivateNode(ServiceReferenceGraphNode $node): bool
  2095.     {
  2096.         if ($node->getValue()->isPublic()) {
  2097.             return false;
  2098.         }
  2099.         $ids = [];
  2100.         foreach ($node->getInEdges() as $edge) {
  2101.             if (!$value = $edge->getSourceNode()->getValue()) {
  2102.                 continue;
  2103.             }
  2104.             if ($edge->isLazy() || !$value instanceof Definition || !$value->isShared()) {
  2105.                 return false;
  2106.             }
  2107.             $ids[$edge->getSourceNode()->getId()] = true;
  2108.         }
  2110.         return 1 === \count($ids);
  2111.     }
  2113.     private function export(mixed $value): mixed
  2114.     {
  2115.         if (null !== $this->targetDirRegex && \is_string($value) && preg_match($this->targetDirRegex, $value, $matches, \PREG_OFFSET_CAPTURE)) {
  2116.             $suffix = $matches[0][1] + \strlen($matches[0][0]);
  2117.             $matches[0][1] += \strlen($matches[1][0]);
  2118.             $prefix = $matches[0][1] ? $this->doExport(substr($value, 0, $matches[0][1]), true).'.' : '';
  2120.             if ('\\' === \DIRECTORY_SEPARATOR && isset($value[$suffix])) {
  2121.                 $cookie = '\\'.random_int(100000, \PHP_INT_MAX);
  2122.                 $suffix = '.'.$this->doExport(str_replace('\\', $cookie, substr($value, $suffix)), true);
  2123.                 $suffix = str_replace('\\'.$cookie, "'.\\DIRECTORY_SEPARATOR.'", $suffix);
  2124.             } else {
  2125.                 $suffix = isset($value[$suffix]) ? '.'.$this->doExport(substr($value, $suffix), true) : '';
  2126.             }
  2128.             $dirname = $this->asFiles ? '$this->containerDir' : '__DIR__';
  2129.             $offset = 2 + $this->targetDirMaxMatches - \count($matches);
  2131.             if (0 < $offset) {
  2132.                 $dirname = sprintf('\dirname(__DIR__, %d)', $offset + (int) $this->asFiles);
  2133.             } elseif ($this->asFiles) {
  2134.                 $dirname = "\$this->targetDir.''"; // empty string concatenation on purpose
  2135.             }
  2137.             if ($prefix || $suffix) {
  2138.                 return sprintf('(%s%s%s)', $prefix, $dirname, $suffix);
  2139.             }
  2141.             return $dirname;
  2142.         }
  2144.         return $this->doExport($value, true);
  2145.     }
  2147.     private function doExport(mixed $value, bool $resolveEnv = false): mixed
  2148.     {
  2149.         $shouldCacheValue = $resolveEnv && \is_string($value);
  2150.         if ($shouldCacheValue && isset($this->exportedVariables[$value])) {
  2151.             return $this->exportedVariables[$value];
  2152.         }
  2153.         if (\is_string($value) && str_contains($value, "\n")) {
  2154.             $cleanParts = explode("\n", $value);
  2155.             $cleanParts = array_map(function ($part) { return var_export($part, true); }, $cleanParts);
  2156.             $export = implode('."\n".', $cleanParts);
  2157.         } else {
  2158.             $export = var_export($value, true);
  2159.         }
  2160.         if ($this->asFiles) {
  2161.             if (str_contains($export, '$this')) {
  2162.                 $export = str_replace('$this', "$'.'this", $export);
  2163.             }
  2164.             if (str_contains($export, 'function () {')) {
  2165.                 $export = str_replace('function () {', "function ('.') {", $export);
  2166.             }
  2167.         }
  2169.         if ($resolveEnv && "'" === $export[0] && $export !== $resolvedExport = $this->container->resolveEnvPlaceholders($export, "'.\$this->getEnv('string:%s').'")) {
  2170.             $export = $resolvedExport;
  2171.             if (str_ends_with($export, ".''")) {
  2172.                 $export = substr($export, 0, -3);
  2173.                 if ("'" === $export[1]) {
  2174.                     $export = substr_replace($export, '', 18, 7);
  2175.                 }
  2176.             }
  2177.             if ("'" === $export[1]) {
  2178.                 $export = substr($export, 3);
  2179.             }
  2180.         }
  2182.         if ($shouldCacheValue) {
  2183.             $this->exportedVariables[$value] = $export;
  2184.         }
  2186.         return $export;
  2187.     }
  2189.     private function getAutoloadFile(): ?string
  2190.     {
  2191.         $file = null;
  2193.         foreach (spl_autoload_functions() as $autoloader) {
  2194.             if (!\is_array($autoloader)) {
  2195.                 continue;
  2196.             }
  2198.             if ($autoloader[0] instanceof DebugClassLoader || $autoloader[0] instanceof LegacyDebugClassLoader) {
  2199.                 $autoloader = $autoloader[0]->getClassLoader();
  2200.             }
  2202.             if (!\is_array($autoloader) || !$autoloader[0] instanceof ClassLoader || !$autoloader[0]->findFile(__CLASS__)) {
  2203.                 continue;
  2204.             }
  2206.             foreach (get_declared_classes() as $class) {
  2207.                 if (str_starts_with($class, 'ComposerAutoloaderInit') && $class::getLoader() === $autoloader[0]) {
  2208.                     $file = \dirname((new \ReflectionClass($class))->getFileName(), 2).'/autoload.php';
  2210.                     if (null !== $this->targetDirRegex && preg_match($this->targetDirRegex.'A', $file)) {
  2211.                         return $file;
  2212.                     }
  2213.                 }
  2214.             }
  2215.         }
  2217.         return $file;
  2218.     }
  2220.     private function getClasses(Definition $definition, string $id): array
  2221.     {
  2222.         $classes = [];
  2224.         while ($definition instanceof Definition) {
  2225.             foreach ($definition->getTag($this->preloadTags[0]) as $tag) {
  2226.                 if (!isset($tag['class'])) {
  2227.                     throw new InvalidArgumentException(sprintf('Missing attribute "class" on tag "%s" for service "%s".', $this->preloadTags[0], $id));
  2228.                 }
  2230.                 $classes[] = trim($tag['class'], '\\');
  2231.             }
  2233.             if ($class = $definition->getClass()) {
  2234.                 $classes[] = trim($class, '\\');
  2235.             }
  2236.             $factory = $definition->getFactory();
  2238.             if (!\is_array($factory)) {
  2239.                 $factory = [$factory];
  2240.             }
  2242.             if (\is_string($factory[0])) {
  2243.                 if (false !== $i = strrpos($factory[0], '::')) {
  2244.                     $factory[0] = substr($factory[0], 0, $i);
  2245.                 }
  2246.                 $classes[] = trim($factory[0], '\\');
  2247.             }
  2249.             $definition = $factory[0];
  2250.         }
  2252.         return $classes;
  2253.     }
  2254. }