Optimized custom type parsing

Optimized custom type parsing for CLI options/arguments feature added in v1.5.0. It's now fully compatible (stable) with AOT compilation !

Author: calacayir

docs/README.md

@@ -192,8 +192,7 @@ The following types for properties is supported:
   * `Uri`, `IPAddress`, `IPEndPoint`
 
 * Any type with a public constructor or a static `Parse` method with a string parameter - These types can be bound/parsed 
-  automatically even if they are wrapped with `Enumerable` or `Nullable` type (note that as of current version, custom class
-  support when using AOT compilation is not stable but trimming works)
+  automatically even if they are wrapped with `Enumerable` or `Nullable` type.
     ```c#
     [CliCommand]
     public class ArgumentConverterCliCommand
@@ -625,6 +624,7 @@ The properties for `CliArgument` attribute (see [CliArgumentAttribute](https://d
 - Description
 - HelpName
 - Hidden
+- Required
 - Arity
 - AllowedValues
 

src/Directory.Build.props

@@ -2,7 +2,8 @@
 
   <PropertyGroup>
     <!-- https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props#generateassemblyinfo -->
-    <VersionPrefix>1.5.2</VersionPrefix>
+    <LangVersion>10.0</LangVersion>
+    <VersionPrefix>1.5.4</VersionPrefix>
     <Product>DotMake Command-Line</Product>
     <Company>DotMake</Company>
     <!-- Copyright is also used for NuGet metadata -->

src/DotMake.CommandLine.SourceGeneration/CliArgumentInfo.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.ComponentModel;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -132,7 +133,19 @@ public void AppendCSharpCreateString(CodeStringBuilder sb, string varName, strin
                 : Symbol.Name.StripSuffixes(Suffixes).ToCase(Parent.Settings.NameCasingConvention);
 
             sb.AppendLine($"// Argument for '{Symbol.Name}' property");
-            using (sb.AppendBlockStart($"var {varName} = new {ArgumentClassNamespace}.{ArgumentClassName}<{Symbol.Type.ToReferenceString()}>(\"{argumentName}\")", ";"))
+            using (sb.AppendParamsBlockStart($"var {varName} = new {ArgumentClassNamespace}.{ArgumentClassName}<{Symbol.Type.ToReferenceString()}>"))
+            {
+                sb.AppendLine($"\"{argumentName}\"");
+                if (Converter != null)
+                {
+                    var parseArgument = $", GetParseArgument<{Symbol.Type.ToReferenceString()}, {Converter.ContainingType.ToReferenceString()}>";
+                    if (Converter.Name == ".ctor")
+                        sb.AppendLine($"{parseArgument}(input => new {Converter.ContainingType.ToReferenceString()}(input))");
+                    else
+                        sb.AppendLine($"{parseArgument}(input => {Converter.ToReferenceString()}(input))");
+                }
+            }
+            using (sb.AppendBlockStart(null, ";"))
             {
                 foreach (var kvp in AttributeArguments)
                 {
@@ -162,14 +175,6 @@ public void AppendCSharpCreateString(CodeStringBuilder sb, string varName, strin
 
             if (!Required)
                 sb.AppendLine($"{varName}.SetDefaultValue({varDefaultValue});");
-
-            if (Converter != null)
-            {
-                if (Converter.Name == ".ctor")
-                    sb.AppendLine($"RegisterArgumentConverter(input => new {Converter.ContainingType.ToReferenceString()}(input));");
-                else
-                    sb.AppendLine($"RegisterArgumentConverter(input => {Converter.ToReferenceString()}(input));");
-            }
         }
 
         public bool Equals(CliArgumentInfo other)
@@ -179,14 +184,20 @@ public bool Equals(CliArgumentInfo other)
 
         public static ITypeSymbol FindTypeIfNeedsConverter(ITypeSymbol type)
         {
-            // note we want System.String and not string so use MetadataName instead of ToDisplayString or ToReferenceString
-            while (!SupportedConverters.Contains(type.ToCompareString()))
+            while (true)
             {
-                var itemType = type.GetTypeIfNullable();
-                if (itemType != null)
-                    type = itemType;
-                
-                itemType = type.GetElementTypeIfEnumerable();
+                // note we want System.String and not string so use MetadataName instead of ToDisplayString or ToReferenceString
+                if (type.TypeKind == TypeKind.Enum || SupportedConverters.Contains(type.ToCompareString()))
+                    return null;
+
+                var underlyingType = type.GetTypeIfNullable();
+                if (underlyingType != null)
+                {
+                    type = underlyingType;
+                    continue;
+                }
+
+                var itemType = type.GetElementTypeIfEnumerable();
                 if (itemType != null)
                 {
                     type = itemType;
@@ -195,8 +206,6 @@ public static ITypeSymbol FindTypeIfNeedsConverter(ITypeSymbol type)
 
                 return type;
             }
-
-            return null;
         }
 
         public static IMethodSymbol FindConverter(ITypeSymbol type)

src/DotMake.CommandLine.SourceGeneration/CliOptionInfo.cs

@@ -106,7 +106,19 @@ public void AppendCSharpCreateString(CodeStringBuilder sb, string varName, strin
                     .AddPrefix(Parent.Settings.NamePrefixConvention);
 
             sb.AppendLine($"// Option for '{Symbol.Name}' property");
-            using (sb.AppendBlockStart($"var {varName} = new {OptionClassNamespace}.{OptionClassName}<{Symbol.Type}>(\"{optionName}\")", ";"))
+            using (sb.AppendParamsBlockStart($"var {varName} = new {OptionClassNamespace}.{OptionClassName}<{Symbol.Type.ToReferenceString()}>"))
+            {
+                sb.AppendLine($"\"{optionName}\"");
+                if (Converter != null)
+                {
+                    var parseArgument = $", GetParseArgument<{Symbol.Type.ToReferenceString()}, {Converter.ContainingType.ToReferenceString()}>";
+                    if (Converter.Name == ".ctor")
+                        sb.AppendLine($"{parseArgument}(input => new {Converter.ContainingType.ToReferenceString()}(input))");
+                    else
+                        sb.AppendLine($"{parseArgument}(input => {Converter.ToReferenceString()}(input))");
+                }
+            }
+            using (sb.AppendBlockStart(null, ";"))
             {
                 foreach (var kvp in AttributeArguments)
                 {
@@ -163,14 +175,6 @@ public void AppendCSharpCreateString(CodeStringBuilder sb, string varName, strin
                     }
                 }
             }
-
-            if (Converter != null)
-            {
-                if (Converter.Name == ".ctor")
-                    sb.AppendLine($"RegisterArgumentConverter(input => new {Converter.ContainingType.ToReferenceString()}(input));");
-                else
-                    sb.AppendLine($"RegisterArgumentConverter(input => {Converter.ToReferenceString()}(input));");
-            }
         }
 
         public bool Equals(CliOptionInfo other)

src/DotMake.CommandLine.SourceGeneration/CodeStringBuilder.cs

@@ -32,41 +32,53 @@ public void AppendLine(string line)
 
         public void AppendLineEnd() => sb.AppendLine();
 
-        public IDisposable AppendBlockStart(string line = null, string afterBlock = null)
+        public IDisposable AppendBlockStart(string line, string startBlock, string endBlock, string afterBlock)
         {
             if (line != null)
                 AppendLine(line);
 
-            AppendLine("{");
+            AppendLine(startBlock);
 
             IndentLevel++;
 
-            return new BlockTracker(this, afterBlock);
+            return new BlockTracker(this, endBlock, afterBlock);
+        }
+
+        public IDisposable AppendBlockStart(string line = null, string afterBlock = null)
+        {
+            return AppendBlockStart(line, "{", "}", afterBlock);
+        }
+
+        public IDisposable AppendParamsBlockStart(string line = null, string afterBlock = null)
+        {
+            return AppendBlockStart(line, "(", ")", afterBlock);
         }
 
-        public void AppendBlockEnd(string afterBlock = null)
+        public void AppendBlockEnd(string endBlock, string afterBlock = null)
         {
             IndentLevel--;
 
-            AppendLine(string.IsNullOrEmpty(afterBlock) ? "}" : "}" + afterBlock);
+            AppendLine(string.IsNullOrEmpty(afterBlock) ? endBlock : endBlock + afterBlock);
         }
 
         public override string ToString() => sb.ToString();
 
         private class BlockTracker : IDisposable
         {
             private readonly CodeStringBuilder parent;
+            private readonly string endBlock;
             private readonly string afterBlock;
 
-            public BlockTracker(CodeStringBuilder parent, string afterBlock)
+            public BlockTracker(CodeStringBuilder parent, string endBlock, string afterBlock)
             {
                 this.parent = parent;
+                this.endBlock = endBlock;
                 this.afterBlock = afterBlock;
             }
 
             public void Dispose()
             {
-                parent.AppendBlockEnd(afterBlock);
+                parent.AppendBlockEnd(endBlock, afterBlock);
             }
         }
     }

src/DotMake.CommandLine.SourceGeneration/SymbolExtensions.cs

@@ -14,8 +14,8 @@ public static class SymbolExtensions
                 memberOptions: SymbolDisplayMemberOptions.IncludeContainingType,
                 miscellaneousOptions:
                     SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers |
-                    SymbolDisplayMiscellaneousOptions.UseSpecialTypes |
-                    SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
+                    SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
+                    //SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
 
         private static readonly SymbolDisplayFormat CompareFormat =
             new SymbolDisplayFormat(

src/DotMake.CommandLine/Binding/ArgumentConversionResult.cs

@@ -0,0 +1,76 @@
+// 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.
+#nullable enable
+// ReSharper disable CheckNamespace
+
+using System.Linq;
+
+namespace System.CommandLine.Binding
+{
+    internal sealed class ArgumentConversionResult
+    {
+        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)
+        {
+        }
+
+        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 static ArgumentConversionResult None(Argument argument) => new(argument);
+
+        private static string FormatErrorMessage(
+            Argument argument,
+            Type expectedType,
+            string value,
+            LocalizationResources localizationResources)
+        {
+            var firstParent = argument.Parents.FirstOrDefault();
+            if (firstParent is IdentifierSymbol identifierSymbol &&
+                firstParent.Parents.FirstOrDefault() 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);
+        }
+    }
+}

src/DotMake.CommandLine/Binding/ArgumentConversionResultType.cs

@@ -0,0 +1,18 @@
+// 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.
+
+// ReSharper disable CheckNamespace
+
+namespace System.CommandLine.Binding
+{
+    internal enum ArgumentConversionResultType
+    {
+        NoArgument, // NoArgumentConversionResult
+        Successful, // SuccessfulArgumentConversionResult
+        Failed, // FailedArgumentConversionResult
+        FailedArity, // FailedArgumentConversionArityResult
+        FailedType, // FailedArgumentTypeConversionResult
+        FailedTooManyArguments, // TooManyArgumentsConversionResult
+        FailedMissingArgument, // MissingArgumentConversionResult
+    }
+}

src/DotMake.CommandLine/Binding/ArgumentConverter.DefaultValues.cs

@@ -0,0 +1,67 @@
+// 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.
+#nullable enable
+// ReSharper disable CheckNamespace
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+
+namespace System.CommandLine.Binding;
+
+internal static partial class ArgumentConverter
+{
+#if NET6_0_OR_GREATER
+    private static ConstructorInfo? _listCtor;
+#endif
+
+    [UnconditionalSuppressMessage("ReflectionAnalysis", "IL3050", Justification = "https://github.com/dotnet/command-line-api/issues/1638")]
+    private static Array CreateArray(Type itemType, int capacity)
+        => Array.CreateInstance(itemType, capacity);
+
+    private static IList CreateEmptyList(Type listType)
+    {
+#if NET6_0_OR_GREATER
+        ConstructorInfo? listCtor = _listCtor;
+
+        if (listCtor is null)
+        {
+            _listCtor = listCtor = typeof(List<>).GetConstructor(Type.EmptyTypes)!;
+        }
+
+        var ctor = (ConstructorInfo)listType.GetMemberWithSameMetadataDefinitionAs(listCtor);
+#else
+        var ctor = listType.GetConstructor(Type.EmptyTypes);
+#endif
+
+        return (IList)ctor.Invoke(null);
+    }
+
+    internal static IList CreateEnumerable(Type type, Type itemType, int capacity = 0)
+    {
+        if (type.IsArray)
+        {
+            return CreateArray(itemType, capacity);
+        }
+
+        if (type.IsGenericType)
+        {
+            var genericTypeDefinition = type.GetGenericTypeDefinition();
+
+            if (genericTypeDefinition == typeof(IEnumerable<>) ||
+                genericTypeDefinition == typeof(IList<>) ||
+                genericTypeDefinition == typeof(ICollection<>))
+            {
+                return CreateArray(itemType, capacity);
+            }
+
+            if (genericTypeDefinition == typeof(List<>))
+            {
+                return CreateEmptyList(type);
+            }
+        }
+
+        throw new ArgumentException($"Type {type} cannot be created without a custom binder.");
+    }
+}