vendor/symfony/symfony/src/Symfony/Component/DependencyInjection/Compiler/AutowirePass.php line 292

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\DependencyInjection\Compiler;
  14. use Symfony\Component\Config\Resource\ClassExistenceResource;
  15. use Symfony\Component\DependencyInjection\Config\AutowireServiceResource;
  16. use Symfony\Component\DependencyInjection\ContainerBuilder;
  17. use Symfony\Component\DependencyInjection\Definition;
  18. use Symfony\Component\DependencyInjection\Exception\AutowiringFailedException;
  19. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  20. use Symfony\Component\DependencyInjection\LazyProxy\ProxyHelper;
  21. use Symfony\Component\DependencyInjection\TypedReference;
  23. /**
  24.  * Inspects existing service definitions and wires the autowired ones using the type hints of their classes.
  25.  *
  26.  * @author Kévin Dunglas <dunglas@gmail.com>
  27.  * @author Nicolas Grekas <p@tchwork.com>
  28.  */
  29. class AutowirePass extends AbstractRecursivePass
  30. {
  31.     private $definedTypes = array();
  32.     private $types;
  33.     private $ambiguousServiceTypes = array();
  34.     private $autowired = array();
  35.     private $lastFailure;
  36.     private $throwOnAutowiringException;
  37.     private $autowiringExceptions = array();
  39.     /**
  40.      * @param bool $throwOnAutowireException If false, retrieved errors via getAutowiringExceptions
  41.      */
  42.     public function __construct($throwOnAutowireException = true)
  43.     {
  44.         $this->throwOnAutowiringException = $throwOnAutowireException;
  45.     }
  47.     /**
  48.      * @return AutowiringFailedException[]
  49.      */
  50.     public function getAutowiringExceptions()
  51.     {
  52.         return $this->autowiringExceptions;
  53.     }
  55.     /**
  56.      * {@inheritdoc}
  57.      */
  58.     public function process(ContainerBuilder $container)
  59.     {
  60.         // clear out any possibly stored exceptions from before
  61.         $this->autowiringExceptions = array();
  63.         try {
  64.             parent::process($container);
  65.         } finally {
  66.             $this->definedTypes = array();
  67.             $this->types = null;
  68.             $this->ambiguousServiceTypes = array();
  69.             $this->autowired = array();
  70.         }
  71.     }
  73.     /**
  74.      * Creates a resource to help know if this service has changed.
  75.      *
  76.      * @param \ReflectionClass $reflectionClass
  77.      *
  78.      * @return AutowireServiceResource
  79.      *
  80.      * @deprecated since version 3.3, to be removed in 4.0. Use ContainerBuilder::getReflectionClass() instead.
  81.      */
  82.     public static function createResourceForClass(\ReflectionClass $reflectionClass)
  83.     {
  84.         @trigger_error('The '.__METHOD__.'() method is deprecated since Symfony 3.3 and will be removed in 4.0. Use ContainerBuilder::getReflectionClass() instead.', E_USER_DEPRECATED);
  86.         $metadata = array();
  88.         foreach ($reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $reflectionMethod) {
  89.             if (!$reflectionMethod->isStatic()) {
  90.                 $metadata[$reflectionMethod->name] = self::getResourceMetadataForMethod($reflectionMethod);
  91.             }
  92.         }
  94.         return new AutowireServiceResource($reflectionClass->name, $reflectionClass->getFileName(), $metadata);
  95.     }
  97.     /**
  98.      * {@inheritdoc}
  99.      */
  100.     protected function processValue($value, $isRoot = false)
  101.     {
  102.         try {
  103.             return $this->doProcessValue($value, $isRoot);
  104.         } catch (AutowiringFailedException $e) {
  105.             if ($this->throwOnAutowiringException) {
  106.                 throw $e;
  107.             }
  109.             $this->autowiringExceptions[] = $e;
  111.             return parent::processValue($value, $isRoot);
  112.         }
  113.     }
  115.     private function doProcessValue($value, $isRoot = false)
  116.     {
  117.         if ($value instanceof TypedReference) {
  118.             if ($ref = $this->getAutowiredReference($value, $value->getRequiringClass() ? sprintf('for "%s" in "%s"', $value->getType(), $value->getRequiringClass()) : '')) {
  119.                 return $ref;
  120.             }
  121.             $this->container->log($this, $this->createTypeNotFoundMessage($value, 'it'));
  122.         }
  123.         $value = parent::processValue($value, $isRoot);
  125.         if (!$value instanceof Definition || !$value->isAutowired() || $value->isAbstract() || !$value->getClass()) {
  126.             return $value;
  127.         }
  128.         if (!$reflectionClass = $this->container->getReflectionClass($value->getClass(), false)) {
  129.             $this->container->log($this, sprintf('Skipping service "%s": Class or interface "%s" cannot be loaded.', $this->currentId, $value->getClass()));
  131.             return $value;
  132.         }
  134.         $autowiredMethods = $this->getMethodsToAutowire($reflectionClass);
  135.         $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($methodCalls, array($constructor, $value->getArguments()));
  145.         }
  147.         $methodCalls = $this->autowireCalls($reflectionClass, $methodCalls, $autowiredMethods);
  149.         if ($constructor) {
  150.             list(, $arguments) = array_shift($methodCalls);
  152.             if ($arguments !== $value->getArguments()) {
  153.                 $value->setArguments($arguments);
  154.             }
  155.         }
  157.         if ($methodCalls !== $value->getMethodCalls()) {
  158.             $value->setMethodCalls($methodCalls);
  159.         }
  161.         return $value;
  162.     }
  164.     /**
  165.      * Gets the list of methods to autowire.
  166.      *
  167.      * @param \ReflectionClass $reflectionClass
  168.      *
  169.      * @return \ReflectionMethod[]
  170.      */
  171.     private function getMethodsToAutowire(\ReflectionClass $reflectionClass)
  172.     {
  173.         $methodsToAutowire = array();
  175.         foreach ($reflectionClass->getMethods() as $reflectionMethod) {
  176.             $r = $reflectionMethod;
  178.             if ($r->isConstructor()) {
  179.                 continue;
  180.             }
  182.             while (true) {
  183.                 if (false !== $doc = $r->getDocComment()) {
  184.                     if (false !== stripos($doc, '@required') && preg_match('#(?:^/\*\*|\n\s*+\*)\s*+@required(?:\s|\*/$)#i', $doc)) {
  185.                         $methodsToAutowire[strtolower($reflectionMethod->name)] = $reflectionMethod;
  186.                         break;
  187.                     }
  188.                     if (false === stripos($doc, '@inheritdoc') || !preg_match('#(?:^/\*\*|\n\s*+\*)\s*+(?:\{@inheritdoc\}|@inheritdoc)(?:\s|\*/$)#i', $doc)) {
  189.                         break;
  190.                     }
  191.                 }
  192.                 try {
  193.                     $r = $r->getPrototype();
  194.                 } catch (\ReflectionException $e) {
  195.                     break; // method has no prototype
  196.                 }
  197.             }
  198.         }
  200.         return $methodsToAutowire;
  201.     }
  203.     /**
  204.      * @param \ReflectionClass    $reflectionClass
  205.      * @param array               $methodCalls
  206.      * @param \ReflectionMethod[] $autowiredMethods
  207.      *
  208.      * @return array
  209.      */
  210.     private function autowireCalls(\ReflectionClass $reflectionClass, array $methodCalls, array $autowiredMethods)
  211.     {
  212.         foreach ($methodCalls as $i => $call) {
  213.             list($method, $arguments) = $call;
  215.             if ($method instanceof \ReflectionFunctionAbstract) {
  216.                 $reflectionMethod = $method;
  217.             } elseif (isset($autowiredMethods[$lcMethod = strtolower($method)]) && $autowiredMethods[$lcMethod]->isPublic()) {
  218.                 $reflectionMethod = $autowiredMethods[$lcMethod];
  219.                 unset($autowiredMethods[$lcMethod]);
  220.             } else {
  221.                 $reflectionMethod = $this->getReflectionMethod(new Definition($reflectionClass->name), $method);
  222.             }
  224.             $arguments = $this->autowireMethod($reflectionMethod, $arguments);
  226.             if ($arguments !== $call[1]) {
  227.                 $methodCalls[$i][1] = $arguments;
  228.             }
  229.         }
  231.         foreach ($autowiredMethods as $lcMethod => $reflectionMethod) {
  232.             $method = $reflectionMethod->name;
  234.             if (!$reflectionMethod->isPublic()) {
  235.                 $class = $reflectionClass->name;
  236.                 throw new AutowiringFailedException($this->currentId, sprintf('Cannot autowire service "%s": method "%s()" must be public.', $this->currentId, $class !== $this->currentId ? $class.'::'.$method : $method));
  237.             }
  238.             $methodCalls[] = array($method, $this->autowireMethod($reflectionMethod, array()));
  239.         }
  241.         return $methodCalls;
  242.     }
  244.     /**
  245.      * Autowires the constructor or a method.
  246.      *
  247.      * @param \ReflectionFunctionAbstract $reflectionMethod
  248.      * @param array                       $arguments
  249.      *
  250.      * @return array The autowired arguments
  251.      *
  252.      * @throws AutowiringFailedException
  253.      */
  254.     private function autowireMethod(\ReflectionFunctionAbstract $reflectionMethod, array $arguments)
  255.     {
  256.         $class = $reflectionMethod instanceof \ReflectionMethod ? $reflectionMethod->class : $this->currentId;
  257.         $method = $reflectionMethod->name;
  258.         $parameters = $reflectionMethod->getParameters();
  259.         if (method_exists('ReflectionMethod', 'isVariadic') && $reflectionMethod->isVariadic()) {
  260.             array_pop($parameters);
  261.         }
  263.         foreach ($parameters as $index => $parameter) {
  264.             if (array_key_exists($index, $arguments) && '' !== $arguments[$index]) {
  265.                 continue;
  266.             }
  268.             $type = ProxyHelper::getTypeHint($reflectionMethod, $parameter, true);
  270.             if (!$type) {
  271.                 if (isset($arguments[$index])) {
  272.                     continue;
  273.                 }
  275.                 // no default value? Then fail
  276.                 if (!$parameter->isDefaultValueAvailable()) {
  277.                     // For core classes, isDefaultValueAvailable() can
  278.                     // be false when isOptional() returns true. If the
  279.                     // argument *is* optional, allow it to be missing
  280.                     if ($parameter->isOptional()) {
  281.                         continue;
  282.                     }
  283.                     throw new AutowiringFailedException($this->currentId, sprintf('Cannot autowire service "%s": argument "$%s" of method "%s()" must have a type-hint or be given a value explicitly.', $this->currentId, $parameter->name, $class !== $this->currentId ? $class.'::'.$method : $method));
  284.                 }
  286.                 // specifically pass the default value
  287.                 $arguments[$index] = $parameter->getDefaultValue();
  289.                 continue;
  290.             }
  292.             if (!$value = $this->getAutowiredReference($ref = new TypedReference($type, $type, !$parameter->isOptional() ? $class : ''), 'for '.sprintf('argument "$%s" of method "%s()"', $parameter->name, $class.'::'.$method))) {
  293.                 $failureMessage = $this->createTypeNotFoundMessage($ref, sprintf('argument "$%s" of method "%s()"', $parameter->name, $class !== $this->currentId ? $class.'::'.$method : $method));
  295.                 if ($parameter->isDefaultValueAvailable()) {
  296.                     $value = $parameter->getDefaultValue();
  297.                 } elseif (!$parameter->allowsNull()) {
  298.                     throw new AutowiringFailedException($this->currentId, $failureMessage);
  299.                 }
  300.                 $this->container->log($this, $failureMessage);
  301.             }
  303.             $arguments[$index] = $value;
  304.         }
  306.         if ($parameters && !isset($arguments[++$index])) {
  307.             while (0 <= --$index) {
  308.                 $parameter = $parameters[$index];
  309.                 if (!$parameter->isDefaultValueAvailable() || $parameter->getDefaultValue() !== $arguments[$index]) {
  310.                     break;
  311.                 }
  312.                 unset($arguments[$index]);
  313.             }
  314.         }
  316.         // it's possible index 1 was set, then index 0, then 2, etc
  317.         // make sure that we re-order so they're injected as expected
  318.         ksort($arguments);
  320.         return $arguments;
  321.     }
  323.     /**
  324.      * @return TypedReference|null A reference to the service matching the given type, if any
  325.      */
  326.     private function getAutowiredReference(TypedReference $reference, $deprecationMessage)
  327.     {
  328.         $this->lastFailure = null;
  329.         $type = $reference->getType();
  331.         if ($type !== (string) $reference || ($this->container->has($type) && !$this->container->findDefinition($type)->isAbstract())) {
  332.             return $reference;
  333.         }
  335.         if (null === $this->types) {
  336.             $this->populateAvailableTypes();
  337.         }
  339.         if (isset($this->definedTypes[$type])) {
  340.             return new TypedReference($this->types[$type], $type);
  341.         }
  343.         if (isset($this->types[$type])) {
  344.             $message = 'Autowiring services based on the types they implement is deprecated since Symfony 3.3 and won\'t be supported in version 4.0.';
  345.             if ($aliasSuggestion = $this->getAliasesSuggestionForType($type = $reference->getType(), $deprecationMessage)) {
  346.                 $message .= ' '.$aliasSuggestion;
  347.             } else {
  348.                 $message .= sprintf(' You should %s the "%s" service to "%s" instead.', isset($this->types[$this->types[$type]]) ? 'alias' : 'rename (or alias)', $this->types[$type], $type);
  349.             }
  351.             @trigger_error($message, E_USER_DEPRECATED);
  353.             return new TypedReference($this->types[$type], $type);
  354.         }
  356.         if (!$reference->canBeAutoregistered() || isset($this->types[$type]) || isset($this->ambiguousServiceTypes[$type])) {
  357.             return;
  358.         }
  360.         if (isset($this->autowired[$type])) {
  361.             return $this->autowired[$type] ? new TypedReference($this->autowired[$type], $type) : null;
  362.         }
  364.         return $this->createAutowiredDefinition($type);
  365.     }
  367.     /**
  368.      * Populates the list of available types.
  369.      */
  370.     private function populateAvailableTypes()
  371.     {
  372.         $this->types = array();
  374.         foreach ($this->container->getDefinitions() as $id => $definition) {
  375.             $this->populateAvailableType($id, $definition);
  376.         }
  377.     }
  379.     /**
  380.      * Populates the list of available types for a given definition.
  381.      *
  382.      * @param string     $id
  383.      * @param Definition $definition
  384.      */
  385.     private function populateAvailableType($id, Definition $definition)
  386.     {
  387.         // Never use abstract services
  388.         if ($definition->isAbstract()) {
  389.             return;
  390.         }
  392.         foreach ($definition->getAutowiringTypes(false) as $type) {
  393.             $this->definedTypes[$type] = true;
  394.             $this->types[$type] = $id;
  395.             unset($this->ambiguousServiceTypes[$type]);
  396.         }
  398.         if ($definition->isDeprecated() || !$reflectionClass = $this->container->getReflectionClass($definition->getClass(), false)) {
  399.             return;
  400.         }
  402.         foreach ($reflectionClass->getInterfaces() as $reflectionInterface) {
  403.             $this->set($reflectionInterface->name, $id);
  404.         }
  406.         do {
  407.             $this->set($reflectionClass->name, $id);
  408.         } while ($reflectionClass = $reflectionClass->getParentClass());
  409.     }
  411.     /**
  412.      * Associates a type and a service id if applicable.
  413.      *
  414.      * @param string $type
  415.      * @param string $id
  416.      */
  417.     private function set($type, $id)
  418.     {
  419.         if (isset($this->definedTypes[$type])) {
  420.             return;
  421.         }
  423.         // is this already a type/class that is known to match multiple services?
  424.         if (isset($this->ambiguousServiceTypes[$type])) {
  425.             $this->ambiguousServiceTypes[$type][] = $id;
  427.             return;
  428.         }
  430.         // check to make sure the type doesn't match multiple services
  431.         if (!isset($this->types[$type]) || $this->types[$type] === $id) {
  432.             $this->types[$type] = $id;
  434.             return;
  435.         }
  437.         // keep an array of all services matching this type
  438.         if (!isset($this->ambiguousServiceTypes[$type])) {
  439.             $this->ambiguousServiceTypes[$type] = array($this->types[$type]);
  440.             unset($this->types[$type]);
  441.         }
  442.         $this->ambiguousServiceTypes[$type][] = $id;
  443.     }
  445.     /**
  446.      * Registers a definition for the type if possible or throws an exception.
  447.      *
  448.      * @param string $type
  449.      *
  450.      * @return TypedReference|null A reference to the registered definition
  451.      */
  452.     private function createAutowiredDefinition($type)
  453.     {
  454.         if (!($typeHint = $this->container->getReflectionClass($type, false)) || !$typeHint->isInstantiable()) {
  455.             return;
  456.         }
  458.         $currentId = $this->currentId;
  459.         $this->currentId = $type;
  460.         $this->autowired[$type] = $argumentId = sprintf('autowired.%s', $type);
  461.         $argumentDefinition = new Definition($type);
  462.         $argumentDefinition->setPublic(false);
  463.         $argumentDefinition->setAutowired(true);
  465.         try {
  466.             $originalThrowSetting = $this->throwOnAutowiringException;
  467.             $this->throwOnAutowiringException = true;
  468.             $this->processValue($argumentDefinition, true);
  469.             $this->container->setDefinition($argumentId, $argumentDefinition);
  470.         } catch (AutowiringFailedException $e) {
  471.             $this->autowired[$type] = false;
  472.             $this->lastFailure = $e->getMessage();
  473.             $this->container->log($this, $this->lastFailure);
  475.             return;
  476.         } finally {
  477.             $this->throwOnAutowiringException = $originalThrowSetting;
  478.             $this->currentId = $currentId;
  479.         }
  481.         $this->container->log($this, sprintf('Type "%s" has been auto-registered for service "%s".', $type, $this->currentId));
  483.         return new TypedReference($argumentId, $type);
  484.     }
  486.     private function createTypeNotFoundMessage(TypedReference $reference, $label)
  487.     {
  488.         if (!$r = $this->container->getReflectionClass($type = $reference->getType(), false)) {
  489.             // either $type does not exist or a parent class does not exist
  490.             try {
  491.                 $resource = new ClassExistenceResource($type, false);
  492.                 // isFresh() will explode ONLY if a parent class/trait does not exist
  493.                 $resource->isFresh(0);
  494.                 $parentMsg = false;
  495.             } catch (\ReflectionException $e) {
  496.                 $parentMsg = $e->getMessage();
  497.             }
  499.             $message = sprintf('has type "%s" but this class %s.', $type, $parentMsg ? sprintf('is missing a parent class (%s)', $parentMsg) : 'was not found');
  500.         } else {
  501.             $message = $this->container->has($type) ? 'this service is abstract' : 'no such service exists';
  502.             $message = sprintf('references %s "%s" but %s.%s', $r->isInterface() ? 'interface' : 'class', $type, $message, $this->createTypeAlternatives($reference));
  503.         }
  505.         $message = sprintf('Cannot autowire service "%s": %s %s', $this->currentId, $label, $message);
  507.         if (null !== $this->lastFailure) {
  508.             $message = $this->lastFailure."\n".$message;
  509.             $this->lastFailure = null;
  510.         }
  512.         return $message;
  513.     }
  515.     private function createTypeAlternatives(TypedReference $reference)
  516.     {
  517.         // try suggesting available aliases first
  518.         if ($message = $this->getAliasesSuggestionForType($type = $reference->getType())) {
  519.             return ' '.$message;
  520.         }
  522.         if (isset($this->ambiguousServiceTypes[$type])) {
  523.             $message = sprintf('one of these existing services: "%s"', implode('", "', $this->ambiguousServiceTypes[$type]));
  524.         } elseif (isset($this->types[$type])) {
  525.             $message = sprintf('the existing "%s" service', $this->types[$type]);
  526.         } elseif ($reference->getRequiringClass() && !$reference->canBeAutoregistered()) {
  527.             return ' It cannot be auto-registered because it is from a different root namespace.';
  528.         } else {
  529.             return;
  530.         }
  532.         return sprintf(' You should maybe alias this %s to %s.', class_exists($type, false) ? 'class' : 'interface', $message);
  533.     }
  535.     /**
  536.      * @deprecated since version 3.3, to be removed in 4.0.
  537.      */
  538.     private static function getResourceMetadataForMethod(\ReflectionMethod $method)
  539.     {
  540.         $methodArgumentsMetadata = array();
  541.         foreach ($method->getParameters() as $parameter) {
  542.             try {
  543.                 $class = $parameter->getClass();
  544.             } catch (\ReflectionException $e) {
  545.                 // type-hint is against a non-existent class
  546.                 $class = false;
  547.             }
  549.             $isVariadic = method_exists($parameter, 'isVariadic') && $parameter->isVariadic();
  550.             $methodArgumentsMetadata[] = array(
  551.                 'class' => $class,
  552.                 'isOptional' => $parameter->isOptional(),
  553.                 'defaultValue' => ($parameter->isOptional() && !$isVariadic) ? $parameter->getDefaultValue() : null,
  554.             );
  555.         }
  557.         return $methodArgumentsMetadata;
  558.     }
  560.     private function getAliasesSuggestionForType($type, $extraContext = null)
  561.     {
  562.         $aliases = array();
  563.         foreach (class_parents($type) + class_implements($type) as $parent) {
  564.             if ($this->container->has($parent) && !$this->container->findDefinition($parent)->isAbstract()) {
  565.                 $aliases[] = $parent;
  566.             }
  567.         }
  569.         $extraContext = $extraContext ? ' '.$extraContext : '';
  570.         if (1 < $len = count($aliases)) {
  571.             $message = sprintf('Try changing the type-hint%s to one of its parents: ', $extraContext);
  572.             for ($i = 0, --$len; $i < $len; ++$i) {
  573.                 $message .= sprintf('%s "%s", ', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  574.             }
  575.             $message .= sprintf('or %s "%s".', class_exists($aliases[$i], false) ? 'class' : 'interface', $aliases[$i]);
  577.             return $message;
  578.         }
  580.         if ($aliases) {
  581.             return sprintf('Try changing the type-hint%s to "%s" instead.', $extraContext, $aliases[0]);
  582.         }
  583.     }
  584. }