vendor/symfony/dependency-injection/Compiler/AbstractRecursivePass.php line 226

  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\ChildDefinition;
  16. use Symfony\Component\DependencyInjection\ContainerBuilder;
  17. use Symfony\Component\DependencyInjection\Definition;
  18. use Symfony\Component\DependencyInjection\Exception\LogicException;
  19. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  20. use Symfony\Component\DependencyInjection\ExpressionLanguage;
  21. use Symfony\Component\DependencyInjection\Reference;
  22. use Symfony\Component\ExpressionLanguage\Expression;
  24. /**
  25.  * @author Nicolas Grekas <p@tchwork.com>
  26.  */
  27. abstract class AbstractRecursivePass implements CompilerPassInterface
  28. {
  29.     /**
  30.      * @var ContainerBuilder
  31.      */
  32.     protected $container;
  33.     protected $currentId;
  35.     private bool $processExpressions = false;
  36.     private ExpressionLanguage $expressionLanguage;
  37.     private bool $inExpression = false;
  39.     public function process(ContainerBuilder $container)
  40.     {
  41.         $this->container = $container;
  43.         try {
  44.             $this->processValue($container->getDefinitions(), true);
  45.         } finally {
  46.             $this->container = null;
  47.         }
  48.     }
  50.     protected function enableExpressionProcessing()
  51.     {
  52.         $this->processExpressions = true;
  53.     }
  55.     protected function inExpression(bool $reset = true): bool
  56.     {
  57.         $inExpression = $this->inExpression;
  58.         if ($reset) {
  59.             $this->inExpression = false;
  60.         }
  62.         return $inExpression;
  63.     }
  65.     /**
  66.      * Processes a value found in a definition tree.
  67.      *
  68.      * @return mixed
  69.      */
  70.     protected function processValue(mixed $value, bool $isRoot = false)
  71.     {
  72.         if (\is_array($value)) {
  73.             foreach ($value as $k => $v) {
  74.                 if ($isRoot) {
  75.                     if ($v->hasTag('container.excluded')) {
  76.                         continue;
  77.                     }
  78.                     $this->currentId = $k;
  79.                 }
  80.                 if ($v !== $processedValue = $this->processValue($v, $isRoot)) {
  81.                     $value[$k] = $processedValue;
  82.                 }
  83.             }
  84.         } elseif ($value instanceof ArgumentInterface) {
  85.             $value->setValues($this->processValue($value->getValues()));
  86.         } elseif ($value instanceof Expression && $this->processExpressions) {
  87.             $this->getExpressionLanguage()->compile((string) $value, ['this' => 'container', 'args' => 'args']);
  88.         } elseif ($value instanceof Definition) {
  89.             $value->setArguments($this->processValue($value->getArguments()));
  90.             $value->setProperties($this->processValue($value->getProperties()));
  91.             $value->setMethodCalls($this->processValue($value->getMethodCalls()));
  93.             $changes = $value->getChanges();
  94.             if (isset($changes['factory'])) {
  95.                 if (\is_string($factory = $value->getFactory()) && str_starts_with($factory, '@=')) {
  96.                     if (!class_exists(Expression::class)) {
  97.                         throw new LogicException('Expressions cannot be used in service factories without the ExpressionLanguage component. Try running "composer require symfony/expression-language".');
  98.                     }
  99.                     $factory = new Expression(substr($factory, 2));
  100.                 }
  101.                 if (($factory = $this->processValue($factory)) instanceof Expression) {
  102.                     $factory = '@='.$factory;
  103.                 }
  104.                 $value->setFactory($factory);
  105.             }
  106.             if (isset($changes['configurator'])) {
  107.                 $value->setConfigurator($this->processValue($value->getConfigurator()));
  108.             }
  109.         }
  111.         return $value;
  112.     }
  114.     /**
  115.      * @throws RuntimeException
  116.      */
  117.     protected function getConstructor(Definition $definition, bool $required): ?\ReflectionFunctionAbstract
  118.     {
  119.         if ($definition->isSynthetic()) {
  120.             return null;
  121.         }
  123.         if (\is_string($factory = $definition->getFactory())) {
  124.             if (str_starts_with($factory, '@=')) {
  125.                 return new \ReflectionFunction(static function (...$args) {});
  126.             }
  128.             if (!\function_exists($factory)) {
  129.                 throw new RuntimeException(sprintf('Invalid service "%s": function "%s" does not exist.', $this->currentId, $factory));
  130.             }
  131.             $r = new \ReflectionFunction($factory);
  132.             if (false !== $r->getFileName() && file_exists($r->getFileName())) {
  133.                 $this->container->fileExists($r->getFileName());
  134.             }
  136.             return $r;
  137.         }
  139.         if ($factory) {
  140.             [$class, $method] = $factory;
  142.             if ('__construct' === $method) {
  143.                 throw new RuntimeException(sprintf('Invalid service "%s": "__construct()" cannot be used as a factory method.', $this->currentId));
  144.             }
  146.             if ($class instanceof Reference) {
  147.                 $factoryDefinition = $this->container->findDefinition((string) $class);
  148.                 while ((null === $class = $factoryDefinition->getClass()) && $factoryDefinition instanceof ChildDefinition) {
  149.                     $factoryDefinition = $this->container->findDefinition($factoryDefinition->getParent());
  150.                 }
  151.             } elseif ($class instanceof Definition) {
  152.                 $class = $class->getClass();
  153.             } else {
  154.                 $class ??= $definition->getClass();
  155.             }
  157.             return $this->getReflectionMethod(new Definition($class), $method);
  158.         }
  160.         while ((null === $class = $definition->getClass()) && $definition instanceof ChildDefinition) {
  161.             $definition = $this->container->findDefinition($definition->getParent());
  162.         }
  164.         try {
  165.             if (!$r = $this->container->getReflectionClass($class)) {
  166.                 if (null === $class) {
  167.                     throw new RuntimeException(sprintf('Invalid service "%s": the class is not set.', $this->currentId));
  168.                 }
  170.                 throw new RuntimeException(sprintf('Invalid service "%s": class "%s" does not exist.', $this->currentId, $class));
  171.             }
  172.         } catch (\ReflectionException $e) {
  173.             throw new RuntimeException(sprintf('Invalid service "%s": ', $this->currentId).lcfirst($e->getMessage()));
  174.         }
  175.         if (!$r = $r->getConstructor()) {
  176.             if ($required) {
  177.                 throw new RuntimeException(sprintf('Invalid service "%s": class%s has no constructor.', $this->currentId, sprintf($class !== $this->currentId ? ' "%s"' : '', $class)));
  178.             }
  179.         } elseif (!$r->isPublic()) {
  180.             throw new RuntimeException(sprintf('Invalid service "%s": ', $this->currentId).sprintf($class !== $this->currentId ? 'constructor of class "%s"' : 'its constructor', $class).' must be public.');
  181.         }
  183.         return $r;
  184.     }
  186.     /**
  187.      * @throws RuntimeException
  188.      */
  189.     protected function getReflectionMethod(Definition $definition, string $method): \ReflectionFunctionAbstract
  190.     {
  191.         if ('__construct' === $method) {
  192.             return $this->getConstructor($definition, true);
  193.         }
  195.         while ((null === $class = $definition->getClass()) && $definition instanceof ChildDefinition) {
  196.             $definition = $this->container->findDefinition($definition->getParent());
  197.         }
  199.         if (null === $class) {
  200.             throw new RuntimeException(sprintf('Invalid service "%s": the class is not set.', $this->currentId));
  201.         }
  203.         if (!$r = $this->container->getReflectionClass($class)) {
  204.             throw new RuntimeException(sprintf('Invalid service "%s": class "%s" does not exist.', $this->currentId, $class));
  205.         }
  207.         if (!$r->hasMethod($method)) {
  208.             if ($r->hasMethod('__call') && ($r = $r->getMethod('__call')) && $r->isPublic()) {
  209.                 return new \ReflectionMethod(static function (...$arguments) {}, '__invoke');
  210.             }
  212.             throw new RuntimeException(sprintf('Invalid service "%s": method "%s()" does not exist.', $this->currentId, $class !== $this->currentId ? $class.'::'.$method : $method));
  213.         }
  215.         $r = $r->getMethod($method);
  216.         if (!$r->isPublic()) {
  217.             throw new RuntimeException(sprintf('Invalid service "%s": method "%s()" must be public.', $this->currentId, $class !== $this->currentId ? $class.'::'.$method : $method));
  218.         }
  220.         return $r;
  221.     }
  223.     private function getExpressionLanguage(): ExpressionLanguage
  224.     {
  225.         if (!isset($this->expressionLanguage)) {
  226.             if (!class_exists(ExpressionLanguage::class)) {
  227.                 throw new LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed. Try running "composer require symfony/expression-language".');
  228.             }
  230.             $providers = $this->container->getExpressionLanguageProviders();
  231.             $this->expressionLanguage = new ExpressionLanguage(null, $providers, function (string $arg): string {
  232.                 if ('""' === substr_replace($arg, '', 1, -1)) {
  233.                     $id = stripcslashes(substr($arg, 1, -1));
  234.                     $this->inExpression = true;
  235.                     $arg = $this->processValue(new Reference($id));
  236.                     $this->inExpression = false;
  237.                     if (!$arg instanceof Reference) {
  238.                         throw new RuntimeException(sprintf('"%s::processValue()" must return a Reference when processing an expression, "%s" returned for service("%s").', static::class, get_debug_type($arg), $id));
  239.                     }
  240.                     $arg = sprintf('"%s"', $arg);
  241.                 }
  243.                 return sprintf('$this->get(%s)', $arg);
  244.             });
  245.         }
  247.         return $this->expressionLanguage;
  248.     }
  249. }