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

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\ArgumentInterface;
  17. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  18. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  19. use Symfony\Component\DependencyInjection\Argument\ServiceLocator;
  20. use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
  21. use Symfony\Component\DependencyInjection\Compiler\AnalyzeServiceReferencesPass;
  22. use Symfony\Component\DependencyInjection\Compiler\CheckCircularReferencesPass;
  23. use Symfony\Component\DependencyInjection\Compiler\ServiceReferenceGraphEdge;
  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 as ProxyDumper;
  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.     const FIRST_CHARS = 'abcdefghijklmnopqrstuvwxyz';
  60.     /**
  61.      * Characters that might appear in the generated variable name as any but the first character.
  62.      */
  63.     const NON_FIRST_CHARS = 'abcdefghijklmnopqrstuvwxyz0123456789_';
  65.     private $definitionVariables;
  66.     private $referenceVariables;
  67.     private $variableCount;
  68.     private $inlinedDefinitions;
  69.     private $serviceCalls;
  70.     private $reservedVariables = ['instance', 'class', 'this'];
  71.     private $expressionLanguage;
  72.     private $targetDirRegex;
  73.     private $targetDirMaxMatches;
  74.     private $docStar;
  75.     private $serviceIdToMethodNameMap;
  76.     private $usedMethodNames;
  77.     private $namespace;
  78.     private $asFiles;
  79.     private $hotPathTag;
  80.     private $inlineFactories;
  81.     private $inlineRequires;
  82.     private $inlinedRequires = [];
  83.     private $circularReferences = [];
  84.     private $singleUsePrivateIds = [];
  85.     private $preload = [];
  86.     private $addThrow = false;
  87.     private $addGetService = false;
  88.     private $locatedIds = [];
  89.     private $serviceLocatorTag;
  90.     private $exportedVariables = [];
  91.     private $baseClass;
  93.     /**
  94.      * @var ProxyDumper
  95.      */
  96.     private $proxyDumper;
  98.     /**
  99.      * {@inheritdoc}
  100.      */
  101.     public function __construct(ContainerBuilder $container)
  102.     {
  103.         if (!$container->isCompiled()) {
  104.             throw new LogicException('Cannot dump an uncompiled container.');
  105.         }
  107.         parent::__construct($container);
  108.     }
  110.     /**
  111.      * Sets the dumper to be used when dumping proxies in the generated container.
  112.      */
  113.     public function setProxyDumper(ProxyDumper $proxyDumper)
  114.     {
  115.         $this->proxyDumper = $proxyDumper;
  116.     }
  118.     /**
  119.      * Dumps the service container as a PHP class.
  120.      *
  121.      * Available options:
  122.      *
  123.      *  * class:      The class name
  124.      *  * base_class: The base class name
  125.      *  * namespace:  The class namespace
  126.      *  * as_files:   To split the container in several files
  127.      *
  128.      * @return string|array A PHP class representing the service container or an array of PHP files if the "as_files" option is set
  129.      *
  130.      * @throws EnvParameterException When an env var exists but has not been dumped
  131.      */
  132.     public function dump(array $options = [])
  133.     {
  134.         $this->locatedIds = [];
  135.         $this->targetDirRegex = null;
  136.         $this->inlinedRequires = [];
  137.         $this->exportedVariables = [];
  138.         $options = array_merge([
  139.             'class' => 'ProjectServiceContainer',
  140.             'base_class' => 'Container',
  141.             'namespace' => '',
  142.             'as_files' => false,
  143.             'debug' => true,
  144.             'hot_path_tag' => 'container.hot_path',
  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->addThrow = $this->addGetService = false;
  153.         $this->namespace = $options['namespace'];
  154.         $this->asFiles = $options['as_files'];
  155.         $this->hotPathTag = $options['hot_path_tag'];
  156.         $this->inlineFactories = $this->asFiles && $options['inline_factories_parameter'] && $this->container->hasParameter($options['inline_factories_parameter']) && $this->container->getParameter($options['inline_factories_parameter']);
  157.         $this->inlineRequires = $options['inline_class_loader_parameter'] && $this->container->hasParameter($options['inline_class_loader_parameter']) && $this->container->getParameter($options['inline_class_loader_parameter']);
  158.         $this->serviceLocatorTag = $options['service_locator_tag'];
  160.         if (0 !== strpos($baseClass = $options['base_class'], '\\') && 'Container' !== $baseClass) {
  161.             $baseClass = sprintf('%s\%s', $options['namespace'] ? '\\'.$options['namespace'] : '', $baseClass);
  162.             $this->baseClass = $baseClass;
  163.         } elseif ('Container' === $baseClass) {
  164.             $this->baseClass = Container::class;
  165.         } else {
  166.             $this->baseClass = $baseClass;
  167.         }
  169.         $this->initializeMethodNamesMap('Container' === $baseClass ? Container::class : $baseClass);
  171.         if ($this->getProxyDumper() instanceof NullDumper) {
  172.             (new AnalyzeServiceReferencesPass(true, false))->process($this->container);
  173.             try {
  174.                 (new CheckCircularReferencesPass())->process($this->container);
  175.             } catch (ServiceCircularReferenceException $e) {
  176.                 $path = $e->getPath();
  177.                 end($path);
  178.                 $path[key($path)] .= '". Try running "composer require symfony/proxy-manager-bridge';
  180.                 throw new ServiceCircularReferenceException($e->getServiceId(), $path);
  181.             }
  182.         }
  184.         (new AnalyzeServiceReferencesPass(false, !$this->getProxyDumper() instanceof NullDumper))->process($this->container);
  185.         $checkedNodes = [];
  186.         $this->circularReferences = [];
  187.         $this->singleUsePrivateIds = [];
  188.         foreach ($this->container->getCompiler()->getServiceReferenceGraph()->getNodes() as $id => $node) {
  189.             if (!$node->getValue() instanceof Definition) {
  190.                 continue;
  191.             }
  192.             if (!isset($checkedNodes[$id])) {
  193.                 $this->analyzeCircularReferences($id, $node->getOutEdges(), $checkedNodes);
  194.             }
  195.             if ($this->isSingleUsePrivateNode($node)) {
  196.                 $this->singleUsePrivateIds[$id] = $id;
  197.             }
  198.         }
  199.         $this->container->getCompiler()->getServiceReferenceGraph()->clear();
  200.         $checkedNodes = [];
  201.         $this->singleUsePrivateIds = array_diff_key($this->singleUsePrivateIds, $this->circularReferences);
  203.         $this->docStar = $options['debug'] ? '*' : '';
  205.         if (!empty($options['file']) && is_dir($dir = \dirname($options['file']))) {
  206.             // Build a regexp where the first root dirs are mandatory,
  207.             // but every other sub-dir is optional up to the full path in $dir
  208.             // Mandate at least 1 root dir and not more than 5 optional dirs.
  210.             $dir = explode(\DIRECTORY_SEPARATOR, realpath($dir));
  211.             $i = \count($dir);
  213.             if (2 + (int) ('\\' === \DIRECTORY_SEPARATOR) <= $i) {
  214.                 $regex = '';
  215.                 $lastOptionalDir = $i > 8 ? $i - 5 : (2 + (int) ('\\' === \DIRECTORY_SEPARATOR));
  216.                 $this->targetDirMaxMatches = $i - $lastOptionalDir;
  218.                 while (--$i >= $lastOptionalDir) {
  219.                     $regex = sprintf('(%s%s)?', preg_quote(\DIRECTORY_SEPARATOR.$dir[$i], '#'), $regex);
  220.                 }
  222.                 do {
  223.                     $regex = preg_quote(\DIRECTORY_SEPARATOR.$dir[$i], '#').$regex;
  224.                 } while (0 < --$i);
  226.                 $this->targetDirRegex = '#(^|file://|[:;, \|\r\n])'.preg_quote($dir[0], '#').$regex.'#';
  227.             }
  228.         }
  230.         $proxyClasses = $this->inlineFactories ? $this->generateProxyClasses() : null;
  232.         if ($options['preload_classes']) {
  233.             $this->preload = array_combine($options['preload_classes'], $options['preload_classes']);
  234.         }
  236.         $code =
  237.             $this->startClass($options['class'], $baseClass).
  238.             $this->addServices($services).
  239.             $this->addDeprecatedAliases().
  240.             $this->addDefaultParametersMethod()
  241.         ;
  243.         $proxyClasses = $proxyClasses ?? $this->generateProxyClasses();
  245.         if ($this->addGetService) {
  246.             $code = preg_replace(
  247.                 "/(\r?\n\r?\n    public function __construct.+?\\{\r?\n)/s",
  248.                 "\n    private \$getService;$1        \$this->getService = \\Closure::fromCallable([\$this, 'getService']);\n",
  249.                 $code,
  250.                 1
  251.             );
  252.         }
  254.         if ($this->asFiles) {
  255.             $fileStart = <<<EOF
  256. <?php
  258. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  259. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  261. // This file has been auto-generated by the Symfony Dependency Injection Component for internal use.
  263. EOF;
  264.             $files = [];
  266.             $ids = $this->container->getRemovedIds();
  267.             foreach ($this->container->getDefinitions() as $id => $definition) {
  268.                 if (!$definition->isPublic()) {
  269.                     $ids[$id] = true;
  270.                 }
  271.             }
  272.             if ($ids = array_keys($ids)) {
  273.                 sort($ids);
  274.                 $c = "<?php\n\nreturn [\n";
  275.                 foreach ($ids as $id) {
  276.                     $c .= '    '.$this->doExport($id)." => true,\n";
  277.                 }
  278.                 $files['removed-ids.php'] = $c."];\n";
  279.             }
  281.             if (!$this->inlineFactories) {
  282.                 foreach ($this->generateServiceFiles($services) as $file => $c) {
  283.                     $files[$file] = $fileStart.$c;
  284.                 }
  285.                 foreach ($proxyClasses as $file => $c) {
  286.                     $files[$file] = "<?php\n".$c;
  287.                 }
  288.             }
  290.             $code .= $this->endClass();
  292.             if ($this->inlineFactories) {
  293.                 foreach ($proxyClasses as $c) {
  294.                     $code .= $c;
  295.                 }
  296.             }
  298.             $files[$options['class'].'.php'] = $code;
  299.             $hash = ucfirst(strtr(ContainerBuilder::hash($files), '._', 'xx'));
  300.             $code = [];
  302.             foreach ($files as $file => $c) {
  303.                 $code["Container{$hash}/{$file}"] = $c;
  304.             }
  305.             array_pop($code);
  306.             $code["Container{$hash}/{$options['class']}.php"] = substr_replace($files[$options['class'].'.php'], "<?php\n\nnamespace Container{$hash};\n", 0, 6);
  307.             $namespaceLine = $this->namespace ? "\nnamespace {$this->namespace};\n" : '';
  308.             $time = $options['build_time'];
  309.             $id = hash('crc32', $hash.$time);
  310.             $this->asFiles = false;
  312.             if ($this->preload && null !== $autoloadFile = $this->getAutoloadFile()) {
  313.                 $autoloadFile = substr($this->export($autoloadFile), 2, -1);
  315.                 $code[$options['class'].'.preload.php'] = <<<EOF
  316. <?php
  318. // This file has been auto-generated by the Symfony Dependency Injection Component
  319. // You can reference it in the "opcache.preload" php.ini setting on PHP >= 7.4 when preloading is desired
  321. use Symfony\Component\DependencyInjection\Dumper\Preloader;
  323. if (in_array(PHP_SAPI, ['cli', 'phpdbg'], true)) {
  324.     return;
  325. }
  327. require $autoloadFile;
  328. require __DIR__.'/Container{$hash}/{$options['class']}.php';
  330. \$classes = [];
  332. EOF;
  334.                 foreach ($this->preload as $class) {
  335.                     if (!$class || false !== strpos($class, '$')) {
  336.                         continue;
  337.                     }
  338.                     if (!(class_exists($class, false) || interface_exists($class, false) || trait_exists($class, false)) || (new \ReflectionClass($class))->isUserDefined()) {
  339.                         $code[$options['class'].'.preload.php'] .= sprintf("\$classes[] = '%s';\n", $class);
  340.                     }
  341.                 }
  343.                 $code[$options['class'].'.preload.php'] .= <<<'EOF'
  345. Preloader::preload($classes);
  347. EOF;
  348.             }
  350.             $code[$options['class'].'.php'] = <<<EOF
  351. <?php
  352. {$namespaceLine}
  353. // This file has been auto-generated by the Symfony Dependency Injection Component for internal use.
  355. if (\\class_exists(\\Container{$hash}\\{$options['class']}::class, false)) {
  356.     // no-op
  357. } elseif (!include __DIR__.'/Container{$hash}/{$options['class']}.php') {
  358.     touch(__DIR__.'/Container{$hash}.legacy');
  360.     return;
  361. }
  363. if (!\\class_exists({$options['class']}::class, false)) {
  364.     \\class_alias(\\Container{$hash}\\{$options['class']}::class, {$options['class']}::class, false);
  365. }
  367. return new \\Container{$hash}\\{$options['class']}([
  368.     'container.build_hash' => '$hash',
  369.     'container.build_id' => '$id',
  370.     'container.build_time' => $time,
  371. ], __DIR__.\\DIRECTORY_SEPARATOR.'Container{$hash}');
  373. EOF;
  374.         } else {
  375.             $code .= $this->endClass();
  376.             foreach ($proxyClasses as $c) {
  377.                 $code .= $c;
  378.             }
  379.         }
  381.         $this->targetDirRegex = null;
  382.         $this->inlinedRequires = [];
  383.         $this->circularReferences = [];
  384.         $this->locatedIds = [];
  385.         $this->exportedVariables = [];
  386.         $this->preload = [];
  388.         $unusedEnvs = [];
  389.         foreach ($this->container->getEnvCounters() as $env => $use) {
  390.             if (!$use) {
  391.                 $unusedEnvs[] = $env;
  392.             }
  393.         }
  394.         if ($unusedEnvs) {
  395.             throw new EnvParameterException($unusedEnvs, null, 'Environment variables "%s" are never used. Please, check your container\'s configuration.');
  396.         }
  398.         return $code;
  399.     }
  401.     /**
  402.      * Retrieves the currently set proxy dumper or instantiates one.
  403.      */
  404.     private function getProxyDumper(): ProxyDumper
  405.     {
  406.         if (!$this->proxyDumper) {
  407.             $this->proxyDumper = new NullDumper();
  408.         }
  410.         return $this->proxyDumper;
  411.     }
  413.     /**
  414.      * @param ServiceReferenceGraphEdge[] $edges
  415.      */
  416.     private function analyzeCircularReferences(string $sourceId, array $edges, array &$checkedNodes, array &$currentPath = [], bool $byConstructor = true)
  417.     {
  418.         $checkedNodes[$sourceId] = true;
  419.         $currentPath[$sourceId] = $byConstructor;
  421.         foreach ($edges as $edge) {
  422.             $node = $edge->getDestNode();
  423.             $id = $node->getId();
  425.             if (!$node->getValue() instanceof Definition || $sourceId === $id || $edge->isLazy() || $edge->isWeak()) {
  426.                 // no-op
  427.             } elseif (isset($currentPath[$id])) {
  428.                 $this->addCircularReferences($id, $currentPath, $edge->isReferencedByConstructor());
  429.             } elseif (!isset($checkedNodes[$id])) {
  430.                 $this->analyzeCircularReferences($id, $node->getOutEdges(), $checkedNodes, $currentPath, $edge->isReferencedByConstructor());
  431.             } elseif (isset($this->circularReferences[$id])) {
  432.                 $this->connectCircularReferences($id, $currentPath, $edge->isReferencedByConstructor());
  433.             }
  434.         }
  435.         unset($currentPath[$sourceId]);
  436.     }
  438.     private function connectCircularReferences(string $sourceId, array &$currentPath, bool $byConstructor, array &$subPath = [])
  439.     {
  440.         $currentPath[$sourceId] = $subPath[$sourceId] = $byConstructor;
  442.         foreach ($this->circularReferences[$sourceId] as $id => $byConstructor) {
  443.             if (isset($currentPath[$id])) {
  444.                 $this->addCircularReferences($id, $currentPath, $byConstructor);
  445.             } elseif (!isset($subPath[$id]) && isset($this->circularReferences[$id])) {
  446.                 $this->connectCircularReferences($id, $currentPath, $byConstructor, $subPath);
  447.             }
  448.         }
  449.         unset($currentPath[$sourceId], $subPath[$sourceId]);
  450.     }
  452.     private function addCircularReferences(string $id, array $currentPath, bool $byConstructor)
  453.     {
  454.         $currentPath[$id] = $byConstructor;
  455.         $circularRefs = [];
  457.         foreach (array_reverse($currentPath) as $parentId => $v) {
  458.             $byConstructor = $byConstructor && $v;
  459.             $circularRefs[] = $parentId;
  461.             if ($parentId === $id) {
  462.                 break;
  463.             }
  464.         }
  466.         $currentId = $id;
  467.         foreach ($circularRefs as $parentId) {
  468.             if (empty($this->circularReferences[$parentId][$currentId])) {
  469.                 $this->circularReferences[$parentId][$currentId] = $byConstructor;
  470.             }
  472.             $currentId = $parentId;
  473.         }
  474.     }
  476.     private function collectLineage(string $class, array &$lineage)
  477.     {
  478.         if (isset($lineage[$class])) {
  479.             return;
  480.         }
  481.         if (!$r = $this->container->getReflectionClass($class, false)) {
  482.             return;
  483.         }
  484.         if (is_a($class, $this->baseClass, true)) {
  485.             return;
  486.         }
  487.         $file = $r->getFileName();
  488.         if (!$file || $this->doExport($file) === $exportedFile = $this->export($file)) {
  489.             return;
  490.         }
  492.         $lineage[$class] = substr($exportedFile, 1, -1);
  494.         if ($parent = $r->getParentClass()) {
  495.             $this->collectLineage($parent->name, $lineage);
  496.         }
  498.         foreach ($r->getInterfaces() as $parent) {
  499.             $this->collectLineage($parent->name, $lineage);
  500.         }
  502.         foreach ($r->getTraits() as $parent) {
  503.             $this->collectLineage($parent->name, $lineage);
  504.         }
  506.         unset($lineage[$class]);
  507.         $lineage[$class] = substr($exportedFile, 1, -1);
  508.     }
  510.     private function generateProxyClasses(): array
  511.     {
  512.         $proxyClasses = [];
  513.         $alreadyGenerated = [];
  514.         $definitions = $this->container->getDefinitions();
  515.         $strip = '' === $this->docStar && method_exists('Symfony\Component\HttpKernel\Kernel', 'stripComments');
  516.         $proxyDumper = $this->getProxyDumper();
  517.         ksort($definitions);
  518.         foreach ($definitions as $definition) {
  519.             if (!$proxyDumper->isProxyCandidate($definition)) {
  520.                 continue;
  521.             }
  522.             if (isset($alreadyGenerated[$class = $definition->getClass()])) {
  523.                 continue;
  524.             }
  525.             $alreadyGenerated[$class] = true;
  526.             // register class' reflector for resource tracking
  527.             $this->container->getReflectionClass($class);
  528.             if ("\n" === $proxyCode = "\n".$proxyDumper->getProxyCode($definition)) {
  529.                 continue;
  530.             }
  532.             if ($this->inlineRequires) {
  533.                 $lineage = [];
  534.                 $this->collectLineage($class, $lineage);
  536.                 $code = '';
  537.                 foreach (array_diff_key(array_flip($lineage), $this->inlinedRequires) as $file => $class) {
  538.                     if ($this->inlineFactories) {
  539.                         $this->inlinedRequires[$file] = true;
  540.                     }
  541.                     $code .= sprintf("include_once %s;\n", $file);
  542.                 }
  544.                 $proxyCode = $code.$proxyCode;
  545.             }
  547.             if ($strip) {
  548.                 $proxyCode = "<?php\n".$proxyCode;
  549.                 $proxyCode = substr(Kernel::stripComments($proxyCode), 5);
  550.             }
  552.             $proxyClasses[sprintf('%s.php', explode(' ', $this->inlineRequires ? substr($proxyCode, \strlen($code)) : $proxyCode, 3)[1])] = $proxyCode;
  553.         }
  555.         return $proxyClasses;
  556.     }
  558.     private function addServiceInclude(string $cId, Definition $definition): string
  559.     {
  560.         $code = '';
  562.         if ($this->inlineRequires && (!$this->isHotPath($definition) || $this->getProxyDumper()->isProxyCandidate($definition))) {
  563.             $lineage = [];
  564.             foreach ($this->inlinedDefinitions as $def) {
  565.                 if (!$def->isDeprecated()) {
  566.                     foreach ($this->getClasses($def) as $class) {
  567.                         $this->collectLineage($class, $lineage);
  568.                     }
  569.                 }
  570.             }
  572.             foreach ($this->serviceCalls as $id => list($callCount, $behavior)) {
  573.                 if ('service_container' !== $id && $id !== $cId
  574.                     && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE !== $behavior
  575.                     && $this->container->has($id)
  576.                     && $this->isTrivialInstance($def = $this->container->findDefinition($id))
  577.                 ) {
  578.                     foreach ($this->getClasses($def) as $class) {
  579.                         $this->collectLineage($class, $lineage);
  580.                     }
  581.                 }
  582.             }
  584.             foreach (array_diff_key(array_flip($lineage), $this->inlinedRequires) as $file => $class) {
  585.                 $code .= sprintf("        include_once %s;\n", $file);
  586.             }
  587.         }
  589.         foreach ($this->inlinedDefinitions as $def) {
  590.             if ($file = $def->getFile()) {
  591.                 $file = $this->dumpValue($file);
  592.                 $file = '(' === $file[0] ? substr($file, 1, -1) : $file;
  593.                 $code .= sprintf("        include_once %s;\n", $file);
  594.             }
  595.         }
  597.         if ('' !== $code) {
  598.             $code .= "\n";
  599.         }
  601.         return $code;
  602.     }
  604.     /**
  605.      * @throws InvalidArgumentException
  606.      * @throws RuntimeException
  607.      */
  608.     private function addServiceInstance(string $id, Definition $definition, bool $isSimpleInstance): string
  609.     {
  610.         $class = $this->dumpValue($definition->getClass());
  612.         if (0 === strpos($class, "'") && false === strpos($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)) {
  613.             throw new InvalidArgumentException(sprintf('"%s" is not a valid class name for the "%s" service.', $class, $id));
  614.         }
  616.         $isProxyCandidate = $this->getProxyDumper()->isProxyCandidate($definition);
  617.         $instantiation = '';
  619.         $lastWitherIndex = null;
  620.         foreach ($definition->getMethodCalls() as $k => $call) {
  621.             if ($call[2] ?? false) {
  622.                 $lastWitherIndex = $k;
  623.             }
  624.         }
  626.         if (!$isProxyCandidate && $definition->isShared() && !isset($this->singleUsePrivateIds[$id]) && null === $lastWitherIndex) {
  627.             $instantiation = sprintf('$this->%s[%s] = %s', $this->container->getDefinition($id)->isPublic() ? 'services' : 'privates', $this->doExport($id), $isSimpleInstance ? '' : '$instance');
  628.         } elseif (!$isSimpleInstance) {
  629.             $instantiation = '$instance';
  630.         }
  632.         $return = '';
  633.         if ($isSimpleInstance) {
  634.             $return = 'return ';
  635.         } else {
  636.             $instantiation .= ' = ';
  637.         }
  639.         return $this->addNewInstance($definition, '        '.$return.$instantiation, $id);
  640.     }
  642.     private function isTrivialInstance(Definition $definition): bool
  643.     {
  644.         if ($definition->hasErrors()) {
  645.             return true;
  646.         }
  647.         if ($definition->isSynthetic() || $definition->getFile() || $definition->getMethodCalls() || $definition->getProperties() || $definition->getConfigurator()) {
  648.             return false;
  649.         }
  650.         if ($definition->isDeprecated() || $definition->isLazy() || $definition->getFactory() || 3 < \count($definition->getArguments())) {
  651.             return false;
  652.         }
  654.         foreach ($definition->getArguments() as $arg) {
  655.             if (!$arg || $arg instanceof Parameter) {
  656.                 continue;
  657.             }
  658.             if (\is_array($arg) && 3 >= \count($arg)) {
  659.                 foreach ($arg as $k => $v) {
  660.                     if ($this->dumpValue($k) !== $this->dumpValue($k, false)) {
  661.                         return false;
  662.                     }
  663.                     if (!$v || $v instanceof Parameter) {
  664.                         continue;
  665.                     }
  666.                     if ($v instanceof Reference && $this->container->has($id = (string) $v) && $this->container->findDefinition($id)->isSynthetic()) {
  667.                         continue;
  668.                     }
  669.                     if (!is_scalar($v) || $this->dumpValue($v) !== $this->dumpValue($v, false)) {
  670.                         return false;
  671.                     }
  672.                 }
  673.             } elseif ($arg instanceof Reference && $this->container->has($id = (string) $arg) && $this->container->findDefinition($id)->isSynthetic()) {
  674.                 continue;
  675.             } elseif (!is_scalar($arg) || $this->dumpValue($arg) !== $this->dumpValue($arg, false)) {
  676.                 return false;
  677.             }
  678.         }
  680.         return true;
  681.     }
  683.     private function addServiceMethodCalls(Definition $definition, string $variableName, ?string $sharedNonLazyId): string
  684.     {
  685.         $lastWitherIndex = null;
  686.         foreach ($definition->getMethodCalls() as $k => $call) {
  687.             if ($call[2] ?? false) {
  688.                 $lastWitherIndex = $k;
  689.             }
  690.         }
  692.         $calls = '';
  693.         foreach ($definition->getMethodCalls() as $k => $call) {
  694.             $arguments = [];
  695.             foreach ($call[1] as $value) {
  696.                 $arguments[] = $this->dumpValue($value);
  697.             }
  699.             $witherAssignation = '';
  701.             if ($call[2] ?? false) {
  702.                 if (null !== $sharedNonLazyId && $lastWitherIndex === $k) {
  703.                     $witherAssignation = sprintf('$this->%s[\'%s\'] = ', $definition->isPublic() ? 'services' : 'privates', $sharedNonLazyId);
  704.                 }
  705.                 $witherAssignation .= sprintf('$%s = ', $variableName);
  706.             }
  708.             $calls .= $this->wrapServiceConditionals($call[1], sprintf("        %s\$%s->%s(%s);\n", $witherAssignation, $variableName, $call[0], implode(', ', $arguments)));
  709.         }
  711.         return $calls;
  712.     }
  714.     private function addServiceProperties(Definition $definition, string $variableName = 'instance'): string
  715.     {
  716.         $code = '';
  717.         foreach ($definition->getProperties() as $name => $value) {
  718.             $code .= sprintf("        \$%s->%s = %s;\n", $variableName, $name, $this->dumpValue($value));
  719.         }
  721.         return $code;
  722.     }
  724.     private function addServiceConfigurator(Definition $definition, string $variableName = 'instance'): string
  725.     {
  726.         if (!$callable = $definition->getConfigurator()) {
  727.             return '';
  728.         }
  730.         if (\is_array($callable)) {
  731.             if ($callable[0] instanceof Reference
  732.                 || ($callable[0] instanceof Definition && $this->definitionVariables->contains($callable[0]))
  733.             ) {
  734.                 return sprintf("        %s->%s(\$%s);\n", $this->dumpValue($callable[0]), $callable[1], $variableName);
  735.             }
  737.             $class = $this->dumpValue($callable[0]);
  738.             // If the class is a string we can optimize away
  739.             if (0 === strpos($class, "'") && false === strpos($class, '$')) {
  740.                 return sprintf("        %s::%s(\$%s);\n", $this->dumpLiteralClass($class), $callable[1], $variableName);
  741.             }
  743.             if (0 === strpos($class, 'new ')) {
  744.                 return sprintf("        (%s)->%s(\$%s);\n", $this->dumpValue($callable[0]), $callable[1], $variableName);
  745.             }
  747.             return sprintf("        [%s, '%s'](\$%s);\n", $this->dumpValue($callable[0]), $callable[1], $variableName);
  748.         }
  750.         return sprintf("        %s(\$%s);\n", $callable, $variableName);
  751.     }
  753.     private function addService(string $id, Definition $definition): array
  754.     {
  755.         $this->definitionVariables = new \SplObjectStorage();
  756.         $this->referenceVariables = [];
  757.         $this->variableCount = 0;
  758.         $this->referenceVariables[$id] = new Variable('instance');
  760.         $return = [];
  762.         if ($class = $definition->getClass()) {
  763.             $class = $class instanceof Parameter ? '%'.$class.'%' : $this->container->resolveEnvPlaceholders($class);
  764.             $return[] = sprintf(0 === strpos($class, '%') ? '@return object A %1$s instance' : '@return \%s', ltrim($class, '\\'));
  765.         } elseif ($definition->getFactory()) {
  766.             $factory = $definition->getFactory();
  767.             if (\is_string($factory)) {
  768.                 $return[] = sprintf('@return object An instance returned by %s()', $factory);
  769.             } elseif (\is_array($factory) && (\is_string($factory[0]) || $factory[0] instanceof Definition || $factory[0] instanceof Reference)) {
  770.                 $class = $factory[0] instanceof Definition ? $factory[0]->getClass() : (string) $factory[0];
  771.                 $class = $class instanceof Parameter ? '%'.$class.'%' : $this->container->resolveEnvPlaceholders($class);
  772.                 $return[] = sprintf('@return object An instance returned by %s::%s()', $class, $factory[1]);
  773.             }
  774.         }
  776.         if ($definition->isDeprecated()) {
  777.             if ($return && 0 === strpos($return[\count($return) - 1], '@return')) {
  778.                 $return[] = '';
  779.             }
  781.             $return[] = sprintf('@deprecated %s', $definition->getDeprecationMessage($id));
  782.         }
  784.         $return = str_replace("\n     * \n", "\n     *\n", implode("\n     * ", $return));
  785.         $return = $this->container->resolveEnvPlaceholders($return);
  787.         $shared = $definition->isShared() ? ' shared' : '';
  788.         $public = $definition->isPublic() ? 'public' : 'private';
  789.         $autowired = $definition->isAutowired() ? ' autowired' : '';
  791.         if ($definition->isLazy()) {
  792.             $lazyInitialization = '$lazyLoad = true';
  793.         } else {
  794.             $lazyInitialization = '';
  795.         }
  797.         $asFile = $this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition);
  798.         $methodName = $this->generateMethodName($id);
  799.         if ($asFile) {
  800.             $file = $methodName.'.php';
  801.             $code = "        // Returns the $public '$id'$shared$autowired service.\n\n";
  802.         } else {
  803.             $file = null;
  804.             $code = <<<EOF
  806.     /*{$this->docStar}
  807.      * Gets the $public '$id'$shared$autowired service.
  808.      *
  809.      * $return
  810. EOF;
  811.             $code = str_replace('*/', ' ', $code).<<<EOF
  813.      */
  814.     protected function {$methodName}($lazyInitialization)
  815.     {
  817. EOF;
  818.         }
  820.         if ($definition->hasErrors() && $e = $definition->getErrors()) {
  821.             $this->addThrow = true;
  823.             $code .= sprintf("        \$this->throw(%s);\n", $this->export(reset($e)));
  824.         } else {
  825.             $this->serviceCalls = [];
  826.             $this->inlinedDefinitions = $this->getDefinitionsFromArguments([$definition], null, $this->serviceCalls);
  828.             if ($definition->isDeprecated()) {
  829.                 $code .= sprintf("        @trigger_error(%s, E_USER_DEPRECATED);\n\n", $this->export($definition->getDeprecationMessage($id)));
  830.             } else {
  831.                 foreach ($this->inlinedDefinitions as $def) {
  832.                     foreach ($this->getClasses($def) as $class) {
  833.                         $this->preload[$class] = $class;
  834.                     }
  835.                 }
  836.             }
  838.             if ($this->getProxyDumper()->isProxyCandidate($definition)) {
  839.                 $factoryCode = $asFile ? ($definition->isShared() ? "\$this->load('%s.php', false)" : '$this->factories[%2$s](false)') : '$this->%s(false)';
  840.                 $code .= $this->getProxyDumper()->getProxyFactoryCode($definition, $id, sprintf($factoryCode, $methodName, $this->doExport($id)));
  841.             }
  843.             $code .= $this->addServiceInclude($id, $definition);
  844.             $code .= $this->addInlineService($id, $definition);
  845.         }
  847.         if ($asFile) {
  848.             $code = implode("\n", array_map(function ($line) { return $line ? substr($line, 8) : $line; }, explode("\n", $code)));
  849.         } else {
  850.             $code .= "    }\n";
  851.         }
  853.         $this->definitionVariables = $this->inlinedDefinitions = null;
  854.         $this->referenceVariables = $this->serviceCalls = null;
  856.         return [$file, $code];
  857.     }
  859.     private function addInlineVariables(string $id, Definition $definition, array $arguments, bool $forConstructor): string
  860.     {
  861.         $code = '';
  863.         foreach ($arguments as $argument) {
  864.             if (\is_array($argument)) {
  865.                 $code .= $this->addInlineVariables($id, $definition, $argument, $forConstructor);
  866.             } elseif ($argument instanceof Reference) {
  867.                 $code .= $this->addInlineReference($id, $definition, $argument, $forConstructor);
  868.             } elseif ($argument instanceof Definition) {
  869.                 $code .= $this->addInlineService($id, $definition, $argument, $forConstructor);
  870.             }
  871.         }
  873.         return $code;
  874.     }
  876.     private function addInlineReference(string $id, Definition $definition, string $targetId, bool $forConstructor): string
  877.     {
  878.         while ($this->container->hasAlias($targetId)) {
  879.             $targetId = (string) $this->container->getAlias($targetId);
  880.         }
  882.         list($callCount, $behavior) = $this->serviceCalls[$targetId];
  884.         if ($id === $targetId) {
  885.             return $this->addInlineService($id, $definition, $definition);
  886.         }
  888.         if ('service_container' === $targetId || isset($this->referenceVariables[$targetId])) {
  889.             return '';
  890.         }
  892.         $hasSelfRef = isset($this->circularReferences[$id][$targetId]) && !isset($this->definitionVariables[$definition]);
  894.         if ($hasSelfRef && !$forConstructor && !$forConstructor = !$this->circularReferences[$id][$targetId]) {
  895.             $code = $this->addInlineService($id, $definition, $definition);
  896.         } else {
  897.             $code = '';
  898.         }
  900.         if (isset($this->referenceVariables[$targetId]) || (2 > $callCount && (!$hasSelfRef || !$forConstructor))) {
  901.             return $code;
  902.         }
  904.         $name = $this->getNextVariableName();
  905.         $this->referenceVariables[$targetId] = new Variable($name);
  907.         $reference = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $behavior ? new Reference($targetId, $behavior) : null;
  908.         $code .= sprintf("        \$%s = %s;\n", $name, $this->getServiceCall($targetId, $reference));
  910.         if (!$hasSelfRef || !$forConstructor) {
  911.             return $code;
  912.         }
  914.         $code .= sprintf(<<<'EOTXT'
  916.         if (isset($this->%s[%s])) {
  917.             return $this->%1$s[%2$s];
  918.         }
  920. EOTXT
  921.             ,
  922.             $this->container->getDefinition($id)->isPublic() ? 'services' : 'privates',
  923.             $this->doExport($id)
  924.         );
  926.         return $code;
  927.     }
  929.     private function addInlineService(string $id, Definition $definition, Definition $inlineDef = null, bool $forConstructor = true): string
  930.     {
  931.         $code = '';
  933.         if ($isSimpleInstance = $isRootInstance = null === $inlineDef) {
  934.             foreach ($this->serviceCalls as $targetId => list($callCount, $behavior, $byConstructor)) {
  935.                 if ($byConstructor && isset($this->circularReferences[$id][$targetId]) && !$this->circularReferences[$id][$targetId]) {
  936.                     $code .= $this->addInlineReference($id, $definition, $targetId, $forConstructor);
  937.                 }
  938.             }
  939.         }
  941.         if (isset($this->definitionVariables[$inlineDef = $inlineDef ?: $definition])) {
  942.             return $code;
  943.         }
  945.         $arguments = [$inlineDef->getArguments(), $inlineDef->getFactory()];
  947.         $code .= $this->addInlineVariables($id, $definition, $arguments, $forConstructor);
  949.         if ($arguments = array_filter([$inlineDef->getProperties(), $inlineDef->getMethodCalls(), $inlineDef->getConfigurator()])) {
  950.             $isSimpleInstance = false;
  951.         } elseif ($definition !== $inlineDef && 2 > $this->inlinedDefinitions[$inlineDef]) {
  952.             return $code;
  953.         }
  955.         if (isset($this->definitionVariables[$inlineDef])) {
  956.             $isSimpleInstance = false;
  957.         } else {
  958.             $name = $definition === $inlineDef ? 'instance' : $this->getNextVariableName();
  959.             $this->definitionVariables[$inlineDef] = new Variable($name);
  960.             $code .= '' !== $code ? "\n" : '';
  962.             if ('instance' === $name) {
  963.                 $code .= $this->addServiceInstance($id, $definition, $isSimpleInstance);
  964.             } else {
  965.                 $code .= $this->addNewInstance($inlineDef, '        $'.$name.' = ', $id);
  966.             }
  968.             if ('' !== $inline = $this->addInlineVariables($id, $definition, $arguments, false)) {
  969.                 $code .= "\n".$inline."\n";
  970.             } elseif ($arguments && 'instance' === $name) {
  971.                 $code .= "\n";
  972.             }
  974.             $code .= $this->addServiceProperties($inlineDef, $name);
  975.             $code .= $this->addServiceMethodCalls($inlineDef, $name, !$this->getProxyDumper()->isProxyCandidate($inlineDef) && $inlineDef->isShared() && !isset($this->singleUsePrivateIds[$id]) ? $id : null);
  976.             $code .= $this->addServiceConfigurator($inlineDef, $name);
  977.         }
  979.         if ($isRootInstance && !$isSimpleInstance) {
  980.             $code .= "\n        return \$instance;\n";
  981.         }
  983.         return $code;
  984.     }
  986.     private function addServices(array &$services = null): string
  987.     {
  988.         $publicServices = $privateServices = '';
  989.         $definitions = $this->container->getDefinitions();
  990.         ksort($definitions);
  991.         foreach ($definitions as $id => $definition) {
  992.             if (!$definition->isSynthetic()) {
  993.                 $services[$id] = $this->addService($id, $definition);
  994.             } else {
  995.                 $services[$id] = null;
  997.                 foreach ($this->getClasses($definition) as $class) {
  998.                     $this->preload[$class] = $class;
  999.                 }
  1000.             }
  1001.         }
  1003.         foreach ($definitions as $id => $definition) {
  1004.             if (!(list($file, $code) = $services[$id]) || null !== $file) {
  1005.                 continue;
  1006.             }
  1007.             if ($definition->isPublic()) {
  1008.                 $publicServices .= $code;
  1009.             } elseif (!$this->isTrivialInstance($definition) || isset($this->locatedIds[$id])) {
  1010.                 $privateServices .= $code;
  1011.             }
  1012.         }
  1014.         return $publicServices.$privateServices;
  1015.     }
  1017.     private function generateServiceFiles(array $services): iterable
  1018.     {
  1019.         $definitions = $this->container->getDefinitions();
  1020.         ksort($definitions);
  1021.         foreach ($definitions as $id => $definition) {
  1022.             if ((list($file, $code) = $services[$id]) && null !== $file && ($definition->isPublic() || !$this->isTrivialInstance($definition) || isset($this->locatedIds[$id]))) {
  1023.                 if (!$definition->isShared()) {
  1024.                     $i = strpos($code, "\n\ninclude_once ");
  1025.                     if (false !== $i && false !== $i = strpos($code, "\n\n", 2 + $i)) {
  1026.                         $code = [substr($code, 0, 2 + $i), substr($code, 2 + $i)];
  1027.                     } else {
  1028.                         $code = ["\n", $code];
  1029.                     }
  1030.                     $code[1] = implode("\n", array_map(function ($line) { return $line ? '    '.$line : $line; }, explode("\n", $code[1])));
  1031.                     $factory = sprintf('$this->factories%s[%s]', $definition->isPublic() ? '' : "['service_container']", $this->doExport($id));
  1032.                     $lazyloadInitialization = $definition->isLazy() ? '$lazyLoad = true' : '';
  1034.                     $code[1] = sprintf("%s = function (%s) {\n%s};\n\nreturn %1\$s();\n", $factory, $lazyloadInitialization, $code[1]);
  1035.                     $code = $code[0].$code[1];
  1036.                 }
  1038.                 yield $file => $code;
  1039.             }
  1040.         }
  1041.     }
  1043.     private function addNewInstance(Definition $definition, string $return = '', string $id = null): string
  1044.     {
  1045.         $tail = $return ? ";\n" : '';
  1047.         if (BaseServiceLocator::class === $definition->getClass() && $definition->hasTag($this->serviceLocatorTag)) {
  1048.             $arguments = [];
  1049.             foreach ($definition->getArgument(0) as $k => $argument) {
  1050.                 $arguments[$k] = $argument->getValues()[0];
  1051.             }
  1053.             return $return.$this->dumpValue(new ServiceLocatorArgument($arguments)).$tail;
  1054.         }
  1056.         $arguments = [];
  1057.         foreach ($definition->getArguments() as $value) {
  1058.             $arguments[] = $this->dumpValue($value);
  1059.         }
  1061.         if (null !== $definition->getFactory()) {
  1062.             $callable = $definition->getFactory();
  1064.             if (\is_array($callable)) {
  1065.                 if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $callable[1])) {
  1066.                     throw new RuntimeException(sprintf('Cannot dump definition because of invalid factory method (%s).', $callable[1] ?: 'n/a'));
  1067.                 }
  1069.                 if ($callable[0] instanceof Reference
  1070.                     || ($callable[0] instanceof Definition && $this->definitionVariables->contains($callable[0]))) {
  1071.                     return $return.sprintf('%s->%s(%s)', $this->dumpValue($callable[0]), $callable[1], $arguments ? implode(', ', $arguments) : '').$tail;
  1072.                 }
  1074.                 $class = $this->dumpValue($callable[0]);
  1075.                 // If the class is a string we can optimize away
  1076.                 if (0 === strpos($class, "'") && false === strpos($class, '$')) {
  1077.                     if ("''" === $class) {
  1078.                         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'));
  1079.                     }
  1081.                     return $return.sprintf('%s::%s(%s)', $this->dumpLiteralClass($class), $callable[1], $arguments ? implode(', ', $arguments) : '').$tail;
  1082.                 }
  1084.                 if (0 === strpos($class, 'new ')) {
  1085.                     return $return.sprintf('(%s)->%s(%s)', $class, $callable[1], $arguments ? implode(', ', $arguments) : '').$tail;
  1086.                 }
  1088.                 return $return.sprintf("[%s, '%s'](%s)", $class, $callable[1], $arguments ? implode(', ', $arguments) : '').$tail;
  1089.             }
  1091.             return $return.sprintf('%s(%s)', $this->dumpLiteralClass($this->dumpValue($callable)), $arguments ? implode(', ', $arguments) : '').$tail;
  1092.         }
  1094.         if (null === $class = $definition->getClass()) {
  1095.             throw new RuntimeException('Cannot dump definitions which have no class nor factory.');
  1096.         }
  1098.         return $return.sprintf('new %s(%s)', $this->dumpLiteralClass($this->dumpValue($class)), implode(', ', $arguments)).$tail;
  1099.     }
  1101.     private function startClass(string $class, string $baseClass): string
  1102.     {
  1103.         $namespaceLine = !$this->asFiles && $this->namespace ? "\nnamespace {$this->namespace};\n" : '';
  1105.         $code = <<<EOF
  1106. <?php
  1107. $namespaceLine
  1108. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  1109. use Symfony\Component\DependencyInjection\ContainerInterface;
  1110. use Symfony\Component\DependencyInjection\Container;
  1111. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  1112. use Symfony\Component\DependencyInjection\Exception\LogicException;
  1113. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  1114. use Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag;
  1115. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  1117. /*{$this->docStar}
  1118.  * This class has been auto-generated
  1119.  * by the Symfony Dependency Injection Component.
  1120.  *
  1121.  * @final
  1122.  */
  1123. class $class extends $baseClass
  1124. {
  1125.     private \$parameters = [];
  1127.     public function __construct()
  1128.     {
  1130. EOF;
  1131.         if ($this->asFiles) {
  1132.             $code = str_replace('$parameters', "\$buildParameters;\n    private \$containerDir;\n    private \$parameters", $code);
  1133.             $code = str_replace('__construct()', '__construct(array $buildParameters = [], $containerDir = __DIR__)', $code);
  1134.             $code .= "        \$this->buildParameters = \$buildParameters;\n";
  1135.             $code .= "        \$this->containerDir = \$containerDir;\n";
  1137.             if (null !== $this->targetDirRegex) {
  1138.                 $code = str_replace('$parameters', "\$targetDir;\n    private \$parameters", $code);
  1139.                 $code .= '        $this->targetDir = \\dirname($containerDir);'."\n";
  1140.             }
  1141.         }
  1143.         if (Container::class !== $this->baseClass) {
  1144.             $r = $this->container->getReflectionClass($this->baseClass, false);
  1145.             if (null !== $r
  1146.                 && (null !== $constructor = $r->getConstructor())
  1147.                 && 0 === $constructor->getNumberOfRequiredParameters()
  1148.                 && Container::class !== $constructor->getDeclaringClass()->name
  1149.             ) {
  1150.                 $code .= "        parent::__construct();\n";
  1151.                 $code .= "        \$this->parameterBag = null;\n\n";
  1152.             }
  1153.         }
  1155.         if ($this->container->getParameterBag()->all()) {
  1156.             $code .= "        \$this->parameters = \$this->getDefaultParameters();\n\n";
  1157.         }
  1158.         $code .= "        \$this->services = \$this->privates = [];\n";
  1160.         $code .= $this->addSyntheticIds();
  1161.         $code .= $this->addMethodMap();
  1162.         $code .= $this->asFiles && !$this->inlineFactories ? $this->addFileMap() : '';
  1163.         $code .= $this->addAliases();
  1164.         $code .= $this->addInlineRequires();
  1165.         $code .= <<<EOF
  1166.     }
  1168.     public function compile(): void
  1169.     {
  1170.         throw new LogicException('You cannot compile a dumped container that was already compiled.');
  1171.     }
  1173.     public function isCompiled(): bool
  1174.     {
  1175.         return true;
  1176.     }
  1178. EOF;
  1179.         $code .= $this->addRemovedIds();
  1181.         if ($this->asFiles && !$this->inlineFactories) {
  1182.             $code .= <<<EOF
  1184.     protected function load(\$file, \$lazyLoad = true)
  1185.     {
  1186.         return require \$this->containerDir.\\DIRECTORY_SEPARATOR.\$file;
  1187.     }
  1189. EOF;
  1190.         }
  1192.         $proxyDumper = $this->getProxyDumper();
  1193.         foreach ($this->container->getDefinitions() as $definition) {
  1194.             if (!$proxyDumper->isProxyCandidate($definition)) {
  1195.                 continue;
  1196.             }
  1197.             if ($this->asFiles && !$this->inlineFactories) {
  1198.                 $proxyLoader = '$this->load("{$class}.php")';
  1199.             } elseif ($this->namespace || $this->inlineFactories) {
  1200.                 $proxyLoader = 'class_alias(__NAMESPACE__."\\\\$class", $class, false)';
  1201.             } else {
  1202.                 $proxyLoader = '';
  1203.             }
  1204.             if ($proxyLoader) {
  1205.                 $proxyLoader = "class_exists(\$class, false) || {$proxyLoader};\n\n        ";
  1206.             }
  1207.             $code .= <<<EOF
  1209.     protected function createProxy(\$class, \Closure \$factory)
  1210.     {
  1211.         {$proxyLoader}return \$factory();
  1212.     }
  1214. EOF;
  1215.             break;
  1216.         }
  1218.         return $code;
  1219.     }
  1221.     private function addSyntheticIds(): string
  1222.     {
  1223.         $code = '';
  1224.         $definitions = $this->container->getDefinitions();
  1225.         ksort($definitions);
  1226.         foreach ($definitions as $id => $definition) {
  1227.             if ($definition->isSynthetic() && 'service_container' !== $id) {
  1228.                 $code .= '            '.$this->doExport($id)." => true,\n";
  1229.             }
  1230.         }
  1232.         return $code ? "        \$this->syntheticIds = [\n{$code}        ];\n" : '';
  1233.     }
  1235.     private function addRemovedIds(): string
  1236.     {
  1237.         $ids = $this->container->getRemovedIds();
  1238.         foreach ($this->container->getDefinitions() as $id => $definition) {
  1239.             if (!$definition->isPublic()) {
  1240.                 $ids[$id] = true;
  1241.             }
  1242.         }
  1243.         if (!$ids) {
  1244.             return '';
  1245.         }
  1246.         if ($this->asFiles) {
  1247.             $code = "require \$this->containerDir.\\DIRECTORY_SEPARATOR.'removed-ids.php'";
  1248.         } else {
  1249.             $code = '';
  1250.             $ids = array_keys($ids);
  1251.             sort($ids);
  1252.             foreach ($ids as $id) {
  1253.                 if (preg_match(FileLoader::ANONYMOUS_ID_REGEXP, $id)) {
  1254.                     continue;
  1255.                 }
  1256.                 $code .= '            '.$this->doExport($id)." => true,\n";
  1257.             }
  1259.             $code = "[\n{$code}        ]";
  1260.         }
  1262.         return <<<EOF
  1264.     public function getRemovedIds(): array
  1265.     {
  1266.         return {$code};
  1267.     }
  1269. EOF;
  1270.     }
  1272.     private function addMethodMap(): string
  1273.     {
  1274.         $code = '';
  1275.         $definitions = $this->container->getDefinitions();
  1276.         ksort($definitions);
  1277.         foreach ($definitions as $id => $definition) {
  1278.             if (!$definition->isSynthetic() && $definition->isPublic() && (!$this->asFiles || $this->inlineFactories || $this->isHotPath($definition))) {
  1279.                 $code .= '            '.$this->doExport($id).' => '.$this->doExport($this->generateMethodName($id)).",\n";
  1280.             }
  1281.         }
  1283.         $aliases = $this->container->getAliases();
  1284.         foreach ($aliases as $alias => $id) {
  1285.             if (!$id->isDeprecated()) {
  1286.                 continue;
  1287.             }
  1288.             $code .= '            '.$this->doExport($alias).' => '.$this->doExport($this->generateMethodName($alias)).",\n";
  1289.         }
  1291.         return $code ? "        \$this->methodMap = [\n{$code}        ];\n" : '';
  1292.     }
  1294.     private function addFileMap(): string
  1295.     {
  1296.         $code = '';
  1297.         $definitions = $this->container->getDefinitions();
  1298.         ksort($definitions);
  1299.         foreach ($definitions as $id => $definition) {
  1300.             if (!$definition->isSynthetic() && $definition->isPublic() && !$this->isHotPath($definition)) {
  1301.                 $code .= sprintf("            %s => '%s.php',\n", $this->doExport($id), $this->generateMethodName($id));
  1302.             }
  1303.         }
  1305.         return $code ? "        \$this->fileMap = [\n{$code}        ];\n" : '';
  1306.     }
  1308.     private function addAliases(): string
  1309.     {
  1310.         if (!$aliases = $this->container->getAliases()) {
  1311.             return "\n        \$this->aliases = [];\n";
  1312.         }
  1314.         $code = "        \$this->aliases = [\n";
  1315.         ksort($aliases);
  1316.         foreach ($aliases as $alias => $id) {
  1317.             if ($id->isDeprecated()) {
  1318.                 continue;
  1319.             }
  1321.             $id = (string) $id;
  1322.             while (isset($aliases[$id])) {
  1323.                 $id = (string) $aliases[$id];
  1324.             }
  1325.             $code .= '            '.$this->doExport($alias).' => '.$this->doExport($id).",\n";
  1326.         }
  1328.         return $code."        ];\n";
  1329.     }
  1331.     private function addDeprecatedAliases(): string
  1332.     {
  1333.         $code = '';
  1334.         $aliases = $this->container->getAliases();
  1335.         foreach ($aliases as $alias => $definition) {
  1336.             if (!$definition->isDeprecated()) {
  1337.                 continue;
  1338.             }
  1339.             $public = $definition->isPublic() ? 'public' : 'private';
  1340.             $id = (string) $definition;
  1341.             $methodNameAlias = $this->generateMethodName($alias);
  1342.             $idExported = $this->export($id);
  1343.             $messageExported = $this->export($definition->getDeprecationMessage($alias));
  1344.             $code .= <<<EOF
  1346.     /*{$this->docStar}
  1347.      * Gets the $public '$alias' alias.
  1348.      *
  1349.      * @return object The "$id" service.
  1350.      */
  1351.     protected function {$methodNameAlias}()
  1352.     {
  1353.         @trigger_error($messageExported, E_USER_DEPRECATED);
  1355.         return \$this->get($idExported);
  1356.     }
  1358. EOF;
  1359.         }
  1361.         return $code;
  1362.     }
  1364.     private function addInlineRequires(): string
  1365.     {
  1366.         if (!$this->hotPathTag || !$this->inlineRequires) {
  1367.             return '';
  1368.         }
  1370.         $lineage = [];
  1372.         foreach ($this->container->findTaggedServiceIds($this->hotPathTag) as $id => $tags) {
  1373.             $definition = $this->container->getDefinition($id);
  1375.             if ($this->getProxyDumper()->isProxyCandidate($definition)) {
  1376.                 continue;
  1377.             }
  1379.             $inlinedDefinitions = $this->getDefinitionsFromArguments([$definition]);
  1381.             foreach ($inlinedDefinitions as $def) {
  1382.                 foreach ($this->getClasses($def) as $class) {
  1383.                     $this->collectLineage($class, $lineage);
  1384.                 }
  1385.             }
  1386.         }
  1388.         $code = '';
  1390.         foreach ($lineage as $file) {
  1391.             if (!isset($this->inlinedRequires[$file])) {
  1392.                 $this->inlinedRequires[$file] = true;
  1393.                 $code .= sprintf("\n            include_once %s;", $file);
  1394.             }
  1395.         }
  1397.         return $code ? sprintf("\n        \$this->privates['service_container'] = function () {%s\n        };\n", $code) : '';
  1398.     }
  1400.     private function addDefaultParametersMethod(): string
  1401.     {
  1402.         if (!$this->container->getParameterBag()->all()) {
  1403.             return '';
  1404.         }
  1406.         $php = [];
  1407.         $dynamicPhp = [];
  1409.         foreach ($this->container->getParameterBag()->all() as $key => $value) {
  1410.             if ($key !== $resolvedKey = $this->container->resolveEnvPlaceholders($key)) {
  1411.                 throw new InvalidArgumentException(sprintf('Parameter name cannot use env parameters: "%s".', $resolvedKey));
  1412.             }
  1413.             $export = $this->exportParameters([$value]);
  1414.             $export = explode('0 => ', substr(rtrim($export, " ]\n"), 2, -1), 2);
  1416.             if (preg_match("/\\\$this->(?:getEnv\('(?:\w++:)*+\w++'\)|targetDir\.'')/", $export[1])) {
  1417.                 $dynamicPhp[$key] = sprintf('%scase %s: $value = %s; break;', $export[0], $this->export($key), $export[1]);
  1418.             } else {
  1419.                 $php[] = sprintf('%s%s => %s,', $export[0], $this->export($key), $export[1]);
  1420.             }
  1421.         }
  1422.         $parameters = sprintf("[\n%s\n%s]", implode("\n", $php), str_repeat(' ', 8));
  1424.         $code = <<<'EOF'
  1426.     public function getParameter(string $name)
  1427.     {
  1428.         if (isset($this->buildParameters[$name])) {
  1429.             return $this->buildParameters[$name];
  1430.         }
  1432.         if (!(isset($this->parameters[$name]) || isset($this->loadedDynamicParameters[$name]) || array_key_exists($name, $this->parameters))) {
  1433.             throw new InvalidArgumentException(sprintf('The parameter "%s" must be defined.', $name));
  1434.         }
  1435.         if (isset($this->loadedDynamicParameters[$name])) {
  1436.             return $this->loadedDynamicParameters[$name] ? $this->dynamicParameters[$name] : $this->getDynamicParameter($name);
  1437.         }
  1439.         return $this->parameters[$name];
  1440.     }
  1442.     public function hasParameter(string $name): bool
  1443.     {
  1444.         if (isset($this->buildParameters[$name])) {
  1445.             return true;
  1446.         }
  1448.         return isset($this->parameters[$name]) || isset($this->loadedDynamicParameters[$name]) || array_key_exists($name, $this->parameters);
  1449.     }
  1451.     public function setParameter(string $name, $value): void
  1452.     {
  1453.         throw new LogicException('Impossible to call set() on a frozen ParameterBag.');
  1454.     }
  1456.     public function getParameterBag(): ParameterBagInterface
  1457.     {
  1458.         if (null === $this->parameterBag) {
  1459.             $parameters = $this->parameters;
  1460.             foreach ($this->loadedDynamicParameters as $name => $loaded) {
  1461.                 $parameters[$name] = $loaded ? $this->dynamicParameters[$name] : $this->getDynamicParameter($name);
  1462.             }
  1463.             foreach ($this->buildParameters as $name => $value) {
  1464.                 $parameters[$name] = $value;
  1465.             }
  1466.             $this->parameterBag = new FrozenParameterBag($parameters);
  1467.         }
  1469.         return $this->parameterBag;
  1470.     }
  1472. EOF;
  1473.         if (!$this->asFiles) {
  1474.             $code = preg_replace('/^.*buildParameters.*\n.*\n.*\n\n?/m', '', $code);
  1475.         }
  1477.         if ($dynamicPhp) {
  1478.             $loadedDynamicParameters = $this->exportParameters(array_combine(array_keys($dynamicPhp), array_fill(0, \count($dynamicPhp), false)), '', 8);
  1479.             $getDynamicParameter = <<<'EOF'
  1480.         switch ($name) {
  1481. %s
  1482.             default: throw new InvalidArgumentException(sprintf('The dynamic parameter "%%s" must be defined.', $name));
  1483.         }
  1484.         $this->loadedDynamicParameters[$name] = true;
  1486.         return $this->dynamicParameters[$name] = $value;
  1487. EOF;
  1488.             $getDynamicParameter = sprintf($getDynamicParameter, implode("\n", $dynamicPhp));
  1489.         } else {
  1490.             $loadedDynamicParameters = '[]';
  1491.             $getDynamicParameter = str_repeat(' ', 8).'throw new InvalidArgumentException(sprintf(\'The dynamic parameter "%s" must be defined.\', $name));';
  1492.         }
  1494.         $code .= <<<EOF
  1496.     private \$loadedDynamicParameters = {$loadedDynamicParameters};
  1497.     private \$dynamicParameters = [];
  1499.     private function getDynamicParameter(string \$name)
  1500.     {
  1501. {$getDynamicParameter}
  1502.     }
  1504.     protected function getDefaultParameters(): array
  1505.     {
  1506.         return $parameters;
  1507.     }
  1509. EOF;
  1511.         return $code;
  1512.     }
  1514.     /**
  1515.      * @throws InvalidArgumentException
  1516.      */
  1517.     private function exportParameters(array $parameters, string $path = '', int $indent = 12): string
  1518.     {
  1519.         $php = [];
  1520.         foreach ($parameters as $key => $value) {
  1521.             if (\is_array($value)) {
  1522.                 $value = $this->exportParameters($value, $path.'/'.$key, $indent + 4);
  1523.             } elseif ($value instanceof ArgumentInterface) {
  1524.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain special arguments. "%s" found in "%s".', \get_class($value), $path.'/'.$key));
  1525.             } elseif ($value instanceof Variable) {
  1526.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain variable references. Variable "%s" found in "%s".', $value, $path.'/'.$key));
  1527.             } elseif ($value instanceof Definition) {
  1528.                 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));
  1529.             } elseif ($value instanceof Reference) {
  1530.                 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));
  1531.             } elseif ($value instanceof Expression) {
  1532.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain expressions. Expression "%s" found in "%s".', $value, $path.'/'.$key));
  1533.             } else {
  1534.                 $value = $this->export($value);
  1535.             }
  1537.             $php[] = sprintf('%s%s => %s,', str_repeat(' ', $indent), $this->export($key), $value);
  1538.         }
  1540.         return sprintf("[\n%s\n%s]", implode("\n", $php), str_repeat(' ', $indent - 4));
  1541.     }
  1543.     private function endClass(): string
  1544.     {
  1545.         if ($this->addThrow) {
  1546.             return <<<'EOF'
  1548.     protected function throw($message)
  1549.     {
  1550.         throw new RuntimeException($message);
  1551.     }
  1552. }
  1554. EOF;
  1555.         }
  1557.         return <<<'EOF'
  1558. }
  1560. EOF;
  1561.     }
  1563.     private function wrapServiceConditionals($value, string $code): string
  1564.     {
  1565.         if (!$condition = $this->getServiceConditionals($value)) {
  1566.             return $code;
  1567.         }
  1569.         // re-indent the wrapped code
  1570.         $code = implode("\n", array_map(function ($line) { return $line ? '    '.$line : $line; }, explode("\n", $code)));
  1572.         return sprintf("        if (%s) {\n%s        }\n", $condition, $code);
  1573.     }
  1575.     private function getServiceConditionals($value): string
  1576.     {
  1577.         $conditions = [];
  1578.         foreach (ContainerBuilder::getInitializedConditionals($value) as $service) {
  1579.             if (!$this->container->hasDefinition($service)) {
  1580.                 return 'false';
  1581.             }
  1582.             $conditions[] = sprintf('isset($this->%s[%s])', $this->container->getDefinition($service)->isPublic() ? 'services' : 'privates', $this->doExport($service));
  1583.         }
  1584.         foreach (ContainerBuilder::getServiceConditionals($value) as $service) {
  1585.             if ($this->container->hasDefinition($service) && !$this->container->getDefinition($service)->isPublic()) {
  1586.                 continue;
  1587.             }
  1589.             $conditions[] = sprintf('$this->has(%s)', $this->doExport($service));
  1590.         }
  1592.         if (!$conditions) {
  1593.             return '';
  1594.         }
  1596.         return implode(' && ', $conditions);
  1597.     }
  1599.     private function getDefinitionsFromArguments(array $arguments, \SplObjectStorage $definitions = null, array &$calls = [], bool $byConstructor = null): \SplObjectStorage
  1600.     {
  1601.         if (null === $definitions) {
  1602.             $definitions = new \SplObjectStorage();
  1603.         }
  1605.         foreach ($arguments as $argument) {
  1606.             if (\is_array($argument)) {
  1607.                 $this->getDefinitionsFromArguments($argument, $definitions, $calls, $byConstructor);
  1608.             } elseif ($argument instanceof Reference) {
  1609.                 $id = (string) $argument;
  1611.                 while ($this->container->hasAlias($id)) {
  1612.                     $id = (string) $this->container->getAlias($id);
  1613.                 }
  1615.                 if (!isset($calls[$id])) {
  1616.                     $calls[$id] = [0, $argument->getInvalidBehavior(), $byConstructor];
  1617.                 } else {
  1618.                     $calls[$id][1] = min($calls[$id][1], $argument->getInvalidBehavior());
  1619.                 }
  1621.                 ++$calls[$id][0];
  1622.             } elseif (!$argument instanceof Definition) {
  1623.                 // no-op
  1624.             } elseif (isset($definitions[$argument])) {
  1625.                 $definitions[$argument] = 1 + $definitions[$argument];
  1626.             } else {
  1627.                 $definitions[$argument] = 1;
  1628.                 $arguments = [$argument->getArguments(), $argument->getFactory()];
  1629.                 $this->getDefinitionsFromArguments($arguments, $definitions, $calls, null === $byConstructor || $byConstructor);
  1630.                 $arguments = [$argument->getProperties(), $argument->getMethodCalls(), $argument->getConfigurator()];
  1631.                 $this->getDefinitionsFromArguments($arguments, $definitions, $calls, null !== $byConstructor && $byConstructor);
  1632.             }
  1633.         }
  1635.         return $definitions;
  1636.     }
  1638.     /**
  1639.      * @throws RuntimeException
  1640.      */
  1641.     private function dumpValue($value, bool $interpolate = true): string
  1642.     {
  1643.         if (\is_array($value)) {
  1644.             if ($value && $interpolate && false !== $param = array_search($value, $this->container->getParameterBag()->all(), true)) {
  1645.                 return $this->dumpValue("%$param%");
  1646.             }
  1647.             $code = [];
  1648.             foreach ($value as $k => $v) {
  1649.                 $code[] = sprintf('%s => %s', $this->dumpValue($k, $interpolate), $this->dumpValue($v, $interpolate));
  1650.             }
  1652.             return sprintf('[%s]', implode(', ', $code));
  1653.         } elseif ($value instanceof ArgumentInterface) {
  1654.             $scope = [$this->definitionVariables, $this->referenceVariables];
  1655.             $this->definitionVariables = $this->referenceVariables = null;
  1657.             try {
  1658.                 if ($value instanceof ServiceClosureArgument) {
  1659.                     $value = $value->getValues()[0];
  1660.                     $code = $this->dumpValue($value, $interpolate);
  1662.                     $returnedType = '';
  1663.                     if ($value instanceof TypedReference) {
  1664.                         $returnedType = sprintf(': %s\%s', ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $value->getInvalidBehavior() ? '' : '?', $value->getType());
  1665.                     }
  1667.                     $code = sprintf('return %s;', $code);
  1669.                     return sprintf("function ()%s {\n            %s\n        }", $returnedType, $code);
  1670.                 }
  1672.                 if ($value instanceof IteratorArgument) {
  1673.                     $operands = [0];
  1674.                     $code = [];
  1675.                     $code[] = 'new RewindableGenerator(function () {';
  1677.                     if (!$values = $value->getValues()) {
  1678.                         $code[] = '            return new \EmptyIterator();';
  1679.                     } else {
  1680.                         $countCode = [];
  1681.                         $countCode[] = 'function () {';
  1683.                         foreach ($values as $k => $v) {
  1684.                             ($c = $this->getServiceConditionals($v)) ? $operands[] = "(int) ($c)" : ++$operands[0];
  1685.                             $v = $this->wrapServiceConditionals($v, sprintf("        yield %s => %s;\n", $this->dumpValue($k, $interpolate), $this->dumpValue($v, $interpolate)));
  1686.                             foreach (explode("\n", $v) as $v) {
  1687.                                 if ($v) {
  1688.                                     $code[] = '    '.$v;
  1689.                                 }
  1690.                             }
  1691.                         }
  1693.                         $countCode[] = sprintf('            return %s;', implode(' + ', $operands));
  1694.                         $countCode[] = '        }';
  1695.                     }
  1697.                     $code[] = sprintf('        }, %s)', \count($operands) > 1 ? implode("\n", $countCode) : $operands[0]);
  1699.                     return implode("\n", $code);
  1700.                 }
  1702.                 if ($value instanceof ServiceLocatorArgument) {
  1703.                     $serviceMap = '';
  1704.                     $serviceTypes = '';
  1705.                     foreach ($value->getValues() as $k => $v) {
  1706.                         if (!$v) {
  1707.                             continue;
  1708.                         }
  1709.                         $id = (string) $v;
  1710.                         while ($this->container->hasAlias($id)) {
  1711.                             $id = (string) $this->container->getAlias($id);
  1712.                         }
  1713.                         $definition = $this->container->getDefinition($id);
  1714.                         $load = !($definition->hasErrors() && $e = $definition->getErrors()) ? $this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition) : reset($e);
  1715.                         $serviceMap .= sprintf("\n            %s => [%s, %s, %s, %s],",
  1716.                             $this->export($k),
  1717.                             $this->export($definition->isShared() ? ($definition->isPublic() ? 'services' : 'privates') : false),
  1718.                             $this->doExport($id),
  1719.                             $this->export(ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE !== $v->getInvalidBehavior() && !\is_string($load) ? $this->generateMethodName($id).($load ? '.php' : '') : null),
  1720.                             $this->export($load)
  1721.                         );
  1722.                         $serviceTypes .= sprintf("\n            %s => %s,", $this->export($k), $this->export($v instanceof TypedReference ? $v->getType() : '?'));
  1723.                         $this->locatedIds[$id] = true;
  1724.                     }
  1725.                     $this->addGetService = true;
  1727.                     return sprintf('new \%s($this->getService, [%s%s], [%s%s])', ServiceLocator::class, $serviceMap, $serviceMap ? "\n        " : '', $serviceTypes, $serviceTypes ? "\n        " : '');
  1728.                 }
  1729.             } finally {
  1730.                 list($this->definitionVariables, $this->referenceVariables) = $scope;
  1731.             }
  1732.         } elseif ($value instanceof Definition) {
  1733.             if ($value->hasErrors() && $e = $value->getErrors()) {
  1734.                 $this->addThrow = true;
  1736.                 return sprintf('$this->throw(%s)', $this->export(reset($e)));
  1737.             }
  1738.             if (null !== $this->definitionVariables && $this->definitionVariables->contains($value)) {
  1739.                 return $this->dumpValue($this->definitionVariables[$value], $interpolate);
  1740.             }
  1741.             if ($value->getMethodCalls()) {
  1742.                 throw new RuntimeException('Cannot dump definitions which have method calls.');
  1743.             }
  1744.             if ($value->getProperties()) {
  1745.                 throw new RuntimeException('Cannot dump definitions which have properties.');
  1746.             }
  1747.             if (null !== $value->getConfigurator()) {
  1748.                 throw new RuntimeException('Cannot dump definitions which have a configurator.');
  1749.             }
  1751.             return $this->addNewInstance($value);
  1752.         } elseif ($value instanceof Variable) {
  1753.             return '$'.$value;
  1754.         } elseif ($value instanceof Reference) {
  1755.             $id = (string) $value;
  1757.             while ($this->container->hasAlias($id)) {
  1758.                 $id = (string) $this->container->getAlias($id);
  1759.             }
  1761.             if (null !== $this->referenceVariables && isset($this->referenceVariables[$id])) {
  1762.                 return $this->dumpValue($this->referenceVariables[$id], $interpolate);
  1763.             }
  1765.             return $this->getServiceCall($id, $value);
  1766.         } elseif ($value instanceof Expression) {
  1767.             return $this->getExpressionLanguage()->compile((string) $value, ['this' => 'container']);
  1768.         } elseif ($value instanceof Parameter) {
  1769.             return $this->dumpParameter($value);
  1770.         } elseif (true === $interpolate && \is_string($value)) {
  1771.             if (preg_match('/^%([^%]+)%$/', $value, $match)) {
  1772.                 // we do this to deal with non string values (Boolean, integer, ...)
  1773.                 // the preg_replace_callback converts them to strings
  1774.                 return $this->dumpParameter($match[1]);
  1775.             } else {
  1776.                 $replaceParameters = function ($match) {
  1777.                     return "'.".$this->dumpParameter($match[2]).".'";
  1778.                 };
  1780.                 $code = str_replace('%%', '%', preg_replace_callback('/(?<!%)(%)([^%]+)\1/', $replaceParameters, $this->export($value)));
  1782.                 return $code;
  1783.             }
  1784.         } elseif (\is_object($value) || \is_resource($value)) {
  1785.             throw new RuntimeException('Unable to dump a service container if a parameter is an object or a resource.');
  1786.         }
  1788.         return $this->export($value);
  1789.     }
  1791.     /**
  1792.      * Dumps a string to a literal (aka PHP Code) class value.
  1793.      *
  1794.      * @throws RuntimeException
  1795.      */
  1796.     private function dumpLiteralClass(string $class): string
  1797.     {
  1798.         if (false !== strpos($class, '$')) {
  1799.             return sprintf('${($_ = %s) && false ?: "_"}', $class);
  1800.         }
  1801.         if (0 !== strpos($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)) {
  1802.             throw new RuntimeException(sprintf('Cannot dump definition because of invalid class name (%s).', $class ?: 'n/a'));
  1803.         }
  1805.         $class = substr(str_replace('\\\\', '\\', $class), 1, -1);
  1807.         return 0 === strpos($class, '\\') ? $class : '\\'.$class;
  1808.     }
  1810.     private function dumpParameter(string $name): string
  1811.     {
  1812.         if ($this->container->hasParameter($name)) {
  1813.             $value = $this->container->getParameter($name);
  1814.             $dumpedValue = $this->dumpValue($value, false);
  1816.             if (!$value || !\is_array($value)) {
  1817.                 return $dumpedValue;
  1818.             }
  1820.             if (!preg_match("/\\\$this->(?:getEnv\('(?:\w++:)*+\w++'\)|targetDir\.'')/", $dumpedValue)) {
  1821.                 return sprintf('$this->parameters[%s]', $this->doExport($name));
  1822.             }
  1823.         }
  1825.         return sprintf('$this->getParameter(%s)', $this->doExport($name));
  1826.     }
  1828.     private function getServiceCall(string $id, Reference $reference = null): string
  1829.     {
  1830.         while ($this->container->hasAlias($id)) {
  1831.             $id = (string) $this->container->getAlias($id);
  1832.         }
  1834.         if ('service_container' === $id) {
  1835.             return '$this';
  1836.         }
  1838.         if ($this->container->hasDefinition($id) && $definition = $this->container->getDefinition($id)) {
  1839.             if ($definition->isSynthetic()) {
  1840.                 $code = sprintf('$this->get(%s%s)', $this->doExport($id), null !== $reference ? ', '.$reference->getInvalidBehavior() : '');
  1841.             } elseif (null !== $reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $reference->getInvalidBehavior()) {
  1842.                 $code = 'null';
  1843.                 if (!$definition->isShared()) {
  1844.                     return $code;
  1845.                 }
  1846.             } elseif ($this->isTrivialInstance($definition)) {
  1847.                 if ($definition->hasErrors() && $e = $definition->getErrors()) {
  1848.                     $this->addThrow = true;
  1850.                     return sprintf('$this->throw(%s)', $this->export(reset($e)));
  1851.                 }
  1852.                 $code = $this->addNewInstance($definition, '', $id);
  1853.                 if ($definition->isShared() && !isset($this->singleUsePrivateIds[$id])) {
  1854.                     $code = sprintf('$this->%s[%s] = %s', $definition->isPublic() ? 'services' : 'privates', $this->doExport($id), $code);
  1855.                 }
  1856.                 $code = "($code)";
  1857.             } elseif ($this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition)) {
  1858.                 $code = sprintf("\$this->load('%s.php')", $this->generateMethodName($id));
  1859.                 if (!$definition->isShared()) {
  1860.                     $factory = sprintf('$this->factories%s[%s]', $definition->isPublic() ? '' : "['service_container']", $this->doExport($id));
  1861.                     $code = sprintf('(isset(%s) ? %1$s() : %s)', $factory, $code);
  1862.                 }
  1863.             } else {
  1864.                 $code = sprintf('$this->%s()', $this->generateMethodName($id));
  1865.             }
  1866.             if ($definition->isShared() && !isset($this->singleUsePrivateIds[$id])) {
  1867.                 $code = sprintf('($this->%s[%s] ?? %s)', $definition->isPublic() ? 'services' : 'privates', $this->doExport($id), $code);
  1868.             }
  1870.             return $code;
  1871.         }
  1872.         if (null !== $reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $reference->getInvalidBehavior()) {
  1873.             return 'null';
  1874.         }
  1875.         if (null !== $reference && ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE < $reference->getInvalidBehavior()) {
  1876.             $code = sprintf('$this->get(%s, /* ContainerInterface::NULL_ON_INVALID_REFERENCE */ %d)', $this->doExport($id), ContainerInterface::NULL_ON_INVALID_REFERENCE);
  1877.         } else {
  1878.             $code = sprintf('$this->get(%s)', $this->doExport($id));
  1879.         }
  1881.         return sprintf('($this->services[%s] ?? %s)', $this->doExport($id), $code);
  1882.     }
  1884.     /**
  1885.      * Initializes the method names map to avoid conflicts with the Container methods.
  1886.      */
  1887.     private function initializeMethodNamesMap(string $class)
  1888.     {
  1889.         $this->serviceIdToMethodNameMap = [];
  1890.         $this->usedMethodNames = [];
  1892.         if ($reflectionClass = $this->container->getReflectionClass($class)) {
  1893.             foreach ($reflectionClass->getMethods() as $method) {
  1894.                 $this->usedMethodNames[strtolower($method->getName())] = true;
  1895.             }
  1896.         }
  1897.     }
  1899.     /**
  1900.      * @throws InvalidArgumentException
  1901.      */
  1902.     private function generateMethodName(string $id): string
  1903.     {
  1904.         if (isset($this->serviceIdToMethodNameMap[$id])) {
  1905.             return $this->serviceIdToMethodNameMap[$id];
  1906.         }
  1908.         $i = strrpos($id, '\\');
  1909.         $name = Container::camelize(false !== $i && isset($id[1 + $i]) ? substr($id, 1 + $i) : $id);
  1910.         $name = preg_replace('/[^a-zA-Z0-9_\x7f-\xff]/', '', $name);
  1911.         $methodName = 'get'.$name.'Service';
  1912.         $suffix = 1;
  1914.         while (isset($this->usedMethodNames[strtolower($methodName)])) {
  1915.             ++$suffix;
  1916.             $methodName = 'get'.$name.$suffix.'Service';
  1917.         }
  1919.         $this->serviceIdToMethodNameMap[$id] = $methodName;
  1920.         $this->usedMethodNames[strtolower($methodName)] = true;
  1922.         return $methodName;
  1923.     }
  1925.     private function getNextVariableName(): string
  1926.     {
  1927.         $firstChars = self::FIRST_CHARS;
  1928.         $firstCharsLength = \strlen($firstChars);
  1929.         $nonFirstChars = self::NON_FIRST_CHARS;
  1930.         $nonFirstCharsLength = \strlen($nonFirstChars);
  1932.         while (true) {
  1933.             $name = '';
  1934.             $i = $this->variableCount;
  1936.             if ('' === $name) {
  1937.                 $name .= $firstChars[$i % $firstCharsLength];
  1938.                 $i = (int) ($i / $firstCharsLength);
  1939.             }
  1941.             while ($i > 0) {
  1942.                 --$i;
  1943.                 $name .= $nonFirstChars[$i % $nonFirstCharsLength];
  1944.                 $i = (int) ($i / $nonFirstCharsLength);
  1945.             }
  1947.             ++$this->variableCount;
  1949.             // check that the name is not reserved
  1950.             if (\in_array($name, $this->reservedVariables, true)) {
  1951.                 continue;
  1952.             }
  1954.             return $name;
  1955.         }
  1956.     }
  1958.     private function getExpressionLanguage(): ExpressionLanguage
  1959.     {
  1960.         if (null === $this->expressionLanguage) {
  1961.             if (!class_exists('Symfony\Component\ExpressionLanguage\ExpressionLanguage')) {
  1962.                 throw new LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  1963.             }
  1964.             $providers = $this->container->getExpressionLanguageProviders();
  1965.             $this->expressionLanguage = new ExpressionLanguage(null, $providers, function ($arg) {
  1966.                 $id = '""' === substr_replace($arg, '', 1, -1) ? stripcslashes(substr($arg, 1, -1)) : null;
  1968.                 if (null !== $id && ($this->container->hasAlias($id) || $this->container->hasDefinition($id))) {
  1969.                     return $this->getServiceCall($id);
  1970.                 }
  1972.                 return sprintf('$this->get(%s)', $arg);
  1973.             });
  1975.             if ($this->container->isTrackingResources()) {
  1976.                 foreach ($providers as $provider) {
  1977.                     $this->container->addObjectResource($provider);
  1978.                 }
  1979.             }
  1980.         }
  1982.         return $this->expressionLanguage;
  1983.     }
  1985.     private function isHotPath(Definition $definition): bool
  1986.     {
  1987.         return $this->hotPathTag && $definition->hasTag($this->hotPathTag) && !$definition->isDeprecated();
  1988.     }
  1990.     private function isSingleUsePrivateNode(ServiceReferenceGraphNode $node): bool
  1991.     {
  1992.         if ($node->getValue()->isPublic()) {
  1993.             return false;
  1994.         }
  1995.         $ids = [];
  1996.         foreach ($node->getInEdges() as $edge) {
  1997.             if (!$value = $edge->getSourceNode()->getValue()) {
  1998.                 continue;
  1999.             }
  2000.             if ($edge->isLazy() || !$value instanceof Definition || !$value->isShared()) {
  2001.                 return false;
  2002.             }
  2003.             $ids[$edge->getSourceNode()->getId()] = true;
  2004.         }
  2006.         return 1 === \count($ids);
  2007.     }
  2009.     /**
  2010.      * @return mixed
  2011.      */
  2012.     private function export($value)
  2013.     {
  2014.         if (null !== $this->targetDirRegex && \is_string($value) && preg_match($this->targetDirRegex, $value, $matches, PREG_OFFSET_CAPTURE)) {
  2015.             $suffix = $matches[0][1] + \strlen($matches[0][0]);
  2016.             $matches[0][1] += \strlen($matches[1][0]);
  2017.             $prefix = $matches[0][1] ? $this->doExport(substr($value, 0, $matches[0][1]), true).'.' : '';
  2018.             $suffix = isset($value[$suffix]) ? '.'.$this->doExport(substr($value, $suffix), true) : '';
  2019.             $dirname = $this->asFiles ? '$this->containerDir' : '__DIR__';
  2020.             $offset = 2 + $this->targetDirMaxMatches - \count($matches);
  2022.             if (0 < $offset) {
  2023.                 $dirname = sprintf('\dirname(__DIR__, %d)', $offset + (int) $this->asFiles);
  2024.             } elseif ($this->asFiles) {
  2025.                 $dirname = "\$this->targetDir.''"; // empty string concatenation on purpose
  2026.             }
  2028.             if ($prefix || $suffix) {
  2029.                 return sprintf('(%s%s%s)', $prefix, $dirname, $suffix);
  2030.             }
  2032.             return $dirname;
  2033.         }
  2035.         return $this->doExport($value, true);
  2036.     }
  2038.     /**
  2039.      * @return mixed
  2040.      */
  2041.     private function doExport($value, bool $resolveEnv = false)
  2042.     {
  2043.         $shouldCacheValue = $resolveEnv && \is_string($value);
  2044.         if ($shouldCacheValue && isset($this->exportedVariables[$value])) {
  2045.             return $this->exportedVariables[$value];
  2046.         }
  2047.         if (\is_string($value) && false !== strpos($value, "\n")) {
  2048.             $cleanParts = explode("\n", $value);
  2049.             $cleanParts = array_map(function ($part) { return var_export($part, true); }, $cleanParts);
  2050.             $export = implode('."\n".', $cleanParts);
  2051.         } else {
  2052.             $export = var_export($value, true);
  2053.         }
  2055.         if ($resolveEnv && "'" === $export[0] && $export !== $resolvedExport = $this->container->resolveEnvPlaceholders($export, "'.\$this->getEnv('string:%s').'")) {
  2056.             $export = $resolvedExport;
  2057.             if (".''" === substr($export, -3)) {
  2058.                 $export = substr($export, 0, -3);
  2059.                 if ("'" === $export[1]) {
  2060.                     $export = substr_replace($export, '', 18, 7);
  2061.                 }
  2062.             }
  2063.             if ("'" === $export[1]) {
  2064.                 $export = substr($export, 3);
  2065.             }
  2066.         }
  2068.         if ($shouldCacheValue) {
  2069.             $this->exportedVariables[$value] = $export;
  2070.         }
  2072.         return $export;
  2073.     }
  2075.     private function getAutoloadFile(): ?string
  2076.     {
  2077.         if (null === $this->targetDirRegex) {
  2078.             return null;
  2079.         }
  2081.         foreach (spl_autoload_functions() as $autoloader) {
  2082.             if (!\is_array($autoloader)) {
  2083.                 continue;
  2084.             }
  2086.             if ($autoloader[0] instanceof DebugClassLoader || $autoloader[0] instanceof LegacyDebugClassLoader) {
  2087.                 $autoloader = $autoloader[0]->getClassLoader();
  2088.             }
  2090.             if (!\is_array($autoloader) || !$autoloader[0] instanceof ClassLoader || !$autoloader[0]->findFile(__CLASS__)) {
  2091.                 continue;
  2092.             }
  2094.             foreach (get_declared_classes() as $class) {
  2095.                 if (0 === strpos($class, 'ComposerAutoloaderInit') && $class::getLoader() === $autoloader[0]) {
  2096.                     $file = \dirname((new \ReflectionClass($class))->getFileName(), 2).'/autoload.php';
  2098.                     if (preg_match($this->targetDirRegex.'A', $file)) {
  2099.                         return $file;
  2100.                     }
  2101.                 }
  2102.             }
  2103.         }
  2105.         return null;
  2106.     }
  2108.     private function getClasses(Definition $definition): array
  2109.     {
  2110.         $classes = [];
  2112.         while ($definition instanceof Definition) {
  2113.             $classes[] = trim($definition->getClass(), '\\');
  2114.             $factory = $definition->getFactory();
  2116.             if (!\is_array($factory)) {
  2117.                 $factory = [$factory];
  2118.             }
  2120.             if (\is_string($factory[0])) {
  2121.                 if (false !== $i = strrpos($factory[0], '::')) {
  2122.                     $factory[0] = substr($factory[0], 0, $i);
  2123.                 }
  2124.                 $classes[] = trim($factory[0], '\\');
  2125.             }
  2127.             $definition = $factory[0];
  2128.         }
  2130.         return array_filter($classes);
  2131.     }
  2132. }