From 790646f97737f40b297ea5e5f3ce4f3b3a56d909 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 13:01:40 +0100
Subject: [PATCH 01/18] extend ICommandHandler with synchronous Invoke method

---
 ...tionBinder_api_is_not_changed.approved.txt |  1 +
 ...ommandLine_api_is_not_changed.approved.txt |  1 +
 .../CommandHandlerSourceGenerator.cs          |  3 ++
 .../HostingHandlerTest.cs                     |  8 +++++
 .../ParameterBindingTests.cs                  |  4 +++
 .../ModelBindingCommandHandler.cs             |  2 ++
 .../Invocation/AnonymousCommandHandler.cs     | 32 +++++++++++--------
 .../Invocation/ICommandHandler.cs             |  9 +++++-
 8 files changed, 45 insertions(+), 15 deletions(-)

diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_NamingConventionBinder_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_NamingConventionBinder_api_is_not_changed.approved.txt
index 28565c243f..d01b397a21 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_NamingConventionBinder_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_NamingConventionBinder_api_is_not_changed.approved.txt
@@ -98,6 +98,7 @@
   public class ModelBindingCommandHandler, System.CommandLine.Invocation.ICommandHandler
     public System.Void BindParameter(System.Reflection.ParameterInfo param, System.CommandLine.Argument argument)
     public System.Void BindParameter(System.Reflection.ParameterInfo param, System.CommandLine.Option option)
+    public System.Int32 Invoke(System.CommandLine.Invocation.InvocationContext context)
     public System.Threading.Tasks.Task<System.Int32> InvokeAsync(System.CommandLine.Invocation.InvocationContext context)
   public class ModelDescriptor
     public static ModelDescriptor FromType<T>()
diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
index f39318f893..52b1dc3683 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
@@ -356,6 +356,7 @@ System.CommandLine.Help
     public System.Int32 GetHashCode()
 System.CommandLine.Invocation
   public interface ICommandHandler
+    public System.Int32 Invoke(InvocationContext context)
     public System.Threading.Tasks.Task<System.Int32> InvokeAsync(InvocationContext context)
   public interface IInvocationResult
     public System.Void Apply(InvocationContext context)
diff --git a/src/System.CommandLine.Generator/CommandHandlerSourceGenerator.cs b/src/System.CommandLine.Generator/CommandHandlerSourceGenerator.cs
index cbae2f8a83..8d4166eb20 100644
--- a/src/System.CommandLine.Generator/CommandHandlerSourceGenerator.cs
+++ b/src/System.CommandLine.Generator/CommandHandlerSourceGenerator.cs
@@ -114,6 +114,9 @@ private class GeneratedHandler_{handlerCount} : {ICommandHandlerType}
             {propertyDeclaration}");
             }
 
+            builder.Append($@"
+            public int Invoke(global::System.CommandLine.Invocation.InvocationContext context) => InvokeAsync(context).GetAwaiter().GetResult();");
+
             builder.Append($@"
             public async global::System.Threading.Tasks.Task<int> InvokeAsync(global::System.CommandLine.Invocation.InvocationContext context)
             {{");
diff --git a/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs b/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
index 6191715e30..ab446b2d9c 100644
--- a/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
+++ b/src/System.CommandLine.Hosting.Tests/HostingHandlerTest.cs
@@ -132,6 +132,12 @@ public MyHandler(MyService service)
                 public int IntOption { get; set; } // bound from option
                 public IConsole Console { get; set; } // bound from DI
 
+                public int Invoke(InvocationContext context)
+                {
+                    service.Value = IntOption;
+                    return IntOption;
+                }
+
                 public Task<int> InvokeAsync(InvocationContext context)
                 {
                     service.Value = IntOption;
@@ -162,6 +168,8 @@ public MyHandler(MyService service)
 
                 public string One { get; set; }
 
+                public int Invoke(InvocationContext context) => InvokeAsync(context).GetAwaiter().GetResult();
+
                 public Task<int> InvokeAsync(InvocationContext context)
                 {
                     service.Value = IntOption;
diff --git a/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs b/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
index 23ad1e474b..2f0530845b 100644
--- a/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
+++ b/src/System.CommandLine.NamingConventionBinder.Tests/ParameterBindingTests.cs
@@ -446,6 +446,8 @@ public abstract class AbstractTestCommandHandler : ICommandHandler
     {
         public abstract Task<int> DoJobAsync();
 
+        public int Invoke(InvocationContext context) => InvokeAsync(context).GetAwaiter().GetResult();
+
         public Task<int> InvokeAsync(InvocationContext context)
             => DoJobAsync();
     }
@@ -458,6 +460,8 @@ public override Task<int> DoJobAsync()
 
     public class VirtualTestCommandHandler : ICommandHandler
     {
+        public int Invoke(InvocationContext context) => 42;
+
         public virtual Task<int> InvokeAsync(InvocationContext context)
             => Task.FromResult(42);
     }
diff --git a/src/System.CommandLine.NamingConventionBinder/ModelBindingCommandHandler.cs b/src/System.CommandLine.NamingConventionBinder/ModelBindingCommandHandler.cs
index aca39c524a..292e545de9 100644
--- a/src/System.CommandLine.NamingConventionBinder/ModelBindingCommandHandler.cs
+++ b/src/System.CommandLine.NamingConventionBinder/ModelBindingCommandHandler.cs
@@ -128,4 +128,6 @@ private void BindValueSource(ParameterInfo param, IValueSource valueSource)
                : _methodDescriptor.ParameterDescriptors
                                   .FirstOrDefault(x => x.ValueName == param.Name &&
                                                        x.ValueType == param.ParameterType);
+
+    public int Invoke(InvocationContext context) => InvokeAsync(context).GetAwaiter().GetResult();
 }
\ No newline at end of file
diff --git a/src/System.CommandLine/Invocation/AnonymousCommandHandler.cs b/src/System.CommandLine/Invocation/AnonymousCommandHandler.cs
index 521f65f945..962fb97e3e 100644
--- a/src/System.CommandLine/Invocation/AnonymousCommandHandler.cs
+++ b/src/System.CommandLine/Invocation/AnonymousCommandHandler.cs
@@ -7,32 +7,36 @@ namespace System.CommandLine.Invocation
 {
     internal class AnonymousCommandHandler : ICommandHandler
     {
-        private readonly Func<InvocationContext, Task> _handle;
+        private readonly Func<InvocationContext, Task>? _asyncHandle;
+        private readonly Action<InvocationContext>? _syncHandle;
 
         public AnonymousCommandHandler(Func<InvocationContext, Task> handle)
-        {
-            _handle = handle ?? throw new ArgumentNullException(nameof(handle));
-        }
+            => _asyncHandle = handle ?? throw new ArgumentNullException(nameof(handle));
 
         public AnonymousCommandHandler(Action<InvocationContext> handle)
+            => _syncHandle = handle ?? throw new ArgumentNullException(nameof(handle));
+
+        public int Invoke(InvocationContext context)
         {
-            if (handle == null)
+            if (_syncHandle is not null)
             {
-                throw new ArgumentNullException(nameof(handle));
+                _syncHandle(context);
+                return context.ExitCode;
             }
 
-            _handle = Handle;
-
-            Task Handle(InvocationContext context)
-            {
-                handle(context);
-                return Task.FromResult(context.ExitCode);
-            }
+            return SyncUsingAsync(context); // kept in a separate method to avoid JITting
         }
 
+        private int SyncUsingAsync(InvocationContext context) => InvokeAsync(context).GetAwaiter().GetResult();
+
         public async Task<int> InvokeAsync(InvocationContext context)
         {
-            object returnValue = _handle(context);
+            if (_syncHandle is not null)
+            {
+                return Invoke(context);
+            }
+
+            object returnValue = _asyncHandle!(context);
 
             int ret;
 
diff --git a/src/System.CommandLine/Invocation/ICommandHandler.cs b/src/System.CommandLine/Invocation/ICommandHandler.cs
index 01b55adbd9..018dbe9b56 100644
--- a/src/System.CommandLine/Invocation/ICommandHandler.cs
+++ b/src/System.CommandLine/Invocation/ICommandHandler.cs
@@ -13,7 +13,14 @@ public interface ICommandHandler
         /// <summary>
         /// Performs an action when the associated command is invoked on the command line.
         /// </summary>
-        /// <param name="context">Provides context for the invocation, including parse results  and binding support.</param>
+        /// <param name="context">Provides context for the invocation, including parse results and binding support.</param>
+        /// <returns>A value that can be used as the exit code for the process.</returns>
+        int Invoke(InvocationContext context);
+
+        /// <summary>
+        /// Performs an action when the associated command is invoked on the command line.
+        /// </summary>
+        /// <param name="context">Provides context for the invocation, including parse results and binding support.</param>
         /// <returns>A value that can be used as the exit code for the process.</returns>
         Task<int> InvokeAsync(InvocationContext context);
     }

From 7b15e52a393ad8870c020cc6cea48d50fcf08c95 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 13:04:26 +0100
Subject: [PATCH 02/18] don't build invocation chain if there is no middleware

---
 .../Invocation/InvocationPipeline.cs          | 42 +++++++++++++++----
 1 file changed, 33 insertions(+), 9 deletions(-)

diff --git a/src/System.CommandLine/Invocation/InvocationPipeline.cs b/src/System.CommandLine/Invocation/InvocationPipeline.cs
index 8e9864713e..08aba2febd 100644
--- a/src/System.CommandLine/Invocation/InvocationPipeline.cs
+++ b/src/System.CommandLine/Invocation/InvocationPipeline.cs
@@ -17,29 +17,51 @@ public InvocationPipeline(ParseResult parseResult)
             this.parseResult = parseResult ?? throw new ArgumentNullException(nameof(parseResult));
         }
 
-        public async Task<int> InvokeAsync(IConsole? console = null)
+        public Task<int> InvokeAsync(IConsole? console = null)
         {
             var context = new InvocationContext(parseResult, console);
 
-            InvocationMiddleware invocationChain = BuildInvocationChain(context);
+            if (context.Parser.Configuration.Middleware.Count == 0
+                && context.ParseResult.CommandResult.Command.Handler is ICommandHandler handler)
+            {
+                return handler.InvokeAsync(context);
+            }
+
+            return FullInvocationChainAsync(context);
+
+            static async Task<int> FullInvocationChainAsync(InvocationContext context)
+            {
+                InvocationMiddleware invocationChain = BuildInvocationChain(context, true);
 
-            await invocationChain(context, _ => Task.CompletedTask);
+                await invocationChain(context, _ => Task.CompletedTask);
 
-            return GetExitCode(context);
+                return GetExitCode(context);
+            }
         }
 
         public int Invoke(IConsole? console = null)
         {
             var context = new InvocationContext(parseResult, console);
 
-            InvocationMiddleware invocationChain = BuildInvocationChain(context);
+            if (context.Parser.Configuration.Middleware.Count == 0
+                && context.ParseResult.CommandResult.Command.Handler is ICommandHandler handler)
+            {
+                return handler.Invoke(context);
+            }
+
+            return FullInvocationChain(context); // kept in a separate method to avoid JITting
+
+            static int FullInvocationChain(InvocationContext context)
+            {
+                InvocationMiddleware invocationChain = BuildInvocationChain(context, false);
 
-            invocationChain(context, static _ => Task.CompletedTask).ConfigureAwait(false).GetAwaiter().GetResult();
+                invocationChain(context, static _ => Task.CompletedTask).ConfigureAwait(false).GetAwaiter().GetResult();
 
-            return GetExitCode(context);
+                return GetExitCode(context);
+            }
         }
 
-        private static InvocationMiddleware BuildInvocationChain(InvocationContext context)
+        private static InvocationMiddleware BuildInvocationChain(InvocationContext context, bool invokeAsync)
         {
             var invocations = new List<InvocationMiddleware>(context.Parser.Configuration.Middleware.Count + 1);
             invocations.AddRange(context.Parser.Configuration.Middleware);
@@ -55,7 +77,9 @@ private static InvocationMiddleware BuildInvocationChain(InvocationContext conte
 
                     if (handler is not null)
                     {
-                        context.ExitCode = await handler.InvokeAsync(invocationContext);
+                        context.ExitCode = invokeAsync
+                            ? await handler.InvokeAsync(invocationContext)
+                            : handler.Invoke(invocationContext);
                     }
                 }
             });

From e084081aa76aa310b464958461199b44d5dbb3b9 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 14:41:44 +0100
Subject: [PATCH 03/18] _executablePath.Value already uses
 Environment.GetCommandLineArgs()[0]

---
 src/System.CommandLine/RootCommand.cs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/System.CommandLine/RootCommand.cs b/src/System.CommandLine/RootCommand.cs
index df85644288..a8e46ba7bc 100644
--- a/src/System.CommandLine/RootCommand.cs
+++ b/src/System.CommandLine/RootCommand.cs
@@ -30,16 +30,6 @@ public class RootCommand : Command
             new(() =>
                 {
                     var location = _executablePath.Value;
-                    if (string.IsNullOrEmpty(location))
-                    {
-                        var commandLineArgs = Environment.GetCommandLineArgs();
-
-                        if (commandLineArgs.Length > 0)
-                        {
-                            location = commandLineArgs[0];
-                        }
-                    }
-
                     return Path.GetFileNameWithoutExtension(location).Replace(" ", "");
                 },
                 LazyThreadSafetyMode.PublicationOnly);

From e950bf073b7278a0026d181efb56a859b60d13d2 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 15:04:47 +0100
Subject: [PATCH 04/18] Command.Validators: allocate when needed

---
 src/System.CommandLine/Command.cs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/System.CommandLine/Command.cs b/src/System.CommandLine/Command.cs
index 48382b05b4..dce000b5cf 100644
--- a/src/System.CommandLine/Command.cs
+++ b/src/System.CommandLine/Command.cs
@@ -23,6 +23,7 @@ public class Command : IdentifierSymbol, IEnumerable<Symbol>
         private List<Argument>? _arguments;
         private List<Option>? _options;
         private List<Command>? _subcommands;
+        private List<ValidateSymbolResult<CommandResult>>? _validators;
 
         /// <summary>
         /// Initializes a new instance of the Command class.
@@ -66,6 +67,11 @@ public IEnumerable<Symbol> Children
         /// </summary>
         public IReadOnlyList<Command> Subcommands => _subcommands is not null ? _subcommands : Array.Empty<Command>();
 
+        internal IReadOnlyList<ValidateSymbolResult<CommandResult>> Validators
+            => _validators is not null ? _validators : Array.Empty<ValidateSymbolResult<CommandResult>>();
+
+        internal bool HasValidators => _validators is not null; // initialized by Add method, so when it's not null the Count is always > 0
+
         /// <summary>
         /// Adds an <see cref="Argument"/> to the command.
         /// </summary>
@@ -129,14 +135,12 @@ public void AddGlobalOption(Option option)
 
         private protected override string DefaultName => throw new NotImplementedException();
 
-        internal List<ValidateSymbolResult<CommandResult>> Validators { get; } = new();
-
         /// <summary>
         /// Adds a custom validator to the command. Validators can be used
         /// to create custom validation logic.
         /// </summary>
         /// <param name="validate">The delegate to validate the symbols during parsing.</param>
-        public void AddValidator(ValidateSymbolResult<CommandResult> validate) => Validators.Add(validate);
+        public void AddValidator(ValidateSymbolResult<CommandResult> validate) => (_validators ??= new()).Add(validate);
 
         /// <summary>
         /// Gets or sets a value that indicates whether unmatched tokens should be treated as errors. For example,

From 465e150f2503de5e1f45039c1707e0aa51c2686e Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 15:05:42 +0100
Subject: [PATCH 05/18] reduce and simplify ValidateCommandResult size to JIT
 less code in most common scenarios

---
 src/System.CommandLine/Command.cs             |  2 +
 .../Parsing/ParseResultVisitor.cs             | 91 +++++++++----------
 2 files changed, 43 insertions(+), 50 deletions(-)

diff --git a/src/System.CommandLine/Command.cs b/src/System.CommandLine/Command.cs
index dce000b5cf..4f9cfc7cd8 100644
--- a/src/System.CommandLine/Command.cs
+++ b/src/System.CommandLine/Command.cs
@@ -57,6 +57,8 @@ public IEnumerable<Symbol> Children
         /// </summary>
         public IReadOnlyList<Argument> Arguments => _arguments is not null ? _arguments : Array.Empty<Argument>();
 
+        internal bool HasArguments => _arguments is not null;
+
         /// <summary>
         /// Represents all of the options for the command, including global options that have been applied to any of the command's ancestors.
         /// </summary>
diff --git a/src/System.CommandLine/Parsing/ParseResultVisitor.cs b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
index 141d7db1bb..a6ea24f343 100644
--- a/src/System.CommandLine/Parsing/ParseResultVisitor.cs
+++ b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
@@ -323,84 +323,75 @@ private void ValidateCommandResult()
         {
             var command = _innermostCommandResult!.Command;
 
-            for (var i = 0; i < command.Validators.Count; i++)
+            if (command.HasValidators && UseValidators(command, _innermostCommandResult))
             {
-                var validateSymbolResult = command.Validators[i];
-                validateSymbolResult(_innermostCommandResult);
-
-                if (!string.IsNullOrWhiteSpace(_innermostCommandResult.ErrorMessage))
-                {
-                    AddErrorToResult(
-                        _innermostCommandResult, 
-                        new ParseError(_innermostCommandResult.ErrorMessage!, _innermostCommandResult));
-
-                    return;
-                }
+                return;
             }
 
-            var commandToCheckForRequiredOptions = command;
-            ParentNode? currentNode = null;
-            var checkOnlyGlobalOptions = false;
-
-            while (commandToCheckForRequiredOptions is not null)
+            bool checkOnlyGlobalOptions = false;
+            Command? currentCommand = command;
+            while (currentCommand is not null)
             {
-                var options = commandToCheckForRequiredOptions.Options;
-
+                var options = currentCommand.Options;
                 for (var i = 0; i < options.Count; i++)
                 {
                     var option = options[i];
-
-                    if (option.IsRequired &&
-                        _rootCommandResult!.FindResultFor(option) is null)
+                    if (option.IsRequired && (!checkOnlyGlobalOptions || (checkOnlyGlobalOptions && option.IsGlobal)))
                     {
-                        if (checkOnlyGlobalOptions && !option.IsGlobal)
+                        if (_rootCommandResult!.FindResultFor(option) is null)
                         {
-                            continue;
+                            AddErrorToResult(
+                                _innermostCommandResult,
+                                new ParseError($"Option '{option.Aliases.First()}' is required.",
+                                               _innermostCommandResult));
                         }
-
-                        AddErrorToResult(
-                            _innermostCommandResult,
-                            new ParseError($"Option '{option.Aliases.First()}' is required.",
-                                           _innermostCommandResult));
                     }
                 }
 
-                if (currentNode is not null)
-                {
-                    commandToCheckForRequiredOptions = currentNode.Next?.Symbol as Command;
-                    if (commandToCheckForRequiredOptions is null)
-                    {
-                        currentNode = null;
-                    }
-                }
-                else if (commandToCheckForRequiredOptions.FirstParent is not null)
-                {
-                    currentNode = commandToCheckForRequiredOptions.FirstParent;
-                    commandToCheckForRequiredOptions = currentNode.Symbol as Command;
-                    currentNode = currentNode.Next;
-                    checkOnlyGlobalOptions = true;
-                }
-                else
+                currentCommand = currentCommand.FirstParent?.Symbol as Command;
+                checkOnlyGlobalOptions = true;
+            }
+
+            if (command.HasArguments)
+            {
+                ValidateArguments(command.Arguments, _innermostCommandResult);
+            }
+        }
+
+        private bool UseValidators(Command command, CommandResult innermostCommandResult)
+        {
+            for (var i = 0; i < command.Validators.Count; i++)
+            {
+                var validateSymbolResult = command.Validators[i];
+                validateSymbolResult(innermostCommandResult);
+
+                if (!string.IsNullOrWhiteSpace(innermostCommandResult.ErrorMessage))
                 {
-                    break;
+                    AddErrorToResult(
+                        innermostCommandResult,
+                        new ParseError(innermostCommandResult.ErrorMessage!, _innermostCommandResult));
+
+                    return true;
                 }
             }
+            return false;
+        }
 
-            var arguments = command.Arguments;
-
+        private void ValidateArguments(IReadOnlyList<Argument> arguments, CommandResult innermostCommandResult)
+        {
             for (var i = 0; i < arguments.Count; i++)
             {
                 var symbol = arguments[i];
 
                 var arityFailure = ArgumentArity.Validate(
-                    _innermostCommandResult,
+                    innermostCommandResult,
                     symbol,
                     symbol.Arity.MinimumNumberOfValues,
                     symbol.Arity.MaximumNumberOfValues);
 
                 if (arityFailure is not null)
                 {
-                    AddErrorToResult(_innermostCommandResult, new ParseError(arityFailure.ErrorMessage!, _innermostCommandResult));
+                    AddErrorToResult(innermostCommandResult, new ParseError(arityFailure.ErrorMessage!, innermostCommandResult));
                 }
             }
         }

From 4f7cc7281afb7b5d1d0bae2ab358996cdb9426c6 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 16:47:32 +0100
Subject: [PATCH 06/18] reduce ParseResultVisitor.Stop size, saves 1 ms of JIT
 time for simple scenarios

---
 .../Parsing/ParseResultVisitor.cs             | 89 ++++++++++---------
 1 file changed, 45 insertions(+), 44 deletions(-)

diff --git a/src/System.CommandLine/Parsing/ParseResultVisitor.cs b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
index a6ea24f343..6e2684c874 100644
--- a/src/System.CommandLine/Parsing/ParseResultVisitor.cs
+++ b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
@@ -251,69 +251,70 @@ private void Stop()
 
             if (_argumentResults.Count > 0)
             {
-                var arguments = _innermostCommandResult!.Command.Arguments;
-
-                var commandArgumentResultCount = _argumentResults.Count;
+                ValidateAndConvertArgumentResults(_innermostCommandResult!.Command.Arguments, _argumentResults.Count);
+            }
+        }
 
-                for (var i = 0; i < arguments.Count; i++)
+        private void ValidateAndConvertArgumentResults(IReadOnlyList<Argument> arguments, int commandArgumentResultCount)
+        {
+            for (var i = 0; i < arguments.Count; i++)
+            {
+                // If this is the current last result but there are more arguments, see if we can shift tokens to the next argument
+                if (commandArgumentResultCount == i)
                 {
-                    // If this is the current last result but there are more arguments, see if we can shift tokens to the next argument
-                    if (commandArgumentResultCount == i)
-                    {
-                        var nextArgument = arguments[i];
-                        var nextArgumentResult = new ArgumentResult(
-                            nextArgument,
-                            _innermostCommandResult);
+                    var nextArgument = arguments[i];
+                    var nextArgumentResult = new ArgumentResult(
+                        nextArgument,
+                        _innermostCommandResult);
 
-                        var previousArgumentResult = _argumentResults[i - 1];
+                    var previousArgumentResult = _argumentResults[i - 1];
 
-                        var passedOnTokensCount = _innermostCommandResult?.Tokens.Count;
+                    var passedOnTokensCount = _innermostCommandResult?.Tokens.Count;
 
-                        for (var j = previousArgumentResult.Tokens.Count; j < passedOnTokensCount; j++)
+                    for (var j = previousArgumentResult.Tokens.Count; j < passedOnTokensCount; j++)
+                    {
+                        if (nextArgumentResult.IsArgumentLimitReached)
                         {
-                            if (nextArgumentResult.IsArgumentLimitReached)
-                            {
-                                break;
-                            }
-
-                            if (_innermostCommandResult is not null)
-                            {
-                                nextArgumentResult.AddToken(_innermostCommandResult.Tokens[j]);
-                            }
+                            break;
                         }
 
-                        _argumentResults.Add(nextArgumentResult);
-
-                        if (previousArgumentResult.Parent is CommandResult)
+                        if (_innermostCommandResult is not null)
                         {
-                            AddToResult(nextArgumentResult);
+                            nextArgumentResult.AddToken(_innermostCommandResult.Tokens[j]);
                         }
-
-                        _symbolResults.TryAdd(nextArgumentResult.Symbol, nextArgumentResult);
                     }
 
-                    var argumentResult = _argumentResults[i];
+                    _argumentResults.Add(nextArgumentResult);
 
-                    ValidateAndConvertArgumentResult(argumentResult);
-
-                    if (argumentResult.PassedOnTokens is { } &&
-                        i == arguments.Count - 1)
+                    if (previousArgumentResult.Parent is CommandResult)
                     {
-                        _unparsedTokens ??= new List<Token>();
-                        _unparsedTokens.AddRange(argumentResult.PassedOnTokens);
+                        AddToResult(nextArgumentResult);
                     }
+
+                    _symbolResults.TryAdd(nextArgumentResult.Symbol, nextArgumentResult);
                 }
 
-                if (_argumentResults.Count > arguments.Count)
+                var argumentResult = _argumentResults[i];
+
+                ValidateAndConvertArgumentResult(argumentResult);
+
+                if (argumentResult.PassedOnTokens is { } &&
+                    i == arguments.Count - 1)
                 {
-                    for (var i = arguments.Count; i < _argumentResults.Count; i++)
-                    {
-                        var result = _argumentResults[i];
+                    _unparsedTokens ??= new List<Token>();
+                    _unparsedTokens.AddRange(argumentResult.PassedOnTokens);
+                }
+            }
 
-                        if (result.Parent is CommandResult)
-                        {
-                            ValidateAndConvertArgumentResult(result);
-                        }
+            if (_argumentResults.Count > arguments.Count)
+            {
+                for (var i = arguments.Count; i < _argumentResults.Count; i++)
+                {
+                    var result = _argumentResults[i];
+
+                    if (result.Parent is CommandResult)
+                    {
+                        ValidateAndConvertArgumentResult(result);
                     }
                 }
             }

From 59b1941e392927c74d42063981050a6dca5f64a4 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 18:03:22 +0100
Subject: [PATCH 07/18] make Token a class again, so JIT does not need to
 compile specialized methods for it.  -3ms for startup!

---
 ...ests.System_CommandLine_api_is_not_changed.approved.txt | 2 +-
 src/System.CommandLine/Completions/CompletionContext.cs    | 6 +++---
 src/System.CommandLine/Help/VersionOption.cs               | 2 +-
 .../Invocation/SuggestDirectiveResult.cs                   | 2 +-
 src/System.CommandLine/Parsing/CommandResult.cs            | 7 +------
 src/System.CommandLine/Parsing/OptionResult.cs             | 6 +++---
 src/System.CommandLine/Parsing/StringExtensions.cs         | 2 +-
 src/System.CommandLine/Parsing/SymbolResultExtensions.cs   | 2 +-
 src/System.CommandLine/Parsing/Token.cs                    | 6 ++----
 9 files changed, 14 insertions(+), 21 deletions(-)

diff --git a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
index 52b1dc3683..7cd496d848 100644
--- a/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
+++ b/src/System.CommandLine.ApiCompatibility.Tests/ApiCompatibilityApprovalTests.System_CommandLine_api_is_not_changed.approved.txt
@@ -499,7 +499,7 @@ System.CommandLine.Parsing
     public T GetValueForOption<T>(Option<T> option)
     public System.Object GetValueForOption(System.CommandLine.Option option)
     public System.String ToString()
-  public struct Token : System.ValueType, System.IEquatable<Token>
+  public class Token, System.IEquatable<Token>
     public static System.Boolean op_Equality(Token left, Token right)
     public static System.Boolean op_Inequality(Token left, Token right)
     .ctor(System.String value, TokenType type, System.CommandLine.Symbol symbol)
diff --git a/src/System.CommandLine/Completions/CompletionContext.cs b/src/System.CommandLine/Completions/CompletionContext.cs
index 8ad7759dc4..720dc33984 100644
--- a/src/System.CommandLine/Completions/CompletionContext.cs
+++ b/src/System.CommandLine/Completions/CompletionContext.cs
@@ -35,7 +35,7 @@ protected static string GetWordToComplete(
             ParseResult parseResult,
             int? position = null)
         {
-            Token lastToken = parseResult.Tokens.LastOrDefault(t => t.Type != TokenType.Directive);
+            Token? lastToken = parseResult.Tokens.LastOrDefault(t => t.Type != TokenType.Directive);
 
             string? textToMatch = null;
             string? rawInput = parseResult.CommandLineText;
@@ -55,7 +55,7 @@ protected static string GetWordToComplete(
                     position = rawInput.Length;
                 }
             }
-            else if (!lastToken.IsDefault)
+            else if (lastToken is not null)
             {
                 position = null;
                 textToMatch = lastToken.Value;
@@ -64,7 +64,7 @@ protected static string GetWordToComplete(
             if (string.IsNullOrWhiteSpace(rawInput))
             {
                 if (parseResult.UnmatchedTokens.Count > 0 ||
-                    lastToken.Type == TokenType.Argument)
+                    lastToken?.Type == TokenType.Argument)
                 {
                     return textToMatch ?? "";
                 }
diff --git a/src/System.CommandLine/Help/VersionOption.cs b/src/System.CommandLine/Help/VersionOption.cs
index 31ea392161..4a7766a431 100644
--- a/src/System.CommandLine/Help/VersionOption.cs
+++ b/src/System.CommandLine/Help/VersionOption.cs
@@ -38,7 +38,7 @@ private void AddValidators()
                     parent.Children.Where(r => r.Symbol is not VersionOption)
                           .Any(IsNotImplicit))
                 {
-                    result.ErrorMessage =  result.LocalizationResources.VersionOptionCannotBeCombinedWithOtherArguments(result.Token.Value ?? result.Symbol.Name);
+                    result.ErrorMessage =  result.LocalizationResources.VersionOptionCannotBeCombinedWithOtherArguments(result.Token?.Value ?? result.Symbol.Name);
                 }
             });
         }
diff --git a/src/System.CommandLine/Invocation/SuggestDirectiveResult.cs b/src/System.CommandLine/Invocation/SuggestDirectiveResult.cs
index b01b09c5ef..62adfc1e6d 100644
--- a/src/System.CommandLine/Invocation/SuggestDirectiveResult.cs
+++ b/src/System.CommandLine/Invocation/SuggestDirectiveResult.cs
@@ -18,7 +18,7 @@ public SuggestDirectiveResult(int position)
 
         public void Apply(InvocationContext context)
         {
-            var commandLineToComplete = context.ParseResult.Tokens.LastOrDefault(t => t.Type != TokenType.Directive).Value ?? "";
+            var commandLineToComplete = context.ParseResult.Tokens.LastOrDefault(t => t.Type != TokenType.Directive)?.Value ?? "";
 
             var completionParseResult = context.Parser.Parse(commandLineToComplete);
 
diff --git a/src/System.CommandLine/Parsing/CommandResult.cs b/src/System.CommandLine/Parsing/CommandResult.cs
index 6c786ff2d4..b6a9140685 100644
--- a/src/System.CommandLine/Parsing/CommandResult.cs
+++ b/src/System.CommandLine/Parsing/CommandResult.cs
@@ -15,13 +15,8 @@ internal CommandResult(
             base(command ?? throw new ArgumentNullException(nameof(command)),
                  parent)
         {
-            if (token.IsDefault)
-            {
-                throw new ArgumentNullException(nameof(token));
-            }
-
             Command = command;
-            Token = token;
+            Token = token ?? throw new ArgumentNullException(nameof(token));
         }
 
         /// <summary>
diff --git a/src/System.CommandLine/Parsing/OptionResult.cs b/src/System.CommandLine/Parsing/OptionResult.cs
index 10b1e5a8d7..e1c2b957d0 100644
--- a/src/System.CommandLine/Parsing/OptionResult.cs
+++ b/src/System.CommandLine/Parsing/OptionResult.cs
@@ -21,7 +21,7 @@ internal OptionResult(
                  parent)
         {
             Option = option;
-            Token = token.GetValueOrDefault();
+            Token = token;
         }
 
         /// <summary>
@@ -33,12 +33,12 @@ internal OptionResult(
         /// Indicates whether the result was created implicitly and not due to the option being specified on the command line.
         /// </summary>
         /// <remarks>Implicit results commonly result from options having a default value.</remarks>
-        public bool IsImplicit => Token.IsImplicit || Token.IsDefault;
+        public bool IsImplicit => Token is null || Token.IsImplicit;
 
         /// <summary>
         /// The token that was parsed to specify the option.
         /// </summary>
-        public Token Token { get; }
+        public Token? Token { get; }
 
         /// <inheritdoc cref="GetValueOrDefault{T}"/>
         public object? GetValueOrDefault() =>
diff --git a/src/System.CommandLine/Parsing/StringExtensions.cs b/src/System.CommandLine/Parsing/StringExtensions.cs
index 74dd6082a1..c9fb3c0801 100644
--- a/src/System.CommandLine/Parsing/StringExtensions.cs
+++ b/src/System.CommandLine/Parsing/StringExtensions.cs
@@ -222,7 +222,7 @@ bool TryUnbundle(ReadOnlySpan<char> alias, int argumentIndex)
                             }
 
                             pCandidate[1] = alias[i];
-                            if (!knownTokens.TryGetValue(candidate, out Token found))
+                            if (!knownTokens.TryGetValue(candidate, out Token? found))
                             {
                                 if (tokensBefore != tokenList.Count && tokenList[tokenList.Count - 1].Type == TokenType.Option)
                                 {
diff --git a/src/System.CommandLine/Parsing/SymbolResultExtensions.cs b/src/System.CommandLine/Parsing/SymbolResultExtensions.cs
index b0a8e09485..021f9c56ad 100644
--- a/src/System.CommandLine/Parsing/SymbolResultExtensions.cs
+++ b/src/System.CommandLine/Parsing/SymbolResultExtensions.cs
@@ -25,7 +25,7 @@ internal static Token Token(this SymbolResult symbolResult)
             return symbolResult switch
             {
                 CommandResult commandResult => commandResult.Token,
-                OptionResult optionResult => optionResult.Token.IsDefault ? CreateImplicitToken(optionResult.Option) : optionResult.Token,
+                OptionResult optionResult => optionResult.Token is null ? CreateImplicitToken(optionResult.Option) : optionResult.Token,
                 _ => throw new ArgumentOutOfRangeException(nameof(symbolResult))
             };
 
diff --git a/src/System.CommandLine/Parsing/Token.cs b/src/System.CommandLine/Parsing/Token.cs
index aab11a3705..7b656c9886 100644
--- a/src/System.CommandLine/Parsing/Token.cs
+++ b/src/System.CommandLine/Parsing/Token.cs
@@ -6,7 +6,7 @@ namespace System.CommandLine.Parsing
     /// <summary>
     /// A unit of significant text on the command line.
     /// </summary>
-    public readonly struct Token : IEquatable<Token>
+    public class Token : IEquatable<Token>
     {
         internal const int ImplicitPosition = -1;
 
@@ -38,8 +38,6 @@ internal Token(string? value, TokenType type, Symbol? symbol, int position)
 
         internal bool IsImplicit => Position == ImplicitPosition;
 
-        internal bool IsDefault => Value is null && Position == default && Type == default && Symbol is null;
-
         /// <summary>
         /// The type of the token.
         /// </summary>
@@ -54,7 +52,7 @@ internal Token(string? value, TokenType type, Symbol? symbol, int position)
         public override bool Equals(object? obj) => obj is Token other && Equals(other);
 
         /// <inheritdoc />
-        public bool Equals(Token other) => Value == other.Value && Type == other.Type && ReferenceEquals(Symbol, other.Symbol);
+        public bool Equals(Token? other) => other is not null && Value == other.Value && Type == other.Type && ReferenceEquals(Symbol, other.Symbol);
 
         /// <inheritdoc />
         public override int GetHashCode() => Value.GetHashCode() ^ (int)Type;

From 0ed55321d8439625f54cd6919bfc9f1c103accb8 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 18:21:26 +0100
Subject: [PATCH 08/18] refactor ParseDirectives to JIT less code when
 directives are not provided (0.4 ms of JIT time)

---
 src/System.CommandLine/Parsing/ParseOperation.cs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/System.CommandLine/Parsing/ParseOperation.cs b/src/System.CommandLine/Parsing/ParseOperation.cs
index 952b267fb3..43de0f2e9e 100644
--- a/src/System.CommandLine/Parsing/ParseOperation.cs
+++ b/src/System.CommandLine/Parsing/ParseOperation.cs
@@ -204,6 +204,11 @@ private void ParseOptionArguments(OptionNode optionNode)
         private void ParseDirectives(RootCommandNode parent)
         {
             while (More(out TokenType currentTokenType) && currentTokenType == TokenType.Directive)
+            {
+                ParseDirective(parent); // kept in separate method to avoid JIT
+            }
+
+            void ParseDirective(RootCommandNode parent)
             {
                 var token = CurrentToken;
                 var withoutBrackets = token.Value.Substring(1, token.Value.Length - 2);

From fb76e4260b01a18668e9b0802276aef24cf806a7 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 18:33:05 +0100
Subject: [PATCH 09/18] refactor GetValueForHandlerParameter to JIT less code
 for most common case

---
 src/System.CommandLine/Handler.cs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/System.CommandLine/Handler.cs b/src/System.CommandLine/Handler.cs
index 87cca4b18f..3b2a6211dc 100644
--- a/src/System.CommandLine/Handler.cs
+++ b/src/System.CommandLine/Handler.cs
@@ -21,7 +21,7 @@ public static partial class Handler
         {
             index++;
 
-            if (symbol is IValueSource valueSource && 
+            if (symbol is IValueSource valueSource &&
                 valueSource.TryGetValue(symbol, context.BindingContext, out var boundValue) &&
                 boundValue is T value)
             {
@@ -33,6 +33,11 @@ public static partial class Handler
             }
         }
 
+        return GetService<T>(ref index, context); // kept in separate method to avoid jitting rare code path
+    }
+
+    private static T? GetService<T>(ref int index, InvocationContext context)
+    {
         var service = context.BindingContext.GetService(typeof(T));
 
         if (service is null)

From bd44fb2c396c00b0a97ca1540401ff5cf7434f99 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Tue, 22 Feb 2022 19:37:41 +0100
Subject: [PATCH 10/18] remove static fields from StringExtensions (they need
 to be compiled and initialized)

---
 .../Parsing/StringExtensions.cs                | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/System.CommandLine/Parsing/StringExtensions.cs b/src/System.CommandLine/Parsing/StringExtensions.cs
index c9fb3c0801..2874054b8f 100644
--- a/src/System.CommandLine/Parsing/StringExtensions.cs
+++ b/src/System.CommandLine/Parsing/StringExtensions.cs
@@ -9,9 +9,6 @@ namespace System.CommandLine.Parsing
 {
     internal static class StringExtensions
     {
-        private static readonly string[] _optionPrefixStrings = { "--", "-", "/" };
-        private static readonly char[] _argumentDelimiters = { ':', '=' };
-
         internal static bool ContainsCaseInsensitive(
             this string source,
             string value) =>
@@ -50,13 +47,18 @@ internal static int GetPrefixLength(this string alias)
 
         internal static (string? Prefix, string Alias) SplitPrefix(this string rawAlias)
         {
-            for (var i = 0; i < _optionPrefixStrings.Length; i++)
+            if (rawAlias[0] == '/')
+            {
+                return ("/", rawAlias.Substring(1));
+            }
+            else if (rawAlias[0] == '-')
             {
-                var prefix = _optionPrefixStrings[i];
-                if (rawAlias.StartsWith(prefix, StringComparison.Ordinal))
+                if (rawAlias.Length > 1 && rawAlias[1] == '-')
                 {
-                    return (prefix, rawAlias.Substring(prefix.Length));
+                    return ("--", rawAlias.Substring(2));
                 }
+
+                return ("-", rawAlias.Substring(1));
             }
 
             return (null, rawAlias);
@@ -386,7 +388,7 @@ internal static bool TrySplitIntoSubtokens(
             out string first,
             out string? rest)
         {
-            var i = arg.IndexOfAny(_argumentDelimiters);
+            var i = arg.AsSpan().IndexOfAny(':', '=');
 
             if (i >= 0)
             {

From 0a82102f2c972da97fe5f2e1b20a83f974be18d4 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Wed, 23 Feb 2022 10:44:46 +0100
Subject: [PATCH 11/18] optimize getting Middleware by using Tuple (class)
 instead of ValueTuple (struct). -4 JIT compilaitons

---
 .../Builder/CommandLineBuilder.cs             | 30 +++++++++----------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/src/System.CommandLine/Builder/CommandLineBuilder.cs b/src/System.CommandLine/Builder/CommandLineBuilder.cs
index 9bd9dfed6d..959fcecdca 100644
--- a/src/System.CommandLine/Builder/CommandLineBuilder.cs
+++ b/src/System.CommandLine/Builder/CommandLineBuilder.cs
@@ -14,7 +14,10 @@ namespace System.CommandLine.Builder
     /// </summary>
     public class CommandLineBuilder 
     {
-        private readonly List<(InvocationMiddleware middleware, int order)> _middlewareList = new();
+        // for every generic type with type argument being struct JIT needs to compile a dedicated version
+        // (because each struct is of a different size)
+        // that is why we don't use List<ValueTuple> for middleware
+        private List<Tuple<InvocationMiddleware, int>>? _middlewareList;
         private LocalizationResources? _localizationResources;
         private Action<HelpContext>? _customizeHelpBuilder;
         private Func<BindingContext, HelpBuilder>? _helpBuilderFactory;
@@ -99,7 +102,7 @@ public Parser Build()
                     enableLegacyDoubleDashBehavior: EnableLegacyDoubleDashBehavior,
                     resources: LocalizationResources,
                     responseFileHandling: ResponseFileHandling,
-                    middlewarePipeline: GetMiddleware(),
+                    middlewarePipeline: _middlewareList is null ? Array.Empty<InvocationMiddleware>() : GetMiddleware(),
                     helpBuilderFactory: GetHelpBuilderFactory()));
             
             return parser;
@@ -107,27 +110,22 @@ public Parser Build()
 
         private IReadOnlyList<InvocationMiddleware> GetMiddleware()
         {
-            _middlewareList.Sort(static (m1, m2) => m1.order.CompareTo(m2.order));
+            _middlewareList!.Sort(static (m1, m2) => m1.Item2.CompareTo(m2.Item2));
             InvocationMiddleware[] result = new InvocationMiddleware[_middlewareList.Count];
             for (int i = 0; i < result.Length; i++)
             {
-                result[i] = _middlewareList[i].middleware;
+                result[i] = _middlewareList[i].Item1;
             }
             return result;
         }
 
-        internal void AddMiddleware(
-            InvocationMiddleware middleware,
-            MiddlewareOrder order)
-        {
-            _middlewareList.Add((middleware, (int) order));
-        }
+        internal void AddMiddleware(InvocationMiddleware middleware, MiddlewareOrder order)
+            => AddMiddleware(middleware, (int)order);
 
-        internal void AddMiddleware(
-            InvocationMiddleware middleware,
-            MiddlewareOrderInternal order)
-        {
-            _middlewareList.Add((middleware, (int) order));
-        }
+        internal void AddMiddleware(InvocationMiddleware middleware, MiddlewareOrderInternal order)
+            => AddMiddleware(middleware, (int)order);
+
+        private void AddMiddleware(InvocationMiddleware middleware, int order)
+            => (_middlewareList ??= new()).Add(new Tuple<InvocationMiddleware, int>(middleware, order));
     }
 }

From 3de63b1c5923bfb27985b052a934c492f4ee7059 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Wed, 23 Feb 2022 11:21:05 +0100
Subject: [PATCH 12/18] use Nullable.GetUnderlyingType instead of custom
 implementation (and compile less)

---
 .../Binding/TypeExtensions.cs                 | 21 +++----------------
 1 file changed, 3 insertions(+), 18 deletions(-)

diff --git a/src/System.CommandLine/Binding/TypeExtensions.cs b/src/System.CommandLine/Binding/TypeExtensions.cs
index 6dd83a7751..b0b680a698 100644
--- a/src/System.CommandLine/Binding/TypeExtensions.cs
+++ b/src/System.CommandLine/Binding/TypeExtensions.cs
@@ -47,29 +47,14 @@ internal static bool IsEnumerable(this Type type)
                 typeof(IEnumerable).IsAssignableFrom(type);
         }
 
-        internal static bool IsNullable(this Type t)
-        {
-            return t.IsGenericType &&
-                   t.GetGenericTypeDefinition() == typeof(Nullable<>);
-        }
+        internal static bool IsNullable(this Type t) => Nullable.GetUnderlyingType(t) is not null;
 
         internal static bool TryGetNullableType(
             this Type type,
             [NotNullWhen(true)] out Type? nullableType)
         {
-            if (type.IsGenericType)
-            {
-                var genericTypeDefinition = type.GetGenericTypeDefinition();
-
-                if (genericTypeDefinition == typeof(Nullable<>))
-                {
-                    nullableType = type.GetGenericArguments()[0];
-                    return true;
-                }
-            }
-
-            nullableType = null;
-            return false;
+            nullableType = Nullable.GetUnderlyingType(type);
+            return nullableType is not null;
         }
     }
 }
\ No newline at end of file

From 2127b1e3427e587d906bbaebe7f76cdd957c27c3 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Wed, 23 Feb 2022 11:34:12 +0100
Subject: [PATCH 13/18] don't use Lazy, -4 compilations

---
 src/System.CommandLine/RootCommand.cs | 28 ++++++++-------------------
 1 file changed, 8 insertions(+), 20 deletions(-)

diff --git a/src/System.CommandLine/RootCommand.cs b/src/System.CommandLine/RootCommand.cs
index a8e46ba7bc..3fe653c1cc 100644
--- a/src/System.CommandLine/RootCommand.cs
+++ b/src/System.CommandLine/RootCommand.cs
@@ -3,7 +3,6 @@
 
 using System.IO;
 using System.Reflection;
-using System.Threading;
 
 namespace System.CommandLine
 {
@@ -17,39 +16,28 @@ namespace System.CommandLine
     /// </remarks>
     public class RootCommand : Command
     {
-        private static readonly Lazy<Assembly> _assembly =
-            new(() => Assembly.GetEntryAssembly() ??
-                      Assembly.GetExecutingAssembly(),
-                LazyThreadSafetyMode.PublicationOnly);
-
-        private static readonly Lazy<string> _executablePath =
-            new(() => Environment.GetCommandLineArgs()[0],
-                LazyThreadSafetyMode.PublicationOnly);
-
-        private static readonly Lazy<string> _executableName =
-            new(() =>
-                {
-                    var location = _executablePath.Value;
-                    return Path.GetFileNameWithoutExtension(location).Replace(" ", "");
-                },
-                LazyThreadSafetyMode.PublicationOnly);
+        private static Assembly? _assembly;
+        private static string? _executablePath;
+        private static string? _executableName;
 
         /// <param name="description">The description of the command, shown in help.</param>
         public RootCommand(string description = "") : base(ExecutableName, description)
         {
         }
 
-        internal static Assembly GetAssembly() => _assembly.Value;
+        internal static Assembly GetAssembly()
+            => _assembly ??= (Assembly.GetEntryAssembly() ?? Assembly.GetExecutingAssembly());
 
         /// <summary>
         /// The name of the currently running executable.
         /// </summary>
-        public static string ExecutableName => _executableName.Value;
+        public static string ExecutableName
+            => _executableName ??= Path.GetFileNameWithoutExtension(ExecutablePath).Replace(" ", "");
 
         /// <summary>
         /// The path to the currently running executable.
         /// </summary>
-        public static string ExecutablePath => _executablePath.Value;
+        public static string ExecutablePath => _executablePath ??= Environment.GetCommandLineArgs()[0];
 
         private protected override void RemoveAlias(string alias)
         {

From 1d7aff765c463e06816fa70188df8bc699db5f3d Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Wed, 23 Feb 2022 12:28:12 +0100
Subject: [PATCH 14/18] reduce the number of types derived from
 ArgumentConversionResult to reduce the number of compilations and type
 loading

---
 src/System.CommandLine/ArgumentArity.cs       | 12 ++--
 .../Binding/ArgumentConversionResult.cs       | 64 +++++++++++++++--
 .../Binding/ArgumentConversionResultType.cs   | 16 +++++
 .../Binding/ArgumentConverter.cs              | 72 ++++++++++---------
 .../Binding/BindingContext.cs                 |  4 +-
 .../FailedArgumentConversionArityResult.cs    | 12 ----
 .../Binding/FailedArgumentConversionResult.cs | 20 ------
 .../FailedArgumentTypeConversionResult.cs     | 42 -----------
 .../Binding/IValueDescriptor.cs               |  2 -
 .../MissingArgumentConversionResult.cs        | 12 ----
 .../Binding/NoArgumentConversionResult.cs     | 12 ----
 .../SuccessfulArgumentConversionResult.cs     | 16 -----
 .../TooManyArgumentsConversionResult.cs       | 12 ----
 .../Parsing/ArgumentResult.cs                 | 20 +++---
 .../Parsing/ParseResultExtensions.cs          | 15 ++--
 .../Parsing/ParseResultVisitor.cs             | 14 ++--
 16 files changed, 147 insertions(+), 198 deletions(-)
 create mode 100644 src/System.CommandLine/Binding/ArgumentConversionResultType.cs
 delete mode 100644 src/System.CommandLine/Binding/FailedArgumentConversionArityResult.cs
 delete mode 100644 src/System.CommandLine/Binding/FailedArgumentConversionResult.cs
 delete mode 100644 src/System.CommandLine/Binding/FailedArgumentTypeConversionResult.cs
 delete mode 100644 src/System.CommandLine/Binding/MissingArgumentConversionResult.cs
 delete mode 100644 src/System.CommandLine/Binding/NoArgumentConversionResult.cs
 delete mode 100644 src/System.CommandLine/Binding/SuccessfulArgumentConversionResult.cs
 delete mode 100644 src/System.CommandLine/Binding/TooManyArgumentsConversionResult.cs

diff --git a/src/System.CommandLine/ArgumentArity.cs b/src/System.CommandLine/ArgumentArity.cs
index f887c474c1..c0153fc86e 100644
--- a/src/System.CommandLine/ArgumentArity.cs
+++ b/src/System.CommandLine/ArgumentArity.cs
@@ -72,7 +72,7 @@ public bool Equals(ArgumentArity other) =>
         public override int GetHashCode()
             => MaximumNumberOfValues ^ MinimumNumberOfValues ^ IsNonDefault.GetHashCode();
 
-        internal static FailedArgumentConversionArityResult? Validate(
+        internal static ArgumentConversionResult? Validate(
             SymbolResult symbolResult,
             Argument argument,
             int minimumNumberOfValues,
@@ -93,9 +93,10 @@ public override int GetHashCode()
                     return null;
                 }
 
-                return new MissingArgumentConversionResult(
+                return ArgumentConversionResult.Failure(
                     argument,
-                    symbolResult.LocalizationResources.RequiredArgumentMissing(symbolResult));
+                    symbolResult.LocalizationResources.RequiredArgumentMissing(symbolResult),
+                    ArgumentConversionResultType.FailedMissingArgument);
             }
 
             if (tokenCount > maximumNumberOfValues)
@@ -104,9 +105,10 @@ public override int GetHashCode()
                 {
                     if (!optionResult.Option.AllowMultipleArgumentsPerToken)
                     {
-                        return new TooManyArgumentsConversionResult(
+                        return ArgumentConversionResult.Failure(
                             argument,
-                            symbolResult!.LocalizationResources.ExpectsOneArgument(symbolResult));
+                            symbolResult!.LocalizationResources.ExpectsOneArgument(symbolResult),
+                            ArgumentConversionResultType.FailedTooManyArguments);
                     }
                 }
             }
diff --git a/src/System.CommandLine/Binding/ArgumentConversionResult.cs b/src/System.CommandLine/Binding/ArgumentConversionResult.cs
index 2da4231ad9..9cc56e88f2 100644
--- a/src/System.CommandLine/Binding/ArgumentConversionResult.cs
+++ b/src/System.CommandLine/Binding/ArgumentConversionResult.cs
@@ -1,23 +1,73 @@
 // 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.Linq;
+
 namespace System.CommandLine.Binding
 {
-    internal abstract class ArgumentConversionResult
+    internal sealed class ArgumentConversionResult
     {
-        private protected ArgumentConversionResult(Argument argument)
+        internal readonly Argument Argument;
+        internal readonly object? Value;
+        internal readonly string? ErrorMessage;
+        internal ArgumentConversionResultType Result;
+
+        private ArgumentConversionResult(Argument argument, string error, ArgumentConversionResultType failure)
+        {
+            Argument = argument ?? throw new ArgumentNullException(nameof(argument));
+            ErrorMessage = error ?? throw new ArgumentNullException(nameof(error));
+            Result = failure;
+        }
+
+        private ArgumentConversionResult(Argument argument, object? value)
+        {
+            Argument = argument ?? throw new ArgumentNullException(nameof(argument));
+            Value = value;
+            Result = ArgumentConversionResultType.Successful;
+        }
+
+        private ArgumentConversionResult(Argument argument)
         {
             Argument = argument ?? throw new ArgumentNullException(nameof(argument));
+            Result = ArgumentConversionResultType.NoArgument;
+        }
+
+        internal ArgumentConversionResult(
+            Argument argument,
+            Type expectedType,
+            string value,
+            LocalizationResources localizationResources) :
+            this(argument, FormatErrorMessage(argument, expectedType, value, localizationResources), ArgumentConversionResultType.FailedType)
+        {
         }
 
-        public Argument Argument { get; }
+        internal static ArgumentConversionResult Failure(Argument argument, string error, ArgumentConversionResultType reason) => new(argument, error, reason);
+
+        public static ArgumentConversionResult Success(Argument argument, object? value) => new(argument, value);
 
-        internal string? ErrorMessage { get; set; }
+        internal static ArgumentConversionResult None(Argument argument) => new(argument);
 
-        internal static FailedArgumentConversionResult Failure(Argument argument, string error) => new(argument, error);
+        private static string FormatErrorMessage(
+            Argument argument,
+            Type expectedType,
+            string value,
+            LocalizationResources localizationResources)
+        {
+            if (argument.FirstParent?.Symbol is IdentifierSymbol identifierSymbol &&
+                argument.FirstParent.Next is null)
+            {
+                var alias = identifierSymbol.Aliases.First();
 
-        public static SuccessfulArgumentConversionResult Success(Argument argument, object? value) => new(argument, value);
+                switch (identifierSymbol)
+                {
+                    case Command _:
+                        return localizationResources.ArgumentConversionCannotParseForCommand(value, alias, expectedType);
+                    case Option _:
+                        return localizationResources.ArgumentConversionCannotParseForOption(value, alias, expectedType);
+                }
+            }
 
-        internal static NoArgumentConversionResult None(Argument argument) => new(argument);
+            return localizationResources.ArgumentConversionCannotParse(value, expectedType);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/System.CommandLine/Binding/ArgumentConversionResultType.cs b/src/System.CommandLine/Binding/ArgumentConversionResultType.cs
new file mode 100644
index 0000000000..8915793850
--- /dev/null
+++ b/src/System.CommandLine/Binding/ArgumentConversionResultType.cs
@@ -0,0 +1,16 @@
+// 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.
+
+namespace System.CommandLine.Binding
+{
+    internal enum ArgumentConversionResultType
+    {
+        NoArgument, // NoArgumentConversionResult
+        Successful, // SuccessfulArgumentConversionResult
+        Failed, // FailedArgumentConversionResult
+        FailedArity, // FailedArgumentConversionArityResult
+        FailedType, // FailedArgumentTypeConversionResult
+        FailedTooManyArguments, // TooManyArgumentsConversionResult
+        FailedMissingArgument, // MissingArgumentConversionResult
+    }
+}
\ No newline at end of file
diff --git a/src/System.CommandLine/Binding/ArgumentConverter.cs b/src/System.CommandLine/Binding/ArgumentConverter.cs
index 0cf0819c97..096e60c3a3 100644
--- a/src/System.CommandLine/Binding/ArgumentConverter.cs
+++ b/src/System.CommandLine/Binding/ArgumentConverter.cs
@@ -97,31 +97,33 @@ private static ArgumentConversionResult ConvertTokens(
 
                 var result = ConvertToken(argument, itemType, token, localizationResources);
 
-                switch (result)
+                switch (result.Result)
                 {
-                    case FailedArgumentTypeConversionResult _:
-                    case FailedArgumentConversionResult _:
-                        if (argumentResult is { Parent: CommandResult })
-                        {
-                            argumentResult.OnlyTake(i);
-
-                            i = tokens.Count;
-                            break;
-                        }
-
-                        return result;
+                    case ArgumentConversionResultType.NoArgument:
+                        break;
 
-                    case SuccessfulArgumentConversionResult success:
+                    case ArgumentConversionResultType.Successful:
                         if (isArray)
                         {
-                            values[i] = success.Value;
+                            values[i] = result.Value;
                         }
                         else
                         {
-                            values.Add(success.Value);
+                            values.Add(result.Value);
                         }
 
                         break;
+
+                    default: // failures
+                        if (argumentResult is { Parent: CommandResult })
+                        {
+                            argumentResult.OnlyTake(i);
+
+                            i = tokens.Count;
+                            break;
+                        }
+
+                        return result;
                 }
             }
 
@@ -183,13 +185,13 @@ private static bool CanBeBoundFromScalarValue(this Type type)
             }
         }
 
-        private static FailedArgumentConversionResult Failure(
+        private static ArgumentConversionResult Failure(
             Argument argument,
             Type expectedType,
             string value,
             LocalizationResources localizationResources)
         {
-            return new FailedArgumentTypeConversionResult(argument, expectedType, value, localizationResources);
+            return new ArgumentConversionResult(argument, expectedType, value, localizationResources);
         }
 
         internal static ArgumentConversionResult ConvertIfNeeded(
@@ -197,22 +199,24 @@ internal static ArgumentConversionResult ConvertIfNeeded(
             SymbolResult symbolResult,
             Type toType)
         {
-            return conversionResult switch
+            return conversionResult.Result switch
             {
-                SuccessfulArgumentConversionResult successful when !toType.IsInstanceOfType(successful.Value) =>
+                ArgumentConversionResultType.Successful when !toType.IsInstanceOfType(conversionResult.Value) =>
                     ConvertObject(conversionResult.Argument,
                                   toType,
-                                  successful.Value,
+                                  conversionResult.Value,
                                   symbolResult.LocalizationResources),
-             
-                NoArgumentConversionResult _ when toType == typeof(bool) || toType == typeof(bool?) =>
+
+                ArgumentConversionResultType.NoArgument when toType == typeof(bool) || toType == typeof(bool?) =>
                     Success(conversionResult.Argument, true),
-                
-                NoArgumentConversionResult _ when conversionResult.Argument.Arity.MinimumNumberOfValues > 0 =>
-                    new MissingArgumentConversionResult(conversionResult.Argument,
-                                                        symbolResult.LocalizationResources.RequiredArgumentMissing(symbolResult)),
 
-                NoArgumentConversionResult _ when conversionResult.Argument.Arity.MaximumNumberOfValues > 1 =>
+                ArgumentConversionResultType.NoArgument when conversionResult.Argument.Arity.MinimumNumberOfValues > 0 =>
+                    ArgumentConversionResult.Failure(
+                        conversionResult.Argument,
+                        symbolResult.LocalizationResources.RequiredArgumentMissing(symbolResult),
+                        ArgumentConversionResultType.FailedMissingArgument),
+
+                ArgumentConversionResultType.NoArgument when conversionResult.Argument.Arity.MaximumNumberOfValues > 1 =>
                     Success(conversionResult.Argument, Array.Empty<string>()),
 
                 _ => conversionResult
@@ -221,12 +225,11 @@ internal static ArgumentConversionResult ConvertIfNeeded(
 
         internal static T GetValueOrDefault<T>(this ArgumentConversionResult result)
         {
-            return result switch
+            return result.Result switch
             {
-                SuccessfulArgumentConversionResult successful => (T)successful.Value!,
-                FailedArgumentConversionResult failed => throw new InvalidOperationException(failed.ErrorMessage),
-                NoArgumentConversionResult _ => default!,
-                _ => default!,
+                ArgumentConversionResultType.Successful => (T)result.Value!,
+                ArgumentConversionResultType.NoArgument => default!,
+                _ => throw new InvalidOperationException(result.ErrorMessage),
             };
         }
 
@@ -234,7 +237,7 @@ public static bool TryConvertArgument(ArgumentResult argumentResult, out object?
         {
             var argument = argumentResult.Argument;
 
-            value = argument.Arity.MaximumNumberOfValues switch
+            ArgumentConversionResult result = argument.Arity.MaximumNumberOfValues switch
             {
                 // 0 is an implicit bool, i.e. a "flag"
                 0 => Success(argumentResult.Argument, true),
@@ -251,7 +254,8 @@ public static bool TryConvertArgument(ArgumentResult argumentResult, out object?
                                     argumentResult)
             };
 
-            return value is SuccessfulArgumentConversionResult;
+            value = result;
+            return result.Result == ArgumentConversionResultType.Successful;
         }
 
         internal static object? GetDefaultValue(Type type)
diff --git a/src/System.CommandLine/Binding/BindingContext.cs b/src/System.CommandLine/Binding/BindingContext.cs
index 67892e84de..0bfa6500c3 100644
--- a/src/System.CommandLine/Binding/BindingContext.cs
+++ b/src/System.CommandLine/Binding/BindingContext.cs
@@ -105,9 +105,9 @@ internal bool TryBindToScalarValue(
                         value,
                         localizationResources);
 
-                    if (parsed is SuccessfulArgumentConversionResult successful)
+                    if (parsed.Result == ArgumentConversionResultType.Successful)
                     {
-                        boundValue = new BoundValue(successful.Value, valueDescriptor, valueSource);
+                        boundValue = new BoundValue(parsed.Value, valueDescriptor, valueSource);
                         return true;
                     }
                 }
diff --git a/src/System.CommandLine/Binding/FailedArgumentConversionArityResult.cs b/src/System.CommandLine/Binding/FailedArgumentConversionArityResult.cs
deleted file mode 100644
index 5efcc2dd87..0000000000
--- a/src/System.CommandLine/Binding/FailedArgumentConversionArityResult.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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.
-
-namespace System.CommandLine.Binding
-{
-    internal abstract class FailedArgumentConversionArityResult : FailedArgumentConversionResult
-    {
-        internal FailedArgumentConversionArityResult(Argument argument, string errorMessage) : base(argument, errorMessage)
-        {
-        }
-    }
-}
diff --git a/src/System.CommandLine/Binding/FailedArgumentConversionResult.cs b/src/System.CommandLine/Binding/FailedArgumentConversionResult.cs
deleted file mode 100644
index ed0946253d..0000000000
--- a/src/System.CommandLine/Binding/FailedArgumentConversionResult.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// 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.
-
-namespace System.CommandLine.Binding
-{
-    internal class FailedArgumentConversionResult : ArgumentConversionResult
-    {
-        internal FailedArgumentConversionResult(
-            Argument argument, 
-            string errorMessage) : base(argument)
-        {
-            if (string.IsNullOrWhiteSpace(errorMessage))
-            {
-                throw new ArgumentException("Value cannot be null or whitespace.", nameof(errorMessage));
-            }
-
-            ErrorMessage = errorMessage;
-        }
-    }
-}
diff --git a/src/System.CommandLine/Binding/FailedArgumentTypeConversionResult.cs b/src/System.CommandLine/Binding/FailedArgumentTypeConversionResult.cs
deleted file mode 100644
index 2dcec61a68..0000000000
--- a/src/System.CommandLine/Binding/FailedArgumentTypeConversionResult.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// 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.Linq;
-
-namespace System.CommandLine.Binding
-{
-    internal class FailedArgumentTypeConversionResult : FailedArgumentConversionResult
-    {
-        internal FailedArgumentTypeConversionResult(
-            Argument argument,
-            Type expectedType,
-            string value,
-            LocalizationResources localizationResources) :
-            base(argument, FormatErrorMessage(argument, expectedType, value, localizationResources))
-        {
-        }
-
-        private static string FormatErrorMessage(
-            Argument argument,
-            Type expectedType,
-            string value,
-            LocalizationResources localizationResources)
-        {
-            if (argument.FirstParent?.Symbol is IdentifierSymbol identifierSymbol &&
-                argument.FirstParent.Next is null)
-            {
-                var alias = identifierSymbol.Aliases.First();
-
-                switch (identifierSymbol)
-                {
-                    case Command _:
-                        return localizationResources.ArgumentConversionCannotParseForCommand(value, alias, expectedType);
-                    case Option _:
-                        return localizationResources.ArgumentConversionCannotParseForOption(value, alias, expectedType);
-                }
-            }
-
-            return localizationResources.ArgumentConversionCannotParse(value, expectedType);
-        }
-    }
-}
diff --git a/src/System.CommandLine/Binding/IValueDescriptor.cs b/src/System.CommandLine/Binding/IValueDescriptor.cs
index 94d8964c90..34b9e0052d 100644
--- a/src/System.CommandLine/Binding/IValueDescriptor.cs
+++ b/src/System.CommandLine/Binding/IValueDescriptor.cs
@@ -1,8 +1,6 @@
 // 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.Diagnostics.CodeAnalysis;
-
 namespace System.CommandLine.Binding
 {
     /// <summary>
diff --git a/src/System.CommandLine/Binding/MissingArgumentConversionResult.cs b/src/System.CommandLine/Binding/MissingArgumentConversionResult.cs
deleted file mode 100644
index 133b8af8b3..0000000000
--- a/src/System.CommandLine/Binding/MissingArgumentConversionResult.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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.
-
-namespace System.CommandLine.Binding
-{
-    internal class MissingArgumentConversionResult : FailedArgumentConversionArityResult
-    {
-        internal MissingArgumentConversionResult(Argument argument, string errorMessage) : base(argument, errorMessage)
-        {
-        }
-    }
-}
diff --git a/src/System.CommandLine/Binding/NoArgumentConversionResult.cs b/src/System.CommandLine/Binding/NoArgumentConversionResult.cs
deleted file mode 100644
index 7dd718a261..0000000000
--- a/src/System.CommandLine/Binding/NoArgumentConversionResult.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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.
-
-namespace System.CommandLine.Binding
-{
-    internal class NoArgumentConversionResult : ArgumentConversionResult
-    {
-        internal NoArgumentConversionResult(Argument argument) : base(argument)
-        {
-        }
-    }
-}
diff --git a/src/System.CommandLine/Binding/SuccessfulArgumentConversionResult.cs b/src/System.CommandLine/Binding/SuccessfulArgumentConversionResult.cs
deleted file mode 100644
index 72c9b5a991..0000000000
--- a/src/System.CommandLine/Binding/SuccessfulArgumentConversionResult.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// 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.
-
-namespace System.CommandLine.Binding;
-
-internal class SuccessfulArgumentConversionResult : ArgumentConversionResult
-{
-    internal SuccessfulArgumentConversionResult(
-        Argument argument,
-        object? value) : base(argument)
-    {
-        Value = value;
-    }
-
-    public object? Value { get; }
-}
\ No newline at end of file
diff --git a/src/System.CommandLine/Binding/TooManyArgumentsConversionResult.cs b/src/System.CommandLine/Binding/TooManyArgumentsConversionResult.cs
deleted file mode 100644
index c35c6f8bd9..0000000000
--- a/src/System.CommandLine/Binding/TooManyArgumentsConversionResult.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// 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.
-
-namespace System.CommandLine.Binding
-{
-    internal class TooManyArgumentsConversionResult : FailedArgumentConversionArityResult
-    {
-        internal TooManyArgumentsConversionResult(Argument argument, string errorMessage) : base(argument, errorMessage)
-        {
-        }
-    }
-}
diff --git a/src/System.CommandLine/Parsing/ArgumentResult.cs b/src/System.CommandLine/Parsing/ArgumentResult.cs
index 8d27abb563..6ae32a14cc 100644
--- a/src/System.CommandLine/Parsing/ArgumentResult.cs
+++ b/src/System.CommandLine/Parsing/ArgumentResult.cs
@@ -105,11 +105,12 @@ private ArgumentConversionResult Convert(Argument argument)
             if (ShouldCheckArity() &&
                 Parent is { } &&
                 ArgumentArity.Validate(Parent,
-                                       argument,
-                                       argument.Arity.MinimumNumberOfValues,
-                                       argument.Arity.MaximumNumberOfValues) is FailedArgumentConversionResult failedResult)
+                    argument,
+                    argument.Arity.MinimumNumberOfValues,
+                    argument.Arity.MaximumNumberOfValues) is ArgumentConversionResult failed &&
+                    failed is not null) // returns null on success
             {
-                return failedResult;
+                return failed;
             }
 
             if (Parent!.UseDefaultValueFor(argument))
@@ -128,7 +129,8 @@ Parent is { } &&
                 {
                     return ArgumentConversionResult.Failure(
                         argument,
-                        argumentResult.ErrorMessage!);
+                        argumentResult.ErrorMessage!,
+                        ArgumentConversionResultType.Failed);
                 }
             }
 
@@ -155,17 +157,15 @@ Parent is { } &&
 
             if (success)
             {
-                return ArgumentConversionResult.Success(
-                    argument,
-                    value);
+                return ArgumentConversionResult.Success(argument, value);
             }
 
             if (ErrorMessage is not null)
             {
-                return new FailedArgumentConversionResult(argument, ErrorMessage);
+                return ArgumentConversionResult.Failure(argument, ErrorMessage, ArgumentConversionResultType.Failed);
             }
 
-            return new FailedArgumentTypeConversionResult(
+            return new ArgumentConversionResult(
                 argument,
                 argument.ValueType,
                 Tokens[0].Value,
diff --git a/src/System.CommandLine/Parsing/ParseResultExtensions.cs b/src/System.CommandLine/Parsing/ParseResultExtensions.cs
index 6cc62f6a42..db990bfb39 100644
--- a/src/System.CommandLine/Parsing/ParseResultExtensions.cs
+++ b/src/System.CommandLine/Parsing/ParseResultExtensions.cs
@@ -101,11 +101,13 @@ private static void Diagram(
 
                 if (argumentResult.Argument.Arity.MaximumNumberOfValues > 0)
                 {
-                    switch (argumentResult.GetArgumentConversionResult())
+                    ArgumentConversionResult conversionResult = argumentResult.GetArgumentConversionResult();
+                    switch (conversionResult.Result)
                     {
-                        case SuccessfulArgumentConversionResult successful:
-
-                            switch (successful.Value)
+                        case ArgumentConversionResultType.NoArgument:
+                            break;
+                        case ArgumentConversionResultType.Successful:
+                            switch (conversionResult.Value)
                             {
                                 case string s:
                                     builder.Append($"<{s}>");
@@ -121,15 +123,14 @@ private static void Diagram(
 
                                 default:
                                     builder.Append("<");
-                                    builder.Append(successful.Value);
+                                    builder.Append(conversionResult.Value);
                                     builder.Append(">");
                                     break;
                             }
 
                             break;
 
-                        case FailedArgumentConversionResult _:
-
+                        default: // failures
                             builder.Append("<");
                             builder.Append(string.Join("> <", symbolResult.Tokens.Select(t => t.Value)));
                             builder.Append(">");
diff --git a/src/System.CommandLine/Parsing/ParseResultVisitor.cs b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
index 6e2684c874..404c6a04c1 100644
--- a/src/System.CommandLine/Parsing/ParseResultVisitor.cs
+++ b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
@@ -487,20 +487,24 @@ private void ValidateAndConvertArgumentResult(ArgumentResult argumentResult)
                 return;
             }
 
-            if (argumentResult.GetArgumentConversionResult() is FailedArgumentConversionResult failed
-                and not FailedArgumentConversionArityResult)
+            ArgumentConversionResult argumentConversionResult = argumentResult.GetArgumentConversionResult();
+            if (argumentConversionResult.Result >= ArgumentConversionResultType.Failed
+                && argumentConversionResult.Result !=  ArgumentConversionResultType.FailedArity)
             {
-                if (argument.Parents.FirstOrDefault() is Option option)
+                if (argument.FirstParent?.Symbol is Option option)
                 {
                     var completions = option.GetCompletions().ToArray();
 
                     if (completions.Length > 0)
                     {
-                        failed.ErrorMessage += " Did you mean one of the following?" + Environment.NewLine + string.Join(Environment.NewLine, completions.Select(c => c.Label));
+                        argumentConversionResult = ArgumentConversionResult.Failure(
+                            argumentConversionResult.Argument,
+                            argumentConversionResult.ErrorMessage + " Did you mean one of the following?" + Environment.NewLine + string.Join(Environment.NewLine, completions.Select(c => c.Label)),
+                            argumentConversionResult.Result);
                     }
                 }
 
-                AddErrorToResult(argumentResult, new ParseError(failed.ErrorMessage!, argumentResult));
+                AddErrorToResult(argumentResult, new ParseError(argumentConversionResult.ErrorMessage!, argumentResult));
             }
         }
 

From 692f0455715c448e10efc3092b4f2a671029bd16 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Wed, 23 Feb 2022 15:21:18 +0100
Subject: [PATCH 15/18] remove RootCommandNode to reduce the number of types

---
 .../Parsing/DirectiveNode.cs                  |  2 +-
 .../Parsing/ParseOperation.cs                 | 15 ++++++++-------
 .../Parsing/ParseResultVisitor.cs             | 19 ++++++++-----------
 .../Parsing/RootCommandNode.cs                | 14 --------------
 4 files changed, 17 insertions(+), 33 deletions(-)
 delete mode 100644 src/System.CommandLine/Parsing/RootCommandNode.cs

diff --git a/src/System.CommandLine/Parsing/DirectiveNode.cs b/src/System.CommandLine/Parsing/DirectiveNode.cs
index a0010085ed..4b50b0e176 100644
--- a/src/System.CommandLine/Parsing/DirectiveNode.cs
+++ b/src/System.CommandLine/Parsing/DirectiveNode.cs
@@ -7,7 +7,7 @@ internal class DirectiveNode : SyntaxNode
     {
         public DirectiveNode(
             Token token,
-            RootCommandNode parent,
+            CommandNode parent,
             string name,
             string? value) : base(token, parent)
         {
diff --git a/src/System.CommandLine/Parsing/ParseOperation.cs b/src/System.CommandLine/Parsing/ParseOperation.cs
index 43de0f2e9e..73effe5e33 100644
--- a/src/System.CommandLine/Parsing/ParseOperation.cs
+++ b/src/System.CommandLine/Parsing/ParseOperation.cs
@@ -23,7 +23,7 @@ public ParseOperation(
 
         public List<ParseError> Errors { get; } = new();
 
-        public RootCommandNode? RootCommandNode { get; private set; }
+        public CommandNode? RootCommandNode { get; private set; }
 
         public List<Token>? UnmatchedTokens { get; private set; }
 
@@ -43,11 +43,12 @@ public void Parse()
             RootCommandNode = ParseRootCommand();
         }
 
-        private RootCommandNode ParseRootCommand()
+        private CommandNode ParseRootCommand()
         {
-            var rootCommandNode = new RootCommandNode(
+            var rootCommandNode = new CommandNode(
                 CurrentToken,
-                _configuration.RootCommand);
+                _configuration.RootCommand,
+                null);
 
             Advance();
 
@@ -201,14 +202,14 @@ private void ParseOptionArguments(OptionNode optionNode)
             }
         }
 
-        private void ParseDirectives(RootCommandNode parent)
+        private void ParseDirectives(CommandNode rootCommandNode)
         {
             while (More(out TokenType currentTokenType) && currentTokenType == TokenType.Directive)
             {
-                ParseDirective(parent); // kept in separate method to avoid JIT
+                ParseDirective(rootCommandNode); // kept in separate method to avoid JIT
             }
 
-            void ParseDirective(RootCommandNode parent)
+            void ParseDirective(CommandNode parent)
             {
                 var token = CurrentToken;
                 var withoutBrackets = token.Value.Substring(1, token.Value.Length - 2);
diff --git a/src/System.CommandLine/Parsing/ParseResultVisitor.cs b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
index 404c6a04c1..3cb4a7f955 100644
--- a/src/System.CommandLine/Parsing/ParseResultVisitor.cs
+++ b/src/System.CommandLine/Parsing/ParseResultVisitor.cs
@@ -65,18 +65,15 @@ private void VisitInternal(SyntaxNode node)
 
                     break;
 
-                case RootCommandNode rootCommandNode:
-                    VisitRootCommandNode(rootCommandNode);
-
-                    for (var i = 0; i < rootCommandNode.Children.Count; i++)
+                case CommandNode commandNode:
+                    if (commandNode.Parent is null)
                     {
-                        VisitInternal(rootCommandNode.Children[i]);
+                        VisitRootCommandNode(commandNode);
+                    }
+                    else
+                    {
+                        VisitCommandNode(commandNode);
                     }
-
-                    break;
-
-                case CommandNode commandNode:
-                    VisitCommandNode(commandNode);
 
                     for (var i = 0; i < commandNode.Children.Count; i++)
                     {
@@ -131,7 +128,7 @@ private void AddToResult(ArgumentResult result)
             }
         }
 
-        private void VisitRootCommandNode(RootCommandNode rootCommandNode)
+        private void VisitRootCommandNode(CommandNode rootCommandNode)
         {
             _rootCommandResult = new RootCommandResult(
                 rootCommandNode.Command,
diff --git a/src/System.CommandLine/Parsing/RootCommandNode.cs b/src/System.CommandLine/Parsing/RootCommandNode.cs
deleted file mode 100644
index b3e9d50f6c..0000000000
--- a/src/System.CommandLine/Parsing/RootCommandNode.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// 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.
-
-namespace System.CommandLine.Parsing
-{
-    internal class RootCommandNode : CommandNode
-    {
-        public RootCommandNode(
-            Token token,
-            Command command) : base(token, command, null)
-        {
-        }
-    }
-}

From 54e26d45c0a07485ec6b856ed29c5893e8eebb01 Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Wed, 23 Feb 2022 15:59:06 +0100
Subject: [PATCH 16/18] remove another Lazy (the code it uses needed to be
 compiled the first time ArgumentConverter was used, no matter if we wanted to
 create a list or not)

---
 .../Binding/ArgumentConverter.DefaultValues.cs   | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/System.CommandLine/Binding/ArgumentConverter.DefaultValues.cs b/src/System.CommandLine/Binding/ArgumentConverter.DefaultValues.cs
index 2538a16a3d..368c937e64 100644
--- a/src/System.CommandLine/Binding/ArgumentConverter.DefaultValues.cs
+++ b/src/System.CommandLine/Binding/ArgumentConverter.DefaultValues.cs
@@ -13,10 +13,7 @@ namespace System.CommandLine.Binding;
 internal static partial class ArgumentConverter
 {
 #if NET6_0_OR_GREATER
-    private static readonly Lazy<ConstructorInfo> _listCtor =
-        new(() => typeof(List<>)
-                  .GetConstructors()
-                  .SingleOrDefault(c => c.GetParameters().Length == 0)!);
+    private static ConstructorInfo? _listCtor;
 #endif
 
     private static Array CreateEmptyArray(Type itemType, int capacity = 0)
@@ -25,14 +22,21 @@ private static Array CreateEmptyArray(Type itemType, int capacity = 0)
     private static IList CreateEmptyList(Type listType)
     {
 #if NET6_0_OR_GREATER
-        var ctor = (ConstructorInfo)listType.GetMemberWithSameMetadataDefinitionAs(_listCtor.Value);
+        ConstructorInfo? listCtor = _listCtor;
+
+        if (listCtor is null)
+        {
+            _listCtor = listCtor = typeof(List<>).GetConstructors().Single(c => c.GetParameters().Length == 0);
+        }
+
+        var ctor = (ConstructorInfo)listType.GetMemberWithSameMetadataDefinitionAs(listCtor);
 #else
         var ctor = listType
                    .GetConstructors()
                    .SingleOrDefault(c => c.GetParameters().Length == 0);
 #endif
 
-        return (IList)ctor.Invoke(new object[] { });
+        return (IList)ctor.Invoke(Array.Empty<object>());
     }
 
     private static IList CreateEnumerable(Type type, Type itemType, int capacity = 0)

From 0d072bdc49d34cbd837332b430e97d4811dc6fcc Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Wed, 23 Feb 2022 17:48:08 +0100
Subject: [PATCH 17/18] add net6.0 to benchmarks project

---
 .../System.CommandLine.Benchmarks.csproj                      | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/System.CommandLine.Benchmarks/System.CommandLine.Benchmarks.csproj b/src/System.CommandLine.Benchmarks/System.CommandLine.Benchmarks.csproj
index 4da123c513..e54aabc422 100644
--- a/src/System.CommandLine.Benchmarks/System.CommandLine.Benchmarks.csproj
+++ b/src/System.CommandLine.Benchmarks/System.CommandLine.Benchmarks.csproj
@@ -9,8 +9,8 @@
     <UseSharedCompilation>false</UseSharedCompilation>
 
     <!-- Supported target frameworks -->
-    <TargetFrameworks Condition="'$(TargetFrameworks)' == '' AND '$(OS)' == 'Windows_NT'">net461;net5.0;</TargetFrameworks>
-    <TargetFrameworks Condition="'$(TargetFrameworks)' == ''">net5.0;</TargetFrameworks>
+    <TargetFrameworks Condition="'$(TargetFrameworks)' == '' AND '$(OS)' == 'Windows_NT'">net461;net5.0;net6.0;</TargetFrameworks>
+    <TargetFrameworks Condition="'$(TargetFrameworks)' == ''">net5.0;net6.0;</TargetFrameworks>
 
     <!-- This repo does not produce any libraries, therefore generating docs is disabled -->
     <GenerateDocumentationFile>False</GenerateDocumentationFile>

From 5f475cbe322b71f9d2993af3a659c2a9196f556a Mon Sep 17 00:00:00 2001
From: Adam Sitnik <adam.sitnik@gmail.com>
Date: Thu, 24 Feb 2022 12:56:23 +0100
Subject: [PATCH 18/18] address code review feedback

---
 .../Binding/ArgumentConverter.DefaultValues.cs           | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/System.CommandLine/Binding/ArgumentConverter.DefaultValues.cs b/src/System.CommandLine/Binding/ArgumentConverter.DefaultValues.cs
index 368c937e64..a4e971961b 100644
--- a/src/System.CommandLine/Binding/ArgumentConverter.DefaultValues.cs
+++ b/src/System.CommandLine/Binding/ArgumentConverter.DefaultValues.cs
@@ -4,7 +4,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
 
@@ -26,17 +25,15 @@ private static IList CreateEmptyList(Type listType)
 
         if (listCtor is null)
         {
-            _listCtor = listCtor = typeof(List<>).GetConstructors().Single(c => c.GetParameters().Length == 0);
+            _listCtor = listCtor = typeof(List<>).GetConstructor(Type.EmptyTypes)!;
         }
 
         var ctor = (ConstructorInfo)listType.GetMemberWithSameMetadataDefinitionAs(listCtor);
 #else
-        var ctor = listType
-                   .GetConstructors()
-                   .SingleOrDefault(c => c.GetParameters().Length == 0);
+        var ctor = listType.GetConstructor(Type.EmptyTypes);
 #endif
 
-        return (IList)ctor.Invoke(Array.Empty<object>());
+        return (IList)ctor.Invoke(null);
     }
 
     private static IList CreateEnumerable(Type type, Type itemType, int capacity = 0)