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

  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\RuntimeException;
  27. use Symfony\Component\DependencyInjection\Reference;
  28. use Symfony\Component\DependencyInjection\TypedReference;
  29. use Symfony\Component\VarExporter\ProxyHelper;
  30. use Symfony\Contracts\Service\Attribute\SubscribedService;
  32. /**
  33.  * Inspects existing service definitions and wires the autowired ones using the type hints of their classes.
  34.  *
  35.  * @author Kévin Dunglas <dunglas@gmail.com>
  36.  * @author Nicolas Grekas <p@tchwork.com>
  37.  */
  38. class AutowirePass extends AbstractRecursivePass
  39. {
  40.     private array $types;
  41.     private array $ambiguousServiceTypes;
  42.     private array $autowiringAliases;
  43.     private ?string $lastFailure = null;
  44.     private bool $throwOnAutowiringException;
  45.     private ?string $decoratedClass = null;
  46.     private ?string $decoratedId = null;
  47.     private ?array $methodCalls = null;
  48.     private object $defaultArgument;
  49.     private ?\Closure $getPreviousValue = null;
  50.     private ?int $decoratedMethodIndex = null;
  51.     private ?int $decoratedMethodArgumentIndex = null;
  52.     private ?self $typesClone = null;
  54.     public function __construct(bool $throwOnAutowireException = true)
  55.     {
  56.         $this->throwOnAutowiringException = $throwOnAutowireException;
  57.         $this->defaultArgument = new class() {
  58.             public $value;
  59.             public $names;
  60.         };
  61.     }
  63.     public function process(ContainerBuilder $container)
  64.     {
  65.         try {
  66.             $this->typesClone = clone $this;
  67.             parent::process($container);
  68.         } finally {
  69.             $this->decoratedClass = null;
  70.             $this->decoratedId = null;
  71.             $this->methodCalls = null;
  72.             $this->defaultArgument->names = null;
  73.             $this->getPreviousValue = null;
  74.             $this->decoratedMethodIndex = null;
  75.             $this->decoratedMethodArgumentIndex = null;
  76.             $this->typesClone = null;
  77.         }
  78.     }
  80.     protected function processValue(mixed $value, bool $isRoot = false): mixed
  81.     {
  82.         try {
  83.             return $this->doProcessValue($value, $isRoot);
  84.         } catch (AutowiringFailedException $e) {
  85.             if ($this->throwOnAutowiringException) {
  86.                 throw $e;
  87.             }
  89.             $this->container->getDefinition($this->currentId)->addError($e->getMessageCallback() ?? $e->getMessage());
  91.             return parent::processValue($value, $isRoot);
  92.         }
  93.     }
  95.     private function doProcessValue(mixed $value, bool $isRoot = false): mixed
  96.     {
  97.         if ($value instanceof TypedReference) {
  98.             if ($attributes = $value->getAttributes()) {
  99.                 $attribute = array_pop($attributes);
  101.                 if ($attributes) {
  102.                     throw new AutowiringFailedException($this->currentId, sprintf('Using multiple attributes with "%s" is not supported.', SubscribedService::class));
  103.                 }
  105.                 if (!$attribute instanceof Target) {
  106.                     return $this->processAttribute($attribute, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE !== $value->getInvalidBehavior());
  107.                 }
  109.                 $value = new TypedReference($value->getType(), $value->getType(), $value->getInvalidBehavior(), $attribute->name);
  110.             }
  111.             if ($ref = $this->getAutowiredReference($value, true)) {
  112.                 return $ref;
  113.             }
  114.             if (ContainerBuilder::RUNTIME_EXCEPTION_ON_INVALID_REFERENCE === $value->getInvalidBehavior()) {
  115.                 $message = $this->createTypeNotFoundMessageCallback($value, 'it');
  117.                 // since the error message varies by referenced id and $this->currentId, so should the id of the dummy errored definition
  118.                 $this->container->register($id = sprintf('.errored.%s.%s', $this->currentId, (string) $value), $value->getType())
  119.                     ->addError($message);
  121.                 return new TypedReference($id, $value->getType(), $value->getInvalidBehavior(), $value->getName());
  122.             }
  123.         }
  124.         $value = parent::processValue($value, $isRoot);
  126.         if (!$value instanceof Definition || !$value->isAutowired() || $value->isAbstract() || !$value->getClass()) {
  127.             return $value;
  128.         }
  129.         if (!$reflectionClass = $this->container->getReflectionClass($value->getClass(), false)) {
  130.             $this->container->log($this, sprintf('Skipping service "%s": Class or interface "%s" cannot be loaded.', $this->currentId, $value->getClass()));
  132.             return $value;
  133.         }
  135.         $this->methodCalls = $value->getMethodCalls();
  137.         try {
  138.             $constructor = $this->getConstructor($value, false);
  139.         } catch (RuntimeException $e) {
  140.             throw new AutowiringFailedException($this->currentId, $e->getMessage(), 0, $e);
  141.         }
  143.         if ($constructor) {
  144.             array_unshift($this->methodCalls, [$constructor, $value->getArguments()]);
  145.         }
  147.         $checkAttributes = !$value->hasTag('container.ignore_attributes');
  148.         $this->methodCalls = $this->autowireCalls($reflectionClass, $isRoot, $checkAttributes);
  150.         if ($constructor) {
  151.             [, $arguments] = array_shift($this->methodCalls);
  153.             if ($arguments !== $value->getArguments()) {
  154.                 $value->setArguments($arguments);
  155.             }
  156.         }
  158.         if ($this->methodCalls !== $value->getMethodCalls()) {
  159.             $value->setMethodCalls($this->methodCalls);
  160.         }
  162.         return $value;
  163.     }
  165.     private function processAttribute(object $attribute, bool $isOptional = false): mixed
  166.     {
  167.         switch (true) {
  168.             case $attribute instanceof Autowire:
  169.                 $value = $this->container->getParameterBag()->resolveValue($attribute->value);
  171.                 return $value instanceof Reference && $isOptional ? new Reference($value, ContainerInterface::NULL_ON_INVALID_REFERENCE) : $value;
  173.             case $attribute instanceof TaggedIterator:
  174.                 return new TaggedIteratorArgument($attribute->tag, $attribute->indexAttribute, $attribute->defaultIndexMethod, false, $attribute->defaultPriorityMethod, (array) $attribute->exclude);
  176.             case $attribute instanceof TaggedLocator:
  177.                 return new ServiceLocatorArgument(new TaggedIteratorArgument($attribute->tag, $attribute->indexAttribute, $attribute->defaultIndexMethod, true, $attribute->defaultPriorityMethod, (array) $attribute->exclude));
  179.             case $attribute instanceof MapDecorated:
  180.                 $definition = $this->container->getDefinition($this->currentId);
  182.                 return new Reference($definition->innerServiceId ?? $this->currentId.'.inner', $definition->decorationOnInvalid ?? ContainerInterface::NULL_ON_INVALID_REFERENCE);
  183.         }
  185.         throw new AutowiringFailedException($this->currentId, sprintf('"%s" is an unsupported attribute.', $attribute::class));
  186.     }
  188.     private function autowireCalls(\ReflectionClass $reflectionClass, bool $isRoot, bool $checkAttributes): array
  189.     {
  190.         $this->decoratedId = null;
  191.         $this->decoratedClass = null;
  192.         $this->getPreviousValue = null;
  194.         if ($isRoot && ($definition = $this->container->getDefinition($this->currentId)) && null !== ($this->decoratedId = $definition->innerServiceId) && $this->container->has($this->decoratedId)) {
  195.             $this->decoratedClass = $this->container->findDefinition($this->decoratedId)->getClass();
  196.         }
  198.         $patchedIndexes = [];
  200.         foreach ($this->methodCalls as $i => $call) {
  201.             [$method, $arguments] = $call;
  203.             if ($method instanceof \ReflectionFunctionAbstract) {
  204.                 $reflectionMethod = $method;
  205.             } else {
  206.                 $definition = new Definition($reflectionClass->name);
  207.                 try {
  208.                     $reflectionMethod = $this->getReflectionMethod($definition, $method);
  209.                 } catch (RuntimeException $e) {
  210.                     if ($definition->getFactory()) {
  211.                         continue;
  212.                     }
  213.                     throw $e;
  214.                 }
  215.             }
  217.             $arguments = $this->autowireMethod($reflectionMethod, $arguments, $checkAttributes, $i);
  219.             if ($arguments !== $call[1]) {
  220.                 $this->methodCalls[$i][1] = $arguments;
  221.                 $patchedIndexes[] = $i;
  222.             }
  223.         }
  225.         // use named arguments to skip complex default values
  226.         foreach ($patchedIndexes as $i) {
  227.             $namedArguments = null;
  228.             $arguments = $this->methodCalls[$i][1];
  230.             foreach ($arguments as $j => $value) {
  231.                 if ($namedArguments && !$value instanceof $this->defaultArgument) {
  232.                     unset($arguments[$j]);
  233.                     $arguments[$namedArguments[$j]] = $value;
  234.                 }
  235.                 if ($namedArguments || !$value instanceof $this->defaultArgument) {
  236.                     continue;
  237.                 }
  239.                 if (\is_array($value->value) ? $value->value : \is_object($value->value)) {
  240.                     unset($arguments[$j]);
  241.                     $namedArguments = $value->names;
  242.                 } else {
  243.                     $arguments[$j] = $value->value;
  244.                 }
  245.             }
  247.             $this->methodCalls[$i][1] = $arguments;
  248.         }
  250.         return $this->methodCalls;
  251.     }
  253.     /**
  254.      * Autowires the constructor or a method.
  255.      *
  256.      * @throws AutowiringFailedException
  257.      */
  258.     private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, array $arguments, bool $checkAttributes, int $methodIndex): array
  259.     {
  260.         $class = $reflectionMethod instanceof \ReflectionMethod ? $reflectionMethod->class : $this->currentId;
  261.         $method = $reflectionMethod->name;
  262.         $parameters = $reflectionMethod->getParameters();
  263.         if ($reflectionMethod->isVariadic()) {
  264.             array_pop($parameters);
  265.         }
  266.         $this->defaultArgument->names = new \ArrayObject();
  268.         foreach ($parameters as $index => $parameter) {
  269.             $this->defaultArgument->names[$index] = $parameter->name;
  271.             if (\array_key_exists($parameter->name, $arguments)) {
  272.                 $arguments[$index] = $arguments[$parameter->name];
  273.                 unset($arguments[$parameter->name]);
  274.             }
  275.             if (\array_key_exists($index, $arguments) && '' !== $arguments[$index]) {
  276.                 continue;
  277.             }
  279.             if ($checkAttributes) {
  280.                 foreach ($parameter->getAttributes() as $attribute) {
  281.                     if (\in_array($attribute->getName(), [TaggedIterator::class, TaggedLocator::class, Autowire::class, MapDecorated::class], true)) {
  282.                         $arguments[$index] = $this->processAttribute($attribute->newInstance(), $parameter->allowsNull());
  284.                         continue 2;
  285.                     }
  286.                 }
  287.             }
  289.             if (!$type = ProxyHelper::exportType($parameter, true)) {
  290.                 if (isset($arguments[$index])) {
  291.                     continue;
  292.                 }
  294.                 // no default value? Then fail
  295.                 if (!$parameter->isDefaultValueAvailable()) {
  296.                     // For core classes, isDefaultValueAvailable() can
  297.                     // be false when isOptional() returns true. If the
  298.                     // argument *is* optional, allow it to be missing
  299.                     if ($parameter->isOptional()) {
  300.                         --$index;
  301.                         break;
  302.                     }
  303.                     $type = ProxyHelper::exportType($parameter);
  304.                     $type = $type ? sprintf('is type-hinted "%s"', preg_replace('/(^|[(|&])\\\\|^\?\\\\?/', '\1', $type)) : 'has no type-hint';
  306.                     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));
  307.                 }
  309.                 // specifically pass the default value
  310.                 $arguments[$index] = clone $this->defaultArgument;
  311.                 $arguments[$index]->value = $parameter->getDefaultValue();
  313.                 continue;
  314.             }
  316.             $getValue = function () use ($type, $parameter, $class, $method) {
  317.                 if (!$value = $this->getAutowiredReference($ref = new TypedReference($type, $type, ContainerBuilder::EXCEPTION_ON_INVALID_REFERENCE, Target::parseName($parameter)), false)) {
  318.                     $failureMessage = $this->createTypeNotFoundMessageCallback($ref, sprintf('argument "$%s" of method "%s()"', $parameter->name, $class !== $this->currentId ? $class.'::'.$method : $method));
  320.                     if ($parameter->isDefaultValueAvailable()) {
  321.                         $value = clone $this->defaultArgument;
  322.                         $value->value = $parameter->getDefaultValue();
  323.                     } elseif (!$parameter->allowsNull()) {
  324.                         throw new AutowiringFailedException($this->currentId, $failureMessage);
  325.                     }
  326.                 }
  328.                 return $value;
  329.             };
  331.             if ($this->decoratedClass && $isDecorated = is_a($this->decoratedClass, $type, true)) {
  332.                 if ($this->getPreviousValue) {
  333.                     // The inner service is injected only if there is only 1 argument matching the type of the decorated class
  334.                     // across all arguments of all autowired methods.
  335.                     // If a second matching argument is found, the default behavior is restored.
  337.                     $getPreviousValue = $this->getPreviousValue;
  338.                     $this->methodCalls[$this->decoratedMethodIndex][1][$this->decoratedMethodArgumentIndex] = $getPreviousValue();
  339.                     $this->decoratedClass = null; // Prevent further checks
  340.                 } else {
  341.                     $arguments[$index] = new TypedReference($this->decoratedId, $this->decoratedClass);
  342.                     $this->getPreviousValue = $getValue;
  343.                     $this->decoratedMethodIndex = $methodIndex;
  344.                     $this->decoratedMethodArgumentIndex = $index;
  346.                     continue;
  347.                 }
  348.             }
  350.             $arguments[$index] = $getValue();
  351.         }
  353.         if ($parameters && !isset($arguments[++$index])) {
  354.             while (0 <= --$index) {
  355.                 if (!$arguments[$index] instanceof $this->defaultArgument) {
  356.                     break;
  357.                 }
  358.                 unset($arguments[$index]);
  359.             }
  360.         }
  362.         // it's possible index 1 was set, then index 0, then 2, etc
  363.         // make sure that we re-order so they're injected as expected
  364.         ksort($arguments, \SORT_NATURAL);
  366.         return $arguments;
  367.     }
  369.     /**
  370.      * Returns a reference to the service matching the given type, if any.
  371.      */
  372.     private function getAutowiredReference(TypedReference $reference, bool $filterType): ?TypedReference
  373.     {
  374.         $this->lastFailure = null;
  375.         $type = $reference->getType();
  377.         if ($type !== (string) $reference) {
  378.             return $reference;
  379.         }
  381.         if ($filterType && false !== $m = strpbrk($type, '&|')) {
  382.             $types = array_diff(explode($m[0], $type), ['int', 'string', 'array', 'bool', 'float', 'iterable', 'object', 'callable', 'null']);
  384.             sort($types);
  386.             $type = implode($m[0], $types);
  387.         }
  389.         if (null !== $name = $reference->getName()) {
  390.             if ($this->container->has($alias = $type.' $'.$name) && !$this->container->findDefinition($alias)->isAbstract()) {
  391.                 return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  392.             }
  394.             if (null !== ($alias = $this->getCombinedAlias($type, $name) ?? null) && !$this->container->findDefinition($alias)->isAbstract()) {
  395.                 return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  396.             }
  398.             if ($this->container->has($name) && !$this->container->findDefinition($name)->isAbstract()) {
  399.                 foreach ($this->container->getAliases() as $id => $alias) {
  400.                     if ($name === (string) $alias && str_starts_with($id, $type.' $')) {
  401.                         return new TypedReference($name, $type, $reference->getInvalidBehavior());
  402.                     }
  403.                 }
  404.             }
  405.         }
  407.         if ($this->container->has($type) && !$this->container->findDefinition($type)->isAbstract()) {
  408.             return new TypedReference($type, $type, $reference->getInvalidBehavior());
  409.         }
  411.         if (null !== ($alias = $this->getCombinedAlias($type) ?? null) && !$this->container->findDefinition($alias)->isAbstract()) {
  412.             return new TypedReference($alias, $type, $reference->getInvalidBehavior());
  413.         }
  415.         return null;
  416.     }
  418.     /**
  419.      * Populates the list of available types.
  420.      */
  421.     private function populateAvailableTypes(ContainerBuilder $container)
  422.     {
  423.         $this->types = [];
  424.         $this->ambiguousServiceTypes = [];
  425.         $this->autowiringAliases = [];
  427.         foreach ($container->getDefinitions() as $id => $definition) {
  428.             $this->populateAvailableType($container, $id, $definition);
  429.         }
  431.         foreach ($container->getAliases() as $id => $alias) {
  432.             $this->populateAutowiringAlias($id);
  433.         }
  434.     }
  436.     /**
  437.      * Populates the list of available types for a given definition.
  438.      */
  439.     private function populateAvailableType(ContainerBuilder $container, string $id, Definition $definition)
  440.     {
  441.         // Never use abstract services
  442.         if ($definition->isAbstract()) {
  443.             return;
  444.         }
  446.         if ('' === $id || '.' === $id[0] || $definition->isDeprecated() || !$reflectionClass = $container->getReflectionClass($definition->getClass(), false)) {
  447.             return;
  448.         }
  450.         foreach ($reflectionClass->getInterfaces() as $reflectionInterface) {
  451.             $this->set($reflectionInterface->name, $id);
  452.         }
  454.         do {
  455.             $this->set($reflectionClass->name, $id);
  456.         } while ($reflectionClass = $reflectionClass->getParentClass());
  458.         $this->populateAutowiringAlias($id);
  459.     }
  461.     /**
  462.      * Associates a type and a service id if applicable.
  463.      */
  464.     private function set(string $type, string $id)
  465.     {
  466.         // is this already a type/class that is known to match multiple services?
  467.         if (isset($this->ambiguousServiceTypes[$type])) {
  468.             $this->ambiguousServiceTypes[$type][] = $id;
  470.             return;
  471.         }
  473.         // check to make sure the type doesn't match multiple services
  474.         if (!isset($this->types[$type]) || $this->types[$type] === $id) {
  475.             $this->types[$type] = $id;
  477.             return;
  478.         }
  480.         // keep an array of all services matching this type
  481.         if (!isset($this->ambiguousServiceTypes[$type])) {
  482.             $this->ambiguousServiceTypes[$type] = [$this->types[$type]];
  483.             unset($this->types[$type]);
  484.         }
  485.         $this->ambiguousServiceTypes[$type][] = $id;
  486.     }
  488.     private function createTypeNotFoundMessageCallback(TypedReference $reference, string $label): \Closure
  489.     {
  490.         if (null === $this->typesClone->container) {
  491.             $this->typesClone->container = new ContainerBuilder($this->container->getParameterBag());
  492.             $this->typesClone->container->setAliases($this->container->getAliases());
  493.             $this->typesClone->container->setDefinitions($this->container->getDefinitions());
  494.             $this->typesClone->container->setResourceTracking(false);
  495.         }
  496.         $currentId = $this->currentId;
  498.         return (function () use ($reference, $label, $currentId) {
  499.             return $this->createTypeNotFoundMessage($reference, $label, $currentId);
  500.         })->bindTo($this->typesClone);
  501.     }
  503.     private function createTypeNotFoundMessage(TypedReference $reference, string $label, string $currentId): string
  504.     {
  505.         $type = $reference->getType();
  507.         $i = null;
  508.         $namespace = $type;
  509.         do {
  510.             $namespace = substr($namespace, 0, $i);
  512.             if ($this->container->hasDefinition($namespace) && $tag = $this->container->getDefinition($namespace)->getTag('container.excluded')) {
  513.                 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');
  514.             }
  515.         } while (false !== $i = strrpos($namespace, '\\'));
  517.         if (!$r = $this->container->getReflectionClass($type, false)) {
  518.             // either $type does not exist or a parent class does not exist
  519.             try {
  520.                 $resource = new ClassExistenceResource($type, false);
  521.                 // isFresh() will explode ONLY if a parent class/trait does not exist
  522.                 $resource->isFresh(0);
  523.                 $parentMsg = false;
  524.             } catch (\ReflectionException $e) {
  525.                 $parentMsg = $e->getMessage();
  526.             }
  528.             $message = sprintf('has type "%s" but this class %s.', $type, $parentMsg ? sprintf('is missing a parent class (%s)', $parentMsg) : 'was not found');
  529.         } else {
  530.             $alternatives = $this->createTypeAlternatives($this->container, $reference);
  531.             $message = $this->container->has($type) ? 'this service is abstract' : 'no such service exists';
  532.             $message = sprintf('references %s "%s" but %s.%s', $r->isInterface() ? 'interface' : 'class', $type, $message, $alternatives);
  534.             if ($r->isInterface() && !$alternatives) {
  535.                 $message .= ' Did you create a class that implements this interface?';
  536.             }
  537.         }
  539.         $message = sprintf('Cannot autowire service "%s": %s %s', $currentId, $label, $message);
  541.         if (null !== $this->lastFailure) {
  542.             $message = $this->lastFailure."\n".$message;
  543.             $this->lastFailure = null;
  544.         }
  546.         return $message;
  547.     }
  549.     private function createTypeAlternatives(ContainerBuilder $container, TypedReference $reference): string
  550.     {
  551.         // try suggesting available aliases first
  552.         if ($message = $this->getAliasesSuggestionForType($container, $type = $reference->getType())) {
  553.             return ' '.$message;
  554.         }
  555.         if (!isset($this->ambiguousServiceTypes)) {
  556.             $this->populateAvailableTypes($container);
  557.         }
  559.         $servicesAndAliases = $container->getServiceIds();
  560.         if (null !== ($autowiringAliases = $this->autowiringAliases[$type] ?? null) && !isset($autowiringAliases[''])) {
  561.             return sprintf(' Available autowiring aliases for this %s are: "$%s".', class_exists($type, false) ? 'class' : 'interface', implode('", "$', $autowiringAliases));
  562.         }
  564.         if (!$container->has($type) && false !== $key = array_search(strtolower($type), array_map('strtolower', $servicesAndAliases))) {
  565.             return sprintf(' Did you mean "%s"?', $servicesAndAliases[$key]);
  566.         } elseif (isset($this->ambiguousServiceTypes[$type])) {
  567.             $message = sprintf('one of these existing services: "%s"', implode('", "', $this->ambiguousServiceTypes[$type]));
  568.         } elseif (isset($this->types[$type])) {
  569.             $message = sprintf('the existing "%s" service', $this->types[$type]);
  570.         } else {
  571.             return '';
  572.         }
  574.         return sprintf(' You should maybe alias this %s to %s.', class_exists($type, false) ? 'class' : 'interface', $message);
  575.     }
  577.     private function getAliasesSuggestionForType(ContainerBuilder $container, string $type): ?string
  578.     {
  579.         $aliases = [];
  580.         foreach (class_parents($type) + class_implements($type) as $parent) {
  581.             if ($container->has($parent) && !$container->findDefinition($parent)->isAbstract()) {
  582.                 $aliases[] = $parent;
  583.             }
  584.         }
  586.         if (1 < $len = \count($aliases)) {
  587.             $message = 'Try changing the type-hint to one of its parents: ';
  588.             for ($i = 0, --$len; $i < $len; ++$i) {
  589.                 $message .= sprintf('%s "%s", ', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  590.             }
  591.             $message .= sprintf('or %s "%s".', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  593.             return $message;
  594.         }
  596.         if ($aliases) {
  597.             return sprintf('Try changing the type-hint to "%s" instead.', $aliases[0]);
  598.         }
  600.         return null;
  601.     }
  603.     private function populateAutowiringAlias(string $id): void
  604.     {
  605.         if (!preg_match('/(?(DEFINE)(?<V>[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+))^((?&V)(?:\\\\(?&V))*+)(?: \$((?&V)))?$/', $id, $m)) {
  606.             return;
  607.         }
  609.         $type = $m[2];
  610.         $name = $m[3] ?? '';
  612.         if (class_exists($type, false) || interface_exists($type, false)) {
  613.             $this->autowiringAliases[$type][$name] = $name;
  614.         }
  615.     }
  617.     private function getCombinedAlias(string $type, string $name = null): ?string
  618.     {
  619.         if (str_contains($type, '&')) {
  620.             $types = explode('&', $type);
  621.         } elseif (str_contains($type, '|')) {
  622.             $types = explode('|', $type);
  623.         } else {
  624.             return null;
  625.         }
  627.         $alias = null;
  628.         $suffix = $name ? ' $'.$name : '';
  630.         foreach ($types as $type) {
  631.             if (!$this->container->hasAlias($type.$suffix)) {
  632.                 return null;
  633.             }
  635.             if (null === $alias) {
  636.                 $alias = (string) $this->container->getAlias($type.$suffix);
  637.             } elseif ((string) $this->container->getAlias($type.$suffix) !== $alias) {
  638.                 return null;
  639.             }
  640.         }
  642.         return $alias;
  643.     }
  644. }