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

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Symfony package.
  4.  *
  5.  * (c) Fabien Potencier <fabien@symfony.com>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Symfony\Component\DependencyInjection\Dumper;
  11. use Composer\Autoload\ClassLoader;
  12. use Symfony\Component\Debug\DebugClassLoader as LegacyDebugClassLoader;
  13. use Symfony\Component\DependencyInjection\Argument\ArgumentInterface;
  14. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  15. use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
  16. use Symfony\Component\DependencyInjection\Argument\ServiceLocator;
  17. use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
  18. use Symfony\Component\DependencyInjection\Compiler\AnalyzeServiceReferencesPass;
  19. use Symfony\Component\DependencyInjection\Compiler\CheckCircularReferencesPass;
  20. use Symfony\Component\DependencyInjection\Compiler\ServiceReferenceGraphNode;
  21. use Symfony\Component\DependencyInjection\Container;
  22. use Symfony\Component\DependencyInjection\ContainerBuilder;
  23. use Symfony\Component\DependencyInjection\ContainerInterface;
  24. use Symfony\Component\DependencyInjection\Definition;
  25. use Symfony\Component\DependencyInjection\Exception\EnvParameterException;
  26. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  27. use Symfony\Component\DependencyInjection\Exception\LogicException;
  28. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  29. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  30. use Symfony\Component\DependencyInjection\ExpressionLanguage;
  31. use Symfony\Component\DependencyInjection\LazyProxy\PhpDumper\DumperInterface as ProxyDumper;
  32. use Symfony\Component\DependencyInjection\LazyProxy\PhpDumper\NullDumper;
  33. use Symfony\Component\DependencyInjection\Loader\FileLoader;
  34. use Symfony\Component\DependencyInjection\Parameter;
  35. use Symfony\Component\DependencyInjection\Reference;
  36. use Symfony\Component\DependencyInjection\ServiceLocator as BaseServiceLocator;
  37. use Symfony\Component\DependencyInjection\TypedReference;
  38. use Symfony\Component\DependencyInjection\Variable;
  39. use Symfony\Component\ErrorHandler\DebugClassLoader;
  40. use Symfony\Component\ExpressionLanguage\Expression;
  41. use Symfony\Component\HttpKernel\Kernel;
  42. /**
  43.  * PhpDumper dumps a service container as a PHP class.
  44.  *
  45.  * @author Fabien Potencier <fabien@symfony.com>
  46.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  47.  */
  48. class PhpDumper extends Dumper
  49. {
  50.     /**
  51.      * Characters that might appear in the generated variable name as first character.
  52.      */
  53.     public const FIRST_CHARS 'abcdefghijklmnopqrstuvwxyz';
  54.     /**
  55.      * Characters that might appear in the generated variable name as any but the first character.
  56.      */
  57.     public const NON_FIRST_CHARS 'abcdefghijklmnopqrstuvwxyz0123456789_';
  58.     private $definitionVariables;
  59.     private $referenceVariables;
  60.     private $variableCount;
  61.     private $inlinedDefinitions;
  62.     private $serviceCalls;
  63.     private $reservedVariables = ['instance''class''this'];
  64.     private $expressionLanguage;
  65.     private $targetDirRegex;
  66.     private $targetDirMaxMatches;
  67.     private $docStar;
  68.     private $serviceIdToMethodNameMap;
  69.     private $usedMethodNames;
  70.     private $namespace;
  71.     private $asFiles;
  72.     private $hotPathTag;
  73.     private $inlineFactories;
  74.     private $inlineRequires;
  75.     private $inlinedRequires = [];
  76.     private $circularReferences = [];
  77.     private $singleUsePrivateIds = [];
  78.     private $preload = [];
  79.     private $addThrow false;
  80.     private $addGetService false;
  81.     private $locatedIds = [];
  82.     private $serviceLocatorTag;
  83.     private $exportedVariables = [];
  84.     private $baseClass;
  85.     /**
  86.      * @var ProxyDumper
  87.      */
  88.     private $proxyDumper;
  89.     /**
  90.      * {@inheritdoc}
  91.      */
  92.     public function __construct(ContainerBuilder $container)
  93.     {
  94.         if (!$container->isCompiled()) {
  95.             throw new LogicException('Cannot dump an uncompiled container.');
  96.         }
  97.         parent::__construct($container);
  98.     }
  99.     /**
  100.      * Sets the dumper to be used when dumping proxies in the generated container.
  101.      */
  102.     public function setProxyDumper(ProxyDumper $proxyDumper)
  103.     {
  104.         $this->proxyDumper $proxyDumper;
  105.     }
  106.     /**
  107.      * Dumps the service container as a PHP class.
  108.      *
  109.      * Available options:
  110.      *
  111.      *  * class:      The class name
  112.      *  * base_class: The base class name
  113.      *  * namespace:  The class namespace
  114.      *  * as_files:   To split the container in several files
  115.      *
  116.      * @return string|array A PHP class representing the service container or an array of PHP files if the "as_files" option is set
  117.      *
  118.      * @throws EnvParameterException When an env var exists but has not been dumped
  119.      */
  120.     public function dump(array $options = [])
  121.     {
  122.         $this->locatedIds = [];
  123.         $this->targetDirRegex null;
  124.         $this->inlinedRequires = [];
  125.         $this->exportedVariables = [];
  126.         $options array_merge([
  127.             'class' => 'ProjectServiceContainer',
  128.             'base_class' => 'Container',
  129.             'namespace' => '',
  130.             'as_files' => false,
  131.             'debug' => true,
  132.             'hot_path_tag' => 'container.hot_path',
  133.             'inline_factories_parameter' => 'container.dumper.inline_factories',
  134.             'inline_class_loader_parameter' => 'container.dumper.inline_class_loader',
  135.             'preload_classes' => [],
  136.             'service_locator_tag' => 'container.service_locator',
  137.             'build_time' => time(),
  138.         ], $options);
  139.         $this->addThrow $this->addGetService false;
  140.         $this->namespace $options['namespace'];
  141.         $this->asFiles $options['as_files'];
  142.         $this->hotPathTag $options['hot_path_tag'];
  143.         $this->inlineFactories $this->asFiles && $options['inline_factories_parameter'] && $this->container->hasParameter($options['inline_factories_parameter']) && $this->container->getParameter($options['inline_factories_parameter']);
  144.         $this->inlineRequires $options['inline_class_loader_parameter'] && $this->container->hasParameter($options['inline_class_loader_parameter']) && $this->container->getParameter($options['inline_class_loader_parameter']);
  145.         $this->serviceLocatorTag $options['service_locator_tag'];
  146.         if (!str_starts_with($baseClass $options['base_class'], '\\') && 'Container' !== $baseClass) {
  147.             $baseClass sprintf('%s\%s'$options['namespace'] ? '\\'.$options['namespace'] : ''$baseClass);
  148.             $this->baseClass $baseClass;
  149.         } elseif ('Container' === $baseClass) {
  150.             $this->baseClass Container::class;
  151.         } else {
  152.             $this->baseClass $baseClass;
  153.         }
  154.         $this->initializeMethodNamesMap('Container' === $baseClass Container::class : $baseClass);
  155.         if ($this->getProxyDumper() instanceof NullDumper) {
  156.             (new AnalyzeServiceReferencesPass(truefalse))->process($this->container);
  157.             try {
  158.                 (new CheckCircularReferencesPass())->process($this->container);
  159.             } catch (ServiceCircularReferenceException $e) {
  160.                 $path $e->getPath();
  161.                 end($path);
  162.                 $path[key($path)] .= '". Try running "composer require symfony/proxy-manager-bridge';
  163.                 throw new ServiceCircularReferenceException($e->getServiceId(), $path);
  164.             }
  165.         }
  166.         $this->analyzeReferences();
  167.         $this->docStar $options['debug'] ? '*' '';
  168.         if (!empty($options['file']) && is_dir($dir = \dirname($options['file']))) {
  169.             // Build a regexp where the first root dirs are mandatory,
  170.             // but every other sub-dir is optional up to the full path in $dir
  171.             // Mandate at least 1 root dir and not more than 5 optional dirs.
  172.             $dir explode(\DIRECTORY_SEPARATORrealpath($dir));
  173.             $i = \count($dir);
  174.             if (+ (int) ('\\' === \DIRECTORY_SEPARATOR) <= $i) {
  175.                 $regex '';
  176.                 $lastOptionalDir $i $i : (+ (int) ('\\' === \DIRECTORY_SEPARATOR));
  177.                 $this->targetDirMaxMatches $i $lastOptionalDir;
  178.                 while (--$i >= $lastOptionalDir) {
  179.                     $regex sprintf('(%s%s)?'preg_quote(\DIRECTORY_SEPARATOR.$dir[$i], '#'), $regex);
  180.                 }
  181.                 do {
  182.                     $regex preg_quote(\DIRECTORY_SEPARATOR.$dir[$i], '#').$regex;
  183.                 } while (< --$i);
  184.                 $this->targetDirRegex '#(^|file://|[:;, \|\r\n])'.preg_quote($dir[0], '#').$regex.'#';
  185.             }
  186.         }
  187.         $proxyClasses $this->inlineFactories $this->generateProxyClasses() : null;
  188.         if ($options['preload_classes']) {
  189.             $this->preload array_combine($options['preload_classes'], $options['preload_classes']);
  190.         }
  191.         $code =
  192.             $this->startClass($options['class'], $baseClass).
  193.             $this->addServices($services).
  194.             $this->addDeprecatedAliases().
  195.             $this->addDefaultParametersMethod()
  196.         ;
  197.         $proxyClasses $proxyClasses ?? $this->generateProxyClasses();
  198.         if ($this->addGetService) {
  199.             $code preg_replace(
  200.                 "/(\r?\n\r?\n    public function __construct.+?\\{\r?\n)/s",
  201.                 "\n    private \$getService;$1        \$this->getService = \\Closure::fromCallable([\$this, 'getService']);\n",
  202.                 $code,
  203.                 1
  204.             );
  205.         }
  206.         if ($this->asFiles) {
  207.             $fileStart = <<<EOF
  208. <?php
  209. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  210. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  211. // This file has been auto-generated by the Symfony Dependency Injection Component for internal use.
  212. EOF;
  213.             $files = [];
  214.             $ids $this->container->getRemovedIds();
  215.             foreach ($this->container->getDefinitions() as $id => $definition) {
  216.                 if (!$definition->isPublic()) {
  217.                     $ids[$id] = true;
  218.                 }
  219.             }
  220.             if ($ids array_keys($ids)) {
  221.                 sort($ids);
  222.                 $c "<?php\n\nreturn [\n";
  223.                 foreach ($ids as $id) {
  224.                     $c .= '    '.$this->doExport($id)." => true,\n";
  225.                 }
  226.                 $files['removed-ids.php'] = $c."];\n";
  227.             }
  228.             if (!$this->inlineFactories) {
  229.                 foreach ($this->generateServiceFiles($services) as $file => $c) {
  230.                     $files[$file] = $fileStart.$c;
  231.                 }
  232.                 foreach ($proxyClasses as $file => $c) {
  233.                     $files[$file] = "<?php\n".$c;
  234.                 }
  235.             }
  236.             $code .= $this->endClass();
  237.             if ($this->inlineFactories) {
  238.                 foreach ($proxyClasses as $c) {
  239.                     $code .= $c;
  240.                 }
  241.             }
  242.             $files[$options['class'].'.php'] = $code;
  243.             $hash ucfirst(strtr(ContainerBuilder::hash($files), '._''xx'));
  244.             $code = [];
  245.             foreach ($files as $file => $c) {
  246.                 $code["Container{$hash}/{$file}"] = $c;
  247.             }
  248.             array_pop($code);
  249.             $code["Container{$hash}/{$options['class']}.php"] = substr_replace($files[$options['class'].'.php'], "<?php\n\nnamespace Container{$hash};\n"06);
  250.             $namespaceLine $this->namespace "\nnamespace {$this->namespace};\n" '';
  251.             $time $options['build_time'];
  252.             $id hash('crc32'$hash.$time);
  253.             $this->asFiles false;
  254.             if ($this->preload && null !== $autoloadFile $this->getAutoloadFile()) {
  255.                 $autoloadFile trim($this->export($autoloadFile), '()\\');
  256.                 $code[$options['class'].'.preload.php'] = <<<EOF
  257. <?php
  258. // This file has been auto-generated by the Symfony Dependency Injection Component
  259. // You can reference it in the "opcache.preload" php.ini setting on PHP >= 7.4 when preloading is desired
  260. use Symfony\Component\DependencyInjection\Dumper\Preloader;
  261. if (in_array(PHP_SAPI, ['cli', 'phpdbg'], true)) {
  262.     return;
  263. }
  264. require $autoloadFile;
  265. require __DIR__.'/Container{$hash}/{$options['class']}.php';
  266. \$classes = [];
  267. EOF;
  268.                 foreach ($this->preload as $class) {
  269.                     if (!$class || str_contains($class'$')) {
  270.                         continue;
  271.                     }
  272.                     if (!(class_exists($classfalse) || interface_exists($classfalse) || trait_exists($classfalse)) || ((new \ReflectionClass($class))->isUserDefined() && !\in_array($class, ['Attribute''JsonException''ReturnTypeWillChange''Stringable''UnhandledMatchError''ValueError'], true))) {
  273.                         $code[$options['class'].'.preload.php'] .= sprintf("\$classes[] = '%s';\n"$class);
  274.                     }
  275.                 }
  276.                 $code[$options['class'].'.preload.php'] .= <<<'EOF'
  277. Preloader::preload($classes);
  278. EOF;
  279.             }
  280.             $code[$options['class'].'.php'] = <<<EOF
  281. <?php
  282. {$namespaceLine}
  283. // This file has been auto-generated by the Symfony Dependency Injection Component for internal use.
  284. if (\\class_exists(\\Container{$hash}\\{$options['class']}::class, false)) {
  285.     // no-op
  286. } elseif (!include __DIR__.'/Container{$hash}/{$options['class']}.php') {
  287.     touch(__DIR__.'/Container{$hash}.legacy');
  288.     return;
  289. }
  290. if (!\\class_exists({$options['class']}::class, false)) {
  291.     \\class_alias(\\Container{$hash}\\{$options['class']}::class, {$options['class']}::class, false);
  292. }
  293. return new \\Container{$hash}\\{$options['class']}([
  294.     'container.build_hash' => '$hash',
  295.     'container.build_id' => '$id',
  296.     'container.build_time' => $time,
  297. ], __DIR__.\\DIRECTORY_SEPARATOR.'Container{$hash}');
  298. EOF;
  299.         } else {
  300.             $code .= $this->endClass();
  301.             foreach ($proxyClasses as $c) {
  302.                 $code .= $c;
  303.             }
  304.         }
  305.         $this->targetDirRegex null;
  306.         $this->inlinedRequires = [];
  307.         $this->circularReferences = [];
  308.         $this->locatedIds = [];
  309.         $this->exportedVariables = [];
  310.         $this->preload = [];
  311.         $unusedEnvs = [];
  312.         foreach ($this->container->getEnvCounters() as $env => $use) {
  313.             if (!$use) {
  314.                 $unusedEnvs[] = $env;
  315.             }
  316.         }
  317.         if ($unusedEnvs) {
  318.             throw new EnvParameterException($unusedEnvsnull'Environment variables "%s" are never used. Please, check your container\'s configuration.');
  319.         }
  320.         return $code;
  321.     }
  322.     /**
  323.      * Retrieves the currently set proxy dumper or instantiates one.
  324.      */
  325.     private function getProxyDumper(): ProxyDumper
  326.     {
  327.         if (!$this->proxyDumper) {
  328.             $this->proxyDumper = new NullDumper();
  329.         }
  330.         return $this->proxyDumper;
  331.     }
  332.     private function analyzeReferences()
  333.     {
  334.         (new AnalyzeServiceReferencesPass(false, !$this->getProxyDumper() instanceof NullDumper))->process($this->container);
  335.         $checkedNodes = [];
  336.         $this->circularReferences = [];
  337.         $this->singleUsePrivateIds = [];
  338.         foreach ($this->container->getCompiler()->getServiceReferenceGraph()->getNodes() as $id => $node) {
  339.             if (!$node->getValue() instanceof Definition) {
  340.                 continue;
  341.             }
  342.             if ($this->isSingleUsePrivateNode($node)) {
  343.                 $this->singleUsePrivateIds[$id] = $id;
  344.             }
  345.             $this->collectCircularReferences($id$node->getOutEdges(), $checkedNodes);
  346.         }
  347.         $this->container->getCompiler()->getServiceReferenceGraph()->clear();
  348.         $this->singleUsePrivateIds array_diff_key($this->singleUsePrivateIds$this->circularReferences);
  349.     }
  350.     private function collectCircularReferences(string $sourceId, array $edges, array &$checkedNodes, array &$loops = [], array $path = [], bool $byConstructor true): void
  351.     {
  352.         $path[$sourceId] = $byConstructor;
  353.         $checkedNodes[$sourceId] = true;
  354.         foreach ($edges as $edge) {
  355.             $node $edge->getDestNode();
  356.             $id $node->getId();
  357.             if ($sourceId === $id || !$node->getValue() instanceof Definition || $edge->isLazy() || $edge->isWeak()) {
  358.                 continue;
  359.             }
  360.             if (isset($path[$id])) {
  361.                 $loop null;
  362.                 $loopByConstructor $edge->isReferencedByConstructor();
  363.                 $pathInLoop = [$id, []];
  364.                 foreach ($path as $k => $pathByConstructor) {
  365.                     if (null !== $loop) {
  366.                         $loop[] = $k;
  367.                         $pathInLoop[1][$k] = $pathByConstructor;
  368.                         $loops[$k][] = &$pathInLoop;
  369.                         $loopByConstructor $loopByConstructor && $pathByConstructor;
  370.                     } elseif ($k === $id) {
  371.                         $loop = [];
  372.                     }
  373.                 }
  374.                 $this->addCircularReferences($id$loop$loopByConstructor);
  375.             } elseif (!isset($checkedNodes[$id])) {
  376.                 $this->collectCircularReferences($id$node->getOutEdges(), $checkedNodes$loops$path$edge->isReferencedByConstructor());
  377.             } elseif (isset($loops[$id])) {
  378.                 // we already had detected loops for this edge
  379.                 // let's check if we have a common ancestor in one of the detected loops
  380.                 foreach ($loops[$id] as [$first$loopPath]) {
  381.                     if (!isset($path[$first])) {
  382.                         continue;
  383.                     }
  384.                     // We have a common ancestor, let's fill the current path
  385.                     $fillPath null;
  386.                     foreach ($loopPath as $k => $pathByConstructor) {
  387.                         if (null !== $fillPath) {
  388.                             $fillPath[$k] = $pathByConstructor;
  389.                         } elseif ($k === $id) {
  390.                             $fillPath $path;
  391.                             $fillPath[$k] = $pathByConstructor;
  392.                         }
  393.                     }
  394.                     // we can now build the loop
  395.                     $loop null;
  396.                     $loopByConstructor $edge->isReferencedByConstructor();
  397.                     foreach ($fillPath as $k => $pathByConstructor) {
  398.                         if (null !== $loop) {
  399.                             $loop[] = $k;
  400.                             $loopByConstructor $loopByConstructor && $pathByConstructor;
  401.                         } elseif ($k === $first) {
  402.                             $loop = [];
  403.                         }
  404.                     }
  405.                     $this->addCircularReferences($first$looptrue);
  406.                     break;
  407.                 }
  408.             }
  409.         }
  410.         unset($path[$sourceId]);
  411.     }
  412.     private function addCircularReferences(string $sourceId, array $currentPathbool $byConstructor)
  413.     {
  414.         $currentId $sourceId;
  415.         $currentPath array_reverse($currentPath);
  416.         $currentPath[] = $currentId;
  417.         foreach ($currentPath as $parentId) {
  418.             if (empty($this->circularReferences[$parentId][$currentId])) {
  419.                 $this->circularReferences[$parentId][$currentId] = $byConstructor;
  420.             }
  421.             $currentId $parentId;
  422.         }
  423.     }
  424.     private function collectLineage(string $class, array &$lineage)
  425.     {
  426.         if (isset($lineage[$class])) {
  427.             return;
  428.         }
  429.         if (!$r $this->container->getReflectionClass($classfalse)) {
  430.             return;
  431.         }
  432.         if (is_a($class$this->baseClasstrue)) {
  433.             return;
  434.         }
  435.         $file $r->getFileName();
  436.         if (str_ends_with($file') : eval()\'d code')) {
  437.             $file substr($file0strrpos($file'(', -17));
  438.         }
  439.         if (!$file || $this->doExport($file) === $exportedFile $this->export($file)) {
  440.             return;
  441.         }
  442.         $lineage[$class] = substr($exportedFile1, -1);
  443.         if ($parent $r->getParentClass()) {
  444.             $this->collectLineage($parent->name$lineage);
  445.         }
  446.         foreach ($r->getInterfaces() as $parent) {
  447.             $this->collectLineage($parent->name$lineage);
  448.         }
  449.         foreach ($r->getTraits() as $parent) {
  450.             $this->collectLineage($parent->name$lineage);
  451.         }
  452.         unset($lineage[$class]);
  453.         $lineage[$class] = substr($exportedFile1, -1);
  454.     }
  455.     private function generateProxyClasses(): array
  456.     {
  457.         $proxyClasses = [];
  458.         $alreadyGenerated = [];
  459.         $definitions $this->container->getDefinitions();
  460.         $strip '' === $this->docStar && method_exists(Kernel::class, 'stripComments');
  461.         $proxyDumper $this->getProxyDumper();
  462.         ksort($definitions);
  463.         foreach ($definitions as $definition) {
  464.             if (!$proxyDumper->isProxyCandidate($definition)) {
  465.                 continue;
  466.             }
  467.             if (isset($alreadyGenerated[$class $definition->getClass()])) {
  468.                 continue;
  469.             }
  470.             $alreadyGenerated[$class] = true;
  471.             // register class' reflector for resource tracking
  472.             $this->container->getReflectionClass($class);
  473.             if ("\n" === $proxyCode "\n".$proxyDumper->getProxyCode($definition)) {
  474.                 continue;
  475.             }
  476.             if ($this->inlineRequires) {
  477.                 $lineage = [];
  478.                 $this->collectLineage($class$lineage);
  479.                 $code '';
  480.                 foreach (array_diff_key(array_flip($lineage), $this->inlinedRequires) as $file => $class) {
  481.                     if ($this->inlineFactories) {
  482.                         $this->inlinedRequires[$file] = true;
  483.                     }
  484.                     $code .= sprintf("include_once %s;\n"$file);
  485.                 }
  486.                 $proxyCode $code.$proxyCode;
  487.             }
  488.             if ($strip) {
  489.                 $proxyCode "<?php\n".$proxyCode;
  490.                 $proxyCode substr(Kernel::stripComments($proxyCode), 5);
  491.             }
  492.             $proxyClasses[sprintf('%s.php'explode(' '$this->inlineRequires substr($proxyCode, \strlen($code)) : $proxyCode3)[1])] = $proxyCode;
  493.         }
  494.         return $proxyClasses;
  495.     }
  496.     private function addServiceInclude(string $cIdDefinition $definition): string
  497.     {
  498.         $code '';
  499.         if ($this->inlineRequires && (!$this->isHotPath($definition) || $this->getProxyDumper()->isProxyCandidate($definition))) {
  500.             $lineage = [];
  501.             foreach ($this->inlinedDefinitions as $def) {
  502.                 if (!$def->isDeprecated()) {
  503.                     foreach ($this->getClasses($def) as $class) {
  504.                         $this->collectLineage($class$lineage);
  505.                     }
  506.                 }
  507.             }
  508.             foreach ($this->serviceCalls as $id => [$callCount$behavior]) {
  509.                 if ('service_container' !== $id && $id !== $cId
  510.                     && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE !== $behavior
  511.                     && $this->container->has($id)
  512.                     && $this->isTrivialInstance($def $this->container->findDefinition($id))
  513.                 ) {
  514.                     foreach ($this->getClasses($def) as $class) {
  515.                         $this->collectLineage($class$lineage);
  516.                     }
  517.                 }
  518.             }
  519.             foreach (array_diff_key(array_flip($lineage), $this->inlinedRequires) as $file => $class) {
  520.                 $code .= sprintf("        include_once %s;\n"$file);
  521.             }
  522.         }
  523.         foreach ($this->inlinedDefinitions as $def) {
  524.             if ($file $def->getFile()) {
  525.                 $file $this->dumpValue($file);
  526.                 $file '(' === $file[0] ? substr($file1, -1) : $file;
  527.                 $code .= sprintf("        include_once %s;\n"$file);
  528.             }
  529.         }
  530.         if ('' !== $code) {
  531.             $code .= "\n";
  532.         }
  533.         return $code;
  534.     }
  535.     /**
  536.      * @throws InvalidArgumentException
  537.      * @throws RuntimeException
  538.      */
  539.     private function addServiceInstance(string $idDefinition $definitionbool $isSimpleInstance): string
  540.     {
  541.         $class $this->dumpValue($definition->getClass());
  542.         if (str_starts_with($class"'") && !str_contains($class'$') && !preg_match('/^\'(?:\\\{2})?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*(?:\\\{2}[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)*\'$/'$class)) {
  543.             throw new InvalidArgumentException(sprintf('"%s" is not a valid class name for the "%s" service.'$class$id));
  544.         }
  545.         $isProxyCandidate $this->getProxyDumper()->isProxyCandidate($definition);
  546.         $instantiation '';
  547.         $lastWitherIndex null;
  548.         foreach ($definition->getMethodCalls() as $k => $call) {
  549.             if ($call[2] ?? false) {
  550.                 $lastWitherIndex $k;
  551.             }
  552.         }
  553.         if (!$isProxyCandidate && $definition->isShared() && !isset($this->singleUsePrivateIds[$id]) && null === $lastWitherIndex) {
  554.             $instantiation sprintf('$this->%s[%s] = %s'$this->container->getDefinition($id)->isPublic() ? 'services' 'privates'$this->doExport($id), $isSimpleInstance '' '$instance');
  555.         } elseif (!$isSimpleInstance) {
  556.             $instantiation '$instance';
  557.         }
  558.         $return '';
  559.         if ($isSimpleInstance) {
  560.             $return 'return ';
  561.         } else {
  562.             $instantiation .= ' = ';
  563.         }
  564.         return $this->addNewInstance($definition'        '.$return.$instantiation$id);
  565.     }
  566.     private function isTrivialInstance(Definition $definition): bool
  567.     {
  568.         if ($definition->hasErrors()) {
  569.             return true;
  570.         }
  571.         if ($definition->isSynthetic() || $definition->getFile() || $definition->getMethodCalls() || $definition->getProperties() || $definition->getConfigurator()) {
  572.             return false;
  573.         }
  574.         if ($definition->isDeprecated() || $definition->isLazy() || $definition->getFactory() || < \count($definition->getArguments())) {
  575.             return false;
  576.         }
  577.         foreach ($definition->getArguments() as $arg) {
  578.             if (!$arg || $arg instanceof Parameter) {
  579.                 continue;
  580.             }
  581.             if (\is_array($arg) && >= \count($arg)) {
  582.                 foreach ($arg as $k => $v) {
  583.                     if ($this->dumpValue($k) !== $this->dumpValue($kfalse)) {
  584.                         return false;
  585.                     }
  586.                     if (!$v || $v instanceof Parameter) {
  587.                         continue;
  588.                     }
  589.                     if ($v instanceof Reference && $this->container->has($id = (string) $v) && $this->container->findDefinition($id)->isSynthetic()) {
  590.                         continue;
  591.                     }
  592.                     if (!\is_scalar($v) || $this->dumpValue($v) !== $this->dumpValue($vfalse)) {
  593.                         return false;
  594.                     }
  595.                 }
  596.             } elseif ($arg instanceof Reference && $this->container->has($id = (string) $arg) && $this->container->findDefinition($id)->isSynthetic()) {
  597.                 continue;
  598.             } elseif (!\is_scalar($arg) || $this->dumpValue($arg) !== $this->dumpValue($argfalse)) {
  599.                 return false;
  600.             }
  601.         }
  602.         return true;
  603.     }
  604.     private function addServiceMethodCalls(Definition $definitionstring $variableName, ?string $sharedNonLazyId): string
  605.     {
  606.         $lastWitherIndex null;
  607.         foreach ($definition->getMethodCalls() as $k => $call) {
  608.             if ($call[2] ?? false) {
  609.                 $lastWitherIndex $k;
  610.             }
  611.         }
  612.         $calls '';
  613.         foreach ($definition->getMethodCalls() as $k => $call) {
  614.             $arguments = [];
  615.             foreach ($call[1] as $i => $value) {
  616.                 $arguments[] = (\is_string($i) ? $i.': ' '').$this->dumpValue($value);
  617.             }
  618.             $witherAssignation '';
  619.             if ($call[2] ?? false) {
  620.                 if (null !== $sharedNonLazyId && $lastWitherIndex === $k) {
  621.                     $witherAssignation sprintf('$this->%s[\'%s\'] = '$definition->isPublic() ? 'services' 'privates'$sharedNonLazyId);
  622.                 }
  623.                 $witherAssignation .= sprintf('$%s = '$variableName);
  624.             }
  625.             $calls .= $this->wrapServiceConditionals($call[1], sprintf("        %s\$%s->%s(%s);\n"$witherAssignation$variableName$call[0], implode(', '$arguments)));
  626.         }
  627.         return $calls;
  628.     }
  629.     private function addServiceProperties(Definition $definitionstring $variableName 'instance'): string
  630.     {
  631.         $code '';
  632.         foreach ($definition->getProperties() as $name => $value) {
  633.             $code .= sprintf("        \$%s->%s = %s;\n"$variableName$name$this->dumpValue($value));
  634.         }
  635.         return $code;
  636.     }
  637.     private function addServiceConfigurator(Definition $definitionstring $variableName 'instance'): string
  638.     {
  639.         if (!$callable $definition->getConfigurator()) {
  640.             return '';
  641.         }
  642.         if (\is_array($callable)) {
  643.             if ($callable[0] instanceof Reference
  644.                 || ($callable[0] instanceof Definition && $this->definitionVariables->contains($callable[0]))
  645.             ) {
  646.                 return sprintf("        %s->%s(\$%s);\n"$this->dumpValue($callable[0]), $callable[1], $variableName);
  647.             }
  648.             $class $this->dumpValue($callable[0]);
  649.             // If the class is a string we can optimize away
  650.             if (str_starts_with($class"'") && !str_contains($class'$')) {
  651.                 return sprintf("        %s::%s(\$%s);\n"$this->dumpLiteralClass($class), $callable[1], $variableName);
  652.             }
  653.             if (str_starts_with($class'new ')) {
  654.                 return sprintf("        (%s)->%s(\$%s);\n"$this->dumpValue($callable[0]), $callable[1], $variableName);
  655.             }
  656.             return sprintf("        [%s, '%s'](\$%s);\n"$this->dumpValue($callable[0]), $callable[1], $variableName);
  657.         }
  658.         return sprintf("        %s(\$%s);\n"$callable$variableName);
  659.     }
  660.     private function addService(string $idDefinition $definition): array
  661.     {
  662.         $this->definitionVariables = new \SplObjectStorage();
  663.         $this->referenceVariables = [];
  664.         $this->variableCount 0;
  665.         $this->referenceVariables[$id] = new Variable('instance');
  666.         $return = [];
  667.         if ($class $definition->getClass()) {
  668.             $class $class instanceof Parameter '%'.$class.'%' $this->container->resolveEnvPlaceholders($class);
  669.             $return[] = sprintf(str_starts_with($class'%') ? '@return object A %1$s instance' '@return \%s'ltrim($class'\\'));
  670.         } elseif ($definition->getFactory()) {
  671.             $factory $definition->getFactory();
  672.             if (\is_string($factory)) {
  673.                 $return[] = sprintf('@return object An instance returned by %s()'$factory);
  674.             } elseif (\is_array($factory) && (\is_string($factory[0]) || $factory[0] instanceof Definition || $factory[0] instanceof Reference)) {
  675.                 $class $factory[0] instanceof Definition $factory[0]->getClass() : (string) $factory[0];
  676.                 $class $class instanceof Parameter '%'.$class.'%' $this->container->resolveEnvPlaceholders($class);
  677.                 $return[] = sprintf('@return object An instance returned by %s::%s()'$class$factory[1]);
  678.             }
  679.         }
  680.         if ($definition->isDeprecated()) {
  681.             if ($return && str_starts_with($return[\count($return) - 1], '@return')) {
  682.                 $return[] = '';
  683.             }
  684.             $return[] = sprintf('@deprecated %s'$definition->getDeprecationMessage($id));
  685.         }
  686.         $return str_replace("\n     * \n""\n     *\n"implode("\n     * "$return));
  687.         $return $this->container->resolveEnvPlaceholders($return);
  688.         $shared $definition->isShared() ? ' shared' '';
  689.         $public $definition->isPublic() ? 'public' 'private';
  690.         $autowired $definition->isAutowired() ? ' autowired' '';
  691.         if ($definition->isLazy()) {
  692.             $lazyInitialization '$lazyLoad = true';
  693.         } else {
  694.             $lazyInitialization '';
  695.         }
  696.         $asFile $this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition);
  697.         $methodName $this->generateMethodName($id);
  698.         if ($asFile) {
  699.             $file $methodName.'.php';
  700.             $code "        // Returns the $public '$id'$shared$autowired service.\n\n";
  701.         } else {
  702.             $file null;
  703.             $code = <<<EOF
  704.     /*{$this->docStar}
  705.      * Gets the $public '$id'$shared$autowired service.
  706.      *
  707.      * $return
  708. EOF;
  709.             $code str_replace('*/'' '$code).<<<EOF
  710.      */
  711.     protected function {$methodName}($lazyInitialization)
  712.     {
  713. EOF;
  714.         }
  715.         if ($definition->hasErrors() && $e $definition->getErrors()) {
  716.             $this->addThrow true;
  717.             $code .= sprintf("        \$this->throw(%s);\n"$this->export(reset($e)));
  718.         } else {
  719.             $this->serviceCalls = [];
  720.             $this->inlinedDefinitions $this->getDefinitionsFromArguments([$definition], null$this->serviceCalls);
  721.             if ($definition->isDeprecated()) {
  722.                 $code .= sprintf("        @trigger_error(%s, E_USER_DEPRECATED);\n\n"$this->export($definition->getDeprecationMessage($id)));
  723.             } else {
  724.                 foreach ($this->inlinedDefinitions as $def) {
  725.                     foreach ($this->getClasses($def) as $class) {
  726.                         $this->preload[$class] = $class;
  727.                     }
  728.                 }
  729.             }
  730.             if ($this->getProxyDumper()->isProxyCandidate($definition)) {
  731.                 $factoryCode $asFile ? ($definition->isShared() ? "\$this->load('%s.php', false)" '$this->factories[%2$s](false)') : '$this->%s(false)';
  732.                 $code .= $this->getProxyDumper()->getProxyFactoryCode($definition$idsprintf($factoryCode$methodName$this->doExport($id)));
  733.             }
  734.             $code .= $this->addServiceInclude($id$definition);
  735.             $code .= $this->addInlineService($id$definition);
  736.         }
  737.         if ($asFile) {
  738.             $code implode("\n"array_map(function ($line) { return $line substr($line8) : $line; }, explode("\n"$code)));
  739.         } else {
  740.             $code .= "    }\n";
  741.         }
  742.         $this->definitionVariables $this->inlinedDefinitions null;
  743.         $this->referenceVariables $this->serviceCalls null;
  744.         return [$file$code];
  745.     }
  746.     private function addInlineVariables(string $idDefinition $definition, array $argumentsbool $forConstructor): string
  747.     {
  748.         $code '';
  749.         foreach ($arguments as $argument) {
  750.             if (\is_array($argument)) {
  751.                 $code .= $this->addInlineVariables($id$definition$argument$forConstructor);
  752.             } elseif ($argument instanceof Reference) {
  753.                 $code .= $this->addInlineReference($id$definition$argument$forConstructor);
  754.             } elseif ($argument instanceof Definition) {
  755.                 $code .= $this->addInlineService($id$definition$argument$forConstructor);
  756.             }
  757.         }
  758.         return $code;
  759.     }
  760.     private function addInlineReference(string $idDefinition $definitionstring $targetIdbool $forConstructor): string
  761.     {
  762.         while ($this->container->hasAlias($targetId)) {
  763.             $targetId = (string) $this->container->getAlias($targetId);
  764.         }
  765.         [$callCount$behavior] = $this->serviceCalls[$targetId];
  766.         if ($id === $targetId) {
  767.             return $this->addInlineService($id$definition$definition);
  768.         }
  769.         if ('service_container' === $targetId || isset($this->referenceVariables[$targetId])) {
  770.             return '';
  771.         }
  772.         if ($this->container->hasDefinition($targetId) && ($def $this->container->getDefinition($targetId)) && !$def->isShared()) {
  773.             return '';
  774.         }
  775.         $hasSelfRef = isset($this->circularReferences[$id][$targetId]) && !isset($this->definitionVariables[$definition]);
  776.         if ($hasSelfRef && !$forConstructor && !$forConstructor = !$this->circularReferences[$id][$targetId]) {
  777.             $code $this->addInlineService($id$definition$definition);
  778.         } else {
  779.             $code '';
  780.         }
  781.         if (isset($this->referenceVariables[$targetId]) || ($callCount && (!$hasSelfRef || !$forConstructor))) {
  782.             return $code;
  783.         }
  784.         $name $this->getNextVariableName();
  785.         $this->referenceVariables[$targetId] = new Variable($name);
  786.         $reference ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $behavior ? new Reference($targetId$behavior) : null;
  787.         $code .= sprintf("        \$%s = %s;\n"$name$this->getServiceCall($targetId$reference));
  788.         if (!$hasSelfRef || !$forConstructor) {
  789.             return $code;
  790.         }
  791.         $code .= sprintf(<<<'EOTXT'
  792.         if (isset($this->%s[%s])) {
  793.             return $this->%1$s[%2$s];
  794.         }
  795. EOTXT
  796.             ,
  797.             $this->container->getDefinition($id)->isPublic() ? 'services' 'privates',
  798.             $this->doExport($id)
  799.         );
  800.         return $code;
  801.     }
  802.     private function addInlineService(string $idDefinition $definitionDefinition $inlineDef nullbool $forConstructor true): string
  803.     {
  804.         $code '';
  805.         if ($isSimpleInstance $isRootInstance null === $inlineDef) {
  806.             foreach ($this->serviceCalls as $targetId => [$callCount$behavior$byConstructor]) {
  807.                 if ($byConstructor && isset($this->circularReferences[$id][$targetId]) && !$this->circularReferences[$id][$targetId]) {
  808.                     $code .= $this->addInlineReference($id$definition$targetId$forConstructor);
  809.                 }
  810.             }
  811.         }
  812.         if (isset($this->definitionVariables[$inlineDef $inlineDef ?: $definition])) {
  813.             return $code;
  814.         }
  815.         $arguments = [$inlineDef->getArguments(), $inlineDef->getFactory()];
  816.         $code .= $this->addInlineVariables($id$definition$arguments$forConstructor);
  817.         if ($arguments array_filter([$inlineDef->getProperties(), $inlineDef->getMethodCalls(), $inlineDef->getConfigurator()])) {
  818.             $isSimpleInstance false;
  819.         } elseif ($definition !== $inlineDef && $this->inlinedDefinitions[$inlineDef]) {
  820.             return $code;
  821.         }
  822.         if (isset($this->definitionVariables[$inlineDef])) {
  823.             $isSimpleInstance false;
  824.         } else {
  825.             $name $definition === $inlineDef 'instance' $this->getNextVariableName();
  826.             $this->definitionVariables[$inlineDef] = new Variable($name);
  827.             $code .= '' !== $code "\n" '';
  828.             if ('instance' === $name) {
  829.                 $code .= $this->addServiceInstance($id$definition$isSimpleInstance);
  830.             } else {
  831.                 $code .= $this->addNewInstance($inlineDef'        $'.$name.' = '$id);
  832.             }
  833.             if ('' !== $inline $this->addInlineVariables($id$definition$argumentsfalse)) {
  834.                 $code .= "\n".$inline."\n";
  835.             } elseif ($arguments && 'instance' === $name) {
  836.                 $code .= "\n";
  837.             }
  838.             $code .= $this->addServiceProperties($inlineDef$name);
  839.             $code .= $this->addServiceMethodCalls($inlineDef$name, !$this->getProxyDumper()->isProxyCandidate($inlineDef) && $inlineDef->isShared() && !isset($this->singleUsePrivateIds[$id]) ? $id null);
  840.             $code .= $this->addServiceConfigurator($inlineDef$name);
  841.         }
  842.         if ($isRootInstance && !$isSimpleInstance) {
  843.             $code .= "\n        return \$instance;\n";
  844.         }
  845.         return $code;
  846.     }
  847.     private function addServices(array &$services null): string
  848.     {
  849.         $publicServices $privateServices '';
  850.         $definitions $this->container->getDefinitions();
  851.         ksort($definitions);
  852.         foreach ($definitions as $id => $definition) {
  853.             if (!$definition->isSynthetic()) {
  854.                 $services[$id] = $this->addService($id$definition);
  855.             } else {
  856.                 $services[$id] = null;
  857.                 foreach ($this->getClasses($definition) as $class) {
  858.                     $this->preload[$class] = $class;
  859.                 }
  860.             }
  861.         }
  862.         foreach ($definitions as $id => $definition) {
  863.             if (!([$file$code] = $services[$id]) || null !== $file) {
  864.                 continue;
  865.             }
  866.             if ($definition->isPublic()) {
  867.                 $publicServices .= $code;
  868.             } elseif (!$this->isTrivialInstance($definition) || isset($this->locatedIds[$id])) {
  869.                 $privateServices .= $code;
  870.             }
  871.         }
  872.         return $publicServices.$privateServices;
  873.     }
  874.     private function generateServiceFiles(array $services): iterable
  875.     {
  876.         $definitions $this->container->getDefinitions();
  877.         ksort($definitions);
  878.         foreach ($definitions as $id => $definition) {
  879.             if (([$file$code] = $services[$id]) && null !== $file && ($definition->isPublic() || !$this->isTrivialInstance($definition) || isset($this->locatedIds[$id]))) {
  880.                 if (!$definition->isShared()) {
  881.                     $i strpos($code"\n\ninclude_once ");
  882.                     if (false !== $i && false !== $i strpos($code"\n\n"$i)) {
  883.                         $code = [substr($code0$i), substr($code$i)];
  884.                     } else {
  885.                         $code = ["\n"$code];
  886.                     }
  887.                     $code[1] = implode("\n"array_map(function ($line) { return $line '    '.$line $line; }, explode("\n"$code[1])));
  888.                     $factory sprintf('$this->factories%s[%s]'$definition->isPublic() ? '' "['service_container']"$this->doExport($id));
  889.                     $lazyloadInitialization $definition->isLazy() ? '$lazyLoad = true' '';
  890.                     $code[1] = sprintf("%s = function (%s) {\n%s};\n\nreturn %1\$s();\n"$factory$lazyloadInitialization$code[1]);
  891.                     $code $code[0].$code[1];
  892.                 }
  893.                 yield $file => $code;
  894.             }
  895.         }
  896.     }
  897.     private function addNewInstance(Definition $definitionstring $return ''string $id null): string
  898.     {
  899.         $tail $return ";\n" '';
  900.         if (BaseServiceLocator::class === $definition->getClass() && $definition->hasTag($this->serviceLocatorTag)) {
  901.             $arguments = [];
  902.             foreach ($definition->getArgument(0) as $k => $argument) {
  903.                 $arguments[$k] = $argument->getValues()[0];
  904.             }
  905.             return $return.$this->dumpValue(new ServiceLocatorArgument($arguments)).$tail;
  906.         }
  907.         $arguments = [];
  908.         foreach ($definition->getArguments() as $i => $value) {
  909.             $arguments[] = (\is_string($i) ? $i.': ' '').$this->dumpValue($value);
  910.         }
  911.         if (null !== $definition->getFactory()) {
  912.             $callable $definition->getFactory();
  913.             if (\is_array($callable)) {
  914.                 if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/'$callable[1])) {
  915.                     throw new RuntimeException(sprintf('Cannot dump definition because of invalid factory method (%s).'$callable[1] ?: 'n/a'));
  916.                 }
  917.                 if ($callable[0] instanceof Reference
  918.                     || ($callable[0] instanceof Definition && $this->definitionVariables->contains($callable[0]))) {
  919.                     return $return.sprintf('%s->%s(%s)'$this->dumpValue($callable[0]), $callable[1], $arguments implode(', '$arguments) : '').$tail;
  920.                 }
  921.                 $class $this->dumpValue($callable[0]);
  922.                 // If the class is a string we can optimize away
  923.                 if (str_starts_with($class"'") && !str_contains($class'$')) {
  924.                     if ("''" === $class) {
  925.                         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'));
  926.                     }
  927.                     return $return.sprintf('%s::%s(%s)'$this->dumpLiteralClass($class), $callable[1], $arguments implode(', '$arguments) : '').$tail;
  928.                 }
  929.                 if (str_starts_with($class'new ')) {
  930.                     return $return.sprintf('(%s)->%s(%s)'$class$callable[1], $arguments implode(', '$arguments) : '').$tail;
  931.                 }
  932.                 return $return.sprintf("[%s, '%s'](%s)"$class$callable[1], $arguments implode(', '$arguments) : '').$tail;
  933.             }
  934.             return $return.sprintf('%s(%s)'$this->dumpLiteralClass($this->dumpValue($callable)), $arguments implode(', '$arguments) : '').$tail;
  935.         }
  936.         if (null === $class $definition->getClass()) {
  937.             throw new RuntimeException('Cannot dump definitions which have no class nor factory.');
  938.         }
  939.         return $return.sprintf('new %s(%s)'$this->dumpLiteralClass($this->dumpValue($class)), implode(', '$arguments)).$tail;
  940.     }
  941.     private function startClass(string $classstring $baseClass): string
  942.     {
  943.         $namespaceLine = !$this->asFiles && $this->namespace "\nnamespace {$this->namespace};\n" '';
  944.         $code = <<<EOF
  945. <?php
  946. $namespaceLine
  947. use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;
  948. use Symfony\Component\DependencyInjection\ContainerInterface;
  949. use Symfony\Component\DependencyInjection\Container;
  950. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  951. use Symfony\Component\DependencyInjection\Exception\LogicException;
  952. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  953. use Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag;
  954. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  955. /*{$this->docStar}
  956.  * This class has been auto-generated
  957.  * by the Symfony Dependency Injection Component.
  958.  *
  959.  * @final
  960.  */
  961. class $class extends $baseClass
  962. {
  963.     private \$parameters = [];
  964.     public function __construct()
  965.     {
  966. EOF;
  967.         if ($this->asFiles) {
  968.             $code str_replace('$parameters'"\$buildParameters;\n    private \$containerDir;\n    private \$parameters"$code);
  969.             $code str_replace('__construct()''__construct(array $buildParameters = [], $containerDir = __DIR__)'$code);
  970.             $code .= "        \$this->buildParameters = \$buildParameters;\n";
  971.             $code .= "        \$this->containerDir = \$containerDir;\n";
  972.             if (null !== $this->targetDirRegex) {
  973.                 $code str_replace('$parameters'"\$targetDir;\n    private \$parameters"$code);
  974.                 $code .= '        $this->targetDir = \\dirname($containerDir);'."\n";
  975.             }
  976.         }
  977.         if (Container::class !== $this->baseClass) {
  978.             $r $this->container->getReflectionClass($this->baseClassfalse);
  979.             if (null !== $r
  980.                 && (null !== $constructor $r->getConstructor())
  981.                 && === $constructor->getNumberOfRequiredParameters()
  982.                 && Container::class !== $constructor->getDeclaringClass()->name
  983.             ) {
  984.                 $code .= "        parent::__construct();\n";
  985.                 $code .= "        \$this->parameterBag = null;\n\n";
  986.             }
  987.         }
  988.         if ($this->container->getParameterBag()->all()) {
  989.             $code .= "        \$this->parameters = \$this->getDefaultParameters();\n\n";
  990.         }
  991.         $code .= "        \$this->services = \$this->privates = [];\n";
  992.         $code .= $this->addSyntheticIds();
  993.         $code .= $this->addMethodMap();
  994.         $code .= $this->asFiles && !$this->inlineFactories $this->addFileMap() : '';
  995.         $code .= $this->addAliases();
  996.         $code .= $this->addInlineRequires();
  997.         $code .= <<<EOF
  998.     }
  999.     public function compile(): void
  1000.     {
  1001.         throw new LogicException('You cannot compile a dumped container that was already compiled.');
  1002.     }
  1003.     public function isCompiled(): bool
  1004.     {
  1005.         return true;
  1006.     }
  1007. EOF;
  1008.         $code .= $this->addRemovedIds();
  1009.         if ($this->asFiles && !$this->inlineFactories) {
  1010.             $code .= <<<EOF
  1011.     protected function load(\$file, \$lazyLoad = true)
  1012.     {
  1013.         return require \$this->containerDir.\\DIRECTORY_SEPARATOR.\$file;
  1014.     }
  1015. EOF;
  1016.         }
  1017.         $proxyDumper $this->getProxyDumper();
  1018.         foreach ($this->container->getDefinitions() as $definition) {
  1019.             if (!$proxyDumper->isProxyCandidate($definition)) {
  1020.                 continue;
  1021.             }
  1022.             if ($this->asFiles && !$this->inlineFactories) {
  1023.                 $proxyLoader '$this->load("{$class}.php")';
  1024.             } elseif ($this->namespace || $this->inlineFactories) {
  1025.                 $proxyLoader 'class_alias(__NAMESPACE__."\\\\$class", $class, false)';
  1026.             } else {
  1027.                 $proxyLoader '';
  1028.             }
  1029.             if ($proxyLoader) {
  1030.                 $proxyLoader "class_exists(\$class, false) || {$proxyLoader};\n\n        ";
  1031.             }
  1032.             $code .= <<<EOF
  1033.     protected function createProxy(\$class, \Closure \$factory)
  1034.     {
  1035.         {$proxyLoader}return \$factory();
  1036.     }
  1037. EOF;
  1038.             break;
  1039.         }
  1040.         return $code;
  1041.     }
  1042.     private function addSyntheticIds(): string
  1043.     {
  1044.         $code '';
  1045.         $definitions $this->container->getDefinitions();
  1046.         ksort($definitions);
  1047.         foreach ($definitions as $id => $definition) {
  1048.             if ($definition->isSynthetic() && 'service_container' !== $id) {
  1049.                 $code .= '            '.$this->doExport($id)." => true,\n";
  1050.             }
  1051.         }
  1052.         return $code "        \$this->syntheticIds = [\n{$code}        ];\n" '';
  1053.     }
  1054.     private function addRemovedIds(): string
  1055.     {
  1056.         $ids $this->container->getRemovedIds();
  1057.         foreach ($this->container->getDefinitions() as $id => $definition) {
  1058.             if (!$definition->isPublic()) {
  1059.                 $ids[$id] = true;
  1060.             }
  1061.         }
  1062.         if (!$ids) {
  1063.             return '';
  1064.         }
  1065.         if ($this->asFiles) {
  1066.             $code "require \$this->containerDir.\\DIRECTORY_SEPARATOR.'removed-ids.php'";
  1067.         } else {
  1068.             $code '';
  1069.             $ids array_keys($ids);
  1070.             sort($ids);
  1071.             foreach ($ids as $id) {
  1072.                 if (preg_match(FileLoader::ANONYMOUS_ID_REGEXP$id)) {
  1073.                     continue;
  1074.                 }
  1075.                 $code .= '            '.$this->doExport($id)." => true,\n";
  1076.             }
  1077.             $code "[\n{$code}        ]";
  1078.         }
  1079.         return <<<EOF
  1080.     public function getRemovedIds(): array
  1081.     {
  1082.         return {$code};
  1083.     }
  1084. EOF;
  1085.     }
  1086.     private function addMethodMap(): string
  1087.     {
  1088.         $code '';
  1089.         $definitions $this->container->getDefinitions();
  1090.         ksort($definitions);
  1091.         foreach ($definitions as $id => $definition) {
  1092.             if (!$definition->isSynthetic() && $definition->isPublic() && (!$this->asFiles || $this->inlineFactories || $this->isHotPath($definition))) {
  1093.                 $code .= '            '.$this->doExport($id).' => '.$this->doExport($this->generateMethodName($id)).",\n";
  1094.             }
  1095.         }
  1096.         $aliases $this->container->getAliases();
  1097.         foreach ($aliases as $alias => $id) {
  1098.             if (!$id->isDeprecated()) {
  1099.                 continue;
  1100.             }
  1101.             $code .= '            '.$this->doExport($alias).' => '.$this->doExport($this->generateMethodName($alias)).",\n";
  1102.         }
  1103.         return $code "        \$this->methodMap = [\n{$code}        ];\n" '';
  1104.     }
  1105.     private function addFileMap(): string
  1106.     {
  1107.         $code '';
  1108.         $definitions $this->container->getDefinitions();
  1109.         ksort($definitions);
  1110.         foreach ($definitions as $id => $definition) {
  1111.             if (!$definition->isSynthetic() && $definition->isPublic() && !$this->isHotPath($definition)) {
  1112.                 $code .= sprintf("            %s => '%s.php',\n"$this->doExport($id), $this->generateMethodName($id));
  1113.             }
  1114.         }
  1115.         return $code "        \$this->fileMap = [\n{$code}        ];\n" '';
  1116.     }
  1117.     private function addAliases(): string
  1118.     {
  1119.         if (!$aliases $this->container->getAliases()) {
  1120.             return "\n        \$this->aliases = [];\n";
  1121.         }
  1122.         $code "        \$this->aliases = [\n";
  1123.         ksort($aliases);
  1124.         foreach ($aliases as $alias => $id) {
  1125.             if ($id->isDeprecated()) {
  1126.                 continue;
  1127.             }
  1128.             $id = (string) $id;
  1129.             while (isset($aliases[$id])) {
  1130.                 $id = (string) $aliases[$id];
  1131.             }
  1132.             $code .= '            '.$this->doExport($alias).' => '.$this->doExport($id).",\n";
  1133.         }
  1134.         return $code."        ];\n";
  1135.     }
  1136.     private function addDeprecatedAliases(): string
  1137.     {
  1138.         $code '';
  1139.         $aliases $this->container->getAliases();
  1140.         foreach ($aliases as $alias => $definition) {
  1141.             if (!$definition->isDeprecated()) {
  1142.                 continue;
  1143.             }
  1144.             $public $definition->isPublic() ? 'public' 'private';
  1145.             $id = (string) $definition;
  1146.             $methodNameAlias $this->generateMethodName($alias);
  1147.             $idExported $this->export($id);
  1148.             $messageExported $this->export($definition->getDeprecationMessage($alias));
  1149.             $code .= <<<EOF
  1150.     /*{$this->docStar}
  1151.      * Gets the $public '$alias' alias.
  1152.      *
  1153.      * @return object The "$id" service.
  1154.      */
  1155.     protected function {$methodNameAlias}()
  1156.     {
  1157.         @trigger_error($messageExported, E_USER_DEPRECATED);
  1158.         return \$this->get($idExported);
  1159.     }
  1160. EOF;
  1161.         }
  1162.         return $code;
  1163.     }
  1164.     private function addInlineRequires(): string
  1165.     {
  1166.         if (!$this->hotPathTag || !$this->inlineRequires) {
  1167.             return '';
  1168.         }
  1169.         $lineage = [];
  1170.         foreach ($this->container->findTaggedServiceIds($this->hotPathTag) as $id => $tags) {
  1171.             $definition $this->container->getDefinition($id);
  1172.             if ($this->getProxyDumper()->isProxyCandidate($definition)) {
  1173.                 continue;
  1174.             }
  1175.             $inlinedDefinitions $this->getDefinitionsFromArguments([$definition]);
  1176.             foreach ($inlinedDefinitions as $def) {
  1177.                 foreach ($this->getClasses($def) as $class) {
  1178.                     $this->collectLineage($class$lineage);
  1179.                 }
  1180.             }
  1181.         }
  1182.         $code '';
  1183.         foreach ($lineage as $file) {
  1184.             if (!isset($this->inlinedRequires[$file])) {
  1185.                 $this->inlinedRequires[$file] = true;
  1186.                 $code .= sprintf("\n            include_once %s;"$file);
  1187.             }
  1188.         }
  1189.         return $code sprintf("\n        \$this->privates['service_container'] = function () {%s\n        };\n"$code) : '';
  1190.     }
  1191.     private function addDefaultParametersMethod(): string
  1192.     {
  1193.         if (!$this->container->getParameterBag()->all()) {
  1194.             return '';
  1195.         }
  1196.         $php = [];
  1197.         $dynamicPhp = [];
  1198.         foreach ($this->container->getParameterBag()->all() as $key => $value) {
  1199.             if ($key !== $resolvedKey $this->container->resolveEnvPlaceholders($key)) {
  1200.                 throw new InvalidArgumentException(sprintf('Parameter name cannot use env parameters: "%s".'$resolvedKey));
  1201.             }
  1202.             $hasEnum false;
  1203.             $export $this->exportParameters([$value], ''12$hasEnum);
  1204.             $export explode('0 => 'substr(rtrim($export" ]\n"), 2, -1), 2);
  1205.             if ($hasEnum || preg_match("/\\\$this->(?:getEnv\('(?:[-.\w]*+:)*+\w++'\)|targetDir\.'')/"$export[1])) {
  1206.                 $dynamicPhp[$key] = sprintf('%scase %s: $value = %s; break;'$export[0], $this->export($key), $export[1]);
  1207.             } else {
  1208.                 $php[] = sprintf('%s%s => %s,'$export[0], $this->export($key), $export[1]);
  1209.             }
  1210.         }
  1211.         $parameters sprintf("[\n%s\n%s]"implode("\n"$php), str_repeat(' '8));
  1212.         $code = <<<'EOF'
  1213.     /**
  1214.      * @return array|bool|float|int|string|\UnitEnum|null
  1215.      */
  1216.     public function getParameter($name)
  1217.     {
  1218.         $name = (string) $name;
  1219.         if (isset($this->buildParameters[$name])) {
  1220.             return $this->buildParameters[$name];
  1221.         }
  1222.         if (!(isset($this->parameters[$name]) || isset($this->loadedDynamicParameters[$name]) || array_key_exists($name, $this->parameters))) {
  1223.             throw new InvalidArgumentException(sprintf('The parameter "%s" must be defined.', $name));
  1224.         }
  1225.         if (isset($this->loadedDynamicParameters[$name])) {
  1226.             return $this->loadedDynamicParameters[$name] ? $this->dynamicParameters[$name] : $this->getDynamicParameter($name);
  1227.         }
  1228.         return $this->parameters[$name];
  1229.     }
  1230.     public function hasParameter($name): bool
  1231.     {
  1232.         $name = (string) $name;
  1233.         if (isset($this->buildParameters[$name])) {
  1234.             return true;
  1235.         }
  1236.         return isset($this->parameters[$name]) || isset($this->loadedDynamicParameters[$name]) || array_key_exists($name, $this->parameters);
  1237.     }
  1238.     public function setParameter($name, $value): void
  1239.     {
  1240.         throw new LogicException('Impossible to call set() on a frozen ParameterBag.');
  1241.     }
  1242.     public function getParameterBag(): ParameterBagInterface
  1243.     {
  1244.         if (null === $this->parameterBag) {
  1245.             $parameters = $this->parameters;
  1246.             foreach ($this->loadedDynamicParameters as $name => $loaded) {
  1247.                 $parameters[$name] = $loaded ? $this->dynamicParameters[$name] : $this->getDynamicParameter($name);
  1248.             }
  1249.             foreach ($this->buildParameters as $name => $value) {
  1250.                 $parameters[$name] = $value;
  1251.             }
  1252.             $this->parameterBag = new FrozenParameterBag($parameters);
  1253.         }
  1254.         return $this->parameterBag;
  1255.     }
  1256. EOF;
  1257.         if (!$this->asFiles) {
  1258.             $code preg_replace('/^.*buildParameters.*\n.*\n.*\n/m'''$code);
  1259.         }
  1260.         if ($dynamicPhp) {
  1261.             $loadedDynamicParameters $this->exportParameters(array_combine(array_keys($dynamicPhp), array_fill(0, \count($dynamicPhp), false)), ''8);
  1262.             $getDynamicParameter = <<<'EOF'
  1263.         switch ($name) {
  1264. %s
  1265.             default: throw new InvalidArgumentException(sprintf('The dynamic parameter "%%s" must be defined.', $name));
  1266.         }
  1267.         $this->loadedDynamicParameters[$name] = true;
  1268.         return $this->dynamicParameters[$name] = $value;
  1269. EOF;
  1270.             $getDynamicParameter sprintf($getDynamicParameterimplode("\n"$dynamicPhp));
  1271.         } else {
  1272.             $loadedDynamicParameters '[]';
  1273.             $getDynamicParameter str_repeat(' '8).'throw new InvalidArgumentException(sprintf(\'The dynamic parameter "%s" must be defined.\', $name));';
  1274.         }
  1275.         $code .= <<<EOF
  1276.     private \$loadedDynamicParameters = {$loadedDynamicParameters};
  1277.     private \$dynamicParameters = [];
  1278.     private function getDynamicParameter(string \$name)
  1279.     {
  1280. {$getDynamicParameter}
  1281.     }
  1282.     protected function getDefaultParameters(): array
  1283.     {
  1284.         return $parameters;
  1285.     }
  1286. EOF;
  1287.         return $code;
  1288.     }
  1289.     /**
  1290.      * @throws InvalidArgumentException
  1291.      */
  1292.     private function exportParameters(array $parametersstring $path ''int $indent 12bool &$hasEnum false): string
  1293.     {
  1294.         $php = [];
  1295.         foreach ($parameters as $key => $value) {
  1296.             if (\is_array($value)) {
  1297.                 $value $this->exportParameters($value$path.'/'.$key$indent 4$hasEnum);
  1298.             } elseif ($value instanceof ArgumentInterface) {
  1299.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain special arguments. "%s" found in "%s".', \get_class($value), $path.'/'.$key));
  1300.             } elseif ($value instanceof Variable) {
  1301.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain variable references. Variable "%s" found in "%s".'$value$path.'/'.$key));
  1302.             } elseif ($value instanceof Definition) {
  1303.                 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));
  1304.             } elseif ($value instanceof Reference) {
  1305.                 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));
  1306.             } elseif ($value instanceof Expression) {
  1307.                 throw new InvalidArgumentException(sprintf('You cannot dump a container with parameters that contain expressions. Expression "%s" found in "%s".'$value$path.'/'.$key));
  1308.             } elseif ($value instanceof \UnitEnum) {
  1309.                 $hasEnum true;
  1310.                 $value sprintf('\%s::%s', \get_class($value), $value->name);
  1311.             } else {
  1312.                 $value $this->export($value);
  1313.             }
  1314.             $php[] = sprintf('%s%s => %s,'str_repeat(' '$indent), $this->export($key), $value);
  1315.         }
  1316.         return sprintf("[\n%s\n%s]"implode("\n"$php), str_repeat(' '$indent 4));
  1317.     }
  1318.     private function endClass(): string
  1319.     {
  1320.         if ($this->addThrow) {
  1321.             return <<<'EOF'
  1322.     protected function throw($message)
  1323.     {
  1324.         throw new RuntimeException($message);
  1325.     }
  1326. }
  1327. EOF;
  1328.         }
  1329.         return <<<'EOF'
  1330. }
  1331. EOF;
  1332.     }
  1333.     private function wrapServiceConditionals($valuestring $code): string
  1334.     {
  1335.         if (!$condition $this->getServiceConditionals($value)) {
  1336.             return $code;
  1337.         }
  1338.         // re-indent the wrapped code
  1339.         $code implode("\n"array_map(function ($line) { return $line '    '.$line $line; }, explode("\n"$code)));
  1340.         return sprintf("        if (%s) {\n%s        }\n"$condition$code);
  1341.     }
  1342.     private function getServiceConditionals($value): string
  1343.     {
  1344.         $conditions = [];
  1345.         foreach (ContainerBuilder::getInitializedConditionals($value) as $service) {
  1346.             if (!$this->container->hasDefinition($service)) {
  1347.                 return 'false';
  1348.             }
  1349.             $conditions[] = sprintf('isset($this->%s[%s])'$this->container->getDefinition($service)->isPublic() ? 'services' 'privates'$this->doExport($service));
  1350.         }
  1351.         foreach (ContainerBuilder::getServiceConditionals($value) as $service) {
  1352.             if ($this->container->hasDefinition($service) && !$this->container->getDefinition($service)->isPublic()) {
  1353.                 continue;
  1354.             }
  1355.             $conditions[] = sprintf('$this->has(%s)'$this->doExport($service));
  1356.         }
  1357.         if (!$conditions) {
  1358.             return '';
  1359.         }
  1360.         return implode(' && '$conditions);
  1361.     }
  1362.     private function getDefinitionsFromArguments(array $arguments, \SplObjectStorage $definitions null, array &$calls = [], bool $byConstructor null): \SplObjectStorage
  1363.     {
  1364.         if (null === $definitions) {
  1365.             $definitions = new \SplObjectStorage();
  1366.         }
  1367.         foreach ($arguments as $argument) {
  1368.             if (\is_array($argument)) {
  1369.                 $this->getDefinitionsFromArguments($argument$definitions$calls$byConstructor);
  1370.             } elseif ($argument instanceof Reference) {
  1371.                 $id = (string) $argument;
  1372.                 while ($this->container->hasAlias($id)) {
  1373.                     $id = (string) $this->container->getAlias($id);
  1374.                 }
  1375.                 if (!isset($calls[$id])) {
  1376.                     $calls[$id] = [0$argument->getInvalidBehavior(), $byConstructor];
  1377.                 } else {
  1378.                     $calls[$id][1] = min($calls[$id][1], $argument->getInvalidBehavior());
  1379.                 }
  1380.                 ++$calls[$id][0];
  1381.             } elseif (!$argument instanceof Definition) {
  1382.                 // no-op
  1383.             } elseif (isset($definitions[$argument])) {
  1384.                 $definitions[$argument] = $definitions[$argument];
  1385.             } else {
  1386.                 $definitions[$argument] = 1;
  1387.                 $arguments = [$argument->getArguments(), $argument->getFactory()];
  1388.                 $this->getDefinitionsFromArguments($arguments$definitions$callsnull === $byConstructor || $byConstructor);
  1389.                 $arguments = [$argument->getProperties(), $argument->getMethodCalls(), $argument->getConfigurator()];
  1390.                 $this->getDefinitionsFromArguments($arguments$definitions$callsnull !== $byConstructor && $byConstructor);
  1391.             }
  1392.         }
  1393.         return $definitions;
  1394.     }
  1395.     /**
  1396.      * @throws RuntimeException
  1397.      */
  1398.     private function dumpValue($valuebool $interpolate true): string
  1399.     {
  1400.         if (\is_array($value)) {
  1401.             if ($value && $interpolate && false !== $param array_search($value$this->container->getParameterBag()->all(), true)) {
  1402.                 return $this->dumpValue("%$param%");
  1403.             }
  1404.             $code = [];
  1405.             foreach ($value as $k => $v) {
  1406.                 $code[] = sprintf('%s => %s'$this->dumpValue($k$interpolate), $this->dumpValue($v$interpolate));
  1407.             }
  1408.             return sprintf('[%s]'implode(', '$code));
  1409.         } elseif ($value instanceof ArgumentInterface) {
  1410.             $scope = [$this->definitionVariables$this->referenceVariables];
  1411.             $this->definitionVariables $this->referenceVariables null;
  1412.             try {
  1413.                 if ($value instanceof ServiceClosureArgument) {
  1414.                     $value $value->getValues()[0];
  1415.                     $code $this->dumpValue($value$interpolate);
  1416.                     $returnedType '';
  1417.                     if ($value instanceof TypedReference) {
  1418.                         $returnedType sprintf(': %s\%s'ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $value->getInvalidBehavior() ? '' '?'$value->getType());
  1419.                     }
  1420.                     $code sprintf('return %s;'$code);
  1421.                     return sprintf("function ()%s {\n            %s\n        }"$returnedType$code);
  1422.                 }
  1423.                 if ($value instanceof IteratorArgument) {
  1424.                     $operands = [0];
  1425.                     $code = [];
  1426.                     $code[] = 'new RewindableGenerator(function () {';
  1427.                     if (!$values $value->getValues()) {
  1428.                         $code[] = '            return new \EmptyIterator();';
  1429.                     } else {
  1430.                         $countCode = [];
  1431.                         $countCode[] = 'function () {';
  1432.                         foreach ($values as $k => $v) {
  1433.                             ($c $this->getServiceConditionals($v)) ? $operands[] = "(int) ($c)" : ++$operands[0];
  1434.                             $v $this->wrapServiceConditionals($vsprintf("        yield %s => %s;\n"$this->dumpValue($k$interpolate), $this->dumpValue($v$interpolate)));
  1435.                             foreach (explode("\n"$v) as $v) {
  1436.                                 if ($v) {
  1437.                                     $code[] = '    '.$v;
  1438.                                 }
  1439.                             }
  1440.                         }
  1441.                         $countCode[] = sprintf('            return %s;'implode(' + '$operands));
  1442.                         $countCode[] = '        }';
  1443.                     }
  1444.                     $code[] = sprintf('        }, %s)', \count($operands) > implode("\n"$countCode) : $operands[0]);
  1445.                     return implode("\n"$code);
  1446.                 }
  1447.                 if ($value instanceof ServiceLocatorArgument) {
  1448.                     $serviceMap '';
  1449.                     $serviceTypes '';
  1450.                     foreach ($value->getValues() as $k => $v) {
  1451.                         if (!$v) {
  1452.                             continue;
  1453.                         }
  1454.                         $id = (string) $v;
  1455.                         while ($this->container->hasAlias($id)) {
  1456.                             $id = (string) $this->container->getAlias($id);
  1457.                         }
  1458.                         $definition $this->container->getDefinition($id);
  1459.                         $load = !($definition->hasErrors() && $e $definition->getErrors()) ? $this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition) : reset($e);
  1460.                         $serviceMap .= sprintf("\n            %s => [%s, %s, %s, %s],",
  1461.                             $this->export($k),
  1462.                             $this->export($definition->isShared() ? ($definition->isPublic() ? 'services' 'privates') : false),
  1463.                             $this->doExport($id),
  1464.                             $this->export(ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE !== $v->getInvalidBehavior() && !\is_string($load) ? $this->generateMethodName($id).($load '.php' '') : null),
  1465.                             $this->export($load)
  1466.                         );
  1467.                         $serviceTypes .= sprintf("\n            %s => %s,"$this->export($k), $this->export($v instanceof TypedReference $v->getType() : '?'));
  1468.                         $this->locatedIds[$id] = true;
  1469.                     }
  1470.                     $this->addGetService true;
  1471.                     return sprintf('new \%s($this->getService, [%s%s], [%s%s])'ServiceLocator::class, $serviceMap$serviceMap "\n        " ''$serviceTypes$serviceTypes "\n        " '');
  1472.                 }
  1473.             } finally {
  1474.                 [$this->definitionVariables$this->referenceVariables] = $scope;
  1475.             }
  1476.         } elseif ($value instanceof Definition) {
  1477.             if ($value->hasErrors() && $e $value->getErrors()) {
  1478.                 $this->addThrow true;
  1479.                 return sprintf('$this->throw(%s)'$this->export(reset($e)));
  1480.             }
  1481.             if (null !== $this->definitionVariables && $this->definitionVariables->contains($value)) {
  1482.                 return $this->dumpValue($this->definitionVariables[$value], $interpolate);
  1483.             }
  1484.             if ($value->getMethodCalls()) {
  1485.                 throw new RuntimeException('Cannot dump definitions which have method calls.');
  1486.             }
  1487.             if ($value->getProperties()) {
  1488.                 throw new RuntimeException('Cannot dump definitions which have properties.');
  1489.             }
  1490.             if (null !== $value->getConfigurator()) {
  1491.                 throw new RuntimeException('Cannot dump definitions which have a configurator.');
  1492.             }
  1493.             return $this->addNewInstance($value);
  1494.         } elseif ($value instanceof Variable) {
  1495.             return '$'.$value;
  1496.         } elseif ($value instanceof Reference) {
  1497.             $id = (string) $value;
  1498.             while ($this->container->hasAlias($id)) {
  1499.                 $id = (string) $this->container->getAlias($id);
  1500.             }
  1501.             if (null !== $this->referenceVariables && isset($this->referenceVariables[$id])) {
  1502.                 return $this->dumpValue($this->referenceVariables[$id], $interpolate);
  1503.             }
  1504.             return $this->getServiceCall($id$value);
  1505.         } elseif ($value instanceof Expression) {
  1506.             return $this->getExpressionLanguage()->compile((string) $value, ['this' => 'container']);
  1507.         } elseif ($value instanceof Parameter) {
  1508.             return $this->dumpParameter($value);
  1509.         } elseif (true === $interpolate && \is_string($value)) {
  1510.             if (preg_match('/^%([^%]+)%$/'$value$match)) {
  1511.                 // we do this to deal with non string values (Boolean, integer, ...)
  1512.                 // the preg_replace_callback converts them to strings
  1513.                 return $this->dumpParameter($match[1]);
  1514.             } else {
  1515.                 $replaceParameters = function ($match) {
  1516.                     return "'.".$this->dumpParameter($match[2]).".'";
  1517.                 };
  1518.                 $code str_replace('%%''%'preg_replace_callback('/(?<!%)(%)([^%]+)\1/'$replaceParameters$this->export($value)));
  1519.                 return $code;
  1520.             }
  1521.         } elseif ($value instanceof \UnitEnum) {
  1522.             return sprintf('\%s::%s', \get_class($value), $value->name);
  1523.         } elseif (\is_object($value) || \is_resource($value)) {
  1524.             throw new RuntimeException('Unable to dump a service container if a parameter is an object or a resource.');
  1525.         }
  1526.         return $this->export($value);
  1527.     }
  1528.     /**
  1529.      * Dumps a string to a literal (aka PHP Code) class value.
  1530.      *
  1531.      * @throws RuntimeException
  1532.      */
  1533.     private function dumpLiteralClass(string $class): string
  1534.     {
  1535.         if (str_contains($class'$')) {
  1536.             return sprintf('${($_ = %s) && false ?: "_"}'$class);
  1537.         }
  1538.         if (!str_starts_with($class"'") || !preg_match('/^\'(?:\\\{2})?[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*(?:\\\{2}[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)*\'$/'$class)) {
  1539.             throw new RuntimeException(sprintf('Cannot dump definition because of invalid class name (%s).'$class ?: 'n/a'));
  1540.         }
  1541.         $class substr(str_replace('\\\\''\\'$class), 1, -1);
  1542.         return str_starts_with($class'\\') ? $class '\\'.$class;
  1543.     }
  1544.     private function dumpParameter(string $name): string
  1545.     {
  1546.         if ($this->container->hasParameter($name)) {
  1547.             $value $this->container->getParameter($name);
  1548.             $dumpedValue $this->dumpValue($valuefalse);
  1549.             if (!$value || !\is_array($value)) {
  1550.                 return $dumpedValue;
  1551.             }
  1552.             if (!preg_match("/\\\$this->(?:getEnv\('(?:[-.\w]*+:)*+\w++'\)|targetDir\.'')/"$dumpedValue)) {
  1553.                 return sprintf('$this->parameters[%s]'$this->doExport($name));
  1554.             }
  1555.         }
  1556.         return sprintf('$this->getParameter(%s)'$this->doExport($name));
  1557.     }
  1558.     private function getServiceCall(string $idReference $reference null): string
  1559.     {
  1560.         while ($this->container->hasAlias($id)) {
  1561.             $id = (string) $this->container->getAlias($id);
  1562.         }
  1563.         if ('service_container' === $id) {
  1564.             return '$this';
  1565.         }
  1566.         if ($this->container->hasDefinition($id) && $definition $this->container->getDefinition($id)) {
  1567.             if ($definition->isSynthetic()) {
  1568.                 $code sprintf('$this->get(%s%s)'$this->doExport($id), null !== $reference ', '.$reference->getInvalidBehavior() : '');
  1569.             } elseif (null !== $reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $reference->getInvalidBehavior()) {
  1570.                 $code 'null';
  1571.                 if (!$definition->isShared()) {
  1572.                     return $code;
  1573.                 }
  1574.             } elseif ($this->isTrivialInstance($definition)) {
  1575.                 if ($definition->hasErrors() && $e $definition->getErrors()) {
  1576.                     $this->addThrow true;
  1577.                     return sprintf('$this->throw(%s)'$this->export(reset($e)));
  1578.                 }
  1579.                 $code $this->addNewInstance($definition''$id);
  1580.                 if ($definition->isShared() && !isset($this->singleUsePrivateIds[$id])) {
  1581.                     $code sprintf('$this->%s[%s] = %s'$definition->isPublic() ? 'services' 'privates'$this->doExport($id), $code);
  1582.                 }
  1583.                 $code "($code)";
  1584.             } elseif ($this->asFiles && !$this->inlineFactories && !$this->isHotPath($definition)) {
  1585.                 $code sprintf("\$this->load('%s.php')"$this->generateMethodName($id));
  1586.                 if (!$definition->isShared()) {
  1587.                     $factory sprintf('$this->factories%s[%s]'$definition->isPublic() ? '' "['service_container']"$this->doExport($id));
  1588.                     $code sprintf('(isset(%s) ? %1$s() : %s)'$factory$code);
  1589.                 }
  1590.             } else {
  1591.                 $code sprintf('$this->%s()'$this->generateMethodName($id));
  1592.             }
  1593.             if ($definition->isShared() && !isset($this->singleUsePrivateIds[$id])) {
  1594.                 $code sprintf('($this->%s[%s] ?? %s)'$definition->isPublic() ? 'services' 'privates'$this->doExport($id), $code);
  1595.             }
  1596.             return $code;
  1597.         }
  1598.         if (null !== $reference && ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE === $reference->getInvalidBehavior()) {
  1599.             return 'null';
  1600.         }
  1601.         if (null !== $reference && ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE $reference->getInvalidBehavior()) {
  1602.             $code sprintf('$this->get(%s, /* ContainerInterface::NULL_ON_INVALID_REFERENCE */ %d)'$this->doExport($id), ContainerInterface::NULL_ON_INVALID_REFERENCE);
  1603.         } else {
  1604.             $code sprintf('$this->get(%s)'$this->doExport($id));
  1605.         }
  1606.         return sprintf('($this->services[%s] ?? %s)'$this->doExport($id), $code);
  1607.     }
  1608.     /**
  1609.      * Initializes the method names map to avoid conflicts with the Container methods.
  1610.      */
  1611.     private function initializeMethodNamesMap(string $class)
  1612.     {
  1613.         $this->serviceIdToMethodNameMap = [];
  1614.         $this->usedMethodNames = [];
  1615.         if ($reflectionClass $this->container->getReflectionClass($class)) {
  1616.             foreach ($reflectionClass->getMethods() as $method) {
  1617.                 $this->usedMethodNames[strtolower($method->getName())] = true;
  1618.             }
  1619.         }
  1620.     }
  1621.     /**
  1622.      * @throws InvalidArgumentException
  1623.      */
  1624.     private function generateMethodName(string $id): string
  1625.     {
  1626.         if (isset($this->serviceIdToMethodNameMap[$id])) {
  1627.             return $this->serviceIdToMethodNameMap[$id];
  1628.         }
  1629.         $i strrpos($id'\\');
  1630.         $name Container::camelize(false !== $i && isset($id[$i]) ? substr($id$i) : $id);
  1631.         $name preg_replace('/[^a-zA-Z0-9_\x7f-\xff]/'''$name);
  1632.         $methodName 'get'.$name.'Service';
  1633.         $suffix 1;
  1634.         while (isset($this->usedMethodNames[strtolower($methodName)])) {
  1635.             ++$suffix;
  1636.             $methodName 'get'.$name.$suffix.'Service';
  1637.         }
  1638.         $this->serviceIdToMethodNameMap[$id] = $methodName;
  1639.         $this->usedMethodNames[strtolower($methodName)] = true;
  1640.         return $methodName;
  1641.     }
  1642.     private function getNextVariableName(): string
  1643.     {
  1644.         $firstChars self::FIRST_CHARS;
  1645.         $firstCharsLength = \strlen($firstChars);
  1646.         $nonFirstChars self::NON_FIRST_CHARS;
  1647.         $nonFirstCharsLength = \strlen($nonFirstChars);
  1648.         while (true) {
  1649.             $name '';
  1650.             $i $this->variableCount;
  1651.             if ('' === $name) {
  1652.                 $name .= $firstChars[$i $firstCharsLength];
  1653.                 $i = (int) ($i $firstCharsLength);
  1654.             }
  1655.             while ($i 0) {
  1656.                 --$i;
  1657.                 $name .= $nonFirstChars[$i $nonFirstCharsLength];
  1658.                 $i = (int) ($i $nonFirstCharsLength);
  1659.             }
  1660.             ++$this->variableCount;
  1661.             // check that the name is not reserved
  1662.             if (\in_array($name$this->reservedVariablestrue)) {
  1663.                 continue;
  1664.             }
  1665.             return $name;
  1666.         }
  1667.     }
  1668.     private function getExpressionLanguage(): ExpressionLanguage
  1669.     {
  1670.         if (null === $this->expressionLanguage) {
  1671.             if (!class_exists(\Symfony\Component\ExpressionLanguage\ExpressionLanguage::class)) {
  1672.                 throw new LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
  1673.             }
  1674.             $providers $this->container->getExpressionLanguageProviders();
  1675.             $this->expressionLanguage = new ExpressionLanguage(null$providers, function ($arg) {
  1676.                 $id '""' === substr_replace($arg''1, -1) ? stripcslashes(substr($arg1, -1)) : null;
  1677.                 if (null !== $id && ($this->container->hasAlias($id) || $this->container->hasDefinition($id))) {
  1678.                     return $this->getServiceCall($id);
  1679.                 }
  1680.                 return sprintf('$this->get(%s)'$arg);
  1681.             });
  1682.             if ($this->container->isTrackingResources()) {
  1683.                 foreach ($providers as $provider) {
  1684.                     $this->container->addObjectResource($provider);
  1685.                 }
  1686.             }
  1687.         }
  1688.         return $this->expressionLanguage;
  1689.     }
  1690.     private function isHotPath(Definition $definition): bool
  1691.     {
  1692.         return $this->hotPathTag && $definition->hasTag($this->hotPathTag) && !$definition->isDeprecated();
  1693.     }
  1694.     private function isSingleUsePrivateNode(ServiceReferenceGraphNode $node): bool
  1695.     {
  1696.         if ($node->getValue()->isPublic()) {
  1697.             return false;
  1698.         }
  1699.         $ids = [];
  1700.         foreach ($node->getInEdges() as $edge) {
  1701.             if (!$value $edge->getSourceNode()->getValue()) {
  1702.                 continue;
  1703.             }
  1704.             if ($edge->isLazy() || !$value instanceof Definition || !$value->isShared()) {
  1705.                 return false;
  1706.             }
  1707.             $ids[$edge->getSourceNode()->getId()] = true;
  1708.         }
  1709.         return === \count($ids);
  1710.     }
  1711.     /**
  1712.      * @return mixed
  1713.      */
  1714.     private function export($value)
  1715.     {
  1716.         if (null !== $this->targetDirRegex && \is_string($value) && preg_match($this->targetDirRegex$value$matches, \PREG_OFFSET_CAPTURE)) {
  1717.             $suffix $matches[0][1] + \strlen($matches[0][0]);
  1718.             $matches[0][1] += \strlen($matches[1][0]);
  1719.             $prefix $matches[0][1] ? $this->doExport(substr($value0$matches[0][1]), true).'.' '';
  1720.             if ('\\' === \DIRECTORY_SEPARATOR && isset($value[$suffix])) {
  1721.                 $cookie '\\'.random_int(100000, \PHP_INT_MAX);
  1722.                 $suffix '.'.$this->doExport(str_replace('\\'$cookiesubstr($value$suffix)), true);
  1723.                 $suffix str_replace('\\'.$cookie"'.\\DIRECTORY_SEPARATOR.'"$suffix);
  1724.             } else {
  1725.                 $suffix = isset($value[$suffix]) ? '.'.$this->doExport(substr($value$suffix), true) : '';
  1726.             }
  1727.             $dirname $this->asFiles '$this->containerDir' '__DIR__';
  1728.             $offset $this->targetDirMaxMatches - \count($matches);
  1729.             if ($offset) {
  1730.                 $dirname sprintf('\dirname(__DIR__, %d)'$offset + (int) $this->asFiles);
  1731.             } elseif ($this->asFiles) {
  1732.                 $dirname "\$this->targetDir.''"// empty string concatenation on purpose
  1733.             }
  1734.             if ($prefix || $suffix) {
  1735.                 return sprintf('(%s%s%s)'$prefix$dirname$suffix);
  1736.             }
  1737.             return $dirname;
  1738.         }
  1739.         return $this->doExport($valuetrue);
  1740.     }
  1741.     /**
  1742.      * @return mixed
  1743.      */
  1744.     private function doExport($valuebool $resolveEnv false)
  1745.     {
  1746.         $shouldCacheValue $resolveEnv && \is_string($value);
  1747.         if ($shouldCacheValue && isset($this->exportedVariables[$value])) {
  1748.             return $this->exportedVariables[$value];
  1749.         }
  1750.         if (\is_string($value) && str_contains($value"\n")) {
  1751.             $cleanParts explode("\n"$value);
  1752.             $cleanParts array_map(function ($part) { return var_export($parttrue); }, $cleanParts);
  1753.             $export implode('."\n".'$cleanParts);
  1754.         } else {
  1755.             $export var_export($valuetrue);
  1756.         }
  1757.         if ($resolveEnv && "'" === $export[0] && $export !== $resolvedExport $this->container->resolveEnvPlaceholders($export"'.\$this->getEnv('string:%s').'")) {
  1758.             $export $resolvedExport;
  1759.             if (str_ends_with($export".''")) {
  1760.                 $export substr($export0, -3);
  1761.                 if ("'" === $export[1]) {
  1762.                     $export substr_replace($export''187);
  1763.                 }
  1764.             }
  1765.             if ("'" === $export[1]) {
  1766.                 $export substr($export3);
  1767.             }
  1768.         }
  1769.         if ($shouldCacheValue) {
  1770.             $this->exportedVariables[$value] = $export;
  1771.         }
  1772.         return $export;
  1773.     }
  1774.     private function getAutoloadFile(): ?string
  1775.     {
  1776.         $file null;
  1777.         foreach (spl_autoload_functions() as $autoloader) {
  1778.             if (!\is_array($autoloader)) {
  1779.                 continue;
  1780.             }
  1781.             if ($autoloader[0] instanceof DebugClassLoader || $autoloader[0] instanceof LegacyDebugClassLoader) {
  1782.                 $autoloader $autoloader[0]->getClassLoader();
  1783.             }
  1784.             if (!\is_array($autoloader) || !$autoloader[0] instanceof ClassLoader || !$autoloader[0]->findFile(__CLASS__)) {
  1785.                 continue;
  1786.             }
  1787.             foreach (get_declared_classes() as $class) {
  1788.                 if (str_starts_with($class'ComposerAutoloaderInit') && $class::getLoader() === $autoloader[0]) {
  1789.                     $file = \dirname((new \ReflectionClass($class))->getFileName(), 2).'/autoload.php';
  1790.                     if (null !== $this->targetDirRegex && preg_match($this->targetDirRegex.'A'$file)) {
  1791.                         return $file;
  1792.                     }
  1793.                 }
  1794.             }
  1795.         }
  1796.         return $file;
  1797.     }
  1798.     private function getClasses(Definition $definition): array
  1799.     {
  1800.         $classes = [];
  1801.         while ($definition instanceof Definition) {
  1802.             if ($class $definition->getClass()) {
  1803.                 $classes[] = trim($class'\\');
  1804.             }
  1805.             $factory $definition->getFactory();
  1806.             if (!\is_array($factory)) {
  1807.                 $factory = [$factory];
  1808.             }
  1809.             if (\is_string($factory[0])) {
  1810.                 if (false !== $i strrpos($factory[0], '::')) {
  1811.                     $factory[0] = substr($factory[0], 0$i);
  1812.                 }
  1813.                 $classes[] = trim($factory[0], '\\');
  1814.             }
  1815.             $definition $factory[0];
  1816.         }
  1817.         return $classes;
  1818.     }
  1819. }