Nette\DI\Compiler::loadDefinition PHP Метод

    public static function loadDefinition(ServiceDefinition $definition, $config)
    {
        if ($config === NULL) {
            return;
        } elseif (is_string($config) && interface_exists($config)) {
            $config = ['class' => NULL, 'implement' => $config];
        } elseif ($config instanceof Statement && is_string($config->getEntity()) && interface_exists($config->getEntity())) {
            $config = ['class' => NULL, 'implement' => $config->getEntity(), 'factory' => array_shift($config->arguments)];
        } elseif (!is_array($config) || isset($config[0], $config[1])) {
            $config = ['class' => NULL, 'factory' => $config];
        }
        if (array_key_exists('create', $config)) {
            trigger_error("Key 'create' is deprecated, use 'factory' or 'class' in configuration.", E_USER_DEPRECATED);
            $config['factory'] = $config['create'];
            unset($config['create']);
        }
        $known = ['class', 'factory', 'arguments', 'setup', 'autowired', 'dynamic', 'inject', 'parameters', 'implement', 'run', 'tags'];
        if ($error = array_diff(array_keys($config), $known)) {
            $hints = array_filter(array_map(function ($error) use($known) {
                return Nette\Utils\ObjectMixin::getSuggestion($known, $error);
            }, $error));
            $hint = $hints ? ", did you mean '" . implode("', '", $hints) . "'?" : '.';
            throw new Nette\InvalidStateException(sprintf("Unknown key '%s' in definition of service{$hint}", implode("', '", $error)));
        }
        $config = Helpers::filterArguments($config);
        if (array_key_exists('class', $config) || array_key_exists('factory', $config)) {
            $definition->setClass(NULL);
            $definition->setFactory(NULL);
        }
        if (array_key_exists('class', $config)) {
            Validators::assertField($config, 'class', 'string|Nette\\DI\\Statement|null');
            if (!$config['class'] instanceof Statement) {
                $definition->setClass($config['class']);
            }
            $definition->setFactory($config['class']);
        }
        if (array_key_exists('factory', $config)) {
            Validators::assertField($config, 'factory', 'callable|Nette\\DI\\Statement|null');
            $definition->setFactory($config['factory']);
        }
        if (array_key_exists('arguments', $config)) {
            Validators::assertField($config, 'arguments', 'array');
            $arguments = $config['arguments'];
            if (!Config\Helpers::takeParent($arguments) && !Nette\Utils\Arrays::isList($arguments) && $definition->getFactory()) {
                $arguments += $definition->getFactory()->arguments;
            }
            $definition->setArguments($arguments);
        }
        if (isset($config['setup'])) {
            if (Config\Helpers::takeParent($config['setup'])) {
                $definition->setSetup([]);
            }
            Validators::assertField($config, 'setup', 'list');
            foreach ($config['setup'] as $id => $setup) {
                Validators::assert($setup, 'callable|Nette\\DI\\Statement|array:1', "setup item #{$id}");
                if (is_array($setup)) {
                    $setup = new Statement(key($setup), array_values($setup));
                }
                $definition->addSetup($setup);
            }
        }
        if (isset($config['parameters'])) {
            Validators::assertField($config, 'parameters', 'array');
            $definition->setParameters($config['parameters']);
        }
        if (isset($config['implement'])) {
            Validators::assertField($config, 'implement', 'string');
            $definition->setImplement($config['implement']);
            $definition->setAutowired(TRUE);
        }
        if (isset($config['autowired'])) {
            Validators::assertField($config, 'autowired', 'bool|string|array');
            $definition->setAutowired($config['autowired']);
        }
        if (isset($config['dynamic'])) {
            Validators::assertField($config, 'dynamic', 'bool');
            $definition->setDynamic($config['dynamic']);
        }
        if (isset($config['inject'])) {
            Validators::assertField($config, 'inject', 'bool');
            $definition->addTag(Extensions\InjectExtension::TAG_INJECT, $config['inject']);
        }
        if (isset($config['run'])) {
            trigger_error("Option 'run' is deprecated, use 'run' as tag.", E_USER_DEPRECATED);
            $config['tags']['run'] = (bool) $config['run'];
        }
        if (isset($config['tags'])) {
            Validators::assertField($config, 'tags', 'array');
            if (Config\Helpers::takeParent($config['tags'])) {
                $definition->setTags([]);
            }
            foreach ($config['tags'] as $tag => $attrs) {
                if (is_int($tag) && is_string($attrs)) {
                    $definition->addTag($attrs);
                } else {
                    $definition->addTag($tag, $attrs);
                }
            }
        }
    }