- Patch #1497230 by Rob Loach, pdrake, effulgentsia: Use Dependency Injection...

- Patch #1497230 by Rob Loach, pdrake, effulgentsia: Use Dependency Injection to handle object definitions.

core/lib/Drupal/Core/Language/Language.php

+<?php
+
+/**
+ * @file
+ * Definition of Drupal\Core\Language\Language.
+ */
+
+namespace Drupal\Core\Language;
+
+/**
+ * An object containing the information for an interface language.
+ *
+ * @todo To keep backwards compatibility with stdClass, we currently use
+ * public scopes for the Language class's variables. We will change these to
+ * full get/set functions in a follow-up issue: http://drupal.org/node/1512424
+ *
+ * @see language_default()
+ */
+class Language {
+  // Properties within the Language are set up as the default language.
+  public $name = 'English';
+  public $langcode = 'en';
+  public $direction = 0;
+  public $enabled = 1;
+  public $weight = 0;
+  public $default = FALSE;
+  public $method_id = NULL;
+
+  /**
+   * Language constructor builds the default language object.
+   *
+   * @param array $options
+   *   The properties used to construct the language.
+   */
+  public function __construct(array $options = array()) {
+    // Set all the properties for the language.
+    foreach ($options as $name => $value) {
+      $this->$name = $value;
+    }
+  }
+
+  /**
+   * Extend $this with properties from the given object.
+   *
+   * @todo Remove this function once $GLOBALS['language'] is gone.
+   */
+  public function extend($obj) {
+    $vars = get_object_vars($obj);
+    foreach ($vars as $var => $value) {
+      $this->$var = $value;
+    }
+  }
+}

core/vendor/Symfony/Component/DependencyInjection/Alias.php

+<?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;
+
+/**
+ * @api
+ */
+class Alias
+{
+    private $id;
+    private $public;
+
+    /**
+     * Constructor.
+     *
+     * @param string $id Alias identifier
+     * @param Boolean $public If this alias is public
+     *
+     * @api
+     */
+    public function __construct($id, $public = true)
+    {
+        $this->id = strtolower($id);
+        $this->public = $public;
+    }
+
+    /**
+     * Checks if this DI Alias should be public or not.
+     *
+     * @return Boolean
+     *
+     * @api
+     */
+    public function isPublic()
+    {
+        return $this->public;
+    }
+
+    /**
+     * Sets if this Alias is public.
+     *
+     * @param Boolean $boolean If this Alias should be public
+     *
+     * @api
+     */
+    public function setPublic($boolean)
+    {
+        $this->public = (Boolean) $boolean;
+    }
+
+    /**
+     * Returns the Id of this alias.
+     *
+     * @return string The alias id
+     *
+     * @api
+     */
+    public function __toString()
+    {
+        return $this->id;
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/AnalyzeServiceReferencesPass.php

+<?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\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * Run this pass before passes that need to know more about the relation of
+ * your services.
+ *
+ * This class will populate the ServiceReferenceGraph with information. You can
+ * retrieve the graph in other passes from the compiler.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class AnalyzeServiceReferencesPass implements RepeatablePassInterface
+{
+    private $graph;
+    private $container;
+    private $currentId;
+    private $currentDefinition;
+    private $repeatedPass;
+    private $onlyConstructorArguments;
+
+    /**
+     * Constructor.
+     *
+     * @param Boolean $onlyConstructorArguments Sets this Service Reference pass to ignore method calls
+     */
+    public function __construct($onlyConstructorArguments = false)
+    {
+        $this->onlyConstructorArguments = (Boolean) $onlyConstructorArguments;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setRepeatedPass(RepeatedPass $repeatedPass)
+    {
+        $this->repeatedPass = $repeatedPass;
+    }
+
+    /**
+     * Processes a ContainerBuilder object to populate the service reference graph.
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $this->container = $container;
+        $this->graph     = $container->getCompiler()->getServiceReferenceGraph();
+        $this->graph->clear();
+
+        foreach ($container->getDefinitions() as $id => $definition) {
+            if ($definition->isSynthetic() || $definition->isAbstract()) {
+                continue;
+            }
+
+            $this->currentId = $id;
+            $this->currentDefinition = $definition;
+            $this->processArguments($definition->getArguments());
+
+            if (!$this->onlyConstructorArguments) {
+                $this->processArguments($definition->getMethodCalls());
+                $this->processArguments($definition->getProperties());
+            }
+        }
+
+        foreach ($container->getAliases() as $id => $alias) {
+            $this->graph->connect($id, $alias, (string) $alias, $this->getDefinition((string) $alias), null);
+        }
+    }
+
+    /**
+     * Processes service definitions for arguments to find relationships for the service graph.
+     *
+     * @param array $arguments An array of Reference or Definition objects relating to service definitions
+     */
+    private function processArguments(array $arguments)
+    {
+        foreach ($arguments as $argument) {
+            if (is_array($argument)) {
+                $this->processArguments($argument);
+            } elseif ($argument instanceof Reference) {
+                $this->graph->connect(
+                    $this->currentId,
+                    $this->currentDefinition,
+                    $this->getDefinitionId((string) $argument),
+                    $this->getDefinition((string) $argument),
+                    $argument
+                );
+            } elseif ($argument instanceof Definition) {
+                $this->processArguments($argument->getArguments());
+                $this->processArguments($argument->getMethodCalls());
+                $this->processArguments($argument->getProperties());
+            }
+        }
+    }
+
+    /**
+     * Returns a service definition given the full name or an alias.
+     *
+     * @param string $id A full id or alias for a service definition.
+     *
+     * @return Definition The definition related to the supplied id
+     */
+    private function getDefinition($id)
+    {
+        $id = $this->getDefinitionId($id);
+
+        return null === $id ? null : $this->container->getDefinition($id);
+    }
+
+    private function getDefinitionId($id)
+    {
+        while ($this->container->hasAlias($id)) {
+            $id = (string) $this->container->getAlias($id);
+        }
+
+        if (!$this->container->hasDefinition($id)) {
+            return null;
+        }
+
+        return $id;
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/CheckCircularReferencesPass.php

+<?php
+
+/*
+ * This file is part of the Symfony framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * Checks your services for circular references
+ *
+ * References from method calls are ignored since we might be able to resolve
+ * these references depending on the order in which services are called.
+ *
+ * Circular reference from method calls will only be detected at run-time.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class CheckCircularReferencesPass implements CompilerPassInterface
+{
+    private $currentId;
+    private $currentPath;
+
+    /**
+     * Checks the ContainerBuilder object for circular references.
+     *
+     * @param ContainerBuilder $container The ContainerBuilder instances
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $graph = $container->getCompiler()->getServiceReferenceGraph();
+
+        foreach ($graph->getNodes() as $id => $node) {
+            $this->currentId = $id;
+            $this->currentPath = array($id);
+
+            $this->checkOutEdges($node->getOutEdges());
+        }
+    }
+
+    /**
+     * Checks for circular references.
+     *
+     * @param array $edges An array of Nodes
+     *
+     * @throws ServiceCircularReferenceException When a circular reference is found.
+     */
+    private function checkOutEdges(array $edges)
+    {
+        foreach ($edges as $edge) {
+            $node = $edge->getDestNode();
+            $this->currentPath[] = $id = $node->getId();
+
+            if ($this->currentId === $id) {
+                throw new ServiceCircularReferenceException($this->currentId, $this->currentPath);
+            }
+
+            $this->checkOutEdges($node->getOutEdges());
+            array_pop($this->currentPath);
+        }
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/CheckDefinitionValidityPass.php

+<?php
+
+/*
+ * This file is part of the Symfony framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+
+/**
+ * This pass validates each definition individually only taking the information
+ * into account which is contained in the definition itself.
+ *
+ * Later passes can rely on the following, and specifically do not need to
+ * perform these checks themselves:
+ *
+ * - non synthetic, non abstract services always have a class set
+ * - synthetic services are always public
+ * - synthetic services are always of non-prototype scope
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class CheckDefinitionValidityPass implements CompilerPassInterface
+{
+    /**
+     * Processes the ContainerBuilder to validate the Definition.
+     *
+     * @param ContainerBuilder $container
+     *
+     * @throws RuntimeException When the Definition is invalid
+     */
+    public function process(ContainerBuilder $container)
+    {
+        foreach ($container->getDefinitions() as $id => $definition) {
+            // synthetic service is public
+            if ($definition->isSynthetic() && !$definition->isPublic()) {
+                throw new RuntimeException(sprintf(
+                    'A synthetic service ("%s") must be public.',
+                    $id
+                ));
+            }
+
+            // synthetic service has non-prototype scope
+            if ($definition->isSynthetic() && ContainerInterface::SCOPE_PROTOTYPE === $definition->getScope()) {
+                throw new RuntimeException(sprintf(
+                    'A synthetic service ("%s") cannot be of scope "prototype".',
+                    $id
+                ));
+            }
+
+            // non-synthetic, non-abstract service has class
+            if (!$definition->isAbstract() && !$definition->isSynthetic() && !$definition->getClass()) {
+                if ($definition->getFactoryClass() || $definition->getFactoryService()) {
+                    throw new RuntimeException(sprintf(
+                        'Please add the class to service "%s" even if it is constructed by a factory '
+                       .'since we might need to add method calls based on compile-time checks.',
+                       $id
+                    ));
+                }
+
+                throw new RuntimeException(sprintf(
+                    'The definition for "%s" has no class. If you intend to inject '
+                   .'this service dynamically at runtime, please mark it as synthetic=true. '
+                   .'If this is an abstract definition solely used by child definitions, '
+                   .'please add abstract=true, otherwise specify a class to get rid of this error.',
+                   $id
+                ));
+            }
+        }
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/CheckExceptionOnInvalidReferenceBehaviorPass.php

+<?php
+
+/*
+ * This file is part of the Symfony framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Definition;
+
+use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * Checks that all references are pointing to a valid service.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class CheckExceptionOnInvalidReferenceBehaviorPass implements CompilerPassInterface
+{
+    private $container;
+    private $sourceId;
+
+    public function process(ContainerBuilder $container)
+    {
+        $this->container = $container;
+
+        foreach ($container->getDefinitions() as $id => $definition) {
+            $this->sourceId = $id;
+            $this->processDefinition($definition);
+        }
+    }
+
+    private function processDefinition(Definition $definition)
+    {
+        $this->processReferences($definition->getArguments());
+        $this->processReferences($definition->getMethodCalls());
+        $this->processReferences($definition->getProperties());
+    }
+
+    private function processReferences(array $arguments)
+    {
+        foreach ($arguments as $argument) {
+            if (is_array($argument)) {
+                $this->processReferences($argument);
+            } elseif ($argument instanceof Definition) {
+                $this->processDefinition($argument);
+            } elseif ($argument instanceof Reference && ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE === $argument->getInvalidBehavior()) {
+                $destId = (string) $argument;
+
+                if (!$this->container->has($destId)) {
+                    throw new ServiceNotFoundException($destId, $this->sourceId);
+                }
+            }
+        }
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/CheckReferenceValidityPass.php

+<?php
+
+/*
+ * This file is part of the Symfony framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Exception\ScopeCrossingInjectionException;
+use Symfony\Component\DependencyInjection\Exception\ScopeWideningInjectionException;
+
+/**
+ * Checks the validity of references
+ *
+ * The following checks are performed by this pass:
+ * - target definitions are not abstract
+ * - target definitions are of equal or wider scope
+ * - target definitions are in the same scope hierarchy
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class CheckReferenceValidityPass implements CompilerPassInterface
+{
+    private $container;
+    private $currentId;
+    private $currentDefinition;
+    private $currentScope;
+    private $currentScopeAncestors;
+    private $currentScopeChildren;
+
+    /**
+     * Processes the ContainerBuilder to validate References.
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $this->container = $container;
+
+        $children = $this->container->getScopeChildren();
+        $ancestors = array();
+
+        $scopes = $this->container->getScopes();
+        foreach ($scopes as $name => $parent) {
+            $ancestors[$name] = array($parent);
+
+            while (isset($scopes[$parent])) {
+                $ancestors[$name][] = $parent = $scopes[$parent];
+            }
+        }
+
+        foreach ($container->getDefinitions() as $id => $definition) {
+            if ($definition->isSynthetic() || $definition->isAbstract()) {
+                continue;
+            }
+
+            $this->currentId = $id;
+            $this->currentDefinition = $definition;
+            $this->currentScope = $scope = $definition->getScope();
+
+            if (ContainerInterface::SCOPE_CONTAINER === $scope) {
+                $this->currentScopeChildren = array_keys($scopes);
+                $this->currentScopeAncestors = array();
+            } elseif (ContainerInterface::SCOPE_PROTOTYPE !== $scope) {
+                $this->currentScopeChildren = $children[$scope];
+                $this->currentScopeAncestors = $ancestors[$scope];
+            }
+
+            $this->validateReferences($definition->getArguments());
+            $this->validateReferences($definition->getMethodCalls());
+            $this->validateReferences($definition->getProperties());
+        }
+    }
+
+    /**
+     * Validates an array of References.
+     *
+     * @param array $arguments An array of Reference objects
+     *
+     * @throws RuntimeException when there is a reference to an abstract definition.
+     */
+    private function validateReferences(array $arguments)
+    {
+        foreach ($arguments as $argument) {
+            if (is_array($argument)) {
+                $this->validateReferences($argument);
+            } elseif ($argument instanceof Reference) {
+                $targetDefinition = $this->getDefinition((string) $argument);
+
+                if (null !== $targetDefinition && $targetDefinition->isAbstract()) {
+                    throw new RuntimeException(sprintf(
+                        'The definition "%s" has a reference to an abstract definition "%s". '
+                       .'Abstract definitions cannot be the target of references.',
+                       $this->currentId,
+                       $argument
+                    ));
+                }
+
+                $this->validateScope($argument, $targetDefinition);
+            }
+        }
+    }
+
+    /**
+     * Validates the scope of a single Reference.
+     *
+     * @param Reference  $reference
+     * @param Definition $definition
+     *
+     * @throws ScopeWideningInjectionException when the definition references a service of a narrower scope
+     * @throws ScopeCrossingInjectionException when the definition references a service of another scope hierarchy
+     */
+    private function validateScope(Reference $reference, Definition $definition = null)
+    {
+        if (ContainerInterface::SCOPE_PROTOTYPE === $this->currentScope) {
+            return;
+        }
+
+        if (!$reference->isStrict()) {
+            return;
+        }
+
+        if (null === $definition) {
+            return;
+        }
+
+        if ($this->currentScope === $scope = $definition->getScope()) {
+            return;
+        }
+
+        $id = (string) $reference;
+
+        if (in_array($scope, $this->currentScopeChildren, true)) {
+            throw new ScopeWideningInjectionException($this->currentId, $this->currentScope, $id, $scope);
+        }
+
+        if (!in_array($scope, $this->currentScopeAncestors, true)) {
+            throw new ScopeCrossingInjectionException($this->currentId, $this->currentScope, $id, $scope);
+        }
+    }
+
+    /**
+     * Returns the Definition given an id.
+     *
+     * @param string $id Definition identifier
+     *
+     * @return Definition
+     */
+    private function getDefinition($id)
+    {
+        if (!$this->container->hasDefinition($id)) {
+            return null;
+        }
+
+        return $this->container->getDefinition($id);
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/Compiler.php

+<?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\Compiler\PassConfig;
+
+/**
+ * This class is used to remove circular dependencies between individual passes.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * @api
+ */
+class Compiler
+{
+    private $passConfig;
+    private $log;
+    private $loggingFormatter;
+    private $serviceReferenceGraph;
+
+    /**
+     * Constructor.
+     */
+    public function __construct()
+    {
+        $this->passConfig = new PassConfig();
+        $this->serviceReferenceGraph = new ServiceReferenceGraph();
+        $this->loggingFormatter = new LoggingFormatter();
+        $this->log = array();
+    }
+
+    /**
+     * Returns the PassConfig.
+     *
+     * @return PassConfig The PassConfig instance
+     *
+     * @api
+     */
+    public function getPassConfig()
+    {
+        return $this->passConfig;
+    }
+
+    /**
+     * Returns the ServiceReferenceGraph.
+     *
+     * @return ServiceReferenceGraph The ServiceReferenceGraph instance
+     *
+     * @api
+     */
+    public function getServiceReferenceGraph()
+    {
+        return $this->serviceReferenceGraph;
+    }
+
+    /**
+     * Returns the logging formatter which can be used by compilation passes.
+     *
+     * @return LoggingFormatter
+     */
+    public function getLoggingFormatter()
+    {
+        return $this->loggingFormatter;
+    }
+
+    /**
+     * Adds a pass to the PassConfig.
+     *
+     * @param CompilerPassInterface $pass A compiler pass
+     * @param string                $type The type of the pass
+     *
+     * @api
+     */
+    public function addPass(CompilerPassInterface $pass, $type = PassConfig::TYPE_BEFORE_OPTIMIZATION)
+    {
+        $this->passConfig->addPass($pass, $type);
+    }
+
+    /**
+     * Adds a log message.
+     *
+     * @param string $string The log message
+     */
+    public function addLogMessage($string)
+    {
+        $this->log[] = $string;
+    }
+
+    /**
+     * Returns the log.
+     *
+     * @return array Log array
+     */
+    public function getLog()
+    {
+        return $this->log;
+    }
+
+    /**
+     * Run the Compiler and process all Passes.
+     *
+     * @param ContainerBuilder $container
+     *
+     * @api
+     */
+    public function compile(ContainerBuilder $container)
+    {
+        foreach ($this->passConfig->getPasses() as $pass) {
+            $pass->process($container);
+        }
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/CompilerPassInterface.php

+<?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;
+
+/**
+ * Interface that must be implemented by compilation passes
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * @api
+ */
+interface CompilerPassInterface
+{
+    /**
+     * You can modify the container here before it is dumped to PHP code.
+     *
+     * @param ContainerBuilder $container
+     *
+     * @api
+     */
+    function process(ContainerBuilder $container);
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/InlineServiceDefinitionsPass.php

+<?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\ContainerInterface;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * Inline service definitions where this is possible.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class InlineServiceDefinitionsPass implements RepeatablePassInterface
+{
+    private $repeatedPass;
+    private $graph;
+    private $compiler;
+    private $formatter;
+    private $currentId;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setRepeatedPass(RepeatedPass $repeatedPass)
+    {
+        $this->repeatedPass = $repeatedPass;
+    }
+
+    /**
+     * Processes the ContainerBuilder for inline service definitions.
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $this->compiler = $container->getCompiler();
+        $this->formatter = $this->compiler->getLoggingFormatter();
+        $this->graph = $this->compiler->getServiceReferenceGraph();
+
+        foreach ($container->getDefinitions() as $id => $definition) {
+            $this->currentId = $id;
+
+            $definition->setArguments(
+                $this->inlineArguments($container, $definition->getArguments())
+            );
+
+            $definition->setMethodCalls(
+                $this->inlineArguments($container, $definition->getMethodCalls())
+            );
+
+            $definition->setProperties(
+                $this->inlineArguments($container, $definition->getProperties())
+            );
+        }
+    }
+
+    /**
+     * Processes inline arguments.
+     *
+     * @param ContainerBuilder $container The ContainerBuilder
+     * @param array            $arguments An array of arguments
+     */
+    private function inlineArguments(ContainerBuilder $container, array $arguments)
+    {
+        foreach ($arguments as $k => $argument) {
+            if (is_array($argument)) {
+                $arguments[$k] = $this->inlineArguments($container, $argument);
+            } elseif ($argument instanceof Reference) {
+                if (!$container->hasDefinition($id = (string) $argument)) {
+                    continue;
+                }
+
+                if ($this->isInlinableDefinition($container, $id, $definition = $container->getDefinition($id))) {
+                    $this->compiler->addLogMessage($this->formatter->formatInlineService($this, $id, $this->currentId));
+
+                    if (ContainerInterface::SCOPE_PROTOTYPE !== $definition->getScope()) {
+                        $arguments[$k] = $definition;
+                    } else {
+                        $arguments[$k] = clone $definition;
+                    }
+                }
+            } elseif ($argument instanceof Definition) {
+                $argument->setArguments($this->inlineArguments($container, $argument->getArguments()));
+                $argument->setMethodCalls($this->inlineArguments($container, $argument->getMethodCalls()));
+                $argument->setProperties($this->inlineArguments($container, $argument->getProperties()));
+            }
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * Checks if the definition is inlineable.
+     *
+     * @param ContainerBuilder $container
+     * @param string           $id
+     * @param Definition       $definition
+     *
+     * @return Boolean If the definition is inlineable
+     */
+    private function isInlinableDefinition(ContainerBuilder $container, $id, Definition $definition)
+    {
+        if (ContainerInterface::SCOPE_PROTOTYPE === $definition->getScope()) {
+            return true;
+        }
+
+        if ($definition->isPublic()) {
+            return false;
+        }
+
+        if (!$this->graph->hasNode($id)) {
+            return true;
+        }
+
+        $ids = array();
+        foreach ($this->graph->getNode($id)->getInEdges() as $edge) {
+            $ids[] = $edge->getSourceNode()->getId();
+        }
+
+        if (count(array_unique($ids)) > 1) {
+            return false;
+        }
+
+        return $container->getDefinition(reset($ids))->getScope() === $definition->getScope();
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/LoggingFormatter.php

+<?php
+
+/*
+ * This file is part of the Symfony framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+
+/**
+ * Used to format logging messages during the compilation.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class LoggingFormatter
+{
+    public function formatRemoveService(CompilerPassInterface $pass, $id, $reason)
+    {
+        return $this->format($pass, sprintf('Removed service "%s"; reason: %s', $id, $reason));
+    }
+
+    public function formatInlineService(CompilerPassInterface $pass, $id, $target)
+    {
+        return $this->format($pass, sprintf('Inlined service "%s" to "%s".', $id, $target));
+    }
+
+    public function formatUpdateReference(CompilerPassInterface $pass, $serviceId, $oldDestId, $newDestId)
+    {
+        return $this->format($pass, sprintf('Changed reference of service "%s" previously pointing to "%s" to "%s".', $serviceId, $oldDestId, $newDestId));
+    }
+
+    public function formatResolveInheritance(CompilerPassInterface $pass, $childId, $parentId)
+    {
+        return $this->format($pass, sprintf('Resolving inheritance for "%s" (parent: %s).', $childId, $parentId));
+    }
+
+    public function format(CompilerPassInterface $pass, $message)
+    {
+        return sprintf('%s: %s', get_class($pass), $message);
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/MergeExtensionConfigurationPass.php

+<?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;
+
+/**
+ * Merges extension configs into the container builder
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class MergeExtensionConfigurationPass implements CompilerPassInterface
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $parameters = $container->getParameterBag()->all();
+        $definitions = $container->getDefinitions();
+        $aliases = $container->getAliases();
+
+        foreach ($container->getExtensions() as $name => $extension) {
+            if (!$config = $container->getExtensionConfig($name)) {
+                // this extension was not called
+                continue;
+            }
+            $config = $container->getParameterBag()->resolveValue($config);
+
+            $tmpContainer = new ContainerBuilder($container->getParameterBag());
+            $tmpContainer->addObjectResource($extension);
+
+            $extension->load($config, $tmpContainer);
+
+            $container->merge($tmpContainer);
+        }
+
+        $container->addDefinitions($definitions);
+        $container->addAliases($aliases);
+        $container->getParameterBag()->add($parameters);
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/PassConfig.php

+<?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\Exception\InvalidArgumentException;
+
+/**
+ * Compiler Pass Configuration
+ *
+ * This class has a default configuration embedded.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ * @api
+ */
+class PassConfig
+{
+    const TYPE_AFTER_REMOVING = 'afterRemoving';
+    const TYPE_BEFORE_OPTIMIZATION = 'beforeOptimization';
+    const TYPE_BEFORE_REMOVING = 'beforeRemoving';
+    const TYPE_OPTIMIZE = 'optimization';
+    const TYPE_REMOVE = 'removing';
+
+    private $mergePass;
+    private $afterRemovingPasses;
+    private $beforeOptimizationPasses;
+    private $beforeRemovingPasses;
+    private $optimizationPasses;
+    private $removingPasses;
+
+    /**
+     * Constructor.
+     */
+    public function __construct()
+    {
+        $this->mergePass = new MergeExtensionConfigurationPass();
+
+        $this->afterRemovingPasses = array();
+        $this->beforeOptimizationPasses = array();
+        $this->beforeRemovingPasses = array();
+
+        $this->optimizationPasses = array(
+            new ResolveDefinitionTemplatesPass(),
+            new ResolveParameterPlaceHoldersPass(),
+            new CheckDefinitionValidityPass(),
+            new ResolveReferencesToAliasesPass(),
+            new ResolveInvalidReferencesPass(),
+            new AnalyzeServiceReferencesPass(true),
+            new CheckCircularReferencesPass(),
+            new CheckReferenceValidityPass(),
+        );
+
+        $this->removingPasses = array(
+            new RemovePrivateAliasesPass(),
+            new RemoveAbstractDefinitionsPass(),
+            new ReplaceAliasByActualDefinitionPass(),
+            new RepeatedPass(array(
+                new AnalyzeServiceReferencesPass(),
+                new InlineServiceDefinitionsPass(),
+                new AnalyzeServiceReferencesPass(),
+                new RemoveUnusedDefinitionsPass(),
+            )),
+            new CheckExceptionOnInvalidReferenceBehaviorPass(),
+        );
+    }
+
+    /**
+     * Returns all passes in order to be processed.
+     *
+     * @return array An array of all passes to process
+     *
+     * @api
+     */
+    public function getPasses()
+    {
+        return array_merge(
+            array($this->mergePass),
+            $this->beforeOptimizationPasses,
+            $this->optimizationPasses,
+            $this->beforeRemovingPasses,
+            $this->removingPasses,
+            $this->afterRemovingPasses
+        );
+    }
+
+    /**
+     * Adds a pass.
+     *
+     * @param CompilerPassInterface $pass A Compiler pass
+     * @param string $type The pass type
+     *
+     * @throws InvalidArgumentException when a pass type doesn't exist
+     *
+     * @api
+     */
+    public function addPass(CompilerPassInterface $pass, $type = self::TYPE_BEFORE_OPTIMIZATION)
+    {
+        $property = $type.'Passes';
+        if (!isset($this->$property)) {
+            throw new InvalidArgumentException(sprintf('Invalid type "%s".', $type));
+        }
+
+        $passes = &$this->$property;
+        $passes[] = $pass;
+    }
+
+    /**
+     * Gets all passes for the AfterRemoving pass.
+     *
+     * @return array An array of passes
+     *
+     * @api
+     */
+    public function getAfterRemovingPasses()
+    {
+        return $this->afterRemovingPasses;
+    }
+
+    /**
+     * Gets all passes for the BeforeOptimization pass.
+     *
+     * @return array An array of passes
+     *
+     * @api
+     */
+    public function getBeforeOptimizationPasses()
+    {
+        return $this->beforeOptimizationPasses;
+    }
+
+    /**
+     * Gets all passes for the BeforeRemoving pass.
+     *
+     * @return array An array of passes
+     *
+     * @api
+     */
+    public function getBeforeRemovingPasses()
+    {
+        return $this->beforeRemovingPasses;
+    }
+
+    /**
+     * Gets all passes for the Optimization pass.
+     *
+     * @return array An array of passes
+     *
+     * @api
+     */
+    public function getOptimizationPasses()
+    {
+        return $this->optimizationPasses;
+    }
+
+    /**
+     * Gets all passes for the Removing pass.
+     *
+     * @return array An array of passes
+     *
+     * @api
+     */
+    public function getRemovingPasses()
+    {
+        return $this->removingPasses;
+    }
+
+    /**
+     * Gets all passes for the Merge pass.
+     *
+     * @return array An array of passes
+     *
+     * @api
+     */
+    public function getMergePass()
+    {
+        return $this->mergePass;
+    }
+
+    /**
+     * Sets the Merge Pass.
+     *
+     * @param CompilerPassInterface $pass The merge pass
+     *
+     * @api
+     */
+    public function setMergePass(CompilerPassInterface $pass)
+    {
+        $this->mergePass = $pass;
+    }
+
+    /**
+     * Sets the AfterRemoving passes.
+     *
+     * @param array $passes An array of passes
+     *
+     * @api
+     */
+    public function setAfterRemovingPasses(array $passes)
+    {
+        $this->afterRemovingPasses = $passes;
+    }
+
+    /**
+     * Sets the BeforeOptimization passes.
+     *
+     * @param array $passes An array of passes
+     *
+     * @api
+     */
+    public function setBeforeOptimizationPasses(array $passes)
+    {
+        $this->beforeOptimizationPasses = $passes;
+    }
+
+    /**
+     * Sets the BeforeRemoving passes.
+     *
+     * @param array $passes An array of passes
+     *
+     * @api
+     */
+    public function setBeforeRemovingPasses(array $passes)
+    {
+        $this->beforeRemovingPasses = $passes;
+    }
+
+    /**
+     * Sets the Optimization passes.
+     *
+     * @param array $passes An array of passes
+     *
+     * @api
+     */
+    public function setOptimizationPasses(array $passes)
+    {
+        $this->optimizationPasses = $passes;
+    }
+
+    /**
+     * Sets the Removing passes.
+     *
+     * @param array $passes An array of passes
+     *
+     * @api
+     */
+    public function setRemovingPasses(array $passes)
+    {
+        $this->removingPasses = $passes;
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/RemoveAbstractDefinitionsPass.php

+<?php
+
+/*
+ * This file is part of the Symfony framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * Removes abstract Definitions
+ *
+ */
+class RemoveAbstractDefinitionsPass implements CompilerPassInterface
+{
+    /**
+     * Removes abstract definitions from the ContainerBuilder
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $compiler = $container->getCompiler();
+        $formatter = $compiler->getLoggingFormatter();
+
+        foreach ($container->getDefinitions() as $id => $definition) {
+            if ($definition->isAbstract()) {
+                $container->removeDefinition($id);
+                $compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'abstract'));
+            }
+        }
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/RemovePrivateAliasesPass.php

+<?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;
+
+/**
+ * Remove private aliases from the container. They were only used to establish
+ * dependencies between services, and these dependencies have been resolved in
+ * one of the previous passes.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class RemovePrivateAliasesPass implements CompilerPassInterface
+{
+    /**
+     * Removes private aliases from the ContainerBuilder
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $compiler = $container->getCompiler();
+        $formatter = $compiler->getLoggingFormatter();
+
+        foreach ($container->getAliases() as $id => $alias) {
+            if ($alias->isPublic()) {
+                continue;
+            }
+
+            $container->removeAlias($id);
+            $compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'private alias'));
+        }
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/RemoveUnusedDefinitionsPass.php

+<?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;
+
+/**
+ * Removes unused service definitions from the container.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class RemoveUnusedDefinitionsPass implements RepeatablePassInterface
+{
+    private $repeatedPass;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setRepeatedPass(RepeatedPass $repeatedPass)
+    {
+        $this->repeatedPass = $repeatedPass;
+    }
+
+    /**
+     * Processes the ContainerBuilder to remove unused definitions.
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $compiler = $container->getCompiler();
+        $formatter = $compiler->getLoggingFormatter();
+        $graph = $compiler->getServiceReferenceGraph();
+
+        $hasChanged = false;
+        foreach ($container->getDefinitions() as $id => $definition) {
+            if ($definition->isPublic()) {
+                continue;
+            }
+
+            if ($graph->hasNode($id)) {
+                $edges = $graph->getNode($id)->getInEdges();
+                $referencingAliases = array();
+                $sourceIds = array();
+                foreach ($edges as $edge) {
+                    $node = $edge->getSourceNode();
+                    $sourceIds[] = $node->getId();
+
+                    if ($node->isAlias()) {
+                        $referencingAliases[] = $node->getValue();
+                    }
+                }
+                $isReferenced = (count(array_unique($sourceIds)) - count($referencingAliases)) > 0;
+            } else {
+                $referencingAliases = array();
+                $isReferenced = false;
+            }
+
+            if (1 === count($referencingAliases) && false === $isReferenced) {
+                $container->setDefinition((string) reset($referencingAliases), $definition);
+                $definition->setPublic(true);
+                $container->removeDefinition($id);
+                $compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'replaces alias '.reset($referencingAliases)));
+            } elseif (0 === count($referencingAliases) && false === $isReferenced) {
+                $container->removeDefinition($id);
+                $compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'unused'));
+                $hasChanged = true;
+            }
+        }
+
+        if ($hasChanged) {
+            $this->repeatedPass->setRepeat();
+        }
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/RepeatablePassInterface.php

+<?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;
+
+/**
+ * Interface that must be implemented by passes that are run as part of an
+ * RepeatedPass.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface RepeatablePassInterface extends CompilerPassInterface
+{
+    /**
+     * Sets the RepeatedPass interface.
+     *
+     * @param RepeatedPass $repeatedPass
+     */
+    function setRepeatedPass(RepeatedPass $repeatedPass);
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/RepeatedPass.php

+<?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\Exception\InvalidArgumentException;
+
+/**
+ * A pass that might be run repeatedly.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class RepeatedPass implements CompilerPassInterface
+{
+    private $repeat;
+    private $passes;
+
+    /**
+     * Constructor.
+     *
+     * @param array $passes An array of RepeatablePassInterface objects
+     * @throws InvalidArgumentException if a pass is not a RepeatablePassInterface instance
+     */
+    public function __construct(array $passes)
+    {
+        foreach ($passes as $pass) {
+            if (!$pass instanceof RepeatablePassInterface) {
+                throw new InvalidArgumentException('$passes must be an array of RepeatablePassInterface.');
+            }
+
+            $pass->setRepeatedPass($this);
+        }
+
+        $this->passes = $passes;
+    }
+
+    /**
+     * Process the repeatable passes that run more than once.
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $this->repeat = false;
+        foreach ($this->passes as $pass) {
+            $pass->process($container);
+        }
+
+        if ($this->repeat) {
+            $this->process($container);
+        }
+    }
+
+    /**
+     * Sets if the pass should repeat
+     */
+    public function setRepeat()
+    {
+        $this->repeat = true;
+    }
+
+    /**
+     * Returns the passes
+     *
+     * @return array An array of RepeatablePassInterface objects
+     */
+    public function getPasses()
+    {
+        return $this->passes;
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/ReplaceAliasByActualDefinitionPass.php

+<?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\Reference;
+
+/**
+ * Replaces aliases with actual service definitions, effectively removing these
+ * aliases.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ReplaceAliasByActualDefinitionPass implements CompilerPassInterface
+{
+    private $compiler;
+    private $formatter;
+    private $sourceId;
+
+    /**
+     * Process the Container to replace aliases with service definitions.
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $this->compiler = $container->getCompiler();
+        $this->formatter = $this->compiler->getLoggingFormatter();
+
+        foreach ($container->getAliases() as $id => $alias) {
+            $aliasId = (string) $alias;
+
+            $definition = $container->getDefinition($aliasId);
+
+            if ($definition->isPublic()) {
+                continue;
+            }
+
+            $definition->setPublic(true);
+            $container->setDefinition($id, $definition);
+            $container->removeDefinition($aliasId);
+
+            $this->updateReferences($container, $aliasId, $id);
+
+            // we have to restart the process due to concurrent modification of
+            // the container
+            $this->process($container);
+
+            break;
+        }
+    }
+
+    /**
+     * Updates references to remove aliases.
+     *
+     * @param ContainerBuilder $container The container
+     * @param string $currentId The alias identifier being replaced
+     * @param string $newId The id of the service the alias points to
+     */
+    private function updateReferences($container, $currentId, $newId)
+    {
+        foreach ($container->getAliases() as $id => $alias) {
+            if ($currentId === (string) $alias) {
+                $container->setAlias($id, $newId);
+            }
+        }
+
+        foreach ($container->getDefinitions() as $id => $definition) {
+            $this->sourceId = $id;
+
+            $definition->setArguments(
+                $this->updateArgumentReferences($definition->getArguments(), $currentId, $newId)
+            );
+
+            $definition->setMethodCalls(
+                $this->updateArgumentReferences($definition->getMethodCalls(), $currentId, $newId)
+            );
+
+            $definition->setProperties(
+                $this->updateArgumentReferences($definition->getProperties(), $currentId, $newId)
+            );
+        }
+    }
+
+    /**
+     * Updates argument references.
+     *
+     * @param array $arguments An array of Arguments
+     * @param string $currentId The alias identifier
+     * @param string $newId The identifier the alias points to
+     */
+    private function updateArgumentReferences(array $arguments, $currentId, $newId)
+    {
+        foreach ($arguments as $k => $argument) {
+            if (is_array($argument)) {
+                $arguments[$k] = $this->updateArgumentReferences($argument, $currentId, $newId);
+            } elseif ($argument instanceof Reference) {
+                if ($currentId === (string) $argument) {
+                    $arguments[$k] = new Reference($newId, $argument->getInvalidBehavior());
+                    $this->compiler->addLogMessage($this->formatter->formatUpdateReference($this, $this->sourceId, $currentId, $newId));
+                }
+            }
+        }
+
+        return $arguments;
+    }
+}

core/vendor/Symfony/Component/DependencyInjection/Compiler/ResolveDefinitionTemplatesPass.php

+<?php
+
+/*
+ * This file is part of the Symfony framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Symfony\Component\DependencyInjection\Compiler;
+
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\DefinitionDecorator;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+
+/**
+ * This replaces all DefinitionDecorator instances with their equivalent fully
+ * merged Definition instance.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class ResolveDefinitionTemplatesPass implements CompilerPassInterface
+{
+    private $container;
+    private $compiler;
+    private $formatter;
+
+    /**
+     * Process the ContainerBuilder to replace DefinitionDecorator instances with their real Definition instances.
+     *
+     * @param ContainerBuilder $container
+     */
+    public function process(ContainerBuilder $container)
+    {
+        $this->container = $container;
+        $this->compiler = $container->getCompiler();
+        $this->formatter = $this->compiler->getLoggingFormatter();
+
+        foreach (array_keys($container->getDefinitions()) as $id) {
+            // yes, we are specifically fetching the definition from the
+            // container to ensure we are not operating on stale data
+            $definition = $container->getDefinition($id);
+            if (!$definition instanceof DefinitionDecorator || $definition->isAbstract()) {
+                continue;
+            }
+
+            $this->resolveDefinition($id, $definition);
+        }
+    }
+
+    /**
+     * Resolves the definition
+     *
+     * @param string              $id         The definition identifier
+     * @param DefinitionDecorator $definition
+     *
+     * @return Definition
+     */
+    private function resolveDefinition($id, DefinitionDecorator $definition)
+    {
+        if (!$this->container->hasDefinition($parent = $definition->getParent())) {
+            throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $id));
+        }
+
+        $parentDef = $this->container->getDefinition($parent);
+        if ($parentDef instanceof DefinitionDecorator) {
+            $parentDef = $this->resolveDefinition($parent, $parentDef);
+        }
+
+        $this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $id, $parent));
+        $def = new Definition();
+
+        // merge in parent definition
+        // purposely ignored attributes: scope, abstract, tags
+        $def->setClass($parentDef->getClass());
+        $def->setArguments($parentDef->getArguments());
+        $def->setMethodCalls($parentDef->getMethodCalls());
+        $def->setProperties($parentDef->getProperties());
+        $def->setFactoryClass($parentDef->getFactoryClass());
+        $def->setFactoryMethod($parentDef->getFactoryMethod());
+        $def->setFactoryService($parentDef->getFactoryService());
+        $def->setConfigurator($parentDef->getConfigurator());
+        $def->setFile($parentDef->getFile());
+        $def->setPublic($parentDef->isPublic());
+
+        // overwrite with values specified in the decorator
+        $changes = $definition->getChanges();
+        if (isset($changes['class'])) {
+            $def->setClass($definition->getClass());
+        }
+        if (isset($changes['factory_class'])) {
+            $def->setFactoryClass($definition->getFactoryClass());
+        }
+        if (isset($changes['factory_method'])) {
+            $def->setFactoryMethod($definition->getFactoryMethod());
+        }
+        if (isset($changes['factory_service'])) {
+            $def->setFactoryService($definition->getFactoryService());
+        }
+        if (isset($changes['configurator'])) {
+            $def->setConfigurator($definition->getConfigurator());
+        }
+        if (isset($changes['file'])) {
+            $def->setFile($definition->getFile());
+        }
+        if (isset($changes['public'])) {
+            $def->setPublic($definition->isPublic());
+        }
+
+        // merge arguments
+        foreach ($definition->getArguments() as $k => $v) {
+            if (is_numeric($k)) {
+                $def->addArgument($v);
+                continue;
+            }
+
+            if (0 !== strpos($k, 'index_')) {
+                throw new RuntimeException(sprintf('Invalid argument key "%s" found.', $k));
+            }
+
+            $index = (integer) substr($k, strlen('index_'));
+            $def->replaceArgument($index, $v);
+        }
+
+        // merge properties
+        foreach ($definition->getProperties() as $k => $v) {
+            $def->setProperty($k, $v);
+        }
+
+        // append method calls
+        if (count($calls = $definition->getMethodCalls()) > 0) {
+            $def->setMethodCalls(array_merge($def->getMethodCalls(), $calls));
+        }
+
+        // these attributes are always taken from the child
+        $def->setAbstract($definition->isAbstract());
+        $def->setScope($definition->getScope());
+        $def->setTags($definition->getTags());
+
+        // set new definition on container
+        $this->container->setDefinition($id, $def);
+
+        return $def;
+    }
+}