[DependencyInjection] Allow using expressions as service factories

Author: nicolas-grekas

Argument/IteratorArgument.php

@@ -18,5 +18,20 @@
  */
 class IteratorArgument implements ArgumentInterface
 {
-    use ReferenceSetArgumentTrait;
+    private array $values;
+
+    public function __construct(array $values)
+    {
+        $this->setValues($values);
+    }
+
+    public function getValues(): array
+    {
+        return $this->values;
+    }
+
+    public function setValues(array $values)
+    {
+        $this->values = $values;
+    }
 }

Argument/ReferenceSetArgumentTrait.php

@@ -11,12 +11,16 @@
 
 namespace Symfony\Component\DependencyInjection\Argument;
 
+trigger_deprecation('symfony/dependency-injection', '6.1', '"%s" is deprecated.', ReferenceSetArgumentTrait::class);
+
 use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
 use Symfony\Component\DependencyInjection\Reference;
 
 /**
  * @author Titouan Galopin <[email protected]>
  * @author Nicolas Grekas <[email protected]>
+ *
+ * @deprecated since Symfony 6.1
  */
 trait ReferenceSetArgumentTrait
 {

Argument/ServiceClosureArgument.php

@@ -12,7 +12,6 @@
 namespace Symfony\Component\DependencyInjection\Argument;
 
 use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
-use Symfony\Component\DependencyInjection\Reference;
 
 /**
  * Represents a service wrapped in a memoizing closure.
@@ -23,9 +22,9 @@ class ServiceClosureArgument implements ArgumentInterface
 {
     private array $values;
 
-    public function __construct(Reference $reference)
+    public function __construct(mixed $value)
     {
-        $this->values = [$reference];
+        $this->values = [$value];
     }
 
     /**
@@ -41,8 +40,8 @@ public function getValues(): array
      */
     public function setValues(array $values)
     {
-        if ([0] !== array_keys($values) || !($values[0] instanceof Reference || null === $values[0])) {
-            throw new InvalidArgumentException('A ServiceClosureArgument must hold one and only one Reference.');
+        if ([0] !== array_keys($values)) {
+            throw new InvalidArgumentException('A ServiceClosureArgument must hold one and only one value.');
         }
 
         $this->values = $values;

Argument/ServiceLocator.php

@@ -37,7 +37,11 @@ public function __construct(\Closure $factory, array $serviceMap, array $service
      */
     public function get(string $id): mixed
     {
-        return isset($this->serviceMap[$id]) ? ($this->factory)(...$this->serviceMap[$id]) : parent::get($id);
+        return match (\count($this->serviceMap[$id] ?? [])) {
+            0 => parent::get($id),
+            1 => $this->serviceMap[$id][0],
+            default => ($this->factory)(...$this->serviceMap[$id]),
+        };
     }
 
     /**

Argument/ServiceLocatorArgument.php

@@ -11,34 +11,38 @@
 
 namespace Symfony\Component\DependencyInjection\Argument;
 
-use Symfony\Component\DependencyInjection\Reference;
-
 /**
  * Represents a closure acting as a service locator.
  *
  * @author Nicolas Grekas <[email protected]>
  */
 class ServiceLocatorArgument implements ArgumentInterface
 {
-    use ReferenceSetArgumentTrait;
-
+    private array $values;
     private ?TaggedIteratorArgument $taggedIteratorArgument = null;
 
-    /**
-     * @param Reference[]|TaggedIteratorArgument $values
-     */
     public function __construct(array|TaggedIteratorArgument $values = [])
     {
         if ($values instanceof TaggedIteratorArgument) {
             $this->taggedIteratorArgument = $values;
-            $this->values = [];
-        } else {
-            $this->setValues($values);
+            $values = [];
         }
+
+        $this->setValues($values);
     }
 
     public function getTaggedIteratorArgument(): ?TaggedIteratorArgument
     {
         return $this->taggedIteratorArgument;
     }
+
+    public function getValues(): array
+    {
+        return $this->values;
+    }
+
+    public function setValues(array $values)
+    {
+        $this->values = $values;
+    }
 }

CHANGELOG.md

@@ -8,6 +8,8 @@ CHANGELOG
  * Add `$exclude` to `tagged_iterator` and `tagged_locator` configurator
  * Add an `env` function to the expression language provider
  * Add an `Autowire` attribute to tell a parameter how to be autowired
+ * Allow using expressions as service factories
+ * Deprecate `ReferenceSetArgumentTrait`
 
 6.0
 ---

Compiler/AbstractRecursivePass.php

@@ -84,15 +84,24 @@ protected function processValue(mixed $value, bool $isRoot = false)
         } elseif ($value instanceof ArgumentInterface) {
             $value->setValues($this->processValue($value->getValues()));
         } elseif ($value instanceof Expression && $this->processExpressions) {
-            $this->getExpressionLanguage()->compile((string) $value, ['this' => 'container']);
+            $this->getExpressionLanguage()->compile((string) $value, ['this' => 'container', 'args' => 'args']);
         } elseif ($value instanceof Definition) {
             $value->setArguments($this->processValue($value->getArguments()));
             $value->setProperties($this->processValue($value->getProperties()));
             $value->setMethodCalls($this->processValue($value->getMethodCalls()));
 
             $changes = $value->getChanges();
             if (isset($changes['factory'])) {
-                $value->setFactory($this->processValue($value->getFactory()));
+                if (\is_string($factory = $value->getFactory()) && str_starts_with($factory, '@=')) {
+                    if (!class_exists(Expression::class)) {
+                        throw new LogicException('Expressions cannot be used in service factories without the ExpressionLanguage component. Try running "composer require symfony/expression-language".');
+                    }
+                    $factory = new Expression(substr($factory, 2));
+                }
+                if (($factory = $this->processValue($factory)) instanceof Expression) {
+                    $factory = '@='.$factory;
+                }
+                $value->setFactory($factory);
             }
             if (isset($changes['configurator'])) {
                 $value->setConfigurator($this->processValue($value->getConfigurator()));
@@ -112,6 +121,10 @@ protected function getConstructor(Definition $definition, bool $required): ?\Ref
         }
 
         if (\is_string($factory = $definition->getFactory())) {
+            if (str_starts_with($factory, '@=')) {
+                return new \ReflectionFunction(static function (...$args) {});
+            }
+
             if (!\function_exists($factory)) {
                 throw new RuntimeException(sprintf('Invalid service "%s": function "%s" does not exist.', $this->currentId, $factory));
             }

Compiler/AnalyzeServiceReferencesPass.php

@@ -16,7 +16,9 @@
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
 use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\ExpressionLanguage\Expression;
 
 /**
  * Run this pass before passes that need to know more about the relation of
@@ -135,8 +137,16 @@ protected function processValue(mixed $value, bool $isRoot = false): mixed
 
         $byFactory = $this->byFactory;
         $this->byFactory = true;
-        $this->processValue($value->getFactory());
+        if (\is_string($factory = $value->getFactory()) && str_starts_with($factory, '@=')) {
+            if (!class_exists(Expression::class)) {
+                throw new LogicException('Expressions cannot be used in service factories without the ExpressionLanguage component. Try running "composer require symfony/expression-language".');
+            }
+
+            $factory = new Expression(substr($factory, 2));
+        }
+        $this->processValue($factory);
         $this->byFactory = $byFactory;
+
         $this->processValue($value->getArguments());
 
         $properties = $value->getProperties();

Compiler/ServiceLocatorTagPass.php

@@ -64,18 +64,17 @@ protected function processValue(mixed $value, bool $isRoot = false): mixed
             if ($v instanceof ServiceClosureArgument) {
                 continue;
             }
-            if (!$v instanceof Reference) {
-                throw new InvalidArgumentException(sprintf('Invalid definition for service "%s": an array of references is expected as first argument when the "container.service_locator" tag is set, "%s" found for key "%s".', $this->currentId, get_debug_type($v), $k));
-            }
 
             if ($i === $k) {
-                unset($services[$k]);
-
-                $k = (string) $v;
+                if ($v instanceof Reference) {
+                    unset($services[$k]);
+                    $k = (string) $v;
+                }
                 ++$i;
             } elseif (\is_int($k)) {
                 $i = null;
             }
+
             $services[$k] = new ServiceClosureArgument($v);
         }
         ksort($services);
@@ -97,20 +96,14 @@ protected function processValue(mixed $value, bool $isRoot = false): mixed
         return new Reference($id);
     }
 
-    /**
-     * @param Reference[] $refMap
-     */
-    public static function register(ContainerBuilder $container, array $refMap, string $callerId = null): Reference
+    public static function register(ContainerBuilder $container, array $map, string $callerId = null): Reference
     {
-        foreach ($refMap as $id => $ref) {
-            if (!$ref instanceof Reference) {
-                throw new InvalidArgumentException(sprintf('Invalid service locator definition: only services can be referenced, "%s" found for key "%s". Inject parameter values using constructors instead.', get_debug_type($ref), $id));
-            }
-            $refMap[$id] = new ServiceClosureArgument($ref);
+        foreach ($map as $k => $v) {
+            $map[$k] = new ServiceClosureArgument($v);
         }
 
         $locator = (new Definition(ServiceLocator::class))
-            ->addArgument($refMap)
+            ->addArgument($map)
             ->addTag('container.service_locator');
 
         if (null !== $callerId && $container->hasDefinition($callerId)) {

ContainerBuilder.php

@@ -1008,16 +1008,23 @@ private function createService(Definition $definition, array &$inlineServices, b
             require_once $parameterBag->resolveValue($definition->getFile());
         }
 
-        $arguments = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($definition->getArguments())), $inlineServices, $isConstructorArgument);
+        $arguments = $definition->getArguments();
 
         if (null !== $factory = $definition->getFactory()) {
             if (\is_array($factory)) {
                 $factory = [$this->doResolveServices($parameterBag->resolveValue($factory[0]), $inlineServices, $isConstructorArgument), $factory[1]];
             } elseif (!\is_string($factory)) {
                 throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory.', $id));
+            } elseif (str_starts_with($factory, '@=')) {
+                $factory = function (ServiceLocator $arguments) use ($factory) {
+                    return $this->getExpressionLanguage()->evaluate(substr($factory, 2), ['container' => $this, 'args' => $arguments]);
+                };
+                $arguments = [new ServiceLocatorArgument($arguments)];
             }
         }
 
+        $arguments = $this->doResolveServices($parameterBag->unescapeValue($parameterBag->resolveValue($arguments)), $inlineServices, $isConstructorArgument);
+
         if (null !== $id && $definition->isShared() && isset($this->services[$id]) && ($tryProxy || !$definition->isLazy())) {
             return $this->services[$id];
         }
@@ -1149,10 +1156,8 @@ private function doResolveServices(mixed $value, array &$inlineServices = [], bo
         } elseif ($value instanceof ServiceLocatorArgument) {
             $refs = $types = [];
             foreach ($value->getValues() as $k => $v) {
-                if ($v) {
-                    $refs[$k] = [$v];
-                    $types[$k] = $v instanceof TypedReference ? $v->getType() : '?';
-                }
+                $refs[$k] = [$v, null];
+                $types[$k] = $v instanceof TypedReference ? $v->getType() : '?';
             }
             $value = new ServiceLocator($this->resolveServices(...), $refs, $types);
         } elseif ($value instanceof Reference) {
@@ -1583,8 +1588,8 @@ private function shareService(Definition $definition, mixed $service, ?string $i
     private function getExpressionLanguage(): ExpressionLanguage
     {
         if (!isset($this->expressionLanguage)) {
-            if (!class_exists(\Symfony\Component\ExpressionLanguage\ExpressionLanguage::class)) {
-                throw new LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
+            if (!class_exists(Expression::class)) {
+                throw new LogicException('Expressions cannot be used without the ExpressionLanguage component. Try running "composer require symfony/expression-language".');
             }
             $this->expressionLanguage = new ExpressionLanguage(null, $this->expressionLanguageProviders, null, $this->getEnv(...));
         }