PartialCall supports argument placeholders (PHP 8.6 partial application)

Author: dg

src/DI/Expressions/ArgumentPlaceholder.php

@@ -0,0 +1,18 @@
+<?php declare(strict_types=1);
+
+/**
+ * This file is part of the Nette Framework (https://nette.org)
+ * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
+ */
+
+namespace Nette\DI\Expressions;
+
+
+/**
+ * Placeholder for an unbound argument in a partial function application (PHP 8.6+).
+ */
+enum ArgumentPlaceholder
+{
+	case Single;     // ?   a single deferred argument
+	case Variadic;   // ... the remaining arguments
+}

src/DI/Expressions/PartialCall.php

@@ -12,17 +12,19 @@
 use Nette\DI\Resolver;
 use Nette\DI\ServiceCreationException;
 use Nette\PhpGenerator as Php;
-use function class_exists, is_string, method_exists, sprintf, str_starts_with;
+use function array_keys, array_map, class_exists, implode, is_string, method_exists, sprintf, str_starts_with;
 
 
 /**
- * Partial function application, i.e. func(...), Class::method(...) or $object->method(...).
+ * Partial function application, i.e. func(...), Class::method(?, $bound) or $object->method(...).
  */
 final class PartialCall extends Expression
 {
 	public function __construct(
 		public readonly Expression|string|null $target,
 		public readonly string $name,
+		/** @var array<mixed>  bound values (may be @references / expressions) interleaved with ArgumentPlaceholder markers */
+		public readonly array $arguments = [ArgumentPlaceholder::Variadic],
 	) {
 	}
 
@@ -35,7 +37,10 @@ public function resolveType(Resolver $resolver): string
 
 	public function complete(Resolver $resolver): self
 	{
-		if (is_string($this->target) && !Php\Helpers::isNamespaceIdentifier($this->target)) {
+		if (!array_filter($this->arguments, fn($arg): bool => $arg instanceof ArgumentPlaceholder)) {
+			throw new ServiceCreationException(sprintf('First-class callable %s must contain at least one placeholder (? or ...).', $this->usedIn($this->target)));
+
+		} elseif (is_string($this->target) && !Php\Helpers::isNamespaceIdentifier($this->target)) {
 			throw new ServiceCreationException(sprintf("Expected a valid class name, '%s' given.", $this->target));
 
 		} elseif ($this->target === null
@@ -62,32 +67,56 @@ public function complete(Resolver $resolver): self
 			}
 		}
 
-		return $this->target instanceof Expression
-			? new self($this->target->complete($resolver), $this->name)
-			: $this;
+		$target = $this->target instanceof Expression
+			? $this->target->complete($resolver)
+			: $this->target;
+
+		$arguments = $resolver->resolveArguments($this->arguments, $this->usedIn($target));
+		return new self($target, $this->name, $arguments);
 	}
 
 
 	public function generateCode(PhpGenerator $generator): string
 	{
+		$args = implode(', ', array_map(
+			fn($key, $arg): string => (is_string($key) ? "$key: " : '') . match ($arg) {
+				ArgumentPlaceholder::Single => '?',
+				ArgumentPlaceholder::Variadic => '...',
+				default => $generator->formatPhp('?', [$arg]),
+			},
+			array_keys($this->arguments),
+			$this->arguments,
+		));
+
 		if ($this->target instanceof Expression) {
 			$inner = $this->target->generateCode($generator);
 			if (str_starts_with($inner, 'new ')) {
 				$inner = "($inner)";
 			}
 
-			return "$inner->$this->name(...)";
+			return "$inner->$this->name($args)";
 		}
 
 		return $this->target === null
-			? "$this->name(...)"
-			: "$this->target::$this->name(...)";
+			? "$this->name($args)"
+			: "$this->target::$this->name($args)";
 	}
 
 
 	public function transformValues(callable $cb): static
 	{
 		$name = $cb($this->name);
-		return new self($cb($this->target), is_string($name) ? $name : $this->name);
+		return new self($cb($this->target), is_string($name) ? $name : $this->name, $cb($this->arguments));
+	}
+
+
+	/** Human-readable callee for error messages, e.g. Foo::bar(), @svc::bar() or bar(). */
+	private function usedIn(Expression|string|null $target): string
+	{
+		return match (true) {
+			$target instanceof Reference => '@' . $target->getValue() . '::',
+			is_string($target) => $target,
+			default => '',
+		} . $this->name . '()';
 	}
 }

tests/Expressions/PartialCall.phpt

@@ -6,6 +6,7 @@
 
 use Nette\DI;
 use Nette\DI\Definitions\Statement;
+use Nette\DI\Expressions\ArgumentPlaceholder;
 use Nette\DI\Expressions\PartialCall;
 use Nette\DI\Expressions\Reference;
 use Tester\Assert;
@@ -52,15 +53,44 @@ test('generateCode(): all target forms', function () {
 });
 
 
-test('complete(): valid callables pass and return the same instance', function () {
+test('generateCode(): partial application with bound arguments and placeholders (PHP 8.6+)', function () {
+	[, $generator] = harness();
+	// single ? placeholders and a bound value
+	Assert::same("str_replace(?, ?, 'x')", (new PartialCall(null, 'str_replace', [ArgumentPlaceholder::Single, ArgumentPlaceholder::Single, 'x']))->generateCode($generator));
+	// bound value then placeholder
+	Assert::same('trim(1, ?)', (new PartialCall(null, 'trim', [1, ArgumentPlaceholder::Single]))->generateCode($generator));
+	// placeholder then variadic rest
+	Assert::same('Subject::pub(?, ...)', (new PartialCall('Subject', 'pub', [ArgumentPlaceholder::Single, ArgumentPlaceholder::Variadic]))->generateCode($generator));
+	// named arguments
+	Assert::same('trim(string: ?, characters: 1)', (new PartialCall(null, 'trim', ['string' => ArgumentPlaceholder::Single, 'characters' => 1]))->generateCode($generator));
+	// placeholder on a method call
+	Assert::same("\$this->getService('a')->pub(?)", (new PartialCall(new Reference('a'), 'pub', [ArgumentPlaceholder::Single]))->generateCode($generator));
+});
+
+
+test('complete(): bound @service arguments are resolved, placeholders pass through untouched', function () {
+	[$resolver, $generator] = harness();
+	$partial = new PartialCall(null, 'str_replace', ['@a', ArgumentPlaceholder::Single, ArgumentPlaceholder::Variadic]);
+	$completed = $partial->complete($resolver);
+
+	Assert::notSame($partial, $completed);
+	Assert::same('@a', $partial->arguments[0]);                       // original untouched
+	Assert::type(Reference::class, $completed->arguments[0]);         // @a resolved
+	Assert::same(ArgumentPlaceholder::Single, $completed->arguments[1]);   // placeholder kept
+	Assert::same(ArgumentPlaceholder::Variadic, $completed->arguments[2]); // placeholder kept
+	Assert::same("str_replace(\$this->getService('a'), ?, ...)", $completed->generateCode($generator));
+});
+
+
+test('complete(): valid callables pass and stay unchanged', function () {
 	[$resolver] = harness();
 	foreach ([
 		new PartialCall(null, 'trim'),
 		new PartialCall(null, 'Foo\undefinedFunc'), // function existence is not verified (not autoloadable)
 		new PartialCall(Subject::class, 'pub'),
 		new PartialCall(Subject::class, 'magic'), // missing method tolerated because of __callStatic
 	] as $callable) {
-		Assert::same($callable, $callable->complete($resolver));
+		Assert::equal($callable, $callable->complete($resolver));
 	}
 });
 
@@ -111,9 +141,15 @@ testException('complete(): reference to missing service inside target', function
 }, DI\ServiceCreationException::class, "Reference to missing service 'missing'.");
 
 
+testException('complete(): plain arguments without any placeholder are rejected', function () {
+	[$resolver] = harness();
+	(new PartialCall(null, 'trim', [1, 2]))->complete($resolver);
+}, DI\ServiceCreationException::class, 'First-class callable trim() must contain at least one placeholder (? or ...).');
+
+
 test('transformValues(): callback is applied to target and name, original is untouched', function () {
 	$callable = new PartialCall('%class%', '%method%');
-	$transformed = $callable->transformValues(fn($v) => strtr($v, ['%class%' => 'Subject', '%method%' => 'pub']));
+	$transformed = $callable->transformValues(fn($v) => is_string($v) ? strtr($v, ['%class%' => 'Subject', '%method%' => 'pub']) : $v);
 	Assert::notSame($callable, $transformed);
 	Assert::same('Subject', $transformed->target);
 	Assert::same('pub', $transformed->name);