Resolver: autowire variadic parameters

src/DI/Resolver.php

@@ -484,7 +484,29 @@ public static function autowireArguments(\ReflectionFunctionAbstract $method, ar
 
 		foreach ($method->getParameters() as $num => $param) {
 			$paramName = $param->name;
-			if (!$param->isVariadic() && array_key_exists($paramName, $arguments)) {
+			if ($param->isVariadic()) {
+				if (array_key_exists($paramName, $arguments)) {
+					$values = (array) $arguments[$paramName];
+				} elseif (array_key_exists($num, $arguments)) {
+					$values = array_slice($arguments, $num, null, true);
+					ksort($values);
+				} else {
+					$values = (array) self::autowireArgument($param, $getter);
+				}
+
+				$valueNum = $num;
+				foreach ($values as $value) {
+					$res[$valueNum] = $value;
+					unset($arguments[$valueNum]);
+					$valueNum++;
+				}
+
+				unset($arguments[$paramName]);
+				if ($valueNum > $num) {
+					$num = $valueNum - 1;
+				}
+
+			} elseif (array_key_exists($paramName, $arguments)) {
 				$res[$num] = $arguments[$paramName];
 				unset($arguments[$paramName], $arguments[$num]);
 
@@ -496,7 +518,7 @@ public static function autowireArguments(\ReflectionFunctionAbstract $method, ar
 				$res[$num] = self::autowireArgument($param, $getter);
 			}
 
-			$optCount = $param->isOptional() && $res[$num] === ($param->isDefaultValueAvailable() ? Reflection::getParameterDefaultValue($param) : null)
+			$optCount = ($param->isVariadic() && !array_key_exists($num, $res)) || ($param->isOptional() && $res[$num] === ($param->isDefaultValueAvailable() ? Reflection::getParameterDefaultValue($param) : null))
 				? $optCount + 1
 				: 0;
 		}
@@ -531,7 +553,7 @@ private static function autowireArgument(\ReflectionParameter $parameter, callab
 
 		if ($type && !Reflection::isBuiltinType($type)) {
 			try {
-				$res = $getter($type, true);
+				$res = $getter($type, !$parameter->isVariadic());
 			} catch (MissingServiceException $e) {
 				$res = null;
 			} catch (ServiceCreationException $e) {

tests/DI/ContainerBuilder.autowiring.variadic.phpt

@@ -0,0 +1,84 @@
+<?php
+
+/**
+ * Test: Nette\DI\ContainerBuilder and variadic parameters.
+ */
+
+declare(strict_types=1);
+
+use Nette\DI;
+use Tester\Assert;
+
+
+require __DIR__ . '/../bootstrap.php';
+
+
+class Foo
+{
+	public $bars;
+
+
+	public function __construct(Service ...$bars)
+	{
+		$this->bars = $bars;
+	}
+}
+
+class Service
+{
+}
+
+class ServiceChild extends Service
+{
+}
+
+
+$builder = new DI\ContainerBuilder;
+
+$builder->addDefinition('foo')
+	->setType('Foo');
+$builder->addDefinition('s1')
+	->setType('Service');
+$builder->addDefinition('s2')
+	->setType('Service');
+$builder->addDefinition('s3')
+	->setType('ServiceChild');
+$builder->addDefinition('s4')
+	->setType('stdClass');
+$builder->addDefinition('s5')
+	->setType('Service')
+	->setAutowired(false);
+$builder->addDefinition('fooWithExplicitBars')
+	->setType('Foo')
+	->setArgument('bars', [
+		$builder->getDefinition('s3'),
+		$builder->getDefinition('s5'),
+	]);
+
+$container = createContainer($builder);
+
+$foo = $container->getService('foo');
+Assert::type(Foo::class, $foo);
+Assert::same([
+	$container->getService('s1'),
+	$container->getService('s2'),
+	$container->getService('s3'),
+], $foo->bars);
+
+$fooWithExplicitBars = $container->getService('fooWithExplicitBars');
+Assert::type(Foo::class, $fooWithExplicitBars);
+Assert::same([
+	$container->getService('s3'),
+	$container->getService('s5'),
+], $fooWithExplicitBars->bars);
+
+
+// runtime
+
+$foo2 = $container->createInstance('Foo');
+Assert::type(Foo::class, $foo2);
+Assert::same([
+	$container->getService('s1'),
+	$container->getService('s2'),
+	$container->getService('s3'),
+], $foo2->bars);

tests/DI/Resolver.autowireArguments.phpt

@@ -23,6 +23,11 @@ class Test
 	public function methodNullable(?self $class, ?self $self, ?Undefined $nullable1, ?int $nullable2)
 	{
 	}
+
+
+	public function methodVariadic(self ...$variadic)
+	{
+	}
 }
 
 Assert::equal(
@@ -38,3 +43,24 @@ Assert::equal(
 		return $type === 'Test' ? new Test : null;
 	})
 );
+
+Assert::equal(
+	[new Test, new Test],
+	Resolver::autowireArguments(new ReflectionMethod('Test', 'methodVariadic'), [], function ($type) {
+		return $type === 'Test' ? [new Test, new Test] : [];
+	})
+);
+
+Assert::equal(
+	[new Test, new Test, new Test],
+	Resolver::autowireArguments(new ReflectionMethod('Test', 'methodVariadic'), [new Test, new Test, new Test], function ($type) {
+		return [];
+	})
+);
+
+Assert::equal(
+	[new Test, new Test, new Test],
+	Resolver::autowireArguments(new ReflectionMethod('Test', 'methodVariadic'), ['variadic' => [new Test, new Test, new Test]], function ($type) {
+		return [];
+	})
+);