Issue #2497243 by Fabianx, znerol, fgm, Wim Leers, darol100, jhedstrom,...

Issue #2497243 by Fabianx, znerol, fgm, Wim Leers, darol100, jhedstrom, hussainweb, pfrenssen, neclimdul, jibran, Nitesh Sethia, dawehner, chx, catch, benjy, Aki Tendo: Replace Symfony container with a Drupal one, stored in cache

core/lib/Drupal/Component/DependencyInjection/Container.php

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\DependencyInjection\Container.
+ */
+
+namespace Drupal\Component\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\IntrospectableContainerInterface;
+use Symfony\Component\DependencyInjection\ScopeInterface;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Exception\ParameterNotFoundException;
+use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
+use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
+
+/**
+ * Provides a container optimized for Drupal's needs.
+ *
+ * This container implementation is compatible with the default Symfony
+ * dependency injection container and similar to the Symfony ContainerBuilder
+ * class, but optimized for speed.
+ *
+ * It is based on a PHP array container definition dumped as a
+ * performance-optimized machine-readable format.
+ *
+ * The best way to initialize this container is to use a Container Builder,
+ * compile it and then retrieve the definition via
+ * \Drupal\Component\DependencyInjection\Dumper\OptimizedPhpArrayDumper::getArray().
+ *
+ * The retrieved array can be cached safely and then passed to this container
+ * via the constructor.
+ *
+ * As the container is unfrozen by default, a second parameter can be passed to
+ * the container to "freeze" the parameter bag.
+ *
+ * This container is different in behavior from the default Symfony container in
+ * the following ways:
+ *
+ * - It only allows lowercase service and parameter names, though it does only
+ *   enforce it via assertions for performance reasons.
+ * - The following functions, that are not part of the interface, are explicitly
+ *   not supported: getParameterBag(), isFrozen(), compile(),
+ *   getAServiceWithAnIdByCamelCase().
+ * - The function getServiceIds() was added as it has a use-case in core and
+ *   contrib.
+ * - Scopes are explicitly not allowed, because Symfony 2.8 has deprecated
+ *   them and they will be removed in Symfony 3.0.
+ * - Synchronized services are explicitly not supported, because Symfony 2.8 has
+ *   deprecated them and they will be removed in Symfony 3.0.
+ *
+ * @ingroup container
+ */
+class Container implements IntrospectableContainerInterface {
+
+  /**
+   * The parameters of the container.
+   *
+   * @var array
+   */
+  protected $parameters = array();
+
+  /**
+   * The aliases of the container.
+   *
+   * @var array
+   */
+  protected $aliases = array();
+
+  /**
+   * The service definitions of the container.
+   *
+   * @var array
+   */
+  protected $serviceDefinitions = array();
+
+  /**
+   * The instantiated services.
+   *
+   * @var array
+   */
+  protected $services = array();
+
+  /**
+   * The instantiated private services.
+   *
+   * @var array
+   */
+  protected $privateServices = array();
+
+  /**
+   * The currently loading services.
+   *
+   * @var array
+   */
+  protected $loading = array();
+
+  /**
+   * Whether the container parameters can still be changed.
+   *
+   * For testing purposes the container needs to be changed.
+   *
+   * @var bool
+   */
+  protected $frozen = TRUE;
+
+  /**
+   * Constructs a new Container instance.
+   *
+   * @param array $container_definition
+   *   An array containing the following keys:
+   *   - aliases: The aliases of the container.
+   *   - parameters: The parameters of the container.
+   *   - services: The service definitions of the container.
+   *   - frozen: Whether the container definition came from a frozen
+   *     container builder or not.
+   *   - machine_format: Whether this container definition uses the optimized
+   *     machine-readable container format.
+   */
+  public function __construct(array $container_definition = array()) {
+    if (!empty($container_definition) && (!isset($container_definition['machine_format']) || $container_definition['machine_format'] !== TRUE)) {
+      throw new InvalidArgumentException('The non-optimized format is not supported by this class. Use an optimized machine-readable format instead, e.g. as produced by \Drupal\Component\DependencyInjection\Dumper\OptimizedPhpArrayDumper.');
+    }
+
+    $this->aliases = isset($container_definition['aliases']) ? $container_definition['aliases'] : array();
+    $this->parameters = isset($container_definition['parameters']) ? $container_definition['parameters'] : array();
+    $this->serviceDefinitions = isset($container_definition['services']) ? $container_definition['services'] : array();
+    $this->frozen = isset($container_definition['frozen']) ? $container_definition['frozen'] : FALSE;
+
+    // Register the service_container with itself.
+    $this->services['service_container'] = $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function get($id, $invalid_behavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+    if (isset($this->aliases[$id])) {
+      $id = $this->aliases[$id];
+    }
+
+    // Re-use shared service instance if it exists.
+    if (isset($this->services[$id]) || ($invalid_behavior === ContainerInterface::NULL_ON_INVALID_REFERENCE && array_key_exists($id, $this->services))) {
+      return $this->services[$id];
+    }
+
+    if (isset($this->loading[$id])) {
+      throw new ServiceCircularReferenceException($id, array_keys($this->loading));
+    }
+
+    $definition = isset($this->serviceDefinitions[$id]) ? $this->serviceDefinitions[$id] : NULL;
+
+    if (!$definition && $invalid_behavior === ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+      if (!$id) {
+        throw new ServiceNotFoundException($id);
+      }
+
+      throw new ServiceNotFoundException($id, NULL, NULL, $this->getServiceAlternatives($id));
+    }
+
+    // In case something else than ContainerInterface::NULL_ON_INVALID_REFERENCE
+    // is used, the actual wanted behavior is to re-try getting the service at a
+    // later point.
+    if (!$definition) {
+      return;
+    }
+
+    // Definition is a keyed array, so [0] is only defined when it is a
+    // serialized string.
+    if (isset($definition[0])) {
+      $definition = unserialize($definition);
+    }
+
+    // Now create the service.
+    $this->loading[$id] = TRUE;
+
+    try {
+      $service = $this->createService($definition, $id);
+    }
+    catch (\Exception $e) {
+      unset($this->loading[$id]);
+
+      // Remove a potentially shared service that was constructed incompletely.
+      if (array_key_exists($id, $this->services)) {
+        unset($this->services[$id]);
+      }
+
+      if (ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE !== $invalid_behavior) {
+        return;
+      }
+
+      throw $e;
+    }
+
+    unset($this->loading[$id]);
+
+    return $service;
+  }
+
+  /**
+   * Creates a service from a service definition.
+   *
+   * @param array $definition
+   *   The service definition to create a service from.
+   * @param string $id
+   *   The service identifier, necessary so it can be shared if its public.
+   *
+   * @return object
+   *   The service described by the service definition.
+   *
+   * @throws \Symfony\Component\DependencyInjection\Exception\RuntimeException
+   *   Thrown when the service is a synthetic service.
+   * @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
+   *   Thrown when the configurator callable in $definition['configurator'] is
+   *   not actually a callable.
+   * @throws \ReflectionException
+   *   Thrown when the service class takes more than 10 parameters to construct,
+   *   and cannot be instantiated.
+   */
+  protected function createService(array $definition, $id) {
+    if (isset($definition['synthetic']) && $definition['synthetic'] === TRUE) {
+      throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The service container does not know how to construct this service. The service will need to be set before it is first used.', $id));
+    }
+
+    $arguments = array();
+    if (isset($definition['arguments'])) {
+      $arguments = $definition['arguments'];
+
+      if ($arguments instanceof \stdClass) {
+        $arguments = $this->resolveServicesAndParameters($arguments);
+      }
+    }
+
+    if (isset($definition['file'])) {
+      $file = $this->frozen ? $definition['file'] : current($this->resolveServicesAndParameters(array($definition['file'])));
+      require_once $file;
+    }
+
+    if (isset($definition['factory'])) {
+      $factory = $definition['factory'];
+      if (is_array($factory)) {
+        $factory = $this->resolveServicesAndParameters(array($factory[0], $factory[1]));
+      }
+      elseif (!is_string($factory)) {
+        throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory', $id));
+      }
+
+      $service = call_user_func_array($factory, $arguments);
+    }
+    else {
+      $class = $this->frozen ? $definition['class'] : current($this->resolveServicesAndParameters(array($definition['class'])));
+      $length = isset($definition['arguments_count']) ? $definition['arguments_count'] : count($arguments);
+
+      // Optimize class instantiation for services with up to 10 parameters as
+      // ReflectionClass is noticeably slow.
+      switch ($length) {
+        case 0:
+          $service = new $class();
+          break;
+
+        case 1:
+          $service = new $class($arguments[0]);
+          break;
+
+        case 2:
+          $service = new $class($arguments[0], $arguments[1]);
+          break;
+
+        case 3:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2]);
+          break;
+
+        case 4:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3]);
+          break;
+
+        case 5:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4]);
+          break;
+
+        case 6:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5]);
+          break;
+
+        case 7:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6]);
+          break;
+
+        case 8:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6], $arguments[7]);
+          break;
+
+        case 9:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6], $arguments[7], $arguments[8]);
+          break;
+
+        case 10:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6], $arguments[7], $arguments[8], $arguments[9]);
+          break;
+
+        default:
+          $r = new \ReflectionClass($class);
+          $service = $r->newInstanceArgs($arguments);
+          break;
+      }
+    }
+
+    // Share the service if it is public.
+    if (!isset($definition['public']) || $definition['public'] !== FALSE) {
+      // Forward compatibility fix for Symfony 2.8 update.
+      if (!isset($definition['shared']) || $definition['shared'] !== FALSE) {
+        $this->services[$id] = $service;
+      }
+    }
+
+    if (isset($definition['calls'])) {
+      foreach ($definition['calls'] as $call) {
+        $method = $call[0];
+        $arguments = array();
+        if (!empty($call[1])) {
+          $arguments = $call[1];
+          if ($arguments instanceof \stdClass) {
+            $arguments = $this->resolveServicesAndParameters($arguments);
+          }
+        }
+        call_user_func_array(array($service, $method), $arguments);
+      }
+    }
+
+    if (isset($definition['properties'])) {
+      if ($definition['properties'] instanceof \stdClass) {
+        $definition['properties'] = $this->resolveServicesAndParameters($definition['properties']);
+      }
+      foreach ($definition['properties'] as $key => $value) {
+        $service->{$key} = $value;
+      }
+    }
+
+    if (isset($definition['configurator'])) {
+      $callable = $definition['configurator'];
+      if (is_array($callable)) {
+        $callable = $this->resolveServicesAndParameters($callable);
+      }
+
+      if (!is_callable($callable)) {
+        throw new InvalidArgumentException(sprintf('The configurator for class "%s" is not a callable.', get_class($service)));
+      }
+
+      call_user_func($callable, $service);
+    }
+
+    return $service;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function set($id, $service, $scope = ContainerInterface::SCOPE_CONTAINER) {
+    $this->services[$id] = $service;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function has($id) {
+    return isset($this->services[$id]) || isset($this->serviceDefinitions[$id]);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getParameter($name) {
+    if (!(isset($this->parameters[$name]) || array_key_exists($name, $this->parameters))) {
+      if (!$name) {
+        throw new ParameterNotFoundException($name);
+      }
+
+      throw new ParameterNotFoundException($name, NULL, NULL, NULL, $this->getParameterAlternatives($name));
+    }
+
+    return $this->parameters[$name];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function hasParameter($name) {
+    return isset($this->parameters[$name]) || array_key_exists($name, $this->parameters);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setParameter($name, $value) {
+    if ($this->frozen) {
+      throw new LogicException('Impossible to call set() on a frozen ParameterBag.');
+    }
+
+    $this->parameters[$name] = $value;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function initialized($id) {
+    if (isset($this->aliases[$id])) {
+      $id = $this->aliases[$id];
+    }
+
+    return isset($this->services[$id]) || array_key_exists($id, $this->services);
+  }
+
+  /**
+   * Resolves arguments that represent services or variables to the real values.
+   *
+   * @param array|\stdClass $arguments
+   *   The arguments to resolve.
+   *
+   * @return array
+   *   The resolved arguments.
+   *
+   * @throws \Symfony\Component\DependencyInjection\Exception\RuntimeException
+   *   If a parameter/service could not be resolved.
+   * @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
+   *   If an unknown type is met while resolving parameters and services.
+   */
+  protected function resolveServicesAndParameters($arguments) {
+    // Check if this collection needs to be resolved.
+    if ($arguments instanceof \stdClass) {
+      if ($arguments->type !== 'collection') {
+        throw new InvalidArgumentException(sprintf('Undefined type "%s" while resolving parameters and services.', $arguments->type));
+      }
+      // In case there is nothing to resolve, we are done here.
+      if (!$arguments->resolve) {
+        return $arguments->value;
+      }
+      $arguments = $arguments->value;
+    }
+
+    // Process the arguments.
+    foreach ($arguments as $key => $argument) {
+      // For this machine-optimized format, only \stdClass arguments are
+      // processed and resolved. All other values are kept as is.
+      if ($argument instanceof \stdClass) {
+        $type = $argument->type;
+
+        // Check for parameter.
+        if ($type == 'parameter') {
+          $name = $argument->name;
+          if (!isset($this->parameters[$name])) {
+            $arguments[$key] = $this->getParameter($name);
+            // This can never be reached as getParameter() throws an Exception,
+            // because we already checked that the parameter is not set above.
+          }
+
+          // Update argument.
+          $argument = $arguments[$key] = $this->parameters[$name];
+
+          // In case there is not a machine readable value (e.g. a service)
+          // behind this resolved parameter, continue.
+          if (!($argument instanceof \stdClass)) {
+            continue;
+          }
+
+          // Fall through.
+          $type = $argument->type;
+        }
+
+        // Create a service.
+        if ($type == 'service') {
+          $id = $argument->id;
+
+          // Does the service already exist?
+          if (isset($this->aliases[$id])) {
+            $id = $this->aliases[$id];
+          }
+
+          if (isset($this->services[$id])) {
+            $arguments[$key] = $this->services[$id];
+            continue;
+          }
+
+          // Return the service.
+          $arguments[$key] = $this->get($id, $argument->invalidBehavior);
+
+          continue;
+        }
+        // Create private service.
+        elseif ($type == 'private_service') {
+          $id = $argument->id;
+
+          // Does the private service already exist.
+          if (isset($this->privateServices[$id])) {
+            $arguments[$key] = $this->privateServices[$id];
+            continue;
+          }
+
+          // Create the private service.
+          $arguments[$key] = $this->createService($argument->value, $id);
+          if ($argument->shared) {
+            $this->privateServices[$id] = $arguments[$key];
+          }
+
+          continue;
+        }
+        // Check for collection.
+        elseif ($type == 'collection') {
+          $value = $argument->value;
+
+          // Does this collection need resolving?
+          if ($argument->resolve) {
+            $arguments[$key] = $this->resolveServicesAndParameters($value);
+          }
+          else {
+            $arguments[$key] = $value;
+          }
+
+          continue;
+        }
+
+        if ($type !== NULL) {
+          throw new InvalidArgumentException(sprintf('Undefined type "%s" while resolving parameters and services.', $type));
+        }
+      }
+    }
+
+    return $arguments;
+  }
+
+  /**
+   * Provides alternatives for a given array and key.
+   *
+   * @param string $search_key
+   *   The search key to get alternatives for.
+   * @param array $keys
+   *   The search space to search for alternatives in.
+   *
+   * @return string[]
+   *   An array of strings with suitable alternatives.
+   */
+  protected function getAlternatives($search_key, array $keys) {
+    $alternatives = array();
+    foreach ($keys as $key) {
+      $lev = levenshtein($search_key, $key);
+      if ($lev <= strlen($search_key) / 3 || strpos($key, $search_key) !== FALSE) {
+        $alternatives[] = $key;
+      }
+    }
+
+    return $alternatives;
+  }
+
+  /**
+   * Provides alternatives in case a service was not found.
+   *
+   * @param string $id
+   *   The service to get alternatives for.
+   *
+   * @return string[]
+   *   An array of strings with suitable alternatives.
+   */
+  protected function getServiceAlternatives($id) {
+    $all_service_keys = array_unique(array_merge(array_keys($this->services), array_keys($this->serviceDefinitions)));
+    return $this->getAlternatives($id, $all_service_keys);
+  }
+
+  /**
+   * Provides alternatives in case a parameter was not found.
+   *
+   * @param string $name
+   *   The parameter to get alternatives for.
+   *
+   * @return string[]
+   *   An array of strings with suitable alternatives.
+   */
+  protected function getParameterAlternatives($name) {
+    return $this->getAlternatives($name, array_keys($this->parameters));
+  }
+
+
+  /**
+   * {@inheritdoc}
+   */
+  public function enterScope($name) {
+    throw new \BadMethodCallException(sprintf("'%s' is not supported by Drupal 8.", __FUNCTION__));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function leaveScope($name) {
+    throw new \BadMethodCallException(sprintf("'%s' is not supported by Drupal 8.", __FUNCTION__));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function addScope(ScopeInterface $scope) {
+    throw new \BadMethodCallException(sprintf("'%s' is not supported by Drupal 8.", __FUNCTION__));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function hasScope($name) {
+    throw new \BadMethodCallException(sprintf("'%s' is not supported by Drupal 8.", __FUNCTION__));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isScopeActive($name) {
+    throw new \BadMethodCallException(sprintf("'%s' is not supported by Drupal 8.", __FUNCTION__));
+  }
+
+  /**
+   * Gets all defined service IDs.
+   *
+   * @return array
+   *   An array of all defined service IDs.
+   */
+  public function getServiceIds() {
+    return array_keys($this->serviceDefinitions + $this->services);
+  }
+
+}

core/lib/Drupal/Component/DependencyInjection/Dumper/OptimizedPhpArrayDumper.php

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\DependencyInjection\Dumper\OptimizedPhpArrayDumper.
+ */
+
+namespace Drupal\Component\DependencyInjection\Dumper;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Parameter;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Dumper\Dumper;
+use Symfony\Component\ExpressionLanguage\Expression;
+
+/**
+ * OptimizedPhpArrayDumper dumps a service container as a serialized PHP array.
+ *
+ * The format of this dumper is very similar to the internal structure of the
+ * ContainerBuilder, but based on PHP arrays and \stdClass objects instead of
+ * rich value objects for performance reasons.
+ *
+ * By removing the abstraction and optimizing some cases like deep collections,
+ * fewer classes need to be loaded, fewer function calls need to be executed and
+ * fewer run time checks need to be made.
+ *
+ * In addition to that, this container dumper treats private services as
+ * strictly private with their own private services storage, whereas in the
+ * Symfony service container builder and PHP dumper, shared private services can
+ * still be retrieved via get() from the container.
+ *
+ * It is machine-optimized, for a human-readable version based on this one see
+ * \Drupal\Component\DependencyInjection\Dumper\PhpArrayDumper.
+ *
+ * @see \Drupal\Component\DependencyInjection\Container
+ */
+class OptimizedPhpArrayDumper extends Dumper {
+
+  /**
+   * Whether to serialize service definitions or not.
+   *
+   * Service definitions are serialized by default to avoid having to
+   * unserialize the whole container on loading time, which improves early
+   * bootstrap performance for e.g. the page cache.
+   *
+   * @var bool
+   */
+  protected $serialize = TRUE;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function dump(array $options = array()) {
+    return serialize($this->getArray());
+  }
+
+  /**
+   * Gets the service container definition as a PHP array.
+   *
+   * @return array
+   *   A PHP array representation of the service container.
+   */
+  public function getArray() {
+    $definition = array();
+    $definition['aliases'] = $this->getAliases();
+    $definition['parameters'] = $this->getParameters();
+    $definition['services'] = $this->getServiceDefinitions();
+    $definition['frozen'] = $this->container->isFrozen();
+    $definition['machine_format'] = $this->supportsMachineFormat();
+    return $definition;
+  }
+
+  /**
+   * Gets the aliases as a PHP array.
+   *
+   * @return array
+   *   The aliases.
+   */
+  protected function getAliases() {
+    $alias_definitions = array();
+
+    $aliases = $this->container->getAliases();
+    foreach ($aliases as $alias => $id) {
+      $id = (string) $id;
+      while (isset($aliases[$id])) {
+        $id = (string) $aliases[$id];
+      }
+      $alias_definitions[$alias] = $id;
+    }
+
+    return $alias_definitions;
+  }
+
+  /**
+   * Gets parameters of the container as a PHP array.
+   *
+   * @return array
+   *   The escaped and prepared parameters of the container.
+   */
+  protected function getParameters() {
+    if (!$this->container->getParameterBag()->all()) {
+      return array();
+    }
+
+    $parameters = $this->container->getParameterBag()->all();
+    $is_frozen = $this->container->isFrozen();
+    return $this->prepareParameters($parameters, $is_frozen);
+  }
+
+  /**
+   * Gets services of the container as a PHP array.
+   *
+   * @return array
+   *   The service definitions.
+   */
+  protected function getServiceDefinitions() {
+    if (!$this->container->getDefinitions()) {
+      return array();
+    }
+
+    $services = array();
+    foreach ($this->container->getDefinitions() as $id => $definition) {
+      // Only store public service definitions, references to shared private
+      // services are handled in ::getReferenceCall().
+      if ($definition->isPublic()) {
+        $service_definition = $this->getServiceDefinition($definition);
+        $services[$id] = $this->serialize ? serialize($service_definition) : $service_definition;
+      }
+    }
+
+    return $services;
+  }
+
+  /**
+   * Prepares parameters for the PHP array dumping.
+   *
+   * @param array $parameters
+   *   An array of parameters.
+   * @param bool $escape
+   *   Whether keys with '%' should be escaped or not.
+   *
+   * @return array
+   *   An array of prepared parameters.
+   */
+  protected function prepareParameters(array $parameters, $escape = TRUE) {
+    $filtered = array();
+    foreach ($parameters as $key => $value) {
+      if (is_array($value)) {
+        $value = $this->prepareParameters($value, $escape);
+      }
+      elseif ($value instanceof Reference) {
+        $value = $this->dumpValue($value);
+      }
+
+      $filtered[$key] = $value;
+    }
+
+    return $escape ? $this->escape($filtered) : $filtered;
+  }
+
+  /**
+   * Escapes parameters.
+   *
+   * @param array $parameters
+   *   The parameters to escape for '%' characters.
+   *
+   * @return array
+   *   The escaped parameters.
+   */
+  protected function escape(array $parameters) {
+    $args = array();
+
+    foreach ($parameters as $key => $value) {
+      if (is_array($value)) {
+        $args[$key] = $this->escape($value);
+      }
+      elseif (is_string($value)) {
+        $args[$key] = str_replace('%', '%%', $value);
+      }
+      else {
+        $args[$key] = $value;
+      }
+    }
+
+    return $args;
+  }
+
+  /**
+   * Gets a service definition as PHP array.
+   *
+   * @param \Symfony\Component\DependencyInjection\Definition $definition
+   *   The definition to process.
+   *
+   * @return array
+   *   The service definition as PHP array.
+   *
+   * @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
+   *   Thrown when the definition is marked as decorated, or with an explicit
+   *   scope different from SCOPE_CONTAINER and SCOPE_PROTOTYPE.
+   */
+  protected function getServiceDefinition(Definition $definition) {
+    $service = array();
+    if ($definition->getClass()) {
+      $service['class'] = $definition->getClass();
+    }
+
+    if (!$definition->isPublic()) {
+      $service['public'] = FALSE;
+    }
+
+    if ($definition->getFile()) {
+      $service['file'] = $definition->getFile();
+    }
+
+    if ($definition->isSynthetic()) {
+      $service['synthetic'] = TRUE;
+    }
+
+    if ($definition->isLazy()) {
+      $service['lazy'] = TRUE;
+    }
+
+    if ($definition->getArguments()) {
+      $arguments = $definition->getArguments();
+      $service['arguments'] = $this->dumpCollection($arguments);
+      $service['arguments_count'] = count($arguments);
+    }
+    else {
+      $service['arguments_count'] = 0;
+    }
+
+    if ($definition->getProperties()) {
+      $service['properties'] = $this->dumpCollection($definition->getProperties());
+    }
+
+    if ($definition->getMethodCalls()) {
+      $service['calls'] = $this->dumpMethodCalls($definition->getMethodCalls());
+    }
+
+    if (($scope = $definition->getScope()) !== ContainerInterface::SCOPE_CONTAINER) {
+      if ($scope === ContainerInterface::SCOPE_PROTOTYPE) {
+        // Scope prototype has been replaced with 'shared' => FALSE.
+        // This is a Symfony 2.8 forward compatibility fix.
+        // Reference: https://github.com/symfony/symfony/blob/2.8/UPGRADE-2.8.md#dependencyinjection
+        $service['shared'] = FALSE;
+      }
+      else {
+        throw new InvalidArgumentException("The 'scope' definition is deprecated in Symfony 3.0 and not supported by Drupal 8.");
+      }
+    }
+
+    if (($decorated = $definition->getDecoratedService()) !== NULL) {
+      throw new InvalidArgumentException("The 'decorated' definition is not supported by the Drupal 8 run-time container. The Container Builder should have resolved that during the DecoratorServicePass compiler pass.");
+    }
+
+    if ($callable = $definition->getFactory()) {
+      $service['factory'] = $this->dumpCallable($callable);
+    }
+
+    if ($callable = $definition->getConfigurator()) {
+      $service['configurator'] = $this->dumpCallable($callable);
+    }
+
+    return $service;
+  }
+
+  /**
+   * Dumps method calls to a PHP array.
+   *
+   * @param array $calls
+   *   An array of method calls.
+   *
+   * @return array
+   *   The PHP array representation of the method calls.
+   */
+  protected function dumpMethodCalls(array $calls) {
+    $code = array();
+
+    foreach ($calls as $key => $call) {
+      $method = $call[0];
+      $arguments = array();
+      if (!empty($call[1])) {
+        $arguments = $this->dumpCollection($call[1]);
+      }
+
+      $code[$key] = [$method, $arguments];
+    }
+
+    return $code;
+  }
+
+
+  /**
+   * Dumps a collection to a PHP array.
+   *
+   * @param mixed $collection
+   *   A collection to process.
+   * @param bool &$resolve
+   *   Used for passing the information to the caller whether the given
+   *   collection needed to be resolved or not. This is used for optimizing
+   *   deep arrays that don't need to be traversed.
+   *
+   * @return \stdClass|array
+   *   The collection in a suitable format.
+   */
+  protected function dumpCollection($collection, &$resolve = FALSE) {
+    $code = array();
+
+    foreach ($collection as $key => $value) {
+      if (is_array($value)) {
+        $resolve_collection = FALSE;
+        $code[$key] = $this->dumpCollection($value, $resolve_collection);
+
+        if ($resolve_collection) {
+          $resolve = TRUE;
+        }
+      }
+      else {
+        if (is_object($value)) {
+          $resolve = TRUE;
+        }
+        $code[$key] = $this->dumpValue($value);
+      }
+    }
+
+    if (!$resolve) {
+      return $collection;
+    }
+
+    return (object) array(
+      'type' => 'collection',
+      'value' => $code,
+      'resolve' => $resolve,
+    );
+  }
+
+  /**
+   * Dumps callable to a PHP array.
+   *
+   * @param array|callable $callable
+   *   The callable to process.
+   *
+   * @return callable
+   *   The processed callable.
+   */
+  protected function dumpCallable($callable) {
+    if (is_array($callable)) {
+      $callable[0] = $this->dumpValue($callable[0]);
+      $callable = array($callable[0], $callable[1]);
+    }
+
+    return $callable;
+  }
+
+  /**
+   * Gets a private service definition in a suitable format.
+   *
+   * @param string $id
+   *   The ID of the service to get a private definition for.
+   * @param \Symfony\Component\DependencyInjection\Definition $definition
+   *   The definition to process.
+   * @param bool $shared
+   *   (optional) Whether the service will be shared with others.
+   *   By default this parameter is FALSE.
+   *
+   * @return \stdClass
+   *   A very lightweight private service value object.
+   */
+  protected function getPrivateServiceCall($id, Definition $definition, $shared = FALSE) {
+    $service_definition = $this->getServiceDefinition($definition);
+    if (!$id) {
+      $hash = hash('sha1', serialize($service_definition));
+      $id = 'private__' . $hash;
+    }
+    return (object) array(
+      'type' => 'private_service',
+      'id' => $id,
+      'value' => $service_definition,
+      'shared' => $shared,
+    );
+  }
+
+  /**
+   * Dumps the value to PHP array format.
+   *
+   * @param mixed $value
+   *   The value to dump.
+   *
+   * @return mixed
+   *   The dumped value in a suitable format.
+   *
+   * @throws RuntimeException
+   *   When trying to dump object or resource.
+   */
+  protected function dumpValue($value) {
+    if (is_array($value)) {
+      $code = array();
+      foreach ($value as $k => $v) {
+        $code[$k] = $this->dumpValue($v);
+      }
+
+      return $code;
+    }
+    elseif ($value instanceof Reference) {
+      return $this->getReferenceCall((string) $value, $value);
+    }
+    elseif ($value instanceof Definition) {
+      return $this->getPrivateServiceCall(NULL, $value);
+    }
+    elseif ($value instanceof Parameter) {
+      return $this->getParameterCall((string) $value);
+    }
+    elseif ($value instanceof Expression) {
+      throw new RuntimeException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
+    }
+    elseif (is_object($value)) {
+      // Drupal specific: Instantiated objects have a _serviceId parameter.
+      if (isset($value->_serviceId)) {
+        return $this->getReferenceCall($value->_serviceId);
+      }
+      throw new RuntimeException('Unable to dump a service container if a parameter is an object without _serviceId.');
+    }
+    elseif (is_resource($value)) {
+      throw new RuntimeException('Unable to dump a service container if a parameter is a resource.');
+    }
+
+    return $value;
+  }
+
+  /**
+   * Gets a service reference for a reference in a suitable PHP array format.
+   *
+   * The main difference is that this function treats references to private
+   * services differently and returns a private service reference instead of
+   * a normal reference.
+   *
+   * @param string $id
+   *   The ID of the service to get a reference for.
+   * @param \Symfony\Component\DependencyInjection\Reference|NULL $reference
+   *   (optional) The reference object to process; needed to get the invalid
+   *   behavior value.
+   *
+   * @return string|\stdClass
+   *   A suitable representation of the service reference.
+   */
+  protected function getReferenceCall($id, Reference $reference = NULL) {
+    $invalid_behavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
+
+    if ($reference !== NULL) {
+      $invalid_behavior = $reference->getInvalidBehavior();
+    }
+
+    // Private shared service.
+    $definition = $this->container->getDefinition($id);
+    if (!$definition->isPublic()) {
+      // The ContainerBuilder does not share a private service, but this means a
+      // new service is instantiated every time. Use a private shared service to
+      // circumvent the problem.
+      return $this->getPrivateServiceCall($id, $definition, TRUE);
+    }
+
+    return $this->getServiceCall($id, $invalid_behavior);
+  }
+
+  /**
+   * Gets a service reference for an ID in a suitable PHP array format.
+   *
+   * @param string $id
+   *   The ID of the service to get a reference for.
+   * @param int $invalid_behavior
+   *   (optional) The invalid behavior of the service.
+   *
+   * @return string|\stdClass
+   *   A suitable representation of the service reference.
+   */
+  protected function getServiceCall($id, $invalid_behavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+    return (object) array(
+      'type' => 'service',
+      'id' => $id,
+      'invalidBehavior' => $invalid_behavior,
+    );
+  }
+
+  /**
+   * Gets a parameter reference in a suitable PHP array format.
+   *
+   * @param string $name
+   *   The name of the parameter to get a reference for.
+   *
+   * @return string|\stdClass
+   *   A suitable representation of the parameter reference.
+   */
+  protected function getParameterCall($name) {
+    return (object) array(
+      'type' => 'parameter',
+      'name' => $name,
+    );
+  }
+
+  /**
+   * Whether this supports the machine-optimized format or not.
+   *
+   * @return bool
+   *   TRUE if this supports machine-optimized format, FALSE otherwise.
+   */
+  protected function supportsMachineFormat() {
+    return TRUE;
+  }
+
+}

core/lib/Drupal/Component/DependencyInjection/Dumper/PhpArrayDumper.php

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Component\DependencyInjection\Dumper\PhpArrayDumper.
+ */
+
+namespace Drupal\Component\DependencyInjection\Dumper;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * PhpArrayDumper dumps a service container as a PHP array.
+ *
+ * The format of this dumper is a human-readable serialized PHP array, which is
+ * very similar to the YAML based format, but based on PHP arrays instead of
+ * YAML strings.
+ *
+ * It is human-readable, for a machine-optimized version based on this one see
+ * \Drupal\Component\DependencyInjection\Dumper\OptimizedPhpArrayDumper.
+ *
+ * @see \Drupal\Component\DependencyInjection\PhpArrayContainer
+ */
+class PhpArrayDumper extends OptimizedPhpArrayDumper {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getArray() {
+    $this->serialize = FALSE;
+    return parent::getArray();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function dumpCollection($collection, &$resolve = FALSE) {
+    $code = array();
+
+    foreach ($collection as $key => $value) {
+      if (is_array($value)) {
+        $code[$key] = $this->dumpCollection($value);
+      }
+      else {
+        $code[$key] = $this->dumpValue($value);
+      }
+    }
+
+    return $code;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getServiceCall($id, $invalid_behavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+    if ($invalid_behavior !== ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+      return '@?' . $id;
+    }
+
+    return '@' . $id;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getParameterCall($name) {
+    return '%' . $name . '%';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function supportsMachineFormat() {
+    return FALSE;
+  }
+
+}

core/lib/Drupal/Component/DependencyInjection/PhpArrayContainer.php

+<?php
+/**
+ * @file
+ * Contains \Drupal\Component\DependencyInjection\PhpArrayContainer.
+ */
+
+namespace Drupal\Component\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+
+/**
+ * Provides a container optimized for Drupal's needs.
+ *
+ * This container implementation is compatible with the default Symfony
+ * dependency injection container and similar to the Symfony ContainerBuilder
+ * class, but optimized for speed.
+ *
+ * It is based on a human-readable PHP array container definition with a
+ * structure very similar to the YAML container definition.
+ *
+ * @see \Drupal\Component\DependencyInjection\Container
+ * @see \Drupal\Component\DependencyInjection\Dumper\PhpArrayDumper
+ * @see \Drupal\Component\DependencyInjection\DependencySerializationTrait
+ *
+ * @ingroup container
+ */
+class PhpArrayContainer extends Container {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $container_definition = array()) {
+    if (isset($container_definition['machine_format']) && $container_definition['machine_format'] === TRUE) {
+      throw new InvalidArgumentException('The machine-optimized format is not supported by this class. Use a human-readable format instead, e.g. as produced by \Drupal\Component\DependencyInjection\Dumper\PhpArrayDumper.');
+    }
+
+    // Do not call the parent's constructor as it would bail on the
+    // machine-optimized format.
+    $this->aliases = isset($container_definition['aliases']) ? $container_definition['aliases'] : array();
+    $this->parameters = isset($container_definition['parameters']) ? $container_definition['parameters'] : array();
+    $this->serviceDefinitions = isset($container_definition['services']) ? $container_definition['services'] : array();
+    $this->frozen = isset($container_definition['frozen']) ? $container_definition['frozen'] : FALSE;
+
+    // Register the service_container with itself.
+    $this->services['service_container'] = $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function createService(array $definition, $id) {
+    // This method is a verbatim copy of
+    // \Drupal\Component\DependencyInjection\Container::createService
+    // except for the following difference:
+    // - There are no instanceof checks on \stdClass, which are used in the
+    //   parent class to avoid resolving services and parameters when it is
+    //   known from dumping that there is nothing to resolve.
+    if (isset($definition['synthetic']) && $definition['synthetic'] === TRUE) {
+      throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The service container does not know how to construct this service. The service will need to be set before it is first used.', $id));
+    }
+
+    $arguments = array();
+    if (isset($definition['arguments'])) {
+      $arguments = $this->resolveServicesAndParameters($definition['arguments']);
+    }
+
+    if (isset($definition['file'])) {
+      $file = $this->frozen ? $definition['file'] : current($this->resolveServicesAndParameters(array($definition['file'])));
+      require_once $file;
+    }
+
+    if (isset($definition['factory'])) {
+      $factory = $definition['factory'];
+      if (is_array($factory)) {
+        $factory = $this->resolveServicesAndParameters(array($factory[0], $factory[1]));
+      }
+      elseif (!is_string($factory)) {
+        throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory', $id));
+      }
+
+      $service = call_user_func_array($factory, $arguments);
+    }
+    else {
+      $class = $this->frozen ? $definition['class'] : current($this->resolveServicesAndParameters(array($definition['class'])));
+      $length = isset($definition['arguments_count']) ? $definition['arguments_count'] : count($arguments);
+
+      // Optimize class instantiation for services with up to 10 parameters as
+      // reflection is noticeably slow.
+      switch ($length) {
+        case 0:
+          $service = new $class();
+          break;
+
+        case 1:
+          $service = new $class($arguments[0]);
+          break;
+
+        case 2:
+          $service = new $class($arguments[0], $arguments[1]);
+          break;
+
+        case 3:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2]);
+          break;
+
+        case 4:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3]);
+          break;
+
+        case 5:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4]);
+          break;
+
+        case 6:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5]);
+          break;
+
+        case 7:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6]);
+          break;
+
+        case 8:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6], $arguments[7]);
+          break;
+
+        case 9:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6], $arguments[7], $arguments[8]);
+          break;
+
+        case 10:
+          $service = new $class($arguments[0], $arguments[1], $arguments[2], $arguments[3], $arguments[4], $arguments[5], $arguments[6], $arguments[7], $arguments[8], $arguments[9]);
+          break;
+
+        default:
+          $r = new \ReflectionClass($class);
+          $service = $r->newInstanceArgs($arguments);
+          break;
+      }
+    }
+
+    // Share the service if it is public.
+    if (!isset($definition['public']) || $definition['public'] !== FALSE) {
+      // Forward compatibility fix for Symfony 2.8 update.
+      if (!isset($definition['shared']) || $definition['shared'] !== FALSE) {
+        $this->services[$id] = $service;
+      }
+    }
+
+    if (isset($definition['calls'])) {
+      foreach ($definition['calls'] as $call) {
+        $method = $call[0];
+        $arguments = array();
+        if (!empty($call[1])) {
+          $arguments = $call[1];
+          $arguments = $this->resolveServicesAndParameters($arguments);
+        }
+        call_user_func_array(array($service, $method), $arguments);
+      }
+    }
+
+    if (isset($definition['properties'])) {
+      $definition['properties'] = $this->resolveServicesAndParameters($definition['properties']);
+      foreach ($definition['properties'] as $key => $value) {
+        $service->{$key} = $value;
+      }
+    }
+
+    if (isset($definition['configurator'])) {
+      $callable = $definition['configurator'];
+      if (is_array($callable)) {
+        $callable = $this->resolveServicesAndParameters($callable);
+      }
+
+      if (!is_callable($callable)) {
+        throw new InvalidArgumentException(sprintf('The configurator for class "%s" is not a callable.', get_class($service)));
+      }
+
+      call_user_func($callable, $service);
+    }
+
+    return $service;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function resolveServicesAndParameters($arguments) {
+    // This method is different from the parent method only for the following
+    // cases:
+    // - A service is denoted by '@service' and not by a \stdClass object.
+    // - A parameter is denoted by '%parameter%' and not by a \stdClass object.
+    // - The depth of the tree representing the arguments is not known in
+    //   advance, so it needs to be fully traversed recursively.
+    foreach ($arguments as $key => $argument) {
+      if ($argument instanceof \stdClass) {
+        $type = $argument->type;
+
+        // Private services are a special flavor: In case a private service is
+        // only used by one other service, the ContainerBuilder uses a
+        // Definition object as an argument, which does not have an ID set.
+        // Therefore the format uses a \stdClass object to store the definition
+        // and to be able to create the service on the fly.
+        //
+        // Note: When constructing a private service by hand, 'id' must be set.
+        //
+        // The PhpArrayDumper just uses the hash of the private service
+        // definition to generate a unique ID.
+        //
+        // @see \Drupal\Component\DependecyInjection\Dumper\OptimizedPhpArrayDumper::getPrivateServiceCall
+        if ($type == 'private_service') {
+          $id = $argument->id;
+
+          // Check if the private service already exists - in case it is shared.
+          if (!empty($argument->shared) && isset($this->privateServices[$id])) {
+            $arguments[$key] = $this->privateServices[$id];
+            continue;
+          }
+
+          // Create a private service from a service definition.
+          $arguments[$key] = $this->createService($argument->value, $id);
+          if (!empty($argument->shared)) {
+            $this->privateServices[$id] = $arguments[$key];
+          }
+
+          continue;
+        }
+
+        if ($type !== NULL) {
+          throw new InvalidArgumentException("Undefined type '$type' while resolving parameters and services.");
+        }
+      }
+
+      if (is_array($argument)) {
+        $arguments[$key] = $this->resolveServicesAndParameters($argument);
+        continue;
+      }
+
+      if (!is_string($argument)) {
+        continue;
+      }
+
+      // Resolve parameters.
+      if ($argument[0] === '%') {
+        $name = substr($argument, 1, -1);
+        if (!isset($this->parameters[$name])) {
+          $arguments[$key] = $this->getParameter($name);
+          // This can never be reached as getParameter() throws an Exception,
+          // because we already checked that the parameter is not set above.
+        }
+        $argument = $this->parameters[$name];
+        $arguments[$key] = $argument;
+      }
+
+      // Resolve services.
+      if ($argument[0] === '@') {
+        $id = substr($argument, 1);
+        $invalid_behavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
+        if ($id[0] === '?') {
+          $id = substr($id, 1);
+          $invalid_behavior = ContainerInterface::NULL_ON_INVALID_REFERENCE;
+        }
+        if (isset($this->services[$id])) {
+          $arguments[$key] = $this->services[$id];
+        }
+        else {
+          $arguments[$key] = $this->get($id, $invalid_behavior);
+        }
+      }
+    }
+
+    return $arguments;
+  }
+
+}

core/lib/Drupal/Component/DependencyInjection/composer.json

+{
+  "name": "drupal/core-dependency-injection",
+  "description": "Dependency Injection container optimized for Drupal's needs.",
+  "keywords": ["drupal", "dependency injection"],
+  "type": "library",
+  "homepage": "https://www.drupal.org/project/drupal",
+  "license": "GPL-2.0+",
+  "support": {
+    "issues": "https://www.drupal.org/project/issues/drupal",
+    "irc": "irc://irc.freenode.net/drupal-contribute",
+    "source": "https://www.drupal.org/project/drupal/git-instructions"
+  },
+  "autoload": {
+    "psr-4": {
+      "Drupal\\Component\\DependencyInjection\\": ""
+    }
+  }
+}

core/lib/Drupal/Core/DependencyInjection/Container.php

@@ -7,17 +7,18 @@
 
 namespace Drupal\Core\DependencyInjection;
 
-use Symfony\Component\DependencyInjection\Container as SymfonyContainer;
+use Drupal\Component\DependencyInjection\Container as DrupalContainer;
+use Symfony\Component\DependencyInjection\ContainerInterface;
 
 /**
- * Extends the symfony container to set the service ID on the created object.
+ * Extends the Drupal container to set the service ID on the created object.
  */
-class Container extends SymfonyContainer {
+class Container extends DrupalContainer {
 
   /**
    * {@inheritdoc}
    */
-  public function set($id, $service, $scope = SymfonyContainer::SCOPE_CONTAINER) {
+  public function set($id, $service, $scope = ContainerInterface::SCOPE_CONTAINER) {
      parent::set($id, $service, $scope);
 
     // Ensure that the _serviceId property is set on synthetic services as well.

core/lib/Drupal/Core/DrupalKernel.php

@@ -23,12 +23,10 @@
 use Drupal\Core\Http\TrustedHostsRequestFactory;
 use Drupal\Core\Language\Language;
 use Drupal\Core\PageCache\RequestPolicyInterface;
-use Drupal\Core\PhpStorage\PhpStorageFactory;
 use Drupal\Core\Site\Settings;
 use Symfony\Cmf\Component\Routing\RouteObjectInterface;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
-use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
 use Symfony\Component\HttpFoundation\RedirectResponse;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\RequestStack;
@@ -53,6 +51,55 @@
  */
 class DrupalKernel implements DrupalKernelInterface, TerminableInterface {
 
+  /**
+   * Holds the class used for dumping the container to a PHP array.
+   *
+   * In combination with swapping the container class this is useful to e.g.
+   * dump to the human-readable PHP array format to debug the container
+   * definition in an easier way.
+   *
+   * @var string
+   */
+  protected $phpArrayDumperClass = '\Drupal\Component\DependencyInjection\Dumper\OptimizedPhpArrayDumper';
+
+  /**
+   * Holds the default bootstrap container definition.
+   *
+   * @var array
+   */
+  protected $defaultBootstrapContainerDefinition = [
+    'parameters' => [],
+    'services' => [
+      'database' => [
+        'class' => 'Drupal\Core\Database\Connection',
+        'factory' => 'Drupal\Core\Database\Database::getConnection',
+        'arguments' => ['default'],
+      ],
+      'cache.container' => [
+        'class' => 'Drupal\Core\Cache\DatabaseBackend',
+        'arguments' => ['@database', '@cache_tags_provider.container', 'container'],
+      ],
+      'cache_tags_provider.container' => [
+        'class' => 'Drupal\Core\Cache\DatabaseCacheTagsChecksum',
+        'arguments' => ['@database'],
+      ],
+    ],
+  ];
+
+  /**
+   * Holds the class used for instantiating the bootstrap container.
+   *
+   * @var string
+   */
+  protected $bootstrapContainerClass = '\Drupal\Component\DependencyInjection\PhpArrayContainer';
+
+  /**
+   * Holds the bootstrap container.
+   *
+   * @var \Symfony\Component\DependencyInjection\ContainerInterface
+   */
+  protected $bootstrapContainer;
+
   /**
    * Holds the container instance.
    *
@@ -97,13 +144,6 @@ class DrupalKernel implements DrupalKernelInterface, TerminableInterface {
    */
   protected $moduleData = array();
 
-  /**
-   * PHP code storage object to use for the compiled container.
-   *
-   * @var \Drupal\Component\PhpStorage\PhpStorageInterface
-   */
-  protected $storage;
-
   /**
    * The class loader object.
    *
@@ -397,6 +437,8 @@ public function boot() {
     FileCacheFactory::setConfiguration($configuration);
     FileCacheFactory::setPrefix(Settings::getApcuPrefix('file_cache', $this->root));
 
+    $this->bootstrapContainer = new $this->bootstrapContainerClass(Settings::get('bootstrap_container_definition', $this->defaultBootstrapContainerDefinition));
+
     // Initialize the container.
     $this->initializeContainer();
 
@@ -446,6 +488,19 @@ public function setContainer(ContainerInterface $container = NULL) {
     return $this;
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function getCachedContainerDefinition() {
+    $cache = $this->bootstrapContainer->get('cache.container')->get($this->getContainerCacheKey());
+
+    if ($cache) {
+      return $cache->data;
+    }
+
+    return NULL;
+  }
+
   /**
    * {@inheritdoc}
    */
@@ -706,24 +761,14 @@ public function updateModules(array $module_list, array $module_filenames = arra
   }
 
   /**
-   * Returns the classname based on environment.
+   * Returns the container cache key based on the environment.
    *
    * @return string
-   *   The class name.
+   *   The cache key used for the service container.
    */
-  protected function getClassName() {
-    $parts = array('service_container', $this->environment, hash('crc32b', \Drupal::VERSION . Settings::get('deployment_identifier')));
-    return implode('_', $parts);
-  }
-
-  /**
-   * Returns the container class namespace based on the environment.
-   *
-   * @return string
-   *   The class name.
-   */
-  protected function getClassNamespace() {
-    return 'Drupal\\Core\\DependencyInjection\\Container\\' . $this->environment;
+  protected function getContainerCacheKey() {
+    $parts = array('service_container', $this->environment, \Drupal::VERSION, Settings::get('deployment_identifier'));
+    return implode(':', $parts);
   }
 
   /**
@@ -766,32 +811,38 @@ protected function initializeContainer() {
     // boot the container injected via setContainer().
     // @see \Drupal\KernelTests\KernelTestBase::setUp()
     if (isset($this->container) && !$this->booted) {
-     $container = $this->container;
+      $container = $this->container;
     }
 
     // If the module list hasn't already been set in updateModules and we are
-    // not forcing a rebuild, then try and load the container from the disk.
+    // not forcing a rebuild, then try and load the container from the cache.
     if (empty($this->moduleList) && !$this->containerNeedsRebuild) {
-      $fully_qualified_class_name = '\\' . $this->getClassNamespace() . '\\' . $this->getClassName();
-
-      // First, try to load from storage.
-      if (!class_exists($fully_qualified_class_name, FALSE)) {
-        $this->storage()->load($this->getClassName() . '.php');
-      }
-      // If the load succeeded or the class already existed, use it.
-      if (class_exists($fully_qualified_class_name, FALSE)) {
-        $container = new $fully_qualified_class_name;
-      }
+      $container_definition = $this->getCachedContainerDefinition();
     }
 
-    // If there is still no container, build a new one from scratch.
-    if (!isset($container)) {
+    // If there is no container and no cached container definition, build a new
+    // one from scratch.
+    if (!isset($container) && !isset($container_definition)) {
       $container = $this->compileContainer();
+
+      // Only dump the container if dumping is allowed. This is useful for
+      // KernelTestBase, which never wants to use the real container, but always
+      // the container builder.
+      if ($this->allowDumping) {
+        $dumper = new $this->phpArrayDumperClass($container);
+        $container_definition = $dumper->getArray();
+      }
     }
 
     // The container was rebuilt successfully.
     $this->containerNeedsRebuild = FALSE;
 
+    // Only create a new class if we have a container definition.
+    if (isset($container_definition)) {
+      $class = Settings::get('container_base_class', '\Drupal\Core\DependencyInjection\Container');
+      $container = new $class($container_definition);
+    }
+
     $this->attachSynthetic($container);
 
     $this->container = $container;
@@ -816,9 +867,8 @@ protected function initializeContainer() {
     \Drupal::setContainer($this->container);
 
     // If needs dumping flag was set, dump the container.
-    $base_class = Settings::get('container_base_class', '\Drupal\Core\DependencyInjection\Container');
-    if ($this->containerNeedsDumping && !$this->dumpDrupalContainer($this->container, $base_class)) {
-      $this->container->get('logger.factory')->get('DrupalKernel')->notice('Container cannot be written to disk');
+    if ($this->containerNeedsDumping && !$this->cacheDrupalContainer($container_definition)) {
+      $this->container->get('logger.factory')->get('DrupalKernel')->notice('Container cannot be saved to cache.');
     }
 
     return $this->container;
@@ -1034,9 +1084,8 @@ public function invalidateContainer() {
       return;
     }
 
-    // Also wipe the PHP Storage caches, so that the container is rebuilt
-    // for the next request.
-    $this->storage()->deleteAll();
+    // Also remove the container definition from the cache backend.
+    $this->bootstrapContainer->get('cache.container')->deleteAll();
   }
 
   /**
@@ -1194,35 +1243,28 @@ protected function getContainerBuilder() {
   }
 
   /**
-   * Dumps the service container to PHP code in the config directory.
-   *
-   * This method is based on the dumpContainer method in the parent class, but
-   * that method is reliant on the Config component which we do not use here.
+   * Stores the container definition in a cache.
    *
-   * @param ContainerBuilder $container
-   *   The service container.
-   * @param string $baseClass
-   *   The name of the container's base class
+   * @param array $container_definition
+   *   The container definition to cache.
    *
    * @return bool
-   *   TRUE if the container was successfully dumped to disk.
+   *   TRUE if the container was successfully cached.
    */
-  protected function dumpDrupalContainer(ContainerBuilder $container, $baseClass) {
-    if (!$this->storage()->writeable()) {
-      return FALSE;
+  protected function cacheDrupalContainer(array $container_definition) {
+    $saved = TRUE;
+    try {
+      $this->bootstrapContainer->get('cache.container')->set($this->getContainerCacheKey(), $container_definition);
+    }
+    catch (\Exception $e) {
+      // There is no way to get from the Cache API if the cache set was
+      // successful or not, hence an Exception is caught and the caller informed
+      // about the error condition.
+      $saved = FALSE;
     }
-    // Cache the container.
-    $dumper = new PhpDumper($container);
-    $class = $this->getClassName();
-    $namespace = $this->getClassNamespace();
-    $content = $dumper->dump([
-      'class' => $class,
-      'base_class' => $baseClass,
-      'namespace' => $namespace,
-    ]);
-    return $this->storage()->save($class . '.php', $content);
-  }
 
+    return $saved;
+  }
 
   /**
    * Gets a http kernel from the container
@@ -1233,18 +1275,6 @@ protected function getHttpKernel() {
     return $this->container->get('http_kernel');
   }
 
-  /**
-   * Gets the PHP code storage object to use for the compiled container.
-   *
-   * @return \Drupal\Component\PhpStorage\PhpStorageInterface
-   */
-  protected function storage() {
-    if (!isset($this->storage)) {
-      $this->storage = PhpStorageFactory::get('service_container');
-    }
-    return $this->storage;
-  }
-
   /**
    * Returns the active configuration storage to use during building the container.
    *

core/lib/Drupal/Core/DrupalKernelInterface.php

@@ -58,6 +58,16 @@ public function getServiceProviders($origin);
    */
   public function getContainer();
 
+  /**
+   * Returns the cached container definition - if any.
+   *
+   * This also allows inspecting a built container for debugging purposes.
+   *
+   * @return array|NULL
+   *   The cached container definition or NULL if not found in cache.
+   */
+  public function getCachedContainerDefinition();
+
   /**
    * Set the current site path.
    *

core/modules/system/src/Tests/DrupalKernel/DrupalKernelTest.php

@@ -55,13 +55,11 @@ protected function prepareConfigDirectories() {
    *   A request object to use in booting the kernel.
    * @param array $modules_enabled
    *   A list of modules to enable on the kernel.
-   * @param bool $read_only
-   *   Build the kernel in a read only state.
    *
    * @return \Drupal\Core\DrupalKernel
    *   New kernel for testing.
    */
-  protected function getTestKernel(Request $request, array $modules_enabled = NULL, $read_only = FALSE) {
+  protected function getTestKernel(Request $request, array $modules_enabled = NULL) {
     // Manually create kernel to avoid replacing settings.
     $class_loader = require DRUPAL_ROOT . '/autoload.php';
     $kernel = DrupalKernel::createFromRequest($request, $class_loader, 'testing');
@@ -72,11 +70,6 @@ protected function getTestKernel(Request $request, array $modules_enabled = NULL
     }
     $kernel->boot();
 
-    if ($read_only) {
-      $php_storage = Settings::get('php_storage');
-      $php_storage['service_container']['class'] = 'Drupal\Component\PhpStorage\FileReadOnlyStorage';
-      $this->settingsSet('php_storage', $php_storage);
-    }
     return $kernel;
   }
 
@@ -98,24 +91,19 @@ public function testCompileDIC() {
     $kernel = $this->getTestKernel($request);
     $container = $kernel->getContainer();
     $refClass = new \ReflectionClass($container);
-    $is_compiled_container =
-      $refClass->getParentClass()->getName() == 'Drupal\Core\DependencyInjection\Container' &&
-      !$refClass->isSubclassOf('Symfony\Component\DependencyInjection\ContainerBuilder');
+    $is_compiled_container = !$refClass->isSubclassOf('Symfony\Component\DependencyInjection\ContainerBuilder');
     $this->assertTrue($is_compiled_container);
     // Verify that the list of modules is the same for the initial and the
     // compiled container.
     $module_list = array_keys($container->get('module_handler')->getModuleList());
     $this->assertEqual(array_values($modules_enabled), $module_list);
 
-    // Now use the read-only storage implementation, simulating a "production"
-    // environment.
-    $container = $this->getTestKernel($request, NULL, TRUE)
+    // Get the container another time, simulating a "production" environment.
+    $container = $this->getTestKernel($request, NULL)
       ->getContainer();
 
     $refClass = new \ReflectionClass($container);
-    $is_compiled_container =
-      $refClass->getParentClass()->getName() == 'Drupal\Core\DependencyInjection\Container' &&
-      !$refClass->isSubclassOf('Symfony\Component\DependencyInjection\ContainerBuilder');
+    $is_compiled_container = !$refClass->isSubclassOf('Symfony\Component\DependencyInjection\ContainerBuilder');
     $this->assertTrue($is_compiled_container);
 
     // Verify that the list of modules is the same for the initial and the
@@ -137,16 +125,16 @@ public function testCompileDIC() {
     // Add another module so that we can test that the new module's bundle is
     // registered to the new container.
     $modules_enabled['service_provider_test'] = 'service_provider_test';
-    $this->getTestKernel($request, $modules_enabled, TRUE);
+    $this->getTestKernel($request, $modules_enabled);
 
-    // Instantiate it a second time and we should still get a ContainerBuilder
-    // class because we are using the read-only PHP storage.
-    $kernel = $this->getTestKernel($request, $modules_enabled, TRUE);
+    // Instantiate it a second time and we should not get a ContainerBuilder
+    // class because we are loading the container definition from cache.
+    $kernel = $this->getTestKernel($request, $modules_enabled);
     $container = $kernel->getContainer();
 
     $refClass = new \ReflectionClass($container);
     $is_container_builder = $refClass->isSubclassOf('Symfony\Component\DependencyInjection\ContainerBuilder');
-    $this->assertTrue($is_container_builder, 'Container is a builder');
+    $this->assertFalse($is_container_builder, 'Container is not a builder');
 
     // Assert that the new module's bundle was registered to the new container.
     $this->assertTrue($container->has('service_provider_test_class'), 'Container has test service');

core/modules/system/src/Tests/ServiceProvider/ServiceProviderTest.php

@@ -7,14 +7,14 @@
 
 namespace Drupal\system\Tests\ServiceProvider;
 
-use Drupal\simpletest\WebTestBase;
+use Drupal\simpletest\KernelTestBase;
 
 /**
  * Tests service provider registration to the DIC.
  *
  * @group ServiceProvider
  */
-class ServiceProviderTest extends WebTestBase {
+class ServiceProviderTest extends KernelTestBase {
 
   /**
    * Modules to enable.
@@ -27,13 +27,9 @@ class ServiceProviderTest extends WebTestBase {
    * Tests that services provided by module service providers get registered to the DIC.
    */
   function testServiceProviderRegistration() {
-    $this->assertTrue(\Drupal::getContainer()->getDefinition('file.usage')->getClass() == 'Drupal\\service_provider_test\\TestFileUsage', 'Class has been changed');
+    $definition = $this->container->getDefinition('file.usage');
+    $this->assertTrue($definition->getClass() == 'Drupal\\service_provider_test\\TestFileUsage', 'Class has been changed');
     $this->assertTrue(\Drupal::hasService('service_provider_test_class'), 'The service_provider_test_class service has been registered to the DIC');
-    // The event subscriber method in the test class calls drupal_set_message with
-    // a message saying it has fired. This will fire on every page request so it
-    // should show up on the front page.
-    $this->drupalGet('');
-    $this->assertText(t('The service_provider_test event subscriber fired!'), 'The service_provider_test event subscriber fired');
   }
 
   /**

core/modules/system/src/Tests/ServiceProvider/ServiceProviderWebTest.php

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\system\Tests\ServiceProvider\ServiceProviderWebTest.
+ */
+
+namespace Drupal\system\Tests\ServiceProvider;
+
+use Drupal\simpletest\WebTestBase;
+
+/**
+ * Tests service provider registration to the DIC.
+ *
+ * @group ServiceProvider
+ */
+class ServiceProviderWebTest extends WebTestBase {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  public static $modules = array('file', 'service_provider_test');
+
+  /**
+   * Tests that module service providers get registered to the DIC.
+   *
+   * Also tests that services provided by module service providers get
+   * registered to the DIC.
+   */
+  public function testServiceProviderRegistrationIntegration() {
+    $this->assertTrue(\Drupal::hasService('service_provider_test_class'), 'The service_provider_test_class service has been registered to the DIC');
+    // The event subscriber method in the test class calls drupal_set_message()
+    // with a message saying it has fired. This will fire on every page request
+    // so it should show up on the front page.
+    $this->drupalGet('');
+    $this->assertText(t('The service_provider_test event subscriber fired!'), 'The service_provider_test event subscriber fired');
+  }
+
+}

core/modules/system/src/Tests/System/UncaughtExceptionTest.php

@@ -170,14 +170,7 @@ public function testErrorContainer() {
       'required' => TRUE,
     ];
     $this->writeSettings($settings);
-
-    // Need to rebuild the container, so the dumped container can be tested
-    // and not the container builder.
-    \Drupal::service('kernel')->rebuildContainer();
-
-    // Ensure that we don't use the now broken generated container on the test
-    // process.
-    \Drupal::setContainer($this->container);
+    \Drupal::service('kernel')->invalidateContainer();
 
     $this->expectedExceptionMessage = 'Argument 1 passed to Drupal\system\Tests\Bootstrap\ErrorContainer::Drupal\system\Tests\Bootstrap\{closur';
     $this->drupalGet('');
@@ -196,14 +189,7 @@ public function testExceptionContainer() {
       'required' => TRUE,
     ];
     $this->writeSettings($settings);
-
-    // Need to rebuild the container, so the dumped container can be tested
-    // and not the container builder.
-    \Drupal::service('kernel')->rebuildContainer();
-
-    // Ensure that we don't use the now broken generated container on the test
-    // process.
-    \Drupal::setContainer($this->container);
+    \Drupal::service('kernel')->invalidateContainer();
 
     $this->expectedExceptionMessage = 'Thrown exception during Container::get';
     $this->drupalGet('');

core/tests/Drupal/Tests/Component/DependencyInjection/Dumper/PhpArrayDumperTest.php

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\Component\DependencyInjection\Dumper\PhpArrayDumperTest.
+ */
+
+namespace Drupal\Tests\Component\DependencyInjection\Dumper;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * @coversDefaultClass \Drupal\Component\DependencyInjection\Dumper\PhpArrayDumper
+ * @group DependencyInjection
+ */
+class PhpArrayDumperTest extends OptimizedPhpArrayDumperTest {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUp() {
+    $this->machineFormat = FALSE;
+    $this->dumperClass = '\Drupal\Component\DependencyInjection\Dumper\PhpArrayDumper';
+    parent::setUp();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function serializeDefinition(array $service_definition) {
+    return $service_definition;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getServiceCall($id, $invalid_behavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+    if ($invalid_behavior !== ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+      return sprintf('@?%s', $id);
+    }
+
+    return sprintf('@%s', $id);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getParameterCall($name) {
+    return '%' . $name . '%';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getCollection($collection, $resolve = TRUE) {
+    return $collection;
+  }
+
+}

core/tests/Drupal/Tests/Component/DependencyInjection/Fixture/container_test_file_service_test_service_function.data

+<?php
+
+/**
+ * @file
+ * Contains a test function for container 'file' include testing.
+ */
+
+/**
+ * Test function for container testing.
+ *
+ * @return string
+ *   A string just for testing.
+ */
+function container_test_file_service_test_service_function() {
+  return 'Hello Container';
+}

core/tests/Drupal/Tests/Component/DependencyInjection/PhpArrayContainerTest.php

+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\Component\DependencyInjection\PhpArrayContainerTest.
+ */
+
+namespace Drupal\Tests\Component\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
+
+/**
+ * @coversDefaultClass \Drupal\Component\DependencyInjection\PhpArrayContainer
+ * @group DependencyInjection
+ */
+class PhpArrayContainerTest extends ContainerTest {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setUp() {
+    $this->machineFormat = FALSE;
+    $this->containerClass = '\Drupal\Component\DependencyInjection\PhpArrayContainer';
+    $this->containerDefinition = $this->getMockContainerDefinition();
+    $this->container = new $this->containerClass($this->containerDefinition);
+  }
+
+  /**
+   * Helper function to return a service definition.
+   */
+  protected function getServiceCall($id, $invalid_behavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+    if ($invalid_behavior !== ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE) {
+      return sprintf('@?%s', $id);
+    }
+
+    return sprintf('@%s', $id);
+  }
+
+  /**
+   * Helper function to return a service definition.
+   */
+  protected function getParameterCall($name) {
+    return '%' . $name . '%';
+  }
+
+  /**
+   * Helper function to return a machine-optimized '@notation'.
+   */
+  protected function getCollection($collection, $resolve = TRUE) {
+    return $collection;
+  }
+
+}