From 0cff2ebc28d97cfe137e60387c0caef895863f6d Mon Sep 17 00:00:00 2001
From: Yonel Ceruto <yonel.ceruto@scnd.com>
Date: Thu, 21 Aug 2025 01:19:55 +0200
Subject: [PATCH] [Console] Add #[Input] attribute to support DTOs in commands

---
 .../Component/Console/Attribute/Argument.php  |  40 +++---
 .../Component/Console/Attribute/Input.php     | 116 +++++++++++++++
 .../Component/Console/Attribute/Option.php    |  53 +++----
 .../Attribute/Reflection/ReflectionMember.php |  99 +++++++++++++
 src/Symfony/Component/Console/CHANGELOG.md    |   1 +
 .../Console/Command/InvokableCommand.php      |  29 +++-
 .../InvokableWithInputTestCommand.php         |  77 ++++++++++
 .../Tests/Tester/CommandTesterTest.php        | 134 ++++++++++++++++++
 8 files changed, 501 insertions(+), 48 deletions(-)
 create mode 100644 src/Symfony/Component/Console/Attribute/Input.php
 create mode 100644 src/Symfony/Component/Console/Attribute/Reflection/ReflectionMember.php
 create mode 100644 src/Symfony/Component/Console/Tests/Fixtures/InvokableWithInputTestCommand.php

diff --git a/src/Symfony/Component/Console/Attribute/Argument.php b/src/Symfony/Component/Console/Attribute/Argument.php
index 203dcc2af980f..b1b40bd3e622e 100644
--- a/src/Symfony/Component/Console/Attribute/Argument.php
+++ b/src/Symfony/Component/Console/Attribute/Argument.php
@@ -11,6 +11,7 @@
 
 namespace Symfony\Component\Console\Attribute;
 
+use Symfony\Component\Console\Attribute\Reflection\ReflectionMember;
 use Symfony\Component\Console\Completion\CompletionInput;
 use Symfony\Component\Console\Completion\Suggestion;
 use Symfony\Component\Console\Exception\InvalidArgumentException;
@@ -19,7 +20,7 @@
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\String\UnicodeString;
 
-#[\Attribute(\Attribute::TARGET_PARAMETER)]
+#[\Attribute(\Attribute::TARGET_PARAMETER | \Attribute::TARGET_PROPERTY)]
 class Argument
 {
     private const ALLOWED_TYPES = ['string', 'bool', 'int', 'float', 'array'];
@@ -27,7 +28,9 @@ class Argument
     private string|bool|int|float|array|null $default = null;
     private array|\Closure $suggestedValues;
     private ?int $mode = null;
-    private string $function = '';
+    /**
+     * @var string|class-string<\BackedEnum>
+     */
     private string $typeName = '';
 
     /**
@@ -48,52 +51,45 @@ public function __construct(
     /**
      * @internal
      */
-    public static function tryFrom(\ReflectionParameter $parameter): ?self
+    public static function tryFrom(\ReflectionParameter|\ReflectionProperty $member): ?self
     {
-        /** @var self $self */
-        if (null === $self = ($parameter->getAttributes(self::class, \ReflectionAttribute::IS_INSTANCEOF)[0] ?? null)?->newInstance()) {
-            return null;
-        }
+        $reflection = new ReflectionMember($member);
 
-        if (($function = $parameter->getDeclaringFunction()) instanceof \ReflectionMethod) {
-            $self->function = $function->class.'::'.$function->name;
-        } else {
-            $self->function = $function->name;
+        if (!$self = $reflection->getAttribute(self::class)) {
+            return null;
         }
 
-        $type = $parameter->getType();
-        $name = $parameter->getName();
+        $type = $reflection->getType();
+        $name = $reflection->getName();
 
         if (!$type instanceof \ReflectionNamedType) {
-            throw new LogicException(\sprintf('The parameter "$%s" of "%s()" must have a named type. Untyped, Union or Intersection types are not supported for command arguments.', $name, $self->function));
+            throw new LogicException(\sprintf('The %s "$%s" of "%s" must have a named type. Untyped, Union or Intersection types are not supported for command arguments.', $reflection->getMemberName(), $name, $reflection->getSourceName()));
         }
 
         $self->typeName = $type->getName();
         $isBackedEnum = is_subclass_of($self->typeName, \BackedEnum::class);
 
         if (!\in_array($self->typeName, self::ALLOWED_TYPES, true) && !$isBackedEnum) {
-            throw new LogicException(\sprintf('The type "%s" on parameter "$%s" of "%s()" is not supported as a command argument. Only "%s" types and backed enums are allowed.', $self->typeName, $name, $self->function, implode('", "', self::ALLOWED_TYPES)));
+            throw new LogicException(\sprintf('The type "%s" on %s "$%s" of "%s" is not supported as a command argument. Only "%s" types and backed enums are allowed.', $self->typeName, $reflection->getMemberName(), $name, $reflection->getSourceName(), implode('", "', self::ALLOWED_TYPES)));
         }
 
         if (!$self->name) {
             $self->name = (new UnicodeString($name))->kebab();
         }
 
-        if ($parameter->isDefaultValueAvailable()) {
-            $self->default = $parameter->getDefaultValue() instanceof \BackedEnum ? $parameter->getDefaultValue()->value : $parameter->getDefaultValue();
-        }
+        $self->default = $reflection->hasDefaultValue() ? $reflection->getDefaultValue() : null;
 
-        $self->mode = $parameter->isDefaultValueAvailable() || $parameter->allowsNull() ? InputArgument::OPTIONAL : InputArgument::REQUIRED;
+        $self->mode = ($reflection->hasDefaultValue() || $reflection->isNullable()) ? InputArgument::OPTIONAL : InputArgument::REQUIRED;
         if ('array' === $self->typeName) {
             $self->mode |= InputArgument::IS_ARRAY;
         }
 
-        if (\is_array($self->suggestedValues) && !\is_callable($self->suggestedValues) && 2 === \count($self->suggestedValues) && ($instance = $parameter->getDeclaringFunction()->getClosureThis()) && $instance::class === $self->suggestedValues[0] && \is_callable([$instance, $self->suggestedValues[1]])) {
+        if (\is_array($self->suggestedValues) && !\is_callable($self->suggestedValues) && 2 === \count($self->suggestedValues) && ($instance = $reflection->getSourceThis()) && $instance::class === $self->suggestedValues[0] && \is_callable([$instance, $self->suggestedValues[1]])) {
             $self->suggestedValues = [$instance, $self->suggestedValues[1]];
         }
 
         if ($isBackedEnum && !$self->suggestedValues) {
-            $self->suggestedValues = array_column(($self->typeName)::cases(), 'value');
+            $self->suggestedValues = array_column($self->typeName::cases(), 'value');
         }
 
         return $self;
@@ -117,7 +113,7 @@ public function resolveValue(InputInterface $input): mixed
         $value = $input->getArgument($this->name);
 
         if (is_subclass_of($this->typeName, \BackedEnum::class) && (\is_string($value) || \is_int($value))) {
-            return ($this->typeName)::tryFrom($value) ?? throw InvalidArgumentException::fromEnumValue($this->name, $value, $this->suggestedValues);
+            return $this->typeName::tryFrom($value) ?? throw InvalidArgumentException::fromEnumValue($this->name, $value, $this->suggestedValues);
         }
 
         return $value;
diff --git a/src/Symfony/Component/Console/Attribute/Input.php b/src/Symfony/Component/Console/Attribute/Input.php
new file mode 100644
index 0000000000000..65bbf4aef965f
--- /dev/null
+++ b/src/Symfony/Component/Console/Attribute/Input.php
@@ -0,0 +1,116 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Attribute;
+
+use Symfony\Component\Console\Attribute\Reflection\ReflectionMember;
+use Symfony\Component\Console\Exception\LogicException;
+use Symfony\Component\Console\Input\InputInterface;
+
+#[\Attribute(\Attribute::TARGET_PARAMETER | \Attribute::TARGET_PROPERTY)]
+final class Input
+{
+    /**
+     * @var array<string, Argument|Option|self>
+     */
+    private array $definition = [];
+
+    private \ReflectionClass $class;
+
+    public static function tryFrom(\ReflectionParameter|\ReflectionProperty $member): ?self
+    {
+        $reflection = new ReflectionMember($member);
+
+        if (!$self = $reflection->getAttribute(self::class)) {
+            return null;
+        }
+
+        $type = $reflection->getType();
+
+        if (!$type instanceof \ReflectionNamedType) {
+            throw new LogicException(\sprintf('The input %s "%s" must have a named type.', $reflection->getMemberName(), $member->name));
+        }
+
+        if (!class_exists($class = $type->getName())) {
+            throw new LogicException(\sprintf('The input class "%s" does not exist.', $type->getName()));
+        }
+
+        $self->class = new \ReflectionClass($class);
+
+        foreach ($self->class->getProperties() as $property) {
+            if (!$property->isPublic() || $property->isStatic()) {
+                continue;
+            }
+
+            if ($argument = Argument::tryFrom($property)) {
+                $self->definition[$property->name] = $argument;
+                continue;
+            }
+
+            if ($option = Option::tryFrom($property)) {
+                $self->definition[$property->name] = $option;
+                continue;
+            }
+
+            if ($input = self::tryFrom($property)) {
+                $self->definition[$property->name] = $input;
+            }
+        }
+
+        if (!$self->definition) {
+            throw new LogicException(\sprintf('The input class "%s" must have at least one argument or option.', $self->class->name));
+        }
+
+        return $self;
+    }
+
+    /**
+     * @internal
+     */
+    public function resolveValue(InputInterface $input): mixed
+    {
+        $instance = $this->class->newInstanceWithoutConstructor();
+
+        foreach ($this->definition as $name => $spec) {
+            $instance->$name = $spec->resolveValue($input);
+        }
+
+        return $instance;
+    }
+
+    /**
+     * @return iterable<Argument>
+     */
+    public function getArguments(): iterable
+    {
+        foreach ($this->definition as $spec) {
+            if ($spec instanceof Argument) {
+                yield $spec;
+            } elseif ($spec instanceof self) {
+                yield from $spec->getArguments();
+            }
+        }
+    }
+
+    /**
+     * @return iterable<Option>
+     */
+    public function getOptions(): iterable
+    {
+        foreach ($this->definition as $spec) {
+            if ($spec instanceof Option) {
+                yield $spec;
+            } elseif ($spec instanceof self) {
+                yield from $spec->getOptions();
+            }
+        }
+    }
+}
diff --git a/src/Symfony/Component/Console/Attribute/Option.php b/src/Symfony/Component/Console/Attribute/Option.php
index 6781e7dbdbb58..5f0f47610b479 100644
--- a/src/Symfony/Component/Console/Attribute/Option.php
+++ b/src/Symfony/Component/Console/Attribute/Option.php
@@ -11,6 +11,7 @@
 
 namespace Symfony\Component\Console\Attribute;
 
+use Symfony\Component\Console\Attribute\Reflection\ReflectionMember;
 use Symfony\Component\Console\Completion\CompletionInput;
 use Symfony\Component\Console\Completion\Suggestion;
 use Symfony\Component\Console\Exception\InvalidOptionException;
@@ -19,7 +20,7 @@
 use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\String\UnicodeString;
 
-#[\Attribute(\Attribute::TARGET_PARAMETER)]
+#[\Attribute(\Attribute::TARGET_PARAMETER | \Attribute::TARGET_PROPERTY)]
 class Option
 {
     private const ALLOWED_TYPES = ['string', 'bool', 'int', 'float', 'array'];
@@ -28,9 +29,13 @@ class Option
     private string|bool|int|float|array|null $default = null;
     private array|\Closure $suggestedValues;
     private ?int $mode = null;
+    /**
+     * @var string|class-string<\BackedEnum>
+     */
     private string $typeName = '';
     private bool $allowNull = false;
-    private string $function = '';
+    private string $memberName = '';
+    private string $sourceName = '';
 
     /**
      * Represents a console command --option definition.
@@ -52,54 +57,52 @@ public function __construct(
     /**
      * @internal
      */
-    public static function tryFrom(\ReflectionParameter $parameter): ?self
+    public static function tryFrom(\ReflectionParameter|\ReflectionProperty $member): ?self
     {
-        /** @var self $self */
-        if (null === $self = ($parameter->getAttributes(self::class, \ReflectionAttribute::IS_INSTANCEOF)[0] ?? null)?->newInstance()) {
+        $reflection = new ReflectionMember($member);
+
+        if (!$self = $reflection->getAttribute(self::class)) {
             return null;
         }
 
-        if (($function = $parameter->getDeclaringFunction()) instanceof \ReflectionMethod) {
-            $self->function = $function->class.'::'.$function->name;
-        } else {
-            $self->function = $function->name;
-        }
+        $self->memberName = $reflection->getMemberName();
+        $self->sourceName = $reflection->getSourceName();
 
-        $name = $parameter->getName();
-        $type = $parameter->getType();
+        $name = $reflection->getName();
+        $type = $reflection->getType();
 
-        if (!$parameter->isDefaultValueAvailable()) {
-            throw new LogicException(\sprintf('The option parameter "$%s" of "%s()" must declare a default value.', $name, $self->function));
+        if (!$reflection->hasDefaultValue()) {
+            throw new LogicException(\sprintf('The option %s "$%s" of "%s" must declare a default value.', $self->memberName, $name, $self->sourceName));
         }
 
         if (!$self->name) {
             $self->name = (new UnicodeString($name))->kebab();
         }
 
-        $self->default = $parameter->getDefaultValue() instanceof \BackedEnum ? $parameter->getDefaultValue()->value : $parameter->getDefaultValue();
-        $self->allowNull = $parameter->allowsNull();
+        $self->default = $reflection->getDefaultValue();
+        $self->allowNull = $reflection->isNullable();
 
         if ($type instanceof \ReflectionUnionType) {
             return $self->handleUnion($type);
         }
 
         if (!$type instanceof \ReflectionNamedType) {
-            throw new LogicException(\sprintf('The parameter "$%s" of "%s()" must have a named type. Untyped or Intersection types are not supported for command options.', $name, $self->function));
+            throw new LogicException(\sprintf('The %s "$%s" of "%s" must have a named type. Untyped or Intersection types are not supported for command options.', $self->memberName, $name, $self->sourceName));
         }
 
         $self->typeName = $type->getName();
         $isBackedEnum = is_subclass_of($self->typeName, \BackedEnum::class);
 
         if (!\in_array($self->typeName, self::ALLOWED_TYPES, true) && !$isBackedEnum) {
-            throw new LogicException(\sprintf('The type "%s" on parameter "$%s" of "%s()" is not supported as a command option. Only "%s" types and BackedEnum are allowed.', $self->typeName, $name, $self->function, implode('", "', self::ALLOWED_TYPES)));
+            throw new LogicException(\sprintf('The type "%s" on %s "$%s" of "%s" is not supported as a command option. Only "%s" types and BackedEnum are allowed.', $self->typeName, $self->memberName, $name, $self->sourceName, implode('", "', self::ALLOWED_TYPES)));
         }
 
         if ('bool' === $self->typeName && $self->allowNull && \in_array($self->default, [true, false], true)) {
-            throw new LogicException(\sprintf('The option parameter "$%s" of "%s()" must not be nullable when it has a default boolean value.', $name, $self->function));
+            throw new LogicException(\sprintf('The option %s "$%s" of "%s" must not be nullable when it has a default boolean value.', $self->memberName, $name, $self->sourceName));
         }
 
         if ($self->allowNull && null !== $self->default) {
-            throw new LogicException(\sprintf('The option parameter "$%s" of "%s()" must either be not-nullable or have a default of null.', $name, $self->function));
+            throw new LogicException(\sprintf('The option %s "$%s" of "%s" must either be not-nullable or have a default of null.', $self->memberName, $name, $self->sourceName));
         }
 
         if ('bool' === $self->typeName) {
@@ -113,12 +116,12 @@ public static function tryFrom(\ReflectionParameter $parameter): ?self
             $self->mode = InputOption::VALUE_REQUIRED;
         }
 
-        if (\is_array($self->suggestedValues) && !\is_callable($self->suggestedValues) && 2 === \count($self->suggestedValues) && ($instance = $parameter->getDeclaringFunction()->getClosureThis()) && $instance::class === $self->suggestedValues[0] && \is_callable([$instance, $self->suggestedValues[1]])) {
+        if (\is_array($self->suggestedValues) && !\is_callable($self->suggestedValues) && 2 === \count($self->suggestedValues) && ($instance = $reflection->getSourceThis()) && $instance::class === $self->suggestedValues[0] && \is_callable([$instance, $self->suggestedValues[1]])) {
             $self->suggestedValues = [$instance, $self->suggestedValues[1]];
         }
 
         if ($isBackedEnum && !$self->suggestedValues) {
-            $self->suggestedValues = array_column(($self->typeName)::cases(), 'value');
+            $self->suggestedValues = array_column($self->typeName::cases(), 'value');
         }
 
         return $self;
@@ -147,7 +150,7 @@ public function resolveValue(InputInterface $input): mixed
         }
 
         if (is_subclass_of($this->typeName, \BackedEnum::class) && (\is_string($value) || \is_int($value))) {
-            return ($this->typeName)::tryFrom($value) ?? throw InvalidOptionException::fromEnumValue($this->name, $value, $this->suggestedValues);
+            return $this->typeName::tryFrom($value) ?? throw InvalidOptionException::fromEnumValue($this->name, $value, $this->suggestedValues);
         }
 
         if ('array' === $this->typeName && $this->allowNull && [] === $value) {
@@ -177,11 +180,11 @@ private function handleUnion(\ReflectionUnionType $type): self
         $this->typeName = implode('|', array_filter($types));
 
         if (!\in_array($this->typeName, self::ALLOWED_UNION_TYPES, true)) {
-            throw new LogicException(\sprintf('The union type for parameter "$%s" of "%s()" is not supported as a command option. Only "%s" types are allowed.', $this->name, $this->function, implode('", "', self::ALLOWED_UNION_TYPES)));
+            throw new LogicException(\sprintf('The union type for %s "$%s" of "%s" is not supported as a command option. Only "%s" types are allowed.', $this->memberName, $this->name, $this->sourceName, implode('", "', self::ALLOWED_UNION_TYPES)));
         }
 
         if (false !== $this->default) {
-            throw new LogicException(\sprintf('The option parameter "$%s" of "%s()" must have a default value of false.', $this->name, $this->function));
+            throw new LogicException(\sprintf('The option %s "$%s" of "%s" must have a default value of false.', $this->memberName, $this->name, $this->sourceName));
         }
 
         $this->mode = InputOption::VALUE_OPTIONAL;
diff --git a/src/Symfony/Component/Console/Attribute/Reflection/ReflectionMember.php b/src/Symfony/Component/Console/Attribute/Reflection/ReflectionMember.php
new file mode 100644
index 0000000000000..7fa13ab9d2265
--- /dev/null
+++ b/src/Symfony/Component/Console/Attribute/Reflection/ReflectionMember.php
@@ -0,0 +1,99 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Attribute\Reflection;
+
+/**
+ * @internal
+ */
+class ReflectionMember
+{
+    public function __construct(
+        private readonly \ReflectionParameter|\ReflectionProperty $member,
+    ) {
+    }
+
+    /**
+     * @template T of object
+     *
+     * @param class-string<T> $class
+     *
+     * @return T|null
+     */
+    public function getAttribute(string $class): ?object
+    {
+        return ($this->member->getAttributes($class, \ReflectionAttribute::IS_INSTANCEOF)[0] ?? null)?->newInstance();
+    }
+
+    public function getSourceName(): string
+    {
+        if ($this->member instanceof \ReflectionProperty) {
+            return $this->member->getDeclaringClass()->name;
+        }
+
+        $function = $this->member->getDeclaringFunction();
+
+        if ($function instanceof \ReflectionMethod) {
+            return $function->class.'::'.$function->name.'()';
+        }
+
+        return $function->name.'()';
+    }
+
+    public function getSourceThis(): ?object
+    {
+        if ($this->member instanceof \ReflectionParameter) {
+            return $this->member->getDeclaringFunction()->getClosureThis();
+        }
+
+        return null;
+    }
+
+    public function getType(): ?\ReflectionType
+    {
+        return $this->member->getType();
+    }
+
+    public function getName(): string
+    {
+        return $this->member->getName();
+    }
+
+    public function hasDefaultValue(): bool
+    {
+        if ($this->member instanceof \ReflectionParameter) {
+            return $this->member->isDefaultValueAvailable();
+        }
+
+        return $this->member->hasDefaultValue();
+    }
+
+    public function getDefaultValue(): mixed
+    {
+        $defaultValue = $this->member->getDefaultValue();
+
+        if ($defaultValue instanceof \BackedEnum) {
+            return $defaultValue->value;
+        }
+
+        return $defaultValue;
+    }
+
+    public function isNullable(): bool
+    {
+        return (bool) $this->member->getType()?->allowsNull();
+    }
+
+    public function getMemberName(): string
+    {
+        return $this->member instanceof \ReflectionParameter ? 'parameter' : 'property';
+    }
+}
diff --git a/src/Symfony/Component/Console/CHANGELOG.md b/src/Symfony/Component/Console/CHANGELOG.md
index 7034aeb880763..bb1d3ec80751e 100644
--- a/src/Symfony/Component/Console/CHANGELOG.md
+++ b/src/Symfony/Component/Console/CHANGELOG.md
@@ -11,6 +11,7 @@ CHANGELOG
  * Add `BackedEnum` support with `#[Argument]` and `#[Option]` inputs in invokable commands
  * Allow Usages to be specified via `#[AsCommand]` attribute.
  * Allow passing invokable commands to `Symfony\Component\Console\Tester\CommandTester`
+ * Add `#[Input]` attribute to support DTOs in commands
 
 7.3
 ---
diff --git a/src/Symfony/Component/Console/Command/InvokableCommand.php b/src/Symfony/Component/Console/Command/InvokableCommand.php
index b497f4df73bfc..9974589961a02 100644
--- a/src/Symfony/Component/Console/Command/InvokableCommand.php
+++ b/src/Symfony/Component/Console/Command/InvokableCommand.php
@@ -13,9 +13,11 @@
 
 use Symfony\Component\Console\Application;
 use Symfony\Component\Console\Attribute\Argument;
+use Symfony\Component\Console\Attribute\Input;
 use Symfony\Component\Console\Attribute\Option;
 use Symfony\Component\Console\Exception\LogicException;
 use Symfony\Component\Console\Exception\RuntimeException;
+use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputDefinition;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
@@ -77,8 +79,27 @@ public function configure(InputDefinition $definition): void
         foreach ($this->reflection->getParameters() as $parameter) {
             if ($argument = Argument::tryFrom($parameter)) {
                 $definition->addArgument($argument->toInputArgument());
-            } elseif ($option = Option::tryFrom($parameter)) {
+                continue;
+            }
+
+            if ($option = Option::tryFrom($parameter)) {
                 $definition->addOption($option->toInputOption());
+                continue;
+            }
+
+            if ($input = Input::tryFrom($parameter)) {
+                $inputArguments = array_map(fn (Argument $a) => $a->toInputArgument(), iterator_to_array($input->getArguments(), false));
+
+                // make sure optional arguments are defined after required ones
+                usort($inputArguments, fn (InputArgument $a, InputArgument $b) => (int) $b->isRequired() - (int) $a->isRequired());
+
+                foreach ($inputArguments as $inputArgument) {
+                    $definition->addArgument($inputArgument);
+                }
+
+                foreach ($input->getOptions() as $option) {
+                    $definition->addOption($option->toInputOption());
+                }
             }
         }
     }
@@ -128,6 +149,12 @@ private function getParameters(InputInterface $input, OutputInterface $output):
                 continue;
             }
 
+            if ($in = Input::tryFrom($parameter)) {
+                $parameters[] = $in->resolveValue($input);
+
+                continue;
+            }
+
             $type = $parameter->getType();
 
             if (!$type instanceof \ReflectionNamedType) {
diff --git a/src/Symfony/Component/Console/Tests/Fixtures/InvokableWithInputTestCommand.php b/src/Symfony/Component/Console/Tests/Fixtures/InvokableWithInputTestCommand.php
new file mode 100644
index 0000000000000..e3a3366425e4e
--- /dev/null
+++ b/src/Symfony/Component/Console/Tests/Fixtures/InvokableWithInputTestCommand.php
@@ -0,0 +1,77 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Console\Tests\Fixtures;
+
+use Symfony\Component\Console\Attribute\Argument;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Attribute\Input;
+use Symfony\Component\Console\Attribute\Option;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Style\SymfonyStyle;
+
+#[AsCommand('invokable:input:test')]
+class InvokableWithInputTestCommand
+{
+    public function __invoke(SymfonyStyle $io, #[Input] UserDto $user): int
+    {
+        $io->writeln($user->name);
+        $io->writeln($user->email);
+        $io->writeln($user->password);
+        $io->writeln($user->admin ? 'yes' : 'no');
+        $io->writeln($user->active ? 'yes' : 'no');
+        $io->writeln($user->status->value);
+        $io->writeln($user->group->name);
+        $io->writeln($user->group->description);
+
+        return Command::SUCCESS;
+    }
+}
+
+final class UserDto
+{
+    #[Argument(name: 'username')]
+    public string $name;
+
+    #[Argument]
+    public string $email;
+
+    #[Argument]
+    public string $password;
+
+    #[Input]
+    public UserGroupDto $group;
+
+    #[Option]
+    public bool $admin = false;
+
+    #[Option]
+    public bool $active = true;
+
+    #[Option]
+    public UserStatus $status = UserStatus::Unverified;
+}
+
+final class UserGroupDto
+{
+    #[Option(name: 'group')]
+    public string $name = 'users';
+
+    #[Option(name: 'group-description')]
+    public string $description = 'Standard Users';
+}
+
+enum UserStatus: string
+{
+    case Unverified = 'unverified';
+    case Verified = 'verified';
+    case Locked = 'locked';
+}
diff --git a/src/Symfony/Component/Console/Tests/Tester/CommandTesterTest.php b/src/Symfony/Component/Console/Tests/Tester/CommandTesterTest.php
index b7490ad3f6965..0b5a4bcbacc4f 100644
--- a/src/Symfony/Component/Console/Tests/Tester/CommandTesterTest.php
+++ b/src/Symfony/Component/Console/Tests/Tester/CommandTesterTest.php
@@ -11,12 +11,15 @@
 
 namespace Symfony\Component\Console\Tests\Tester;
 
+use PHPUnit\Framework\Attributes\DataProvider;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Console\Application;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Helper\HelperSet;
 use Symfony\Component\Console\Helper\QuestionHelper;
+use Symfony\Component\Console\Input\ArrayInput;
 use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\BufferedOutput;
 use Symfony\Component\Console\Output\Output;
 use Symfony\Component\Console\Output\OutputInterface;
 use Symfony\Component\Console\Question\ChoiceQuestion;
@@ -25,6 +28,7 @@
 use Symfony\Component\Console\Tester\CommandTester;
 use Symfony\Component\Console\Tests\Fixtures\InvokableExtendingCommandTestCommand;
 use Symfony\Component\Console\Tests\Fixtures\InvokableTestCommand;
+use Symfony\Component\Console\Tests\Fixtures\InvokableWithInputTestCommand;
 
 class CommandTesterTest extends TestCase
 {
@@ -289,4 +293,134 @@ public function testAInvokableExtendedCommand()
 
         $tester->assertCommandIsSuccessful();
     }
+
+    public function testInvokableDefinitionWithInputAttribute()
+    {
+        $application = new Application();
+        $application->addCommand(new InvokableWithInputTestCommand());
+        $application->setAutoExit(false);
+
+        $bufferedOutput = new BufferedOutput();
+        $statusCode = $application->run(new ArrayInput(['command' => 'help', 'command_name' => 'invokable:input:test']), $bufferedOutput);
+
+        $expectedOutput = <<<TXT
+            Usage:
+              invokable:input:test [options] [--] <username> <email> <password>
+
+            Arguments:
+              username %S
+              email %S
+              password %S
+
+            Options:
+                  --group=GROUP                           [default: "users"]
+                  --group-description=GROUP-DESCRIPTION   [default: "Standard Users"]
+                  --admin %S
+                  --active|--no-active %S
+                  --status=STATUS                         [default: "unverified"]
+            %A
+            TXT;
+
+        self::assertSame(0, $statusCode);
+        self::assertStringMatchesFormat($expectedOutput, $bufferedOutput->fetch());
+    }
+
+    #[DataProvider('getInvokableWithInputData')]
+    public function testInvokableWithInputAttribute(array $input, string $output)
+    {
+        $command = new InvokableWithInputTestCommand();
+
+        $tester = new CommandTester($command);
+        $tester->execute($input);
+
+        $tester->assertCommandIsSuccessful();
+        self::assertSame($output, $tester->getDisplay(true));
+    }
+
+    public static function getInvokableWithInputData(): iterable
+    {
+        yield 'all set' => [
+            'input' => [
+                'username' => 'user1',
+                'email' => 'user1@example.com',
+                'password' => 'password123',
+                '--admin' => true,
+                '--active' => false,
+                '--status' => 'verified',
+                '--group' => 'admins',
+                '--group-description' => 'Super Administrators',
+            ],
+            'output' => <<<TXT
+                user1
+                user1@example.com
+                password123
+                yes
+                no
+                verified
+                admins
+                Super Administrators
+
+                TXT,
+        ];
+
+        yield 'only required arguments' => [
+            'input' => [
+                'username' => 'test',
+                'email' => 'test@example.com',
+                'password' => 'password123',
+            ],
+            'output' => <<<TXT
+                test
+                test@example.com
+                password123
+                no
+                yes
+                unverified
+                users
+                Standard Users
+
+                TXT,
+        ];
+
+        yield 'admin enabled with defaults' => [
+            'input' => [
+                'username' => 'admin',
+                'email' => 'admin@example.com',
+                'password' => 'admin123',
+                '--admin' => true,
+            ],
+            'output' => <<<TXT
+                admin
+                admin@example.com
+                admin123
+                yes
+                yes
+                unverified
+                users
+                Standard Users
+
+                TXT,
+        ];
+
+        yield 'custom group with defaults' => [
+            'input' => [
+                'username' => 'user',
+                'email' => 'user@custom.com',
+                'password' => 'custom123',
+                '--group' => 'moderators',
+                '--group-description' => 'System Moderators',
+            ],
+            'output' => <<<TXT
+                user
+                user@custom.com
+                custom123
+                no
+                yes
+                unverified
+                moderators
+                System Moderators
+
+                TXT,
+        ];
+    }
 }