class CheckDefinitionValidityPass in Service Container 7.2

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 <[e-mail]>

Hierarchy

• class \Symfony\Component\DependencyInjection\Compiler\CheckDefinitionValidityPass implements CompilerPassInterface

1 file declares its use of CheckDefinitionValidityPass

CheckDefinitionValidityPassTest.php in modules/providers/service_container_symfony/lib/Symfony/Component/DependencyInjection/Tests/Compiler/CheckDefinitionValidityPassTest.php

File

modules/providers/service_container_symfony/lib/Symfony/Component/DependencyInjection/Compiler/CheckDefinitionValidityPass.php, line 31

Namespace

Symfony\Component\DependencyInjection\Compiler

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));
      }
      if ($definition
        ->getFactory() && ($definition
        ->getFactoryClass(false) || $definition
        ->getFactoryService(false) || $definition
        ->getFactoryMethod(false))) {
        throw new RuntimeException(sprintf('A service ("%s") can use either the old or the new factory syntax, not both.', $id));
      }

      // non-synthetic, non-abstract service has class
      if (!$definition
        ->isAbstract() && !$definition
        ->isSynthetic() && !$definition
        ->getClass()) {
        if ($definition
          ->getFactory() || $definition
          ->getFactoryClass(false) || $definition
          ->getFactoryService(false)) {
          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));
      }

      // tag attribute values must be scalars
      foreach ($definition
        ->getTags() as $name => $tags) {
        foreach ($tags as $attributes) {
          foreach ($attributes as $attribute => $value) {
            if (!is_scalar($value) && null !== $value) {
              throw new RuntimeException(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s", attribute "%s".', $id, $name, $attribute));
            }
          }
        }
      }
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
CheckDefinitionValidityPass::process	public	function	Processes the ContainerBuilder to validate the Definition. Overrides CompilerPassInterface::process