experiment in avoiding name-based matching on handler invocation

Author: jonsequitur

src/System.CommandLine.Tests/Binding/ModelBindingCommandHandlerTests.cs

@@ -5,6 +5,7 @@
 using System.CommandLine.Binding;
 using System.CommandLine.Invocation;
 using System.CommandLine.IO;
+using System.CommandLine.Parsing;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -458,6 +459,46 @@ public async Task Handler_method_receives_command_arguments_bound_to_the_specifi
             c.AssertBoundValue(boundValue);
         }
 
+        [Fact]
+        public void EXPERIMENT()
+        {
+            var stringOption = new Option<string>("--string");
+            var intOption = new Option<int>("--int");
+            var filesArg = new Argument<FileInfo[]>();
+            var wasCalled = false;
+            var command = new RootCommand
+            {
+                stringOption,
+                intOption,
+                filesArg
+            };
+
+            command.Handler = CommandHandler.Create(
+                stringOption, intOption, filesArg,
+                (s, i, fs) =>
+                {
+                    wasCalled = true;
+            
+                    s.Should().Be("hello");
+                    i.Should().Be(123);
+                    fs.Select(f => f.Name)
+                      .Should()
+                      .BeEquivalentTo(
+                          "1.txt",
+                          "2.txt",
+                          "3.txt"
+                      );
+
+                    return Task.CompletedTask;
+                });
+
+            var parser = new Parser(command);
+
+            parser.Invoke("--int 123 --string hello 1.txt 2.txt 3.txt");
+
+            wasCalled.Should().BeTrue();
+        }
+
         private static void CaptureMethod<T>(T value, InvocationContext invocationContext)
         {
             invocationContext.InvocationResult = new BoundValueCapturer(value);

src/System.CommandLine/Argument{T}.cs

@@ -1,11 +1,12 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.CommandLine.Binding;
 using System.CommandLine.Parsing;
 
 namespace System.CommandLine
 {
-    public class Argument<T> : Argument
+    public class Argument<T> : Argument, IValueDescriptor<T>
     {
         public Argument()
         {

src/System.CommandLine/Binding/IValueDescriptor.cs

@@ -13,4 +13,9 @@ public interface IValueDescriptor
 
         object? GetDefaultValue();
     }
+
+    public interface IValueDescriptor<T> : IValueDescriptor
+    {
+        // FIX: (IValueDescriptor) 
+    }
 }

src/System.CommandLine/Invocation/CommandHandler.cs

@@ -139,6 +139,34 @@ public static ICommandHandler Create<T1, T2, T3, T4, T5, T6, T7>(
             Func<T1, T2, T3, T4, T5, T6, T7, Task<int>> action) =>
             HandlerDescriptor.FromDelegate(action).GetCommandHandler();
 
+        public static ICommandHandler Create<T1, T2, T3>(
+            IValueDescriptor<T1> symbol1,
+            IValueDescriptor<T2> symbol2,
+            IValueDescriptor<T3> symbol3,
+            Func<T1, T2, T3, Task> handle)
+        {
+            return new AnonymousCommandHandler(async context =>
+            {
+                await handle(
+                    context.ParseResult.ValueFor(symbol1),
+                    context.ParseResult.ValueFor(symbol2), 
+                    context.ParseResult.ValueFor(symbol3));
+            });
+        }
+
+        private class AnonymousCommandHandler : ICommandHandler
+        {
+            private readonly Func<InvocationContext, Task> _getResult;
+
+            public AnonymousCommandHandler(Func<InvocationContext, Task> getResult)
+            {
+                _getResult = getResult;
+            }
+
+            public async Task<int> InvokeAsync(InvocationContext context) =>
+                await GetResultCodeAsync(_getResult(context), context);
+        }
+
         internal static async Task<int> GetResultCodeAsync(object value, InvocationContext context)
         {
             switch (value)

src/System.CommandLine/Option{T}.cs

@@ -1,11 +1,12 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.CommandLine.Binding;
 using System.CommandLine.Parsing;
 
 namespace System.CommandLine
 {
-    public class Option<T> : Option
+    public class Option<T> : Option, IValueDescriptor<T>
     {
         public Option(
             string alias, 

src/System.CommandLine/Parsing/ParseResult.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Collections.Generic;
+using System.CommandLine.Binding;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 
@@ -133,6 +134,15 @@ public T ValueForOption<T>(Option option)
             return default!;
         }
 
+        [return: MaybeNull]
+        internal T ValueFor<T>(IValueDescriptor<T> symbol) =>
+            symbol switch
+            {
+                Argument<T> argument => ValueForArgument(argument),
+                Option<T> option => ValueForOption(option),
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
         public SymbolResult? this[string alias] => CommandResult.Children[alias];
 
         public override string ToString() => $"{nameof(ParseResult)}: {this.Diagram()}";