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

  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\Argument\ServiceLocatorArgument;
  16. use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
  17. use Symfony\Component\DependencyInjection\Attribute\Autowire;
  18. use Symfony\Component\DependencyInjection\Attribute\MapDecorated;
  19. use Symfony\Component\DependencyInjection\Attribute\TaggedIterator;
  20. use Symfony\Component\DependencyInjection\Attribute\TaggedLocator;
  21. use Symfony\Component\DependencyInjection\Attribute\Target;
  22. use Symfony\Component\DependencyInjection\ContainerBuilder;
  23. use Symfony\Component\DependencyInjection\ContainerInterface;
  24. use Symfony\Component\DependencyInjection\Definition;
  25. use Symfony\Component\DependencyInjection\Exception\AutowiringFailedException;
  26. use Symfony\Component\DependencyInjection\Exception\ParameterNotFoundException;
  27. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  28. use Symfony\Component\DependencyInjection\Reference;
  29. use Symfony\Component\DependencyInjection\TypedReference;
  30. use Symfony\Component\VarExporter\ProxyHelper;
  31. use Symfony\Contracts\Service\Attribute\SubscribedService;
  33. /**
  34.  * Inspects existing service definitions and wires the autowired ones using the type hints of their classes.
  35.  *
  36.  * @author Kévin Dunglas <dunglas@gmail.com>
  37.  * @author Nicolas Grekas <p@tchwork.com>
  38.  */
  39. class AutowirePass extends AbstractRecursivePass
  40. {
  41.     private array $types;
  42.     private array $ambiguousServiceTypes;
  43.     private array $autowiringAliases;
  44.     private ?string $lastFailure = null;
  45.     private bool $throwOnAutowiringException;
  46.     private ?string $decoratedClass = null;
  47.     private ?string $decoratedId = null;
  48.     private ?array $methodCalls = null;
  49.     private object $defaultArgument;
  50.     private ?\Closure $getPreviousValue = null;
  51.     private ?int $decoratedMethodIndex = null;
  52.     private ?int $decoratedMethodArgumentIndex = null;
  53.     private ?self $typesClone = null;
  55.     public function __construct(bool $throwOnAutowireException = true)
  56.     {
  57.         $this->throwOnAutowiringException = $throwOnAutowireException;
  58.         $this->defaultArgument = new class() {
  59.             public $value;
  60.             public $names;
  61.             public $bag;
  63.             public function withValue(\ReflectionParameter $parameter): self
  64.             {
  65.                 $clone = clone $this;
  66.                 $clone->value = $this->bag->escapeValue($parameter->getDefaultValue());
  68.                 return $clone;
  69.             }
  70.         };
  71.     }
  73.     public function process(ContainerBuilder $container)
  74.     {
  75.         $this->defaultArgument->bag = $container->getParameterBag();
  77.         try {
  78.             $this->typesClone = clone $this;
  79.             parent::process($container);
  80.         } finally {
  81.             $this->decoratedClass = null;
  82.             $this->decoratedId = null;
  83.             $this->methodCalls = null;
  84.             $this->defaultArgument->bag = null;
  85.             $this->defaultArgument->names = null;
  86.             $this->getPreviousValue = null;
  87.             $this->decoratedMethodIndex = null;
  88.             $this->decoratedMethodArgumentIndex = null;
  89.             $this->typesClone = null;
  90.         }
  91.     }
  93.     protected function processValue(mixed $value, bool $isRoot = false): mixed
  94.     {
  95.         try {
  96.             return $this->doProcessValue($value, $isRoot);
  97.         } catch (AutowiringFailedException $e) {
  98.             if ($this->throwOnAutowiringException) {
  99.                 throw $e;
  100.             }
  102.             $this->container->getDefinition($this->currentId)->addError($e->getMessageCallback() ?? $e->getMessage());
  104.             return parent::processValue($value, $isRoot);
  105.         }
  106.     }
  108.     private function doProcessValue(mixed $value, bool $isRoot = false): mixed
  109.     {
  110.         if ($value instanceof TypedReference) {
  111.             if ($attributes = $value->getAttributes()) {
  112.                 $attribute = array_pop($attributes);
  114.                 if ($attributes) {
  115.                     throw new AutowiringFailedException($this->currentId, sprintf('Using multiple attributes with "%s" is not supported.', SubscribedService::class));
  116.                 }
  118.                 if (!$attribute instanceof Target) {
  119.                     return $this->processAttribute($attribute, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE !== $value->getInvalidBehavior());
  120.                 }
  122.                 $value = new TypedReference($value->getType(), $value->getType(), $value->getInvalidBehavior(), $attribute->name);
  123.             }
  124.             if ($ref = $this->getAutowiredReference($value, true)) {
  125.                 return $ref;
  126.             }
  127.             if (ContainerBuilder::RUNTIME_EXCEPTION_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  128.                 $message = $this->createTypeNotFoundMessageCallback($value, 'it');
  130.                 // since the error message varies by referenced id and $this->currentId, so should the id of the dummy errored definition
  131.                 $this->container->register($id = sprintf('.errored.%s.%s', $this->currentId, (string) $value), $value->getType())
  132.                     ->addError($message);
  134.                 return new TypedReference($id, $value->getType(), $value->getInvalidBehavior(), $value->getName());
  135.             }
  136.         }
  137.         $value = parent::processValue($value, $isRoot);
  139.         if (!$value instanceof Definition || !$value->isAutowired() || $value->isAbstract() || !$value->getClass()) {
  140.             return $value;
  141.         }
  142.         if (!$reflectionClass = $this->container->getReflectionClass($value->getClass(), false)) {
  143.             $this->container->log($this, sprintf('Skipping service "%s": Class or interface "%s" cannot be loaded.', $this->currentId, $value->getClass()));
  145.             return $value;
  146.         }
  148.         $this->methodCalls = $value->getMethodCalls();
  150.         try {
  151.             $constructor = $this->getConstructor($value, false);
  152.         } catch (RuntimeException $e) {
  153.             throw new AutowiringFailedException($this->currentId, $e->getMessage(), 0, $e);
  154.         }
  156.         if ($constructor) {
  157.             array_unshift($this->methodCalls, [$constructor, $value->getArguments()]);
  158.         }
  160.         $checkAttributes = !$value->hasTag('container.ignore_attributes');
  161.         $this->methodCalls = $this->autowireCalls($reflectionClass, $isRoot, $checkAttributes);
  163.         if ($constructor) {
  164.             [, $arguments] = array_shift($this->methodCalls);
  166.             if ($arguments !== $value->getArguments()) {
  167.                 $value->setArguments($arguments);
  168.             }
  169.         }
  171.         if ($this->methodCalls !== $value->getMethodCalls()) {
  172.             $value->setMethodCalls($this->methodCalls);
  173.         }
  175.         return $value;
  176.     }
  178.     private function processAttribute(object $attribute, bool $isOptional = false): mixed
  179.     {
  180.         switch (true) {
  181.             case $attribute instanceof Autowire:
  182.                 $value = $this->container->getParameterBag()->resolveValue($attribute->value);
  184.                 return $value instanceof Reference && $isOptional ? new Reference($value, ContainerInterface::NULL_ON_INVALID_REFERENCE) : $value;
  186.             case $attribute instanceof TaggedIterator:
  187.                 return new TaggedIteratorArgument($attribute->tag, $attribute->indexAttribute, $attribute->defaultIndexMethod, false, $attribute->defaultPriorityMethod, (array) $attribute->exclude);
  189.             case $attribute instanceof TaggedLocator:
  190.                 return new ServiceLocatorArgument(new TaggedIteratorArgument($attribute->tag, $attribute->indexAttribute, $attribute->defaultIndexMethod, true, $attribute->defaultPriorityMethod, (array) $attribute->exclude));
  192.             case $attribute instanceof MapDecorated:
  193.                 $definition = $this->container->getDefinition($this->currentId);
  195.                 return new Reference($definition->innerServiceId ?? $this->currentId.'.inner', $definition->decorationOnInvalid ?? ContainerInterface::NULL_ON_INVALID_REFERENCE);
  196.         }
  198.         throw new AutowiringFailedException($this->currentId, sprintf('"%s" is an unsupported attribute.', $attribute::class));
  199.     }
  201.     private function autowireCalls(\ReflectionClass $reflectionClass, bool $isRoot, bool $checkAttributes): array
  202.     {
  203.         $this->decoratedId = null;
  204.         $this->decoratedClass = null;
  205.         $this->getPreviousValue = null;
  207.         if ($isRoot && ($definition = $this->container->getDefinition($this->currentId)) && null !== ($this->decoratedId = $definition->innerServiceId) && $this->container->has($this->decoratedId)) {
  208.             $this->decoratedClass = $this->container->findDefinition($this->decoratedId)->getClass();
  209.         }
  211.         $patchedIndexes = [];
  213.         foreach ($this->methodCalls as $i => $call) {
  214.             [$method, $arguments] = $call;
  216.             if ($method instanceof \ReflectionFunctionAbstract) {
  217.                 $reflectionMethod = $method;
  218.             } else {
  219.                 $definition = new Definition($reflectionClass->name);
  220.                 try {
  221.                     $reflectionMethod = $this->getReflectionMethod($definition, $method);
  222.                 } catch (RuntimeException $e) {
  223.                     if ($definition->getFactory()) {
  224.                         continue;
  225.                     }
  226.                     throw $e;
  227.                 }
  228.             }
  230.             $arguments = $this->autowireMethod($reflectionMethod, $arguments, $checkAttributes, $i);
  232.             if ($arguments !== $call[1]) {
  233.                 $this->methodCalls[$i][1] = $arguments;
  234.                 $patchedIndexes[] = $i;
  235.             }
  236.         }
  238.         // use named arguments to skip complex default values
  239.         foreach ($patchedIndexes as $i) {
  240.             $namedArguments = null;
  241.             $arguments = $this->methodCalls[$i][1];
  243.             foreach ($arguments as $j => $value) {
  244.                 if ($namedArguments && !$value instanceof $this->defaultArgument) {
  245.                     unset($arguments[$j]);
  246.                     $arguments[$namedArguments[$j]] = $value;
  247.                 }
  248.                 if ($namedArguments || !$value instanceof $this->defaultArgument) {
  249.                     continue;
  250.                 }
  252.                 if (\is_array($value->value) ? $value->value : \is_object($value->value)) {
  253.                     unset($arguments[$j]);
  254.                     $namedArguments = $value->names;
  255.                 } else {
  256.                     $arguments[$j] = $value->value;
  257.                 }
  258.             }
  260.             $this->methodCalls[$i][1] = $arguments;
  261.         }
  263.         return $this->methodCalls;
  264.     }
  266.     /**
  267.      * Autowires the constructor or a method.
  268.      *
  269.      * @throws AutowiringFailedException
  270.      */
  271.     private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, array $arguments, bool $checkAttributes, int $methodIndex): array
  272.     {
  273.         $class = $reflectionMethod instanceof \ReflectionMethod ? $reflectionMethod->class : $this->currentId;
  274.         $method = $reflectionMethod->name;
  275.         $parameters = $reflectionMethod->getParameters();
  276.         if ($reflectionMethod->isVariadic()) {
  277.             array_pop($parameters);
  278.         }
  279.         $this->defaultArgument->names = new \ArrayObject();
  281.         foreach ($parameters as $index => $parameter) {
  282.             $this->defaultArgument->names[$index] = $parameter->name;
  284.             if (\array_key_exists($parameter->name, $arguments)) {
  285.                 $arguments[$index] = $arguments[$parameter->name];
  286.                 unset($arguments[$parameter->name]);
  287.             }
  288.             if (\array_key_exists($index, $arguments) && '' !== $arguments[$index]) {
  289.                 continue;
  290.             }
  292.             if ($checkAttributes) {
  293.                 foreach ($parameter->getAttributes() as $attribute) {
  294.                     if (\in_array($attribute->getName(), [TaggedIterator::class, TaggedLocator::class, Autowire::class, MapDecorated::class], true)) {
  295.                         try {
  296.                             $arguments[$index] = $this->processAttribute($attribute->newInstance(), $parameter->allowsNull());
  297.                             continue 2;
  298.                         } catch (ParameterNotFoundException $e) {
  299.                             if (!$parameter->isDefaultValueAvailable()) {
  300.                                 throw new AutowiringFailedException($this->currentId, $e->getMessage(), 0, $e);
  301.                             }
  302.                             $arguments[$index] = clone $this->defaultArgument;
  303.                             $arguments[$index]->value = $parameter->getDefaultValue();
  304.                         }
  305.                     }
  306.                 }
  307.             }
  309.             if (!$type = ProxyHelper::exportType($parameter, true)) {
  310.                 if (isset($arguments[$index])) {
  311.                     continue;
  312.                 }
  314.                 // no default value? Then fail
  315.                 if (!$parameter->isDefaultValueAvailable()) {
  316.                     // For core classes, isDefaultValueAvailable() can
  317.                     // be false when isOptional() returns true. If the
  318.                     // argument *is* optional, allow it to be missing
  319.                     if ($parameter->isOptional()) {
  320.                         --$index;
  321.                         break;
  322.                     }
  323.                     $type = ProxyHelper::exportType($parameter);
  324.                     $type = $type ? sprintf('is type-hinted "%s"', preg_replace('/(^|[(|&])\\\\|^\?\\\\?/', '\1', $type)) : 'has no type-hint';
  326.                     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));
  327.                 }
  329.                 // specifically pass the default value
  330.                 $arguments[$index] = $this->defaultArgument->withValue($parameter);
  332.                 continue;
  333.             }
  335.             $getValue = function () use ($type, $parameter, $class, $method) {
  336.                 if (!$value = $this->getAutowiredReference($ref = new TypedReference($type, $type, ContainerBuilder::EXCEPTION_ON_INVALID_REFERENCE, Target::parseName($parameter)), false)) {
  337.                     $failureMessage = $this->createTypeNotFoundMessageCallback($ref, sprintf('argument "$%s" of method "%s()"', $parameter->name, $class !== $this->currentId ? $class.'::'.$method : $method));
  339.                     if ($parameter->isDefaultValueAvailable()) {
  340.                         $value = $this->defaultArgument->withValue($parameter);
  341.                     } elseif (!$parameter->allowsNull()) {
  342.                         throw new AutowiringFailedException($this->currentId, $failureMessage);
  343.                     }
  344.                 }
  346.                 return $value;
  347.             };
  349.             if ($this->decoratedClass && $isDecorated = is_a($this->decoratedClass, $type, true)) {
  350.                 if ($this->getPreviousValue) {
  351.                     // The inner service is injected only if there is only 1 argument matching the type of the decorated class
  352.                     // across all arguments of all autowired methods.
  353.                     // If a second matching argument is found, the default behavior is restored.
  355.                     $getPreviousValue = $this->getPreviousValue;
  356.                     $this->methodCalls[$this->decoratedMethodIndex][1][$this->decoratedMethodArgumentIndex] = $getPreviousValue();
  357.                     $this->decoratedClass = null; // Prevent further checks
  358.                 } else {
  359.                     $arguments[$index] = new TypedReference($this->decoratedId, $this->decoratedClass);
  360.                     $this->getPreviousValue = $getValue;
  361.                     $this->decoratedMethodIndex = $methodIndex;
  362.                     $this->decoratedMethodArgumentIndex = $index;
  364.                     continue;
  365.                 }
  366.             }
  368.             $arguments[$index] = $getValue();
  369.         }
  371.         if ($parameters && !isset($arguments[++$index])) {
  372.             while (0 <= --$index) {
  373.                 if (!$arguments[$index] instanceof $this->defaultArgument) {
  374.                     break;
  375.                 }
  376.                 unset($arguments[$index]);
  377.             }
  378.         }
  380.         // it's possible index 1 was set, then index 0, then 2, etc
  381.         // make sure that we re-order so they're injected as expected
  382.         ksort($arguments, \SORT_NATURAL);
  384.         return $arguments;
  385.     }
  387.     /**
  388.      * Returns a reference to the service matching the given type, if any.
  389.      */
  390.     private function getAutowiredReference(TypedReference $reference, bool $filterType): ?TypedReference
  391.     {
  392.         $this->lastFailure = null;
  393.         $type = $reference->getType();
  395.         if ($type !== (string) $reference) {
  396.             return $reference;
  397.         }
  399.         if ($filterType && false !== $m = strpbrk($type, '&|')) {
  400.             $types = array_diff(explode($m[0], $type), ['int', 'string', 'array', 'bool', 'float', 'iterable', 'object', 'callable', 'null']);
  402.             sort($types);
  404.             $type = implode($m[0], $types);
  405.         }
  407.         if (null !== $name = $reference->getName()) {
  408.             if ($this->container->has($alias = $type.' $'.$name) && !$this->container->findDefinition($alias)->isAbstract()) {
  409.                 return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  410.             }
  412.             if (null !== ($alias = $this->getCombinedAlias($type, $name) ?? null) && !$this->container->findDefinition($alias)->isAbstract()) {
  413.                 return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  414.             }
  416.             if ($this->container->has($name) && !$this->container->findDefinition($name)->isAbstract()) {
  417.                 foreach ($this->container->getAliases() as $id => $alias) {
  418.                     if ($name === (string) $alias && str_starts_with($id, $type.' $')) {
  419.                         return new TypedReference($name, $type, $reference->getInvalidBehavior());
  420.                     }
  421.                 }
  422.             }
  423.         }
  425.         if ($this->container->has($type) && !$this->container->findDefinition($type)->isAbstract()) {
  426.             return new TypedReference($type, $type, $reference->getInvalidBehavior());
  427.         }
  429.         if (null !== ($alias = $this->getCombinedAlias($type) ?? null) && !$this->container->findDefinition($alias)->isAbstract()) {
  430.             return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  431.         }
  433.         return null;
  434.     }
  436.     /**
  437.      * Populates the list of available types.
  438.      */
  439.     private function populateAvailableTypes(ContainerBuilder $container)
  440.     {
  441.         $this->types = [];
  442.         $this->ambiguousServiceTypes = [];
  443.         $this->autowiringAliases = [];
  445.         foreach ($container->getDefinitions() as $id => $definition) {
  446.             $this->populateAvailableType($container, $id, $definition);
  447.         }
  449.         foreach ($container->getAliases() as $id => $alias) {
  450.             $this->populateAutowiringAlias($id);
  451.         }
  452.     }
  454.     /**
  455.      * Populates the list of available types for a given definition.
  456.      */
  457.     private function populateAvailableType(ContainerBuilder $container, string $id, Definition $definition)
  458.     {
  459.         // Never use abstract services
  460.         if ($definition->isAbstract()) {
  461.             return;
  462.         }
  464.         if ('' === $id || '.' === $id[0] || $definition->isDeprecated() || !$reflectionClass = $container->getReflectionClass($definition->getClass(), false)) {
  465.             return;
  466.         }
  468.         foreach ($reflectionClass->getInterfaces() as $reflectionInterface) {
  469.             $this->set($reflectionInterface->name, $id);
  470.         }
  472.         do {
  473.             $this->set($reflectionClass->name, $id);
  474.         } while ($reflectionClass = $reflectionClass->getParentClass());
  476.         $this->populateAutowiringAlias($id);
  477.     }
  479.     /**
  480.      * Associates a type and a service id if applicable.
  481.      */
  482.     private function set(string $type, string $id)
  483.     {
  484.         // is this already a type/class that is known to match multiple services?
  485.         if (isset($this->ambiguousServiceTypes[$type])) {
  486.             $this->ambiguousServiceTypes[$type][] = $id;
  488.             return;
  489.         }
  491.         // check to make sure the type doesn't match multiple services
  492.         if (!isset($this->types[$type]) || $this->types[$type] === $id) {
  493.             $this->types[$type] = $id;
  495.             return;
  496.         }
  498.         // keep an array of all services matching this type
  499.         if (!isset($this->ambiguousServiceTypes[$type])) {
  500.             $this->ambiguousServiceTypes[$type] = [$this->types[$type]];
  501.             unset($this->types[$type]);
  502.         }
  503.         $this->ambiguousServiceTypes[$type][] = $id;
  504.     }
  506.     private function createTypeNotFoundMessageCallback(TypedReference $reference, string $label): \Closure
  507.     {
  508.         if (null === $this->typesClone->container) {
  509.             $this->typesClone->container = new ContainerBuilder($this->container->getParameterBag());
  510.             $this->typesClone->container->setAliases($this->container->getAliases());
  511.             $this->typesClone->container->setDefinitions($this->container->getDefinitions());
  512.             $this->typesClone->container->setResourceTracking(false);
  513.         }
  514.         $currentId = $this->currentId;
  516.         return (function () use ($reference, $label, $currentId) {
  517.             return $this->createTypeNotFoundMessage($reference, $label, $currentId);
  518.         })->bindTo($this->typesClone);
  519.     }
  521.     private function createTypeNotFoundMessage(TypedReference $reference, string $label, string $currentId): string
  522.     {
  523.         $type = $reference->getType();
  525.         $i = null;
  526.         $namespace = $type;
  527.         do {
  528.             $namespace = substr($namespace, 0, $i);
  530.             if ($this->container->hasDefinition($namespace) && $tag = $this->container->getDefinition($namespace)->getTag('container.excluded')) {
  531.                 return sprintf('Cannot autowire service "%s": %s needs an instance of "%s" but this type has been excluded %s.', $currentId, $label, $type, $tag[0]['source'] ?? 'from autowiring');
  532.             }
  533.         } while (false !== $i = strrpos($namespace, '\\'));
  535.         if (!$r = $this->container->getReflectionClass($type, false)) {
  536.             // either $type does not exist or a parent class does not exist
  537.             try {
  538.                 $resource = new ClassExistenceResource($type, false);
  539.                 // isFresh() will explode ONLY if a parent class/trait does not exist
  540.                 $resource->isFresh(0);
  541.                 $parentMsg = false;
  542.             } catch (\ReflectionException $e) {
  543.                 $parentMsg = $e->getMessage();
  544.             }
  546.             $message = sprintf('has type "%s" but this class %s.', $type, $parentMsg ? sprintf('is missing a parent class (%s)', $parentMsg) : 'was not found');
  547.         } else {
  548.             $alternatives = $this->createTypeAlternatives($this->container, $reference);
  549.             $message = $this->container->has($type) ? 'this service is abstract' : 'no such service exists';
  550.             $message = sprintf('references %s "%s" but %s.%s', $r->isInterface() ? 'interface' : 'class', $type, $message, $alternatives);
  552.             if ($r->isInterface() && !$alternatives) {
  553.                 $message .= ' Did you create a class that implements this interface?';
  554.             }
  555.         }
  557.         $message = sprintf('Cannot autowire service "%s": %s %s', $currentId, $label, $message);
  559.         if (null !== $this->lastFailure) {
  560.             $message = $this->lastFailure."\n".$message;
  561.             $this->lastFailure = null;
  562.         }
  564.         return $message;
  565.     }
  567.     private function createTypeAlternatives(ContainerBuilder $container, TypedReference $reference): string
  568.     {
  569.         // try suggesting available aliases first
  570.         if ($message = $this->getAliasesSuggestionForType($container, $type = $reference->getType())) {
  571.             return ' '.$message;
  572.         }
  573.         if (!isset($this->ambiguousServiceTypes)) {
  574.             $this->populateAvailableTypes($container);
  575.         }
  577.         $servicesAndAliases = $container->getServiceIds();
  578.         if (null !== ($autowiringAliases = $this->autowiringAliases[$type] ?? null) && !isset($autowiringAliases[''])) {
  579.             return sprintf(' Available autowiring aliases for this %s are: "$%s".', class_exists($type, false) ? 'class' : 'interface', implode('", "$', $autowiringAliases));
  580.         }
  582.         if (!$container->has($type) && false !== $key = array_search(strtolower($type), array_map('strtolower', $servicesAndAliases))) {
  583.             return sprintf(' Did you mean "%s"?', $servicesAndAliases[$key]);
  584.         } elseif (isset($this->ambiguousServiceTypes[$type])) {
  585.             $message = sprintf('one of these existing services: "%s"', implode('", "', $this->ambiguousServiceTypes[$type]));
  586.         } elseif (isset($this->types[$type])) {
  587.             $message = sprintf('the existing "%s" service', $this->types[$type]);
  588.         } else {
  589.             return '';
  590.         }
  592.         return sprintf(' You should maybe alias this %s to %s.', class_exists($type, false) ? 'class' : 'interface', $message);
  593.     }
  595.     private function getAliasesSuggestionForType(ContainerBuilder $container, string $type): ?string
  596.     {
  597.         $aliases = [];
  598.         foreach (class_parents($type) + class_implements($type) as $parent) {
  599.             if ($container->has($parent) && !$container->findDefinition($parent)->isAbstract()) {
  600.                 $aliases[] = $parent;
  601.             }
  602.         }
  604.         if (1 < $len = \count($aliases)) {
  605.             $message = 'Try changing the type-hint to one of its parents: ';
  606.             for ($i = 0, --$len; $i < $len; ++$i) {
  607.                 $message .= sprintf('%s "%s", ', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  608.             }
  609.             $message .= sprintf('or %s "%s".', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  611.             return $message;
  612.         }
  614.         if ($aliases) {
  615.             return sprintf('Try changing the type-hint to "%s" instead.', $aliases[0]);
  616.         }
  618.         return null;
  619.     }
  621.     private function populateAutowiringAlias(string $id): void
  622.     {
  623.         if (!preg_match('/(?(DEFINE)(?<V>[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+))^((?&V)(?:\\\\(?&V))*+)(?: \$((?&V)))?$/', $id, $m)) {
  624.             return;
  625.         }
  627.         $type = $m[2];
  628.         $name = $m[3] ?? '';
  630.         if (class_exists($type, false) || interface_exists($type, false)) {
  631.             $this->autowiringAliases[$type][$name] = $name;
  632.         }
  633.     }
  635.     private function getCombinedAlias(string $type, string $name = null): ?string
  636.     {
  637.         if (str_contains($type, '&')) {
  638.             $types = explode('&', $type);
  639.         } elseif (str_contains($type, '|')) {
  640.             $types = explode('|', $type);
  641.         } else {
  642.             return null;
  643.         }
  645.         $alias = null;
  646.         $suffix = $name ? ' $'.$name : '';
  648.         foreach ($types as $type) {
  649.             if (!$this->container->hasAlias($type.$suffix)) {
  650.                 return null;
  651.             }
  653.             if (null === $alias) {
  654.                 $alias = (string) $this->container->getAlias($type.$suffix);
  655.             } elseif ((string) $this->container->getAlias($type.$suffix) !== $alias) {
  656.                 return null;
  657.             }
  658.         }
  660.         return $alias;
  661.     }
  662. }