vendor/symfony/symfony/src/Symfony/Component/DependencyInjection/Loader/YamlFileLoader.php line 441

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\DependencyInjection\Loader;
  14. use Symfony\Component\DependencyInjection\Alias;
  15. use Symfony\Component\DependencyInjection\Argument\ArgumentInterface;
  16. use Symfony\Component\DependencyInjection\Argument\BoundArgument;
  17. use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
  18. use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
  19. use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
  20. use Symfony\Component\DependencyInjection\ChildDefinition;
  21. use Symfony\Component\DependencyInjection\ContainerBuilder;
  22. use Symfony\Component\DependencyInjection\ContainerInterface;
  23. use Symfony\Component\DependencyInjection\Definition;
  24. use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
  25. use Symfony\Component\DependencyInjection\Exception\RuntimeException;
  26. use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
  27. use Symfony\Component\DependencyInjection\Reference;
  28. use Symfony\Component\ExpressionLanguage\Expression;
  29. use Symfony\Component\Yaml\Exception\ParseException;
  30. use Symfony\Component\Yaml\Parser as YamlParser;
  31. use Symfony\Component\Yaml\Tag\TaggedValue;
  32. use Symfony\Component\Yaml\Yaml;
  34. /**
  35.  * YamlFileLoader loads YAML files service definitions.
  36.  *
  37.  * @author Fabien Potencier <fabien@symfony.com>
  38.  */
  39. class YamlFileLoader extends FileLoader
  40. {
  41.     private static $serviceKeywords = [
  42.         'alias' => 'alias',
  43.         'parent' => 'parent',
  44.         'class' => 'class',
  45.         'shared' => 'shared',
  46.         'synthetic' => 'synthetic',
  47.         'lazy' => 'lazy',
  48.         'public' => 'public',
  49.         'abstract' => 'abstract',
  50.         'deprecated' => 'deprecated',
  51.         'factory' => 'factory',
  52.         'file' => 'file',
  53.         'arguments' => 'arguments',
  54.         'properties' => 'properties',
  55.         'configurator' => 'configurator',
  56.         'calls' => 'calls',
  57.         'tags' => 'tags',
  58.         'decorates' => 'decorates',
  59.         'decoration_inner_name' => 'decoration_inner_name',
  60.         'decoration_priority' => 'decoration_priority',
  61.         'decoration_on_invalid' => 'decoration_on_invalid',
  62.         'autowire' => 'autowire',
  63.         'autoconfigure' => 'autoconfigure',
  64.         'bind' => 'bind',
  65.     ];
  67.     private static $prototypeKeywords = [
  68.         'resource' => 'resource',
  69.         'namespace' => 'namespace',
  70.         'exclude' => 'exclude',
  71.         'parent' => 'parent',
  72.         'shared' => 'shared',
  73.         'lazy' => 'lazy',
  74.         'public' => 'public',
  75.         'abstract' => 'abstract',
  76.         'deprecated' => 'deprecated',
  77.         'factory' => 'factory',
  78.         'arguments' => 'arguments',
  79.         'properties' => 'properties',
  80.         'configurator' => 'configurator',
  81.         'calls' => 'calls',
  82.         'tags' => 'tags',
  83.         'autowire' => 'autowire',
  84.         'autoconfigure' => 'autoconfigure',
  85.         'bind' => 'bind',
  86.     ];
  88.     private static $instanceofKeywords = [
  89.         'shared' => 'shared',
  90.         'lazy' => 'lazy',
  91.         'public' => 'public',
  92.         'properties' => 'properties',
  93.         'configurator' => 'configurator',
  94.         'calls' => 'calls',
  95.         'tags' => 'tags',
  96.         'autowire' => 'autowire',
  97.         'bind' => 'bind',
  98.     ];
  100.     private static $defaultsKeywords = [
  101.         'public' => 'public',
  102.         'tags' => 'tags',
  103.         'autowire' => 'autowire',
  104.         'autoconfigure' => 'autoconfigure',
  105.         'bind' => 'bind',
  106.     ];
  108.     private $yamlParser;
  110.     private $anonymousServicesCount;
  111.     private $anonymousServicesSuffix;
  113.     protected $autoRegisterAliasesForSinglyImplementedInterfaces = false;
  115.     /**
  116.      * {@inheritdoc}
  117.      */
  118.     public function load($resource, $type = null)
  119.     {
  120.         $path = $this->locator->locate($resource);
  122.         $content = $this->loadFile($path);
  124.         $this->container->fileExists($path);
  126.         // empty file
  127.         if (null === $content) {
  128.             return;
  129.         }
  131.         // imports
  132.         $this->parseImports($content, $path);
  134.         // parameters
  135.         if (isset($content['parameters'])) {
  136.             if (!\is_array($content['parameters'])) {
  137.                 throw new InvalidArgumentException(sprintf('The "parameters" key should contain an array in %s. Check your YAML syntax.', $path));
  138.             }
  140.             foreach ($content['parameters'] as $key => $value) {
  141.                 $this->container->setParameter($key, $this->resolveServices($value, $path, true));
  142.             }
  143.         }
  145.         // extensions
  146.         $this->loadFromExtensions($content);
  148.         // services
  149.         $this->anonymousServicesCount = 0;
  150.         $this->anonymousServicesSuffix = '~'.ContainerBuilder::hash($path);
  151.         $this->setCurrentDir(\dirname($path));
  152.         try {
  153.             $this->parseDefinitions($content, $path);
  154.         } finally {
  155.             $this->instanceof = [];
  156.             $this->registerAliasesForSinglyImplementedInterfaces();
  157.         }
  158.     }
  160.     /**
  161.      * {@inheritdoc}
  162.      */
  163.     public function supports($resource, $type = null)
  164.     {
  165.         if (!\is_string($resource)) {
  166.             return false;
  167.         }
  169.         if (null === $type && \in_array(pathinfo($resource, PATHINFO_EXTENSION), ['yaml', 'yml'], true)) {
  170.             return true;
  171.         }
  173.         return \in_array($type, ['yaml', 'yml'], true);
  174.     }
  176.     private function parseImports(array $content, string $file)
  177.     {
  178.         if (!isset($content['imports'])) {
  179.             return;
  180.         }
  182.         if (!\is_array($content['imports'])) {
  183.             throw new InvalidArgumentException(sprintf('The "imports" key should contain an array in %s. Check your YAML syntax.', $file));
  184.         }
  186.         $defaultDirectory = \dirname($file);
  187.         foreach ($content['imports'] as $import) {
  188.             if (!\is_array($import)) {
  189.                 $import = ['resource' => $import];
  190.             }
  191.             if (!isset($import['resource'])) {
  192.                 throw new InvalidArgumentException(sprintf('An import should provide a resource in %s. Check your YAML syntax.', $file));
  193.             }
  195.             $this->setCurrentDir($defaultDirectory);
  196.             $this->import($import['resource'], $import['type'] ?? null, $import['ignore_errors'] ?? false, $file);
  197.         }
  198.     }
  200.     private function parseDefinitions(array $content, string $file)
  201.     {
  202.         if (!isset($content['services'])) {
  203.             return;
  204.         }
  206.         if (!\is_array($content['services'])) {
  207.             throw new InvalidArgumentException(sprintf('The "services" key should contain an array in %s. Check your YAML syntax.', $file));
  208.         }
  210.         if (\array_key_exists('_instanceof', $content['services'])) {
  211.             $instanceof = $content['services']['_instanceof'];
  212.             unset($content['services']['_instanceof']);
  214.             if (!\is_array($instanceof)) {
  215.                 throw new InvalidArgumentException(sprintf('Service "_instanceof" key must be an array, "%s" given in "%s".', \gettype($instanceof), $file));
  216.             }
  217.             $this->instanceof = [];
  218.             $this->isLoadingInstanceof = true;
  219.             foreach ($instanceof as $id => $service) {
  220.                 if (!$service || !\is_array($service)) {
  221.                     throw new InvalidArgumentException(sprintf('Type definition "%s" must be a non-empty array within "_instanceof" in %s. Check your YAML syntax.', $id, $file));
  222.                 }
  223.                 if (\is_string($service) && 0 === strpos($service, '@')) {
  224.                     throw new InvalidArgumentException(sprintf('Type definition "%s" cannot be an alias within "_instanceof" in %s. Check your YAML syntax.', $id, $file));
  225.                 }
  226.                 $this->parseDefinition($id, $service, $file, []);
  227.             }
  228.         }
  230.         $this->isLoadingInstanceof = false;
  231.         $defaults = $this->parseDefaults($content, $file);
  232.         foreach ($content['services'] as $id => $service) {
  233.             $this->parseDefinition($id, $service, $file, $defaults);
  234.         }
  235.     }
  237.     /**
  238.      * @throws InvalidArgumentException
  239.      */
  240.     private function parseDefaults(array &$content, string $file): array
  241.     {
  242.         if (!\array_key_exists('_defaults', $content['services'])) {
  243.             return [];
  244.         }
  245.         $defaults = $content['services']['_defaults'];
  246.         unset($content['services']['_defaults']);
  248.         if (!\is_array($defaults)) {
  249.             throw new InvalidArgumentException(sprintf('Service "_defaults" key must be an array, "%s" given in "%s".', \gettype($defaults), $file));
  250.         }
  252.         foreach ($defaults as $key => $default) {
  253.             if (!isset(self::$defaultsKeywords[$key])) {
  254.                 throw new InvalidArgumentException(sprintf('The configuration key "%s" cannot be used to define a default value in "%s". Allowed keys are "%s".', $key, $file, implode('", "', self::$defaultsKeywords)));
  255.             }
  256.         }
  258.         if (isset($defaults['tags'])) {
  259.             if (!\is_array($tags = $defaults['tags'])) {
  260.                 throw new InvalidArgumentException(sprintf('Parameter "tags" in "_defaults" must be an array in %s. Check your YAML syntax.', $file));
  261.             }
  263.             foreach ($tags as $tag) {
  264.                 if (!\is_array($tag)) {
  265.                     $tag = ['name' => $tag];
  266.                 }
  268.                 if (!isset($tag['name'])) {
  269.                     throw new InvalidArgumentException(sprintf('A "tags" entry in "_defaults" is missing a "name" key in %s.', $file));
  270.                 }
  271.                 $name = $tag['name'];
  272.                 unset($tag['name']);
  274.                 if (!\is_string($name) || '' === $name) {
  275.                     throw new InvalidArgumentException(sprintf('The tag name in "_defaults" must be a non-empty string in %s.', $file));
  276.                 }
  278.                 foreach ($tag as $attribute => $value) {
  279.                     if (!is_scalar($value) && null !== $value) {
  280.                         throw new InvalidArgumentException(sprintf('Tag "%s", attribute "%s" in "_defaults" must be of a scalar-type in %s. Check your YAML syntax.', $name, $attribute, $file));
  281.                     }
  282.                 }
  283.             }
  284.         }
  286.         if (isset($defaults['bind'])) {
  287.             if (!\is_array($defaults['bind'])) {
  288.                 throw new InvalidArgumentException(sprintf('Parameter "bind" in "_defaults" must be an array in %s. Check your YAML syntax.', $file));
  289.             }
  291.             foreach ($this->resolveServices($defaults['bind'], $file) as $argument => $value) {
  292.                 $defaults['bind'][$argument] = new BoundArgument($value, true, BoundArgument::DEFAULTS_BINDING, $file);
  293.             }
  294.         }
  296.         return $defaults;
  297.     }
  299.     private function isUsingShortSyntax(array $service): bool
  300.     {
  301.         foreach ($service as $key => $value) {
  302.             if (\is_string($key) && ('' === $key || '$' !== $key[0])) {
  303.                 return false;
  304.             }
  305.         }
  307.         return true;
  308.     }
  310.     /**
  311.      * Parses a definition.
  312.      *
  313.      * @param array|string $service
  314.      *
  315.      * @throws InvalidArgumentException When tags are invalid
  316.      */
  317.     private function parseDefinition(string $id, $service, string $file, array $defaults)
  318.     {
  319.         if (preg_match('/^_[a-zA-Z0-9_]*$/', $id)) {
  320.             throw new InvalidArgumentException(sprintf('Service names that start with an underscore are reserved. Rename the "%s" service or define it in XML instead.', $id));
  321.         }
  323.         if (\is_string($service) && 0 === strpos($service, '@')) {
  324.             $this->container->setAlias($id, $alias = new Alias(substr($service, 1)));
  325.             if (isset($defaults['public'])) {
  326.                 $alias->setPublic($defaults['public']);
  327.             }
  329.             return;
  330.         }
  332.         if (\is_array($service) && $this->isUsingShortSyntax($service)) {
  333.             $service = ['arguments' => $service];
  334.         }
  336.         if (null === $service) {
  337.             $service = [];
  338.         }
  340.         if (!\is_array($service)) {
  341.             throw new InvalidArgumentException(sprintf('A service definition must be an array or a string starting with "@" but %s found for service "%s" in %s. Check your YAML syntax.', \gettype($service), $id, $file));
  342.         }
  344.         $this->checkDefinition($id, $service, $file);
  346.         if (isset($service['alias'])) {
  347.             $this->container->setAlias($id, $alias = new Alias($service['alias']));
  348.             if (\array_key_exists('public', $service)) {
  349.                 $alias->setPublic($service['public']);
  350.             } elseif (isset($defaults['public'])) {
  351.                 $alias->setPublic($defaults['public']);
  352.             }
  354.             foreach ($service as $key => $value) {
  355.                 if (!\in_array($key, ['alias', 'public', 'deprecated'])) {
  356.                     throw new InvalidArgumentException(sprintf('The configuration key "%s" is unsupported for the service "%s" which is defined as an alias in "%s". Allowed configuration keys for service aliases are "alias", "public" and "deprecated".', $key, $id, $file));
  357.                 }
  359.                 if ('deprecated' === $key) {
  360.                     $alias->setDeprecated(true, $value);
  361.                 }
  362.             }
  364.             return;
  365.         }
  367.         if ($this->isLoadingInstanceof) {
  368.             $definition = new ChildDefinition('');
  369.         } elseif (isset($service['parent'])) {
  370.             if (!empty($this->instanceof)) {
  371.                 throw new InvalidArgumentException(sprintf('The service "%s" cannot use the "parent" option in the same file where "_instanceof" configuration is defined as using both is not supported. Move your child definitions to a separate file.', $id));
  372.             }
  374.             foreach ($defaults as $k => $v) {
  375.                 if ('tags' === $k) {
  376.                     // since tags are never inherited from parents, there is no confusion
  377.                     // thus we can safely add them as defaults to ChildDefinition
  378.                     continue;
  379.                 }
  380.                 if ('bind' === $k) {
  381.                     throw new InvalidArgumentException(sprintf('Attribute "bind" on service "%s" cannot be inherited from "_defaults" when a "parent" is set. Move your child definitions to a separate file.', $id));
  382.                 }
  383.                 if (!isset($service[$k])) {
  384.                     throw new InvalidArgumentException(sprintf('Attribute "%s" on service "%s" cannot be inherited from "_defaults" when a "parent" is set. Move your child definitions to a separate file or define this attribute explicitly.', $k, $id));
  385.                 }
  386.             }
  388.             if ('' !== $service['parent'] && '@' === $service['parent'][0]) {
  389.                 throw new InvalidArgumentException(sprintf('The value of the "parent" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s").', $id, $service['parent'], substr($service['parent'], 1)));
  390.             }
  392.             $definition = new ChildDefinition($service['parent']);
  393.         } else {
  394.             $definition = new Definition();
  396.             if (isset($defaults['public'])) {
  397.                 $definition->setPublic($defaults['public']);
  398.             }
  399.             if (isset($defaults['autowire'])) {
  400.                 $definition->setAutowired($defaults['autowire']);
  401.             }
  402.             if (isset($defaults['autoconfigure'])) {
  403.                 $definition->setAutoconfigured($defaults['autoconfigure']);
  404.             }
  406.             $definition->setChanges([]);
  407.         }
  409.         if (isset($service['class'])) {
  410.             $definition->setClass($service['class']);
  411.         }
  413.         if (isset($service['shared'])) {
  414.             $definition->setShared($service['shared']);
  415.         }
  417.         if (isset($service['synthetic'])) {
  418.             $definition->setSynthetic($service['synthetic']);
  419.         }
  421.         if (isset($service['lazy'])) {
  422.             $definition->setLazy((bool) $service['lazy']);
  423.             if (\is_string($service['lazy'])) {
  424.                 $definition->addTag('proxy', ['interface' => $service['lazy']]);
  425.             }
  426.         }
  428.         if (isset($service['public'])) {
  429.             $definition->setPublic($service['public']);
  430.         }
  432.         if (isset($service['abstract'])) {
  433.             $definition->setAbstract($service['abstract']);
  434.         }
  436.         if (\array_key_exists('deprecated', $service)) {
  437.             $definition->setDeprecated(true, $service['deprecated']);
  438.         }
  440.         if (isset($service['factory'])) {
  441.             $definition->setFactory($this->parseCallable($service['factory'], 'factory', $id, $file));
  442.         }
  444.         if (isset($service['file'])) {
  445.             $definition->setFile($service['file']);
  446.         }
  448.         if (isset($service['arguments'])) {
  449.             $definition->setArguments($this->resolveServices($service['arguments'], $file));
  450.         }
  452.         if (isset($service['properties'])) {
  453.             $definition->setProperties($this->resolveServices($service['properties'], $file));
  454.         }
  456.         if (isset($service['configurator'])) {
  457.             $definition->setConfigurator($this->parseCallable($service['configurator'], 'configurator', $id, $file));
  458.         }
  460.         if (isset($service['calls'])) {
  461.             if (!\is_array($service['calls'])) {
  462.                 throw new InvalidArgumentException(sprintf('Parameter "calls" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
  463.             }
  465.             foreach ($service['calls'] as $k => $call) {
  466.                 if (!\is_array($call) && (!\is_string($k) || !$call instanceof TaggedValue)) {
  467.                     throw new InvalidArgumentException(sprintf('Invalid method call for service "%s": expected map or array, %s given in %s.', $id, $call instanceof TaggedValue ? '!'.$call->getTag() : \gettype($call), $file));
  468.                 }
  470.                 if (\is_string($k)) {
  471.                     throw new InvalidArgumentException(sprintf('Invalid method call for service "%s", did you forgot a leading dash before "%s: ..." in %s?', $id, $k, $file));
  472.                 }
  474.                 if (isset($call['method'])) {
  475.                     $method = $call['method'];
  476.                     $args = $call['arguments'] ?? [];
  477.                     $returnsClone = $call['returns_clone'] ?? false;
  478.                 } else {
  479.                     if (1 === \count($call) && \is_string(key($call))) {
  480.                         $method = key($call);
  481.                         $args = $call[$method];
  483.                         if ($args instanceof TaggedValue) {
  484.                             if ('returns_clone' !== $args->getTag()) {
  485.                                 throw new InvalidArgumentException(sprintf('Unsupported tag "!%s", did you mean "!returns_clone" for service "%s" in %s?', $args->getTag(), $id, $file));
  486.                             }
  488.                             $returnsClone = true;
  489.                             $args = $args->getValue();
  490.                         } else {
  491.                             $returnsClone = false;
  492.                         }
  493.                     } elseif (empty($call[0])) {
  494.                         throw new InvalidArgumentException(sprintf('Invalid call for service "%s": the method must be defined as the first index of an array or as the only key of a map in %s.', $id, $file));
  495.                     } else {
  496.                         $method = $call[0];
  497.                         $args = $call[1] ?? [];
  498.                         $returnsClone = $call[2] ?? false;
  499.                     }
  500.                 }
  502.                 if (!\is_array($args)) {
  503.                     throw new InvalidArgumentException(sprintf('The second parameter for function call "%s" must be an array of its arguments for service "%s" in %s. Check your YAML syntax.', $method, $id, $file));
  504.                 }
  506.                 $args = $this->resolveServices($args, $file);
  507.                 $definition->addMethodCall($method, $args, $returnsClone);
  508.             }
  509.         }
  511.         $tags = isset($service['tags']) ? $service['tags'] : [];
  512.         if (!\is_array($tags)) {
  513.             throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
  514.         }
  516.         if (isset($defaults['tags'])) {
  517.             $tags = array_merge($tags, $defaults['tags']);
  518.         }
  520.         foreach ($tags as $tag) {
  521.             if (!\is_array($tag)) {
  522.                 $tag = ['name' => $tag];
  523.             }
  525.             if (!isset($tag['name'])) {
  526.                 throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file));
  527.             }
  528.             $name = $tag['name'];
  529.             unset($tag['name']);
  531.             if (!\is_string($name) || '' === $name) {
  532.                 throw new InvalidArgumentException(sprintf('The tag name for service "%s" in %s must be a non-empty string.', $id, $file));
  533.             }
  535.             foreach ($tag as $attribute => $value) {
  536.                 if (!is_scalar($value) && null !== $value) {
  537.                     throw new InvalidArgumentException(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s", attribute "%s" in %s. Check your YAML syntax.', $id, $name, $attribute, $file));
  538.                 }
  539.             }
  541.             $definition->addTag($name, $tag);
  542.         }
  544.         if (null !== $decorates = $service['decorates'] ?? null) {
  545.             if ('' !== $decorates && '@' === $decorates[0]) {
  546.                 throw new InvalidArgumentException(sprintf('The value of the "decorates" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s").', $id, $service['decorates'], substr($decorates, 1)));
  547.             }
  549.             $decorationOnInvalid = \array_key_exists('decoration_on_invalid', $service) ? $service['decoration_on_invalid'] : 'exception';
  550.             if ('exception' === $decorationOnInvalid) {
  551.                 $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
  552.             } elseif ('ignore' === $decorationOnInvalid) {
  553.                 $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
  554.             } elseif (null === $decorationOnInvalid) {
  555.                 $invalidBehavior = ContainerInterface::NULL_ON_INVALID_REFERENCE;
  556.             } elseif ('null' === $decorationOnInvalid) {
  557.                 throw new InvalidArgumentException(sprintf('Invalid value "%s" for attribute "decoration_on_invalid" on service "%s". Did you mean null (without quotes) in "%s"?', $decorationOnInvalid, $id, $file));
  558.             } else {
  559.                 throw new InvalidArgumentException(sprintf('Invalid value "%s" for attribute "decoration_on_invalid" on service "%s". Did you mean "exception", "ignore" or null in "%s"?', $decorationOnInvalid, $id, $file));
  560.             }
  562.             $renameId = isset($service['decoration_inner_name']) ? $service['decoration_inner_name'] : null;
  563.             $priority = isset($service['decoration_priority']) ? $service['decoration_priority'] : 0;
  565.             $definition->setDecoratedService($decorates, $renameId, $priority, $invalidBehavior);
  566.         }
  568.         if (isset($service['autowire'])) {
  569.             $definition->setAutowired($service['autowire']);
  570.         }
  572.         if (isset($defaults['bind']) || isset($service['bind'])) {
  573.             // deep clone, to avoid multiple process of the same instance in the passes
  574.             $bindings = isset($defaults['bind']) ? unserialize(serialize($defaults['bind'])) : [];
  576.             if (isset($service['bind'])) {
  577.                 if (!\is_array($service['bind'])) {
  578.                     throw new InvalidArgumentException(sprintf('Parameter "bind" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
  579.                 }
  581.                 $bindings = array_merge($bindings, $this->resolveServices($service['bind'], $file));
  582.                 $bindingType = $this->isLoadingInstanceof ? BoundArgument::INSTANCEOF_BINDING : BoundArgument::SERVICE_BINDING;
  583.                 foreach ($bindings as $argument => $value) {
  584.                     if (!$value instanceof BoundArgument) {
  585.                         $bindings[$argument] = new BoundArgument($value, true, $bindingType, $file);
  586.                     }
  587.                 }
  588.             }
  590.             $definition->setBindings($bindings);
  591.         }
  593.         if (isset($service['autoconfigure'])) {
  594.             if (!$definition instanceof ChildDefinition) {
  595.                 $definition->setAutoconfigured($service['autoconfigure']);
  596.             } elseif ($service['autoconfigure']) {
  597.                 throw new InvalidArgumentException(sprintf('The service "%s" cannot have a "parent" and also have "autoconfigure". Try setting "autoconfigure: false" for the service.', $id));
  598.             }
  599.         }
  601.         if (\array_key_exists('namespace', $service) && !\array_key_exists('resource', $service)) {
  602.             throw new InvalidArgumentException(sprintf('A "resource" attribute must be set when the "namespace" attribute is set for service "%s" in %s. Check your YAML syntax.', $id, $file));
  603.         }
  605.         if (\array_key_exists('resource', $service)) {
  606.             if (!\is_string($service['resource'])) {
  607.                 throw new InvalidArgumentException(sprintf('A "resource" attribute must be of type string for service "%s" in %s. Check your YAML syntax.', $id, $file));
  608.             }
  609.             $exclude = isset($service['exclude']) ? $service['exclude'] : null;
  610.             $namespace = isset($service['namespace']) ? $service['namespace'] : $id;
  611.             $this->registerClasses($definition, $namespace, $service['resource'], $exclude);
  612.         } else {
  613.             $this->setDefinition($id, $definition);
  614.         }
  615.     }
  617.     /**
  618.      * Parses a callable.
  619.      *
  620.      * @param string|array $callable A callable reference
  621.      *
  622.      * @throws InvalidArgumentException When errors occur
  623.      *
  624.      * @return string|array|Reference A parsed callable
  625.      */
  626.     private function parseCallable($callable, string $parameter, string $id, string $file)
  627.     {
  628.         if (\is_string($callable)) {
  629.             if ('' !== $callable && '@' === $callable[0]) {
  630.                 if (false === strpos($callable, ':')) {
  631.                     return [$this->resolveServices($callable, $file), '__invoke'];
  632.                 }
  634.                 throw new InvalidArgumentException(sprintf('The value of the "%s" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s" in "%s").', $parameter, $id, $callable, substr($callable, 1), $file));
  635.             }
  637.             if (false !== strpos($callable, ':') && false === strpos($callable, '::')) {
  638.                 $parts = explode(':', $callable);
  640.                 @trigger_error(sprintf('Using short %s syntax for service "%s" is deprecated since Symfony 4.4, use "[\'@%s\', \'%s\']" instead.', $parameter, $id, ...$parts), E_USER_DEPRECATED);
  642.                 return [$this->resolveServices('@'.$parts[0], $file), $parts[1]];
  643.             }
  645.             return $callable;
  646.         }
  648.         if (\is_array($callable)) {
  649.             if (isset($callable[0]) && isset($callable[1])) {
  650.                 return [$this->resolveServices($callable[0], $file), $callable[1]];
  651.             }
  653.             if ('factory' === $parameter && isset($callable[1]) && null === $callable[0]) {
  654.                 return $callable;
  655.             }
  657.             throw new InvalidArgumentException(sprintf('Parameter "%s" must contain an array with two elements for service "%s" in %s. Check your YAML syntax.', $parameter, $id, $file));
  658.         }
  660.         throw new InvalidArgumentException(sprintf('Parameter "%s" must be a string or an array for service "%s" in %s. Check your YAML syntax.', $parameter, $id, $file));
  661.     }
  663.     /**
  664.      * Loads a YAML file.
  665.      *
  666.      * @param string $file
  667.      *
  668.      * @return array The file content
  669.      *
  670.      * @throws InvalidArgumentException when the given file is not a local file or when it does not exist
  671.      */
  672.     protected function loadFile($file)
  673.     {
  674.         if (!class_exists('Symfony\Component\Yaml\Parser')) {
  675.             throw new RuntimeException('Unable to load YAML config files as the Symfony Yaml Component is not installed.');
  676.         }
  678.         if (!stream_is_local($file)) {
  679.             throw new InvalidArgumentException(sprintf('This is not a local file "%s".', $file));
  680.         }
  682.         if (!file_exists($file)) {
  683.             throw new InvalidArgumentException(sprintf('The file "%s" does not exist.', $file));
  684.         }
  686.         if (null === $this->yamlParser) {
  687.             $this->yamlParser = new YamlParser();
  688.         }
  690.         try {
  691.             $configuration = $this->yamlParser->parseFile($file, Yaml::PARSE_CONSTANT | Yaml::PARSE_CUSTOM_TAGS);
  692.         } catch (ParseException $e) {
  693.             throw new InvalidArgumentException(sprintf('The file "%s" does not contain valid YAML: %s', $file, $e->getMessage()), 0, $e);
  694.         }
  696.         return $this->validate($configuration, $file);
  697.     }
  699.     /**
  700.      * Validates a YAML file.
  701.      *
  702.      * @throws InvalidArgumentException When service file is not valid
  703.      */
  704.     private function validate($content, string $file): ?array
  705.     {
  706.         if (null === $content) {
  707.             return $content;
  708.         }
  710.         if (!\is_array($content)) {
  711.             throw new InvalidArgumentException(sprintf('The service file "%s" is not valid. It should contain an array. Check your YAML syntax.', $file));
  712.         }
  714.         foreach ($content as $namespace => $data) {
  715.             if (\in_array($namespace, ['imports', 'parameters', 'services'])) {
  716.                 continue;
  717.             }
  719.             if (!$this->container->hasExtension($namespace)) {
  720.                 $extensionNamespaces = array_filter(array_map(function (ExtensionInterface $ext) { return $ext->getAlias(); }, $this->container->getExtensions()));
  721.                 throw new InvalidArgumentException(sprintf('There is no extension able to load the configuration for "%s" (in %s). Looked for namespace "%s", found %s', $namespace, $file, $namespace, $extensionNamespaces ? sprintf('"%s"', implode('", "', $extensionNamespaces)) : 'none'));
  722.             }
  723.         }
  725.         return $content;
  726.     }
  728.     /**
  729.      * Resolves services.
  730.      *
  731.      * @return array|string|Reference|ArgumentInterface
  732.      */
  733.     private function resolveServices($value, string $file, bool $isParameter = false)
  734.     {
  735.         if ($value instanceof TaggedValue) {
  736.             $argument = $value->getValue();
  737.             if ('iterator' === $value->getTag()) {
  738.                 if (!\is_array($argument)) {
  739.                     throw new InvalidArgumentException(sprintf('"!iterator" tag only accepts sequences in "%s".', $file));
  740.                 }
  741.                 $argument = $this->resolveServices($argument, $file, $isParameter);
  742.                 try {
  743.                     return new IteratorArgument($argument);
  744.                 } catch (InvalidArgumentException $e) {
  745.                     throw new InvalidArgumentException(sprintf('"!iterator" tag only accepts arrays of "@service" references in "%s".', $file));
  746.                 }
  747.             }
  748.             if ('service_locator' === $value->getTag()) {
  749.                 if (!\is_array($argument)) {
  750.                     throw new InvalidArgumentException(sprintf('"!service_locator" tag only accepts maps in "%s".', $file));
  751.                 }
  753.                 $argument = $this->resolveServices($argument, $file, $isParameter);
  755.                 try {
  756.                     return new ServiceLocatorArgument($argument);
  757.                 } catch (InvalidArgumentException $e) {
  758.                     throw new InvalidArgumentException(sprintf('"!service_locator" tag only accepts maps of "@service" references in "%s".', $file));
  759.                 }
  760.             }
  761.             if (\in_array($value->getTag(), ['tagged', 'tagged_iterator', 'tagged_locator'], true)) {
  762.                 $forLocator = 'tagged_locator' === $value->getTag();
  764.                 if (\is_array($argument) && isset($argument['tag']) && $argument['tag']) {
  765.                     if ($diff = array_diff(array_keys($argument), ['tag', 'index_by', 'default_index_method', 'default_priority_method'])) {
  766.                         throw new InvalidArgumentException(sprintf('"!%s" tag contains unsupported key "%s"; supported ones are "tag", "index_by", "default_index_method", and "default_priority_method".', $value->getTag(), implode('"", "', $diff)));
  767.                     }
  769.                     $argument = new TaggedIteratorArgument($argument['tag'], $argument['index_by'] ?? null, $argument['default_index_method'] ?? null, $forLocator, $argument['default_priority_method'] ?? null);
  770.                 } elseif (\is_string($argument) && $argument) {
  771.                     $argument = new TaggedIteratorArgument($argument, null, null, $forLocator);
  772.                 } else {
  773.                     throw new InvalidArgumentException(sprintf('"!%s" tags only accept a non empty string or an array with a key "tag" in "%s".', $value->getTag(), $file));
  774.                 }
  776.                 if ($forLocator) {
  777.                     $argument = new ServiceLocatorArgument($argument);
  778.                 }
  780.                 return $argument;
  781.             }
  782.             if ('service' === $value->getTag()) {
  783.                 if ($isParameter) {
  784.                     throw new InvalidArgumentException(sprintf('Using an anonymous service in a parameter is not allowed in "%s".', $file));
  785.                 }
  787.                 $isLoadingInstanceof = $this->isLoadingInstanceof;
  788.                 $this->isLoadingInstanceof = false;
  789.                 $instanceof = $this->instanceof;
  790.                 $this->instanceof = [];
  792.                 $id = sprintf('.%d_%s', ++$this->anonymousServicesCount, preg_replace('/^.*\\\\/', '', isset($argument['class']) ? $argument['class'] : '').$this->anonymousServicesSuffix);
  793.                 $this->parseDefinition($id, $argument, $file, []);
  795.                 if (!$this->container->hasDefinition($id)) {
  796.                     throw new InvalidArgumentException(sprintf('Creating an alias using the tag "!service" is not allowed in "%s".', $file));
  797.                 }
  799.                 $this->container->getDefinition($id)->setPublic(false);
  801.                 $this->isLoadingInstanceof = $isLoadingInstanceof;
  802.                 $this->instanceof = $instanceof;
  804.                 return new Reference($id);
  805.             }
  807.             throw new InvalidArgumentException(sprintf('Unsupported tag "!%s".', $value->getTag()));
  808.         }
  810.         if (\is_array($value)) {
  811.             foreach ($value as $k => $v) {
  812.                 $value[$k] = $this->resolveServices($v, $file, $isParameter);
  813.             }
  814.         } elseif (\is_string($value) && 0 === strpos($value, '@=')) {
  815.             if (!class_exists(Expression::class)) {
  816.                 throw new \LogicException(sprintf('The "@=" expression syntax cannot be used without the ExpressionLanguage component. Try running "composer require symfony/expression-language".'));
  817.             }
  819.             return new Expression(substr($value, 2));
  820.         } elseif (\is_string($value) && 0 === strpos($value, '@')) {
  821.             if (0 === strpos($value, '@@')) {
  822.                 $value = substr($value, 1);
  823.                 $invalidBehavior = null;
  824.             } elseif (0 === strpos($value, '@!')) {
  825.                 $value = substr($value, 2);
  826.                 $invalidBehavior = ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE;
  827.             } elseif (0 === strpos($value, '@?')) {
  828.                 $value = substr($value, 2);
  829.                 $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
  830.             } else {
  831.                 $value = substr($value, 1);
  832.                 $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
  833.             }
  835.             if (null !== $invalidBehavior) {
  836.                 $value = new Reference($value, $invalidBehavior);
  837.             }
  838.         }
  840.         return $value;
  841.     }
  843.     /**
  844.      * Loads from Extensions.
  845.      */
  846.     private function loadFromExtensions(array $content)
  847.     {
  848.         foreach ($content as $namespace => $values) {
  849.             if (\in_array($namespace, ['imports', 'parameters', 'services'])) {
  850.                 continue;
  851.             }
  853.             if (!\is_array($values) && null !== $values) {
  854.                 $values = [];
  855.             }
  857.             $this->container->loadFromExtension($namespace, $values);
  858.         }
  859.     }
  861.     /**
  862.      * Checks the keywords used to define a service.
  863.      */
  864.     private function checkDefinition(string $id, array $definition, string $file)
  865.     {
  866.         if ($this->isLoadingInstanceof) {
  867.             $keywords = self::$instanceofKeywords;
  868.         } elseif (isset($definition['resource']) || isset($definition['namespace'])) {
  869.             $keywords = self::$prototypeKeywords;
  870.         } else {
  871.             $keywords = self::$serviceKeywords;
  872.         }
  874.         foreach ($definition as $key => $value) {
  875.             if (!isset($keywords[$key])) {
  876.                 throw new InvalidArgumentException(sprintf('The configuration key "%s" is unsupported for definition "%s" in "%s". Allowed configuration keys are "%s".', $key, $id, $file, implode('", "', $keywords)));
  877.             }
  878.         }
  879.     }
  880. }