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

  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.         };
  62.     }
  64.     public function process(ContainerBuilder $container)
  65.     {
  66.         try {
  67.             $this->typesClone = clone $this;
  68.             parent::process($container);
  69.         } finally {
  70.             $this->decoratedClass = null;
  71.             $this->decoratedId = null;
  72.             $this->methodCalls = null;
  73.             $this->defaultArgument->names = null;
  74.             $this->getPreviousValue = null;
  75.             $this->decoratedMethodIndex = null;
  76.             $this->decoratedMethodArgumentIndex = null;
  77.             $this->typesClone = null;
  78.         }
  79.     }
  81.     protected function processValue(mixed $value, bool $isRoot = false): mixed
  82.     {
  83.         try {
  84.             return $this->doProcessValue($value, $isRoot);
  85.         } catch (AutowiringFailedException $e) {
  86.             if ($this->throwOnAutowiringException) {
  87.                 throw $e;
  88.             }
  90.             $this->container->getDefinition($this->currentId)->addError($e->getMessageCallback() ?? $e->getMessage());
  92.             return parent::processValue($value, $isRoot);
  93.         }
  94.     }
  96.     private function doProcessValue(mixed $value, bool $isRoot = false): mixed
  97.     {
  98.         if ($value instanceof TypedReference) {
  99.             if ($attributes = $value->getAttributes()) {
  100.                 $attribute = array_pop($attributes);
  102.                 if ($attributes) {
  103.                     throw new AutowiringFailedException($this->currentId, sprintf('Using multiple attributes with "%s" is not supported.', SubscribedService::class));
  104.                 }
  106.                 if (!$attribute instanceof Target) {
  107.                     return $this->processAttribute($attribute, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE !== $value->getInvalidBehavior());
  108.                 }
  110.                 $value = new TypedReference($value->getType(), $value->getType(), $value->getInvalidBehavior(), $attribute->name);
  111.             }
  112.             if ($ref = $this->getAutowiredReference($value, true)) {
  113.                 return $ref;
  114.             }
  115.             if (ContainerBuilder::RUNTIME_EXCEPTION_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  116.                 $message = $this->createTypeNotFoundMessageCallback($value, 'it');
  118.                 // since the error message varies by referenced id and $this->currentId, so should the id of the dummy errored definition
  119.                 $this->container->register($id = sprintf('.errored.%s.%s', $this->currentId, (string) $value), $value->getType())
  120.                     ->addError($message);
  122.                 return new TypedReference($id, $value->getType(), $value->getInvalidBehavior(), $value->getName());
  123.             }
  124.         }
  125.         $value = parent::processValue($value, $isRoot);
  127.         if (!$value instanceof Definition || !$value->isAutowired() || $value->isAbstract() || !$value->getClass()) {
  128.             return $value;
  129.         }
  130.         if (!$reflectionClass = $this->container->getReflectionClass($value->getClass(), false)) {
  131.             $this->container->log($this, sprintf('Skipping service "%s": Class or interface "%s" cannot be loaded.', $this->currentId, $value->getClass()));
  133.             return $value;
  134.         }
  136.         $this->methodCalls = $value->getMethodCalls();
  138.         try {
  139.             $constructor = $this->getConstructor($value, false);
  140.         } catch (RuntimeException $e) {
  141.             throw new AutowiringFailedException($this->currentId, $e->getMessage(), 0, $e);
  142.         }
  144.         if ($constructor) {
  145.             array_unshift($this->methodCalls, [$constructor, $value->getArguments()]);
  146.         }
  148.         $checkAttributes = !$value->hasTag('container.ignore_attributes');
  149.         $this->methodCalls = $this->autowireCalls($reflectionClass, $isRoot, $checkAttributes);
  151.         if ($constructor) {
  152.             [, $arguments] = array_shift($this->methodCalls);
  154.             if ($arguments !== $value->getArguments()) {
  155.                 $value->setArguments($arguments);
  156.             }
  157.         }
  159.         if ($this->methodCalls !== $value->getMethodCalls()) {
  160.             $value->setMethodCalls($this->methodCalls);
  161.         }
  163.         return $value;
  164.     }
  166.     private function processAttribute(object $attribute, bool $isOptional = false): mixed
  167.     {
  168.         switch (true) {
  169.             case $attribute instanceof Autowire:
  170.                 $value = $this->container->getParameterBag()->resolveValue($attribute->value);
  172.                 return $value instanceof Reference && $isOptional ? new Reference($value, ContainerInterface::NULL_ON_INVALID_REFERENCE) : $value;
  174.             case $attribute instanceof TaggedIterator:
  175.                 return new TaggedIteratorArgument($attribute->tag, $attribute->indexAttribute, $attribute->defaultIndexMethod, false, $attribute->defaultPriorityMethod, (array) $attribute->exclude);
  177.             case $attribute instanceof TaggedLocator:
  178.                 return new ServiceLocatorArgument(new TaggedIteratorArgument($attribute->tag, $attribute->indexAttribute, $attribute->defaultIndexMethod, true, $attribute->defaultPriorityMethod, (array) $attribute->exclude));
  180.             case $attribute instanceof MapDecorated:
  181.                 $definition = $this->container->getDefinition($this->currentId);
  183.                 return new Reference($definition->innerServiceId ?? $this->currentId.'.inner', $definition->decorationOnInvalid ?? ContainerInterface::NULL_ON_INVALID_REFERENCE);
  184.         }
  186.         throw new AutowiringFailedException($this->currentId, sprintf('"%s" is an unsupported attribute.', $attribute::class));
  187.     }
  189.     private function autowireCalls(\ReflectionClass $reflectionClass, bool $isRoot, bool $checkAttributes): array
  190.     {
  191.         $this->decoratedId = null;
  192.         $this->decoratedClass = null;
  193.         $this->getPreviousValue = null;
  195.         if ($isRoot && ($definition = $this->container->getDefinition($this->currentId)) && null !== ($this->decoratedId = $definition->innerServiceId) && $this->container->has($this->decoratedId)) {
  196.             $this->decoratedClass = $this->container->findDefinition($this->decoratedId)->getClass();
  197.         }
  199.         $patchedIndexes = [];
  201.         foreach ($this->methodCalls as $i => $call) {
  202.             [$method, $arguments] = $call;
  204.             if ($method instanceof \ReflectionFunctionAbstract) {
  205.                 $reflectionMethod = $method;
  206.             } else {
  207.                 $definition = new Definition($reflectionClass->name);
  208.                 try {
  209.                     $reflectionMethod = $this->getReflectionMethod($definition, $method);
  210.                 } catch (RuntimeException $e) {
  211.                     if ($definition->getFactory()) {
  212.                         continue;
  213.                     }
  214.                     throw $e;
  215.                 }
  216.             }
  218.             $arguments = $this->autowireMethod($reflectionMethod, $arguments, $checkAttributes, $i);
  220.             if ($arguments !== $call[1]) {
  221.                 $this->methodCalls[$i][1] = $arguments;
  222.                 $patchedIndexes[] = $i;
  223.             }
  224.         }
  226.         // use named arguments to skip complex default values
  227.         foreach ($patchedIndexes as $i) {
  228.             $namedArguments = null;
  229.             $arguments = $this->methodCalls[$i][1];
  231.             foreach ($arguments as $j => $value) {
  232.                 if ($namedArguments && !$value instanceof $this->defaultArgument) {
  233.                     unset($arguments[$j]);
  234.                     $arguments[$namedArguments[$j]] = $value;
  235.                 }
  236.                 if ($namedArguments || !$value instanceof $this->defaultArgument) {
  237.                     continue;
  238.                 }
  240.                 if (\is_array($value->value) ? $value->value : \is_object($value->value)) {
  241.                     unset($arguments[$j]);
  242.                     $namedArguments = $value->names;
  243.                 } else {
  244.                     $arguments[$j] = $value->value;
  245.                 }
  246.             }
  248.             $this->methodCalls[$i][1] = $arguments;
  249.         }
  251.         return $this->methodCalls;
  252.     }
  254.     /**
  255.      * Autowires the constructor or a method.
  256.      *
  257.      * @throws AutowiringFailedException
  258.      */
  259.     private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, array $arguments, bool $checkAttributes, int $methodIndex): array
  260.     {
  261.         $class = $reflectionMethod instanceof \ReflectionMethod ? $reflectionMethod->class : $this->currentId;
  262.         $method = $reflectionMethod->name;
  263.         $parameters = $reflectionMethod->getParameters();
  264.         if ($reflectionMethod->isVariadic()) {
  265.             array_pop($parameters);
  266.         }
  267.         $this->defaultArgument->names = new \ArrayObject();
  269.         foreach ($parameters as $index => $parameter) {
  270.             $this->defaultArgument->names[$index] = $parameter->name;
  272.             if (\array_key_exists($parameter->name, $arguments)) {
  273.                 $arguments[$index] = $arguments[$parameter->name];
  274.                 unset($arguments[$parameter->name]);
  275.             }
  276.             if (\array_key_exists($index, $arguments) && '' !== $arguments[$index]) {
  277.                 continue;
  278.             }
  280.             if ($checkAttributes) {
  281.                 foreach ($parameter->getAttributes() as $attribute) {
  282.                     if (\in_array($attribute->getName(), [TaggedIterator::class, TaggedLocator::class, Autowire::class, MapDecorated::class], true)) {
  283.                         try {
  284.                             $arguments[$index] = $this->processAttribute($attribute->newInstance(), $parameter->allowsNull());
  285.                             continue 2;
  286.                         } catch (ParameterNotFoundException $e) {
  287.                             if (!$parameter->isDefaultValueAvailable()) {
  288.                                 throw new AutowiringFailedException($this->currentId, $e->getMessage(), 0, $e);
  289.                             }
  290.                             $arguments[$index] = clone $this->defaultArgument;
  291.                             $arguments[$index]->value = $parameter->getDefaultValue();
  292.                         }
  293.                     }
  294.                 }
  295.             }
  297.             if (!$type = ProxyHelper::exportType($parameter, true)) {
  298.                 if (isset($arguments[$index])) {
  299.                     continue;
  300.                 }
  302.                 // no default value? Then fail
  303.                 if (!$parameter->isDefaultValueAvailable()) {
  304.                     // For core classes, isDefaultValueAvailable() can
  305.                     // be false when isOptional() returns true. If the
  306.                     // argument *is* optional, allow it to be missing
  307.                     if ($parameter->isOptional()) {
  308.                         --$index;
  309.                         break;
  310.                     }
  311.                     $type = ProxyHelper::exportType($parameter);
  312.                     $type = $type ? sprintf('is type-hinted "%s"', preg_replace('/(^|[(|&])\\\\|^\?\\\\?/', '\1', $type)) : 'has no type-hint';
  314.                     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));
  315.                 }
  317.                 // specifically pass the default value
  318.                 $arguments[$index] = clone $this->defaultArgument;
  319.                 $arguments[$index]->value = $parameter->getDefaultValue();
  321.                 continue;
  322.             }
  324.             $getValue = function () use ($type, $parameter, $class, $method) {
  325.                 if (!$value = $this->getAutowiredReference($ref = new TypedReference($type, $type, ContainerBuilder::EXCEPTION_ON_INVALID_REFERENCE, Target::parseName($parameter)), false)) {
  326.                     $failureMessage = $this->createTypeNotFoundMessageCallback($ref, sprintf('argument "$%s" of method "%s()"', $parameter->name, $class !== $this->currentId ? $class.'::'.$method : $method));
  328.                     if ($parameter->isDefaultValueAvailable()) {
  329.                         $value = clone $this->defaultArgument;
  330.                         $value->value = $parameter->getDefaultValue();
  331.                     } elseif (!$parameter->allowsNull()) {
  332.                         throw new AutowiringFailedException($this->currentId, $failureMessage);
  333.                     }
  334.                 }
  336.                 return $value;
  337.             };
  339.             if ($this->decoratedClass && $isDecorated = is_a($this->decoratedClass, $type, true)) {
  340.                 if ($this->getPreviousValue) {
  341.                     // The inner service is injected only if there is only 1 argument matching the type of the decorated class
  342.                     // across all arguments of all autowired methods.
  343.                     // If a second matching argument is found, the default behavior is restored.
  345.                     $getPreviousValue = $this->getPreviousValue;
  346.                     $this->methodCalls[$this->decoratedMethodIndex][1][$this->decoratedMethodArgumentIndex] = $getPreviousValue();
  347.                     $this->decoratedClass = null; // Prevent further checks
  348.                 } else {
  349.                     $arguments[$index] = new TypedReference($this->decoratedId, $this->decoratedClass);
  350.                     $this->getPreviousValue = $getValue;
  351.                     $this->decoratedMethodIndex = $methodIndex;
  352.                     $this->decoratedMethodArgumentIndex = $index;
  354.                     continue;
  355.                 }
  356.             }
  358.             $arguments[$index] = $getValue();
  359.         }
  361.         if ($parameters && !isset($arguments[++$index])) {
  362.             while (0 <= --$index) {
  363.                 if (!$arguments[$index] instanceof $this->defaultArgument) {
  364.                     break;
  365.                 }
  366.                 unset($arguments[$index]);
  367.             }
  368.         }
  370.         // it's possible index 1 was set, then index 0, then 2, etc
  371.         // make sure that we re-order so they're injected as expected
  372.         ksort($arguments, \SORT_NATURAL);
  374.         return $arguments;
  375.     }
  377.     /**
  378.      * Returns a reference to the service matching the given type, if any.
  379.      */
  380.     private function getAutowiredReference(TypedReference $reference, bool $filterType): ?TypedReference
  381.     {
  382.         $this->lastFailure = null;
  383.         $type = $reference->getType();
  385.         if ($type !== (string) $reference) {
  386.             return $reference;
  387.         }
  389.         if ($filterType && false !== $m = strpbrk($type, '&|')) {
  390.             $types = array_diff(explode($m[0], $type), ['int', 'string', 'array', 'bool', 'float', 'iterable', 'object', 'callable', 'null']);
  392.             sort($types);
  394.             $type = implode($m[0], $types);
  395.         }
  397.         if (null !== $name = $reference->getName()) {
  398.             if ($this->container->has($alias = $type.' $'.$name) && !$this->container->findDefinition($alias)->isAbstract()) {
  399.                 return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  400.             }
  402.             if (null !== ($alias = $this->getCombinedAlias($type, $name) ?? null) && !$this->container->findDefinition($alias)->isAbstract()) {
  403.                 return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  404.             }
  406.             if ($this->container->has($name) && !$this->container->findDefinition($name)->isAbstract()) {
  407.                 foreach ($this->container->getAliases() as $id => $alias) {
  408.                     if ($name === (string) $alias && str_starts_with($id, $type.' $')) {
  409.                         return new TypedReference($name, $type, $reference->getInvalidBehavior());
  410.                     }
  411.                 }
  412.             }
  413.         }
  415.         if ($this->container->has($type) && !$this->container->findDefinition($type)->isAbstract()) {
  416.             return new TypedReference($type, $type, $reference->getInvalidBehavior());
  417.         }
  419.         if (null !== ($alias = $this->getCombinedAlias($type) ?? null) && !$this->container->findDefinition($alias)->isAbstract()) {
  420.             return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  421.         }
  423.         return null;
  424.     }
  426.     /**
  427.      * Populates the list of available types.
  428.      */
  429.     private function populateAvailableTypes(ContainerBuilder $container)
  430.     {
  431.         $this->types = [];
  432.         $this->ambiguousServiceTypes = [];
  433.         $this->autowiringAliases = [];
  435.         foreach ($container->getDefinitions() as $id => $definition) {
  436.             $this->populateAvailableType($container, $id, $definition);
  437.         }
  439.         foreach ($container->getAliases() as $id => $alias) {
  440.             $this->populateAutowiringAlias($id);
  441.         }
  442.     }
  444.     /**
  445.      * Populates the list of available types for a given definition.
  446.      */
  447.     private function populateAvailableType(ContainerBuilder $container, string $id, Definition $definition)
  448.     {
  449.         // Never use abstract services
  450.         if ($definition->isAbstract()) {
  451.             return;
  452.         }
  454.         if ('' === $id || '.' === $id[0] || $definition->isDeprecated() || !$reflectionClass = $container->getReflectionClass($definition->getClass(), false)) {
  455.             return;
  456.         }
  458.         foreach ($reflectionClass->getInterfaces() as $reflectionInterface) {
  459.             $this->set($reflectionInterface->name, $id);
  460.         }
  462.         do {
  463.             $this->set($reflectionClass->name, $id);
  464.         } while ($reflectionClass = $reflectionClass->getParentClass());
  466.         $this->populateAutowiringAlias($id);
  467.     }
  469.     /**
  470.      * Associates a type and a service id if applicable.
  471.      */
  472.     private function set(string $type, string $id)
  473.     {
  474.         // is this already a type/class that is known to match multiple services?
  475.         if (isset($this->ambiguousServiceTypes[$type])) {
  476.             $this->ambiguousServiceTypes[$type][] = $id;
  478.             return;
  479.         }
  481.         // check to make sure the type doesn't match multiple services
  482.         if (!isset($this->types[$type]) || $this->types[$type] === $id) {
  483.             $this->types[$type] = $id;
  485.             return;
  486.         }
  488.         // keep an array of all services matching this type
  489.         if (!isset($this->ambiguousServiceTypes[$type])) {
  490.             $this->ambiguousServiceTypes[$type] = [$this->types[$type]];
  491.             unset($this->types[$type]);
  492.         }
  493.         $this->ambiguousServiceTypes[$type][] = $id;
  494.     }
  496.     private function createTypeNotFoundMessageCallback(TypedReference $reference, string $label): \Closure
  497.     {
  498.         if (null === $this->typesClone->container) {
  499.             $this->typesClone->container = new ContainerBuilder($this->container->getParameterBag());
  500.             $this->typesClone->container->setAliases($this->container->getAliases());
  501.             $this->typesClone->container->setDefinitions($this->container->getDefinitions());
  502.             $this->typesClone->container->setResourceTracking(false);
  503.         }
  504.         $currentId = $this->currentId;
  506.         return (function () use ($reference, $label, $currentId) {
  507.             return $this->createTypeNotFoundMessage($reference, $label, $currentId);
  508.         })->bindTo($this->typesClone);
  509.     }
  511.     private function createTypeNotFoundMessage(TypedReference $reference, string $label, string $currentId): string
  512.     {
  513.         $type = $reference->getType();
  515.         $i = null;
  516.         $namespace = $type;
  517.         do {
  518.             $namespace = substr($namespace, 0, $i);
  520.             if ($this->container->hasDefinition($namespace) && $tag = $this->container->getDefinition($namespace)->getTag('container.excluded')) {
  521.                 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');
  522.             }
  523.         } while (false !== $i = strrpos($namespace, '\\'));
  525.         if (!$r = $this->container->getReflectionClass($type, false)) {
  526.             // either $type does not exist or a parent class does not exist
  527.             try {
  528.                 $resource = new ClassExistenceResource($type, false);
  529.                 // isFresh() will explode ONLY if a parent class/trait does not exist
  530.                 $resource->isFresh(0);
  531.                 $parentMsg = false;
  532.             } catch (\ReflectionException $e) {
  533.                 $parentMsg = $e->getMessage();
  534.             }
  536.             $message = sprintf('has type "%s" but this class %s.', $type, $parentMsg ? sprintf('is missing a parent class (%s)', $parentMsg) : 'was not found');
  537.         } else {
  538.             $alternatives = $this->createTypeAlternatives($this->container, $reference);
  539.             $message = $this->container->has($type) ? 'this service is abstract' : 'no such service exists';
  540.             $message = sprintf('references %s "%s" but %s.%s', $r->isInterface() ? 'interface' : 'class', $type, $message, $alternatives);
  542.             if ($r->isInterface() && !$alternatives) {
  543.                 $message .= ' Did you create a class that implements this interface?';
  544.             }
  545.         }
  547.         $message = sprintf('Cannot autowire service "%s": %s %s', $currentId, $label, $message);
  549.         if (null !== $this->lastFailure) {
  550.             $message = $this->lastFailure."\n".$message;
  551.             $this->lastFailure = null;
  552.         }
  554.         return $message;
  555.     }
  557.     private function createTypeAlternatives(ContainerBuilder $container, TypedReference $reference): string
  558.     {
  559.         // try suggesting available aliases first
  560.         if ($message = $this->getAliasesSuggestionForType($container, $type = $reference->getType())) {
  561.             return ' '.$message;
  562.         }
  563.         if (!isset($this->ambiguousServiceTypes)) {
  564.             $this->populateAvailableTypes($container);
  565.         }
  567.         $servicesAndAliases = $container->getServiceIds();
  568.         if (null !== ($autowiringAliases = $this->autowiringAliases[$type] ?? null) && !isset($autowiringAliases[''])) {
  569.             return sprintf(' Available autowiring aliases for this %s are: "$%s".', class_exists($type, false) ? 'class' : 'interface', implode('", "$', $autowiringAliases));
  570.         }
  572.         if (!$container->has($type) && false !== $key = array_search(strtolower($type), array_map('strtolower', $servicesAndAliases))) {
  573.             return sprintf(' Did you mean "%s"?', $servicesAndAliases[$key]);
  574.         } elseif (isset($this->ambiguousServiceTypes[$type])) {
  575.             $message = sprintf('one of these existing services: "%s"', implode('", "', $this->ambiguousServiceTypes[$type]));
  576.         } elseif (isset($this->types[$type])) {
  577.             $message = sprintf('the existing "%s" service', $this->types[$type]);
  578.         } else {
  579.             return '';
  580.         }
  582.         return sprintf(' You should maybe alias this %s to %s.', class_exists($type, false) ? 'class' : 'interface', $message);
  583.     }
  585.     private function getAliasesSuggestionForType(ContainerBuilder $container, string $type): ?string
  586.     {
  587.         $aliases = [];
  588.         foreach (class_parents($type) + class_implements($type) as $parent) {
  589.             if ($container->has($parent) && !$container->findDefinition($parent)->isAbstract()) {
  590.                 $aliases[] = $parent;
  591.             }
  592.         }
  594.         if (1 < $len = \count($aliases)) {
  595.             $message = 'Try changing the type-hint to one of its parents: ';
  596.             for ($i = 0, --$len; $i < $len; ++$i) {
  597.                 $message .= sprintf('%s "%s", ', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  598.             }
  599.             $message .= sprintf('or %s "%s".', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  601.             return $message;
  602.         }
  604.         if ($aliases) {
  605.             return sprintf('Try changing the type-hint to "%s" instead.', $aliases[0]);
  606.         }
  608.         return null;
  609.     }
  611.     private function populateAutowiringAlias(string $id): void
  612.     {
  613.         if (!preg_match('/(?(DEFINE)(?<V>[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+))^((?&V)(?:\\\\(?&V))*+)(?: \$((?&V)))?$/', $id, $m)) {
  614.             return;
  615.         }
  617.         $type = $m[2];
  618.         $name = $m[3] ?? '';
  620.         if (class_exists($type, false) || interface_exists($type, false)) {
  621.             $this->autowiringAliases[$type][$name] = $name;
  622.         }
  623.     }
  625.     private function getCombinedAlias(string $type, string $name = null): ?string
  626.     {
  627.         if (str_contains($type, '&')) {
  628.             $types = explode('&', $type);
  629.         } elseif (str_contains($type, '|')) {
  630.             $types = explode('|', $type);
  631.         } else {
  632.             return null;
  633.         }
  635.         $alias = null;
  636.         $suffix = $name ? ' $'.$name : '';
  638.         foreach ($types as $type) {
  639.             if (!$this->container->hasAlias($type.$suffix)) {
  640.                 return null;
  641.             }
  643.             if (null === $alias) {
  644.                 $alias = (string) $this->container->getAlias($type.$suffix);
  645.             } elseif ((string) $this->container->getAlias($type.$suffix) !== $alias) {
  646.                 return null;
  647.             }
  648.         }
  650.         return $alias;
  651.     }
  652. }