[DependencyInjection] Add autowiring capabilities

symfony · dunglas · Aug 24, 2015 · Aug 25, 2015 · Aug 25, 2015 · Aug 25, 2015
commit 9828da296f6f2f45a741fffc8acd28e85f14a0e1
diff --git a/src/Symfony/Component/DependencyInjection/Compiler/AutowiringPass.php b/src/Symfony/Component/DependencyInjection/Compiler/AutowiringPass.php
@@ -0,0 +1,233 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Reference;
+
+/**
+ * Guesses constructor arguments of services definitions and try to instantiate services if necessary.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class AutowiringPass implements CompilerPassInterface
+{
+    private $container;
+    private $definitions;
+    private $reflectionClassesToId = array();
+    private $definedTypes = array();
+    private $typesToId;
+    private $notGuessableTypesToId = array();
+
+    /**
+     * {@inheritdoc}
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $this->container = $container;
+        $this->definitions = $container->getDefinitions();
+        foreach ($this->definitions as $id => $definition) {
+            $this->completeDefinition($id, $definition, $container);
+        }
+    }
+
+    /**
+     * Wires the given definition.
+     *
+     * @param string $id
+     * @param Definition $definition
+     *
+     * @throws RuntimeException
+     */
+    private function completeDefinition($id, Definition $definition)
+    {
+        if (!($reflectionClass = $this->getReflectionClass($id, $definition))) {
+            return;
+        }
+
+        if (!($constructor = $reflectionClass->getConstructor())) {
+            return;
+        }
+
+        $arguments = $definition->getArguments();
+        foreach ($constructor->getParameters() as $index => $parameter) {
+            if (!($typeHint = $parameter->getClass()) || $parameter->isOptional()) {
+                continue;
+            }
+
+            $argumentExist = array_key_exists($index, $arguments);
+            if ($argumentExist && '' !== $arguments[$index]) {
+                continue;
+            }
+
+            if (null === $this->typesToId) {
+                $this->populateAvailableTypes();
+            }
+
+            if (isset($this->typesToId[$typeHint->name])) {
+                $reference = new Reference($this->typesToId[$typeHint->name]);
+            } else {
+                $reference = $this->createAutowiredDefinition($typeHint);
+            }
+
+            if ($argumentExist) {
+                $definition->replaceArgument($index, $reference);
+            } else {
+                $definition->addArgument($reference);
+            }
+        }
+    }
+
+    /**
+     * Populates the list of available types.
+     */
+    private function populateAvailableTypes()
+    {
+        $this->typesToId = array();
+
+        foreach ($this->definitions as $id => $definition) {
+            $this->populateAvailableType($id, $definition);
+        }
+    }
+
+    /**
+     * Populates the of available types for a given definition.
+     *
+     * @param string     $id
+     * @param Definition $definition
+     */
+    private function populateAvailableType($id, Definition $definition) {
+        if (!($class = $definition->getClass())) {
+            return;
+        }
+
+        foreach ($definition->getTypes() as $type) {
+            $this->definedTypes[$type] = true;
+            $this->typesToId[$type] = $id;
+        }
+
+        if ($reflectionClass = $this->getReflectionClass($id, $definition)) {
+            $this->extractInterfaces($id, $reflectionClass);
+            $this->extractAncestors($id, $reflectionClass);
+        }
+    }
+
+    /**
+     * Extracts the list of all interfaces implemented by a class.
+     *
+     * @param string           $id
+     * @param \ReflectionClass $reflectionClass
+     */
+    private function extractInterfaces($id, \ReflectionClass $reflectionClass)
+    {
+        foreach ($reflectionClass->getInterfaces() as $interfaceName => $reflectionInterface) {
+            $this->set($interfaceName, $id);
+
+            $this->extractInterfaces($id, $reflectionInterface);
+        }
+    }
+
+    /**
+     * Extracts all inherited types of a class.
+     *
+     * @param string           $id
+     * @param \ReflectionClass $reflectionClass
+     */
+    private function extractAncestors($id, \ReflectionClass $reflectionClass)
+    {
+        $this->set($reflectionClass->name, $id);
+
+        if ($reflectionParentClass = $reflectionClass->getParentClass()) {
+            $this->extractAncestors($id, $reflectionParentClass);
+        }
+    }
+
+    /**
+     * Associates if applicable a type and a service id or a class.
+     *
+     * @param string $type
+     * @param string $value A service id or a class name depending of the value of $class
+     */
+    private function set($type, $value)
+    {
+        if (isset($this->definedTypes[$type]) || isset($this->notGuessableTypesToId[$type])) {
+            return;
+        }
+
+        if (isset($this->typesToId[$type])) {
+            if ($this->typesToId[$type] === $value) {
+                return;
+            }
+
+            unset($this->typesToId[$type]);
+
+            $this->notGuessableTypesToId[$type] = true;
+            return;
+        }
+
+        $this->typesToId[$type] = $value;
+    }
+
+    /**
+     * Registers a definition for the type if possible or throws an exception.
+     *
+     * @param \ReflectionClass $typeHint
+     *
+     * @return Reference A reference to the registered definition
+     *
+     * @throws RuntimeException
+     */
+    private function createAutowiredDefinition(\ReflectionClass $typeHint)
+    {
+        if (!$typeHint->isInstantiable()) {
+            throw new RuntimeException(sprintf('Unable to autowire type "%s".', $typeHint->name));
+        }
+
+        $argumentId = sprintf('autowired.%s', $typeHint->name);
+
+        $argumentDefinition = $this->container->register($argumentId, $typeHint->name);
+        $argumentDefinition->setPublic(false);
+
+        $this->definitions = $this->container->getDefinitions();
+        $this->populateAvailableType($argumentId, $argumentDefinition);
+        $this->completeDefinition($argumentId, $argumentDefinition);
+
+        return new Reference($argumentId);
+    }
+
+    /**
+     * Retrieves the reflection class associated with the given service.
+     *
+     * @param string $id
+     * @param Definition $definition
+     *
+     * @return \ReflectionClass|null
+     */
+    private function getReflectionClass($id, Definition $definition)
+    {
+        if (isset($this->reflectionClassesToId[$id])) {
+            return $this->reflectionClassesToId[$id];
+        }
+
+        if (!$class = $definition->getClass()) {
+            return;
+        }
+
+        try {
+            return $this->reflectionClassesToId[$id] = new \ReflectionClass($class);
+        } catch (\ReflectionException $e) {
+            // Skip invalid classes definitions to keep BC
+        }
+    }
+}
diff --git a/src/Symfony/Component/DependencyInjection/Compiler/PassConfig.php b/src/Symfony/Component/DependencyInjection/Compiler/PassConfig.php
@@ -51,6 +51,7 @@ public function __construct()
             new ResolveReferencesToAliasesPass(),
             new ResolveInvalidReferencesPass(),
             new AnalyzeServiceReferencesPass(true),
+            new AutowiringPass(),
             new CheckCircularReferencesPass(),
             new CheckReferenceValidityPass(),
         );

diff --git a/src/Symfony/Component/DependencyInjection/Definition.php b/src/Symfony/Component/DependencyInjection/Definition.php
@@ -41,6 +41,7 @@ class Definition
     private $synchronized = false;
     private $lazy = false;
     private $decoratedService;
+    private $types = array();
 
     protected $arguments;
 
@@ -818,4 +819,71 @@ public function getConfigurator()
     {
         return $this->configurator;
     }
+
+    /**
+     * Sets types that will default to this definition.
+     *
+     * @param string[] $types
+     *
+     * @return Definition The current instance
+     */
+    public function setTypes(array $types)
+    {
+        $this->types = array();
+
+        foreach ($types as $type) {
+            $this->types[$type] = true;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Gets types that will default to this definition.
+     *
+     * @return string[]
+     */
+    public function getTypes()
+    {
+        return array_keys($this->types);
+    }
+
+    /**
+     * Adds a type that will default to this definition.
+     *
+     * @param string $type
+     *
+     * @return Definition The current instance
+     */
+    public function addType($type)
+    {
+        $this->types[$type] = true;
+
+        return $this;
+    }
+
+    /**
+     * Removes a type.
+     *
+     * @param string $type
+     *
+     * @return Definition The current instance
+     */
+    public function removeType($type)
+    {
+        unset($this->types[$type]);
+
+        return $this;
+    }
+
+    /**
+     * Will this definition default for the given type?
+     *
+     * @param string $type
+     *
+     * @return bool
+     */
+    public function hasType($type) {
+        return isset($this->types[$type]);
+    }
 }
diff --git a/src/Symfony/Component/DependencyInjection/Loader/XmlFileLoader.php b/src/Symfony/Component/DependencyInjection/Loader/XmlFileLoader.php
@@ -247,6 +247,10 @@ private function parseDefinition(\DOMElement $service, $file)
             $definition->addTag($tag->getAttribute('name'), $parameters);
         }
 
+        foreach ($this->getChildren($service, 'type') as $type) {
+            $definition->addType($type->textContent);
+        }
+
         if ($value = $service->getAttribute('decorates')) {
             $renameId = $service->hasAttribute('decoration-inner-name') ? $service->getAttribute('decoration-inner-name') : null;
             $priority = $service->hasAttribute('decoration-priority') ? $service->getAttribute('decoration-priority') : 0;

diff --git a/src/Symfony/Component/DependencyInjection/Loader/YamlFileLoader.php b/src/Symfony/Component/DependencyInjection/Loader/YamlFileLoader.php
@@ -299,6 +299,20 @@ private function parseDefinition($id, $service, $file)
             $definition->setDecoratedService($service['decorates'], $renameId, $priority);
         }
 
+        if (isset($service['types'])) {
+            if (!is_array($service['types'])) {
+                throw new InvalidArgumentException(sprintf('Parameter "types" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
+            }
+
+            foreach ($service['types'] as $type) {
+                if (!is_string($type)) {
+                    throw new InvalidArgumentException(sprintf('A "types" attribute must be of type string for service "%s" in %s. Check your YAML syntax.', $id, $file));
+                }
+
+                $definition->addType($type);
+            }
+        }
+
         $this->container->setDefinition($id, $definition);
     }
 

diff --git a/src/Symfony/Component/DependencyInjection/Loader/schema/dic/services/services-1.0.xsd b/src/Symfony/Component/DependencyInjection/Loader/schema/dic/services/services-1.0.xsd
@@ -85,6 +85,7 @@
       <xsd:element name="call" type="call" minOccurs="0" maxOccurs="unbounded" />
       <xsd:element name="tag" type="tag" minOccurs="0" maxOccurs="unbounded" />
       <xsd:element name="property" type="property" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="type" type="xsd:string" minOccurs="0" maxOccurs="unbounded" />
     </xsd:choice>
     <xsd:attribute name="id" type="xsd:string" />
     <xsd:attribute name="class" type="xsd:string" />