vendor/symfony/dependency-injection/Compiler/InlineServiceDefinitionsPass.php line 35

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\DependencyInjection\Compiler;
  14. use Symfony\Component\DependencyInjection\Argument\ArgumentInterface;
  15. use Symfony\Component\DependencyInjection\ContainerBuilder;
  16. use Symfony\Component\DependencyInjection\Definition;
  17. use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
  18. use Symfony\Component\DependencyInjection\Reference;
  20. /**
  21.  * Inline service definitions where this is possible.
  22.  *
  23.  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  24.  */
  25. class InlineServiceDefinitionsPass extends AbstractRecursivePass
  26. {
  27.     private ?AnalyzeServiceReferencesPass $analyzingPass;
  28.     private array $cloningIds = [];
  29.     private array $connectedIds = [];
  30.     private array $notInlinedIds = [];
  31.     private array $inlinedIds = [];
  32.     private array $notInlinableIds = [];
  33.     private ?ServiceReferenceGraph $graph = null;
  35.     public function __construct(AnalyzeServiceReferencesPass $analyzingPass = null)
  36.     {
  37.         $this->analyzingPass = $analyzingPass;
  38.     }
  40.     public function process(ContainerBuilder $container)
  41.     {
  42.         $this->container = $container;
  43.         if ($this->analyzingPass) {
  44.             $analyzedContainer = new ContainerBuilder();
  45.             $analyzedContainer->setAliases($container->getAliases());
  46.             $analyzedContainer->setDefinitions($container->getDefinitions());
  47.             foreach ($container->getExpressionLanguageProviders() as $provider) {
  48.                 $analyzedContainer->addExpressionLanguageProvider($provider);
  49.             }
  50.         } else {
  51.             $analyzedContainer = $container;
  52.         }
  53.         try {
  54.             $remainingInlinedIds = [];
  55.             $this->connectedIds = $this->notInlinedIds = $container->getDefinitions();
  56.             do {
  57.                 if ($this->analyzingPass) {
  58.                     $analyzedContainer->setDefinitions(array_intersect_key($analyzedContainer->getDefinitions(), $this->connectedIds));
  59.                     $this->analyzingPass->process($analyzedContainer);
  60.                 }
  61.                 $this->graph = $analyzedContainer->getCompiler()->getServiceReferenceGraph();
  62.                 $notInlinedIds = $this->notInlinedIds;
  63.                 $this->connectedIds = $this->notInlinedIds = $this->inlinedIds = [];
  65.                 foreach ($analyzedContainer->getDefinitions() as $id => $definition) {
  66.                     if (!$this->graph->hasNode($id)) {
  67.                         continue;
  68.                     }
  69.                     foreach ($this->graph->getNode($id)->getOutEdges() as $edge) {
  70.                         if (isset($notInlinedIds[$edge->getSourceNode()->getId()])) {
  71.                             $this->currentId = $id;
  72.                             $this->processValue($definition, true);
  73.                             break;
  74.                         }
  75.                     }
  76.                 }
  78.                 foreach ($this->inlinedIds as $id => $isPublicOrNotShared) {
  79.                     if ($isPublicOrNotShared) {
  80.                         $remainingInlinedIds[$id] = $id;
  81.                     } else {
  82.                         $container->removeDefinition($id);
  83.                         $analyzedContainer->removeDefinition($id);
  84.                     }
  85.                 }
  86.             } while ($this->inlinedIds && $this->analyzingPass);
  88.             foreach ($remainingInlinedIds as $id) {
  89.                 if (isset($this->notInlinableIds[$id])) {
  90.                     continue;
  91.                 }
  93.                 $definition = $container->getDefinition($id);
  95.                 if (!$definition->isShared() && !$definition->isPublic()) {
  96.                     $container->removeDefinition($id);
  97.                 }
  98.             }
  99.         } finally {
  100.             $this->container = null;
  101.             $this->connectedIds = $this->notInlinedIds = $this->inlinedIds = [];
  102.             $this->notInlinableIds = [];
  103.             $this->graph = null;
  104.         }
  105.     }
  107.     protected function processValue(mixed $value, bool $isRoot = false): mixed
  108.     {
  109.         if ($value instanceof ArgumentInterface) {
  110.             // References found in ArgumentInterface::getValues() are not inlineable
  111.             return $value;
  112.         }
  114.         if ($value instanceof Definition && $this->cloningIds) {
  115.             if ($value->isShared()) {
  116.                 return $value;
  117.             }
  118.             $value = clone $value;
  119.         }
  121.         if (!$value instanceof Reference) {
  122.             return parent::processValue($value, $isRoot);
  123.         } elseif (!$this->container->hasDefinition($id = (string) $value)) {
  124.             return $value;
  125.         }
  127.         $definition = $this->container->getDefinition($id);
  129.         if (!$this->isInlineableDefinition($id, $definition)) {
  130.             $this->notInlinableIds[$id] = true;
  132.             return $value;
  133.         }
  135.         $this->container->log($this, sprintf('Inlined service "%s" to "%s".', $id, $this->currentId));
  136.         $this->inlinedIds[$id] = $definition->isPublic() || !$definition->isShared();
  137.         $this->notInlinedIds[$this->currentId] = true;
  139.         if ($definition->isShared()) {
  140.             return $definition;
  141.         }
  143.         if (isset($this->cloningIds[$id])) {
  144.             $ids = array_keys($this->cloningIds);
  145.             $ids[] = $id;
  147.             throw new ServiceCircularReferenceException($id, \array_slice($ids, array_search($id, $ids)));
  148.         }
  150.         $this->cloningIds[$id] = true;
  151.         try {
  152.             return $this->processValue($definition);
  153.         } finally {
  154.             unset($this->cloningIds[$id]);
  155.         }
  156.     }
  158.     /**
  159.      * Checks if the definition is inlineable.
  160.      */
  161.     private function isInlineableDefinition(string $id, Definition $definition): bool
  162.     {
  163.         if ($definition->hasErrors() || $definition->isDeprecated() || $definition->isLazy() || $definition->isSynthetic() || $definition->hasTag('container.do_not_inline')) {
  164.             return false;
  165.         }
  167.         if (!$definition->isShared()) {
  168.             if (!$this->graph->hasNode($id)) {
  169.                 return true;
  170.             }
  172.             foreach ($this->graph->getNode($id)->getInEdges() as $edge) {
  173.                 $srcId = $edge->getSourceNode()->getId();
  174.                 $this->connectedIds[$srcId] = true;
  175.                 if ($edge->isWeak() || $edge->isLazy()) {
  176.                     return !$this->connectedIds[$id] = true;
  177.                 }
  178.             }
  180.             return true;
  181.         }
  183.         if ($definition->isPublic()) {
  184.             return false;
  185.         }
  187.         if (!$this->graph->hasNode($id)) {
  188.             return true;
  189.         }
  191.         if ($this->currentId == $id) {
  192.             return false;
  193.         }
  194.         $this->connectedIds[$id] = true;
  196.         $srcIds = [];
  197.         $srcCount = 0;
  198.         foreach ($this->graph->getNode($id)->getInEdges() as $edge) {
  199.             $srcId = $edge->getSourceNode()->getId();
  200.             $this->connectedIds[$srcId] = true;
  201.             if ($edge->isWeak() || $edge->isLazy()) {
  202.                 return false;
  203.             }
  204.             $srcIds[$srcId] = true;
  205.             ++$srcCount;
  206.         }
  208.         if (1 !== \count($srcIds)) {
  209.             $this->notInlinedIds[$id] = true;
  211.             return false;
  212.         }
  214.         if ($srcCount > 1 && \is_array($factory = $definition->getFactory()) && ($factory[0] instanceof Reference || $factory[0] instanceof Definition)) {
  215.             return false;
  216.         }
  218.         return $this->container->getDefinition($srcId)->isShared();
  219.     }
  220. }