vendor/symfony/dependency-injection/Compiler/AutowirePass.php line 427

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\DependencyInjection\Compiler;
  14. use Symfony\Component\Config\Resource\ClassExistenceResource;
  15. use Symfony\Component\DependencyInjection\ContainerBuilder;
  16. use Symfony\Component\DependencyInjection\Definition;
  17. use Symfony\Component\DependencyInjection\Exception\AutowiringFailedException;
  18. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  19. use Symfony\Component\DependencyInjection\LazyProxy\ProxyHelper;
  20. use Symfony\Component\DependencyInjection\TypedReference;
  22. /**
  23.  * Inspects existing service definitions and wires the autowired ones using the type hints of their classes.
  24.  *
  25.  * @author Kévin Dunglas <dunglas@gmail.com>
  26.  * @author Nicolas Grekas <p@tchwork.com>
  27.  */
  28. class AutowirePass extends AbstractRecursivePass
  29. {
  30.     private $types;
  31.     private $ambiguousServiceTypes;
  32.     private $lastFailure;
  33.     private $throwOnAutowiringException;
  34.     private $decoratedClass;
  35.     private $decoratedId;
  36.     private $methodCalls;
  37.     private $defaultArgument;
  38.     private $getPreviousValue;
  39.     private $decoratedMethodIndex;
  40.     private $decoratedMethodArgumentIndex;
  41.     private $typesClone;
  43.     public function __construct(bool $throwOnAutowireException = true)
  44.     {
  45.         $this->throwOnAutowiringException = $throwOnAutowireException;
  46.         $this->defaultArgument = new class() {
  47.             public $value;
  48.             public $names;
  49.         };
  50.     }
  52.     /**
  53.      * {@inheritdoc}
  54.      */
  55.     public function process(ContainerBuilder $container)
  56.     {
  57.         try {
  58.             $this->typesClone = clone $this;
  59.             parent::process($container);
  60.         } finally {
  61.             $this->decoratedClass = null;
  62.             $this->decoratedId = null;
  63.             $this->methodCalls = null;
  64.             $this->defaultArgument->names = null;
  65.             $this->getPreviousValue = null;
  66.             $this->decoratedMethodIndex = null;
  67.             $this->decoratedMethodArgumentIndex = null;
  68.             $this->typesClone = null;
  69.         }
  70.     }
  72.     /**
  73.      * {@inheritdoc}
  74.      */
  75.     protected function processValue($value, $isRoot = false)
  76.     {
  77.         try {
  78.             return $this->doProcessValue($value, $isRoot);
  79.         } catch (AutowiringFailedException $e) {
  80.             if ($this->throwOnAutowiringException) {
  81.                 throw $e;
  82.             }
  84.             $this->container->getDefinition($this->currentId)->addError($e->getMessageCallback() ?? $e->getMessage());
  86.             return parent::processValue($value, $isRoot);
  87.         }
  88.     }
  90.     /**
  91.      * @return mixed
  92.      */
  93.     private function doProcessValue($value, bool $isRoot = false)
  94.     {
  95.         if ($value instanceof TypedReference) {
  96.             if ($ref = $this->getAutowiredReference($value)) {
  97.                 return $ref;
  98.             }
  99.             if (ContainerBuilder::RUNTIME_EXCEPTION_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  100.                 $message = $this->createTypeNotFoundMessageCallback($value, 'it');
  102.                 // since the error message varies by referenced id and $this->currentId, so should the id of the dummy errored definition
  103.                 $this->container->register($id = sprintf('.errored.%s.%s', $this->currentId, (string) $value), $value->getType())
  104.                     ->addError($message);
  106.                 return new TypedReference($id, $value->getType(), $value->getInvalidBehavior(), $value->getName());
  107.             }
  108.         }
  109.         $value = parent::processValue($value, $isRoot);
  111.         if (!$value instanceof Definition || !$value->isAutowired() || $value->isAbstract() || !$value->getClass()) {
  112.             return $value;
  113.         }
  114.         if (!$reflectionClass = $this->container->getReflectionClass($value->getClass(), false)) {
  115.             $this->container->log($this, sprintf('Skipping service "%s": Class or interface "%s" cannot be loaded.', $this->currentId, $value->getClass()));
  117.             return $value;
  118.         }
  120.         $this->methodCalls = $value->getMethodCalls();
  122.         try {
  123.             $constructor = $this->getConstructor($value, false);
  124.         } catch (RuntimeException $e) {
  125.             throw new AutowiringFailedException($this->currentId, $e->getMessage(), 0, $e);
  126.         }
  128.         if ($constructor) {
  129.             array_unshift($this->methodCalls, [$constructor, $value->getArguments()]);
  130.         }
  132.         $this->methodCalls = $this->autowireCalls($reflectionClass, $isRoot);
  134.         if ($constructor) {
  135.             [, $arguments] = array_shift($this->methodCalls);
  137.             if ($arguments !== $value->getArguments()) {
  138.                 $value->setArguments($arguments);
  139.             }
  140.         }
  142.         if ($this->methodCalls !== $value->getMethodCalls()) {
  143.             $value->setMethodCalls($this->methodCalls);
  144.         }
  146.         return $value;
  147.     }
  149.     private function autowireCalls(\ReflectionClass $reflectionClass, bool $isRoot): array
  150.     {
  151.         $this->decoratedId = null;
  152.         $this->decoratedClass = null;
  153.         $this->getPreviousValue = null;
  155.         if ($isRoot && ($definition = $this->container->getDefinition($this->currentId)) && null !== ($this->decoratedId = $definition->innerServiceId) && $this->container->has($this->decoratedId)) {
  156.             $this->decoratedClass = $this->container->findDefinition($this->decoratedId)->getClass();
  157.         }
  159.         $patchedIndexes = [];
  161.         foreach ($this->methodCalls as $i => $call) {
  162.             [$method, $arguments] = $call;
  164.             if ($method instanceof \ReflectionFunctionAbstract) {
  165.                 $reflectionMethod = $method;
  166.             } else {
  167.                 $definition = new Definition($reflectionClass->name);
  168.                 try {
  169.                     $reflectionMethod = $this->getReflectionMethod($definition, $method);
  170.                 } catch (RuntimeException $e) {
  171.                     if ($definition->getFactory()) {
  172.                         continue;
  173.                     }
  174.                     throw $e;
  175.                 }
  176.             }
  178.             $arguments = $this->autowireMethod($reflectionMethod, $arguments, $i);
  180.             if ($arguments !== $call[1]) {
  181.                 $this->methodCalls[$i][1] = $arguments;
  182.                 $patchedIndexes[] = $i;
  183.             }
  184.         }
  186.         // use named arguments to skip complex default values
  187.         foreach ($patchedIndexes as $i) {
  188.             $namedArguments = null;
  189.             $arguments = $this->methodCalls[$i][1];
  191.             foreach ($arguments as $j => $value) {
  192.                 if ($namedArguments && !$value instanceof $this->defaultArgument) {
  193.                     unset($arguments[$j]);
  194.                     $arguments[$namedArguments[$j]] = $value;
  195.                 }
  196.                 if ($namedArguments || !$value instanceof $this->defaultArgument) {
  197.                     continue;
  198.                 }
  200.                 if (\PHP_VERSION_ID >= 80100 && (\is_array($value->value) ? $value->value : \is_object($value->value))) {
  201.                     unset($arguments[$j]);
  202.                     $namedArguments = $value->names;
  203.                 } else {
  204.                     $arguments[$j] = $value->value;
  205.                 }
  206.             }
  208.             $this->methodCalls[$i][1] = $arguments;
  209.         }
  211.         return $this->methodCalls;
  212.     }
  214.     /**
  215.      * Autowires the constructor or a method.
  216.      *
  217.      * @return array The autowired arguments
  218.      *
  219.      * @throws AutowiringFailedException
  220.      */
  221.     private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, array $arguments, int $methodIndex): array
  222.     {
  223.         $class = $reflectionMethod instanceof \ReflectionMethod ? $reflectionMethod->class : $this->currentId;
  224.         $method = $reflectionMethod->name;
  225.         $parameters = $reflectionMethod->getParameters();
  226.         if ($reflectionMethod->isVariadic()) {
  227.             array_pop($parameters);
  228.         }
  229.         $this->defaultArgument->names = new \ArrayObject();
  231.         foreach ($parameters as $index => $parameter) {
  232.             $this->defaultArgument->names[$index] = $parameter->name;
  234.             if (\array_key_exists($index, $arguments) && '' !== $arguments[$index]) {
  235.                 continue;
  236.             }
  238.             $type = ProxyHelper::getTypeHint($reflectionMethod, $parameter, true);
  240.             if (!$type) {
  241.                 if (isset($arguments[$index])) {
  242.                     continue;
  243.                 }
  245.                 // no default value? Then fail
  246.                 if (!$parameter->isDefaultValueAvailable()) {
  247.                     // For core classes, isDefaultValueAvailable() can
  248.                     // be false when isOptional() returns true. If the
  249.                     // argument *is* optional, allow it to be missing
  250.                     if ($parameter->isOptional()) {
  251.                         --$index;
  252.                         break;
  253.                     }
  254.                     $type = ProxyHelper::getTypeHint($reflectionMethod, $parameter, false);
  255.                     $type = $type ? sprintf('is type-hinted "%s"', ltrim($type, '\\')) : 'has no type-hint';
  257.                     throw new AutowiringFailedException($this->currentId, sprintf('Cannot autowire service "%s": argument "$%s" of method "%s()" %s, you should configure its value explicitly.', $this->currentId, $parameter->name, $class !== $this->currentId ? $class.'::'.$method : $method, $type));
  258.                 }
  260.                 // specifically pass the default value
  261.                 $arguments[$index] = clone $this->defaultArgument;
  262.                 $arguments[$index]->value = $parameter->getDefaultValue();
  264.                 continue;
  265.             }
  267.             $getValue = function () use ($type, $parameter, $class, $method) {
  268.                 if (!$value = $this->getAutowiredReference($ref = new TypedReference($type, $type, ContainerBuilder::EXCEPTION_ON_INVALID_REFERENCE, $parameter->name))) {
  269.                     $failureMessage = $this->createTypeNotFoundMessageCallback($ref, sprintf('argument "$%s" of method "%s()"', $parameter->name, $class !== $this->currentId ? $class.'::'.$method : $method));
  271.                     if ($parameter->isDefaultValueAvailable()) {
  272.                         $value = clone $this->defaultArgument;
  273.                         $value->value = $parameter->getDefaultValue();
  274.                     } elseif (!$parameter->allowsNull()) {
  275.                         throw new AutowiringFailedException($this->currentId, $failureMessage);
  276.                     }
  277.                 }
  279.                 return $value;
  280.             };
  282.             if ($this->decoratedClass && $isDecorated = is_a($this->decoratedClass, $type, true)) {
  283.                 if ($this->getPreviousValue) {
  284.                     // The inner service is injected only if there is only 1 argument matching the type of the decorated class
  285.                     // across all arguments of all autowired methods.
  286.                     // If a second matching argument is found, the default behavior is restored.
  288.                     $getPreviousValue = $this->getPreviousValue;
  289.                     $this->methodCalls[$this->decoratedMethodIndex][1][$this->decoratedMethodArgumentIndex] = $getPreviousValue();
  290.                     $this->decoratedClass = null; // Prevent further checks
  291.                 } else {
  292.                     $arguments[$index] = new TypedReference($this->decoratedId, $this->decoratedClass);
  293.                     $this->getPreviousValue = $getValue;
  294.                     $this->decoratedMethodIndex = $methodIndex;
  295.                     $this->decoratedMethodArgumentIndex = $index;
  297.                     continue;
  298.                 }
  299.             }
  301.             $arguments[$index] = $getValue();
  302.         }
  304.         if ($parameters && !isset($arguments[++$index])) {
  305.             while (0 <= --$index) {
  306.                 if (!$arguments[$index] instanceof $this->defaultArgument) {
  307.                     break;
  308.                 }
  309.                 unset($arguments[$index]);
  310.             }
  311.         }
  313.         // it's possible index 1 was set, then index 0, then 2, etc
  314.         // make sure that we re-order so they're injected as expected
  315.         ksort($arguments);
  317.         return $arguments;
  318.     }
  320.     /**
  321.      * Returns a reference to the service matching the given type, if any.
  322.      */
  323.     private function getAutowiredReference(TypedReference $reference): ?TypedReference
  324.     {
  325.         $this->lastFailure = null;
  326.         $type = $reference->getType();
  328.         if ($type !== (string) $reference) {
  329.             return $reference;
  330.         }
  332.         if (null !== $name = $reference->getName()) {
  333.             if ($this->container->has($alias = $type.' $'.$name) && !$this->container->findDefinition($alias)->isAbstract()) {
  334.                 return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  335.             }
  337.             if ($this->container->has($name) && !$this->container->findDefinition($name)->isAbstract()) {
  338.                 foreach ($this->container->getAliases() as $id => $alias) {
  339.                     if ($name === (string) $alias && str_starts_with($id, $type.' $')) {
  340.                         return new TypedReference($name, $type, $reference->getInvalidBehavior());
  341.                     }
  342.                 }
  343.             }
  344.         }
  346.         if ($this->container->has($type) && !$this->container->findDefinition($type)->isAbstract()) {
  347.             return new TypedReference($type, $type, $reference->getInvalidBehavior());
  348.         }
  350.         return null;
  351.     }
  353.     /**
  354.      * Populates the list of available types.
  355.      */
  356.     private function populateAvailableTypes(ContainerBuilder $container)
  357.     {
  358.         $this->types = [];
  359.         $this->ambiguousServiceTypes = [];
  361.         foreach ($container->getDefinitions() as $id => $definition) {
  362.             $this->populateAvailableType($container, $id, $definition);
  363.         }
  364.     }
  366.     /**
  367.      * Populates the list of available types for a given definition.
  368.      */
  369.     private function populateAvailableType(ContainerBuilder $container, string $id, Definition $definition)
  370.     {
  371.         // Never use abstract services
  372.         if ($definition->isAbstract()) {
  373.             return;
  374.         }
  376.         if ('' === $id || '.' === $id[0] || $definition->isDeprecated() || !$reflectionClass = $container->getReflectionClass($definition->getClass(), false)) {
  377.             return;
  378.         }
  380.         foreach ($reflectionClass->getInterfaces() as $reflectionInterface) {
  381.             $this->set($reflectionInterface->name, $id);
  382.         }
  384.         do {
  385.             $this->set($reflectionClass->name, $id);
  386.         } while ($reflectionClass = $reflectionClass->getParentClass());
  387.     }
  389.     /**
  390.      * Associates a type and a service id if applicable.
  391.      */
  392.     private function set(string $type, string $id)
  393.     {
  394.         // is this already a type/class that is known to match multiple services?
  395.         if (isset($this->ambiguousServiceTypes[$type])) {
  396.             $this->ambiguousServiceTypes[$type][] = $id;
  398.             return;
  399.         }
  401.         // check to make sure the type doesn't match multiple services
  402.         if (!isset($this->types[$type]) || $this->types[$type] === $id) {
  403.             $this->types[$type] = $id;
  405.             return;
  406.         }
  408.         // keep an array of all services matching this type
  409.         if (!isset($this->ambiguousServiceTypes[$type])) {
  410.             $this->ambiguousServiceTypes[$type] = [$this->types[$type]];
  411.             unset($this->types[$type]);
  412.         }
  413.         $this->ambiguousServiceTypes[$type][] = $id;
  414.     }
  416.     private function createTypeNotFoundMessageCallback(TypedReference $reference, string $label): \Closure
  417.     {
  418.         if (null === $this->typesClone->container) {
  419.             $this->typesClone->container = new ContainerBuilder($this->container->getParameterBag());
  420.             $this->typesClone->container->setAliases($this->container->getAliases());
  421.             $this->typesClone->container->setDefinitions($this->container->getDefinitions());
  422.             $this->typesClone->container->setResourceTracking(false);
  423.         }
  424.         $currentId = $this->currentId;
  426.         return (function () use ($reference, $label, $currentId) {
  427.             return $this->createTypeNotFoundMessage($reference, $label, $currentId);
  428.         })->bindTo($this->typesClone);
  429.     }
  431.     private function createTypeNotFoundMessage(TypedReference $reference, string $label, string $currentId): string
  432.     {
  433.         if (!$r = $this->container->getReflectionClass($type = $reference->getType(), false)) {
  434.             // either $type does not exist or a parent class does not exist
  435.             try {
  436.                 $resource = new ClassExistenceResource($type, false);
  437.                 // isFresh() will explode ONLY if a parent class/trait does not exist
  438.                 $resource->isFresh(0);
  439.                 $parentMsg = false;
  440.             } catch (\ReflectionException $e) {
  441.                 $parentMsg = $e->getMessage();
  442.             }
  444.             $message = sprintf('has type "%s" but this class %s.', $type, $parentMsg ? sprintf('is missing a parent class (%s)', $parentMsg) : 'was not found');
  445.         } else {
  446.             $alternatives = $this->createTypeAlternatives($this->container, $reference);
  447.             $message = $this->container->has($type) ? 'this service is abstract' : 'no such service exists';
  448.             $message = sprintf('references %s "%s" but %s.%s', $r->isInterface() ? 'interface' : 'class', $type, $message, $alternatives);
  450.             if ($r->isInterface() && !$alternatives) {
  451.                 $message .= ' Did you create a class that implements this interface?';
  452.             }
  453.         }
  455.         $message = sprintf('Cannot autowire service "%s": %s %s', $currentId, $label, $message);
  457.         if (null !== $this->lastFailure) {
  458.             $message = $this->lastFailure."\n".$message;
  459.             $this->lastFailure = null;
  460.         }
  462.         return $message;
  463.     }
  465.     private function createTypeAlternatives(ContainerBuilder $container, TypedReference $reference): string
  466.     {
  467.         // try suggesting available aliases first
  468.         if ($message = $this->getAliasesSuggestionForType($container, $type = $reference->getType())) {
  469.             return ' '.$message;
  470.         }
  471.         if (null === $this->ambiguousServiceTypes) {
  472.             $this->populateAvailableTypes($container);
  473.         }
  475.         $servicesAndAliases = $container->getServiceIds();
  476.         if (!$container->has($type) && false !== $key = array_search(strtolower($type), array_map('strtolower', $servicesAndAliases))) {
  477.             return sprintf(' Did you mean "%s"?', $servicesAndAliases[$key]);
  478.         } elseif (isset($this->ambiguousServiceTypes[$type])) {
  479.             $message = sprintf('one of these existing services: "%s"', implode('", "', $this->ambiguousServiceTypes[$type]));
  480.         } elseif (isset($this->types[$type])) {
  481.             $message = sprintf('the existing "%s" service', $this->types[$type]);
  482.         } else {
  483.             return '';
  484.         }
  486.         return sprintf(' You should maybe alias this %s to %s.', class_exists($type, false) ? 'class' : 'interface', $message);
  487.     }
  489.     private function getAliasesSuggestionForType(ContainerBuilder $container, string $type): ?string
  490.     {
  491.         $aliases = [];
  492.         foreach (class_parents($type) + class_implements($type) as $parent) {
  493.             if ($container->has($parent) && !$container->findDefinition($parent)->isAbstract()) {
  494.                 $aliases[] = $parent;
  495.             }
  496.         }
  498.         if (1 < $len = \count($aliases)) {
  499.             $message = 'Try changing the type-hint to one of its parents: ';
  500.             for ($i = 0, --$len; $i < $len; ++$i) {
  501.                 $message .= sprintf('%s "%s", ', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  502.             }
  503.             $message .= sprintf('or %s "%s".', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  505.             return $message;
  506.         }
  508.         if ($aliases) {
  509.             return sprintf('Try changing the type-hint to "%s" instead.', $aliases[0]);
  510.         }
  512.         return null;
  513.     }
  514. }