Update to 2.0.0-beta4.25072.1 and fix class name changes

  - Updated to latest daily build 2.0.0-beta4.25072.1 of System.CommandLine.
  - Fixed: New naming convention of classes from System.CommandLine (they dropped `Cli` prefix from symbol classes and replaced it with `CommandLine` for other classes).
  - Changed: Nuget framework targets from `net7.0;netstandard2.0` to `net8.0;netstandard2.0` as underlying System.CommandLine package did so.
    `net7.0` project can still use `netstandard2.0` target.
  - Added: We now include a MSBuild .props file in the nuget package so referencing projects
    that do not explicitly set SatelliteResourceLanguages property, will be considered using "en" by default:
    Prevent satellite resource DLL pollution (which come from System.CommandLine package) in bin folder,
    by setting a specific culture in referencing project, if not already set.
    Empty value (default) for SatelliteResourceLanguages property causes copying of all culture subfolders and DLLs to bin folder,
    so we opt for "en" culture by default, to prevent copying of satellite resource DLLs.
  - Fixed: Referencing DotMake.CommandLine DLL instead of project in DotMake.CommandLine.SourceGeneration.Embedded project,
    does not work well, especially if you Clean and Build (or for first build) you get reference errors
    as DotMake.CommandLine.dll is not yet produced, so better to use project reference but only from this project (to avoid circular dependency).
    Ensure that the .Embedded project is built after DotMake.CommandLine project only for checking compile errors,
    otherwise .cs files are only embedded as resource in DotMake.CommandLine.SourceGeneration.dll.

Author: calacayir

docs/README.md

@@ -36,8 +36,8 @@ PM> Install-Package DotMake.CommandLine
 
 ### Prerequisites
 
-- .NET 7.0 and later project or .NET Standard 2.0 and later project.  
-  Note that .NET Framework 4.7.2+ or .NET Core 2.0 to NET 6.0 projects can reference our netstandard2.0 target (automatic in nuget).  
+- .NET 8.0 and later project or .NET Standard 2.0 and later project.  
+  Note that .NET Framework 4.7.2+ or .NET Core 2.0 to NET 7.0 projects can reference our netstandard2.0 target (automatic in nuget).  
   If your target framework is below net5.0, you also need `<LangVersion>9.0</LangVersion>` tag (minimum) in your .csproj file.
 - Visual Studio 2022 v17.3+ or .NET SDK 6.0.407+ (when building via `dotnet` cli).  
   Our incremental source generator requires performance features added first in these versions.
@@ -198,7 +198,7 @@ And that's it! You now have a fully working command-line app.
 ## Help output
 
 When you run the app via 
-- `TestApp.exe -?` in project output path (e.g. in `TestApp\bin\Debug\net7.0`)
+- `TestApp.exe -?` in project output path (e.g. in `TestApp\bin\Debug\net8.0`)
 - or `dotnet run -- -?` in project directory (e.g. in `TestApp`) (note the double hyphen/dash which allows `dotnet run` to pass arguments to our actual application)
 
 - You see this usage help:
@@ -1168,7 +1168,7 @@ Cli.Run<RootCliCommand>();
 
 ## Response files
 
-A *response file* is a file that contains a set of [tokens](syntax.md#tokens) for a command-line app. Response files are a feature of `System.CommandLine` that is useful in two scenarios:
+A *response file* is a file that contains a set of tokens for a command-line app. Response files are a feature of `System.CommandLine` that is useful in two scenarios:
 
 * To invoke a command-line app by specifying input that is longer than the character limit of the terminal.
 * To invoke the same command repeatedly without retyping the whole line.

src/Directory.Build.props

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

src/DotMake.CommandLine.SourceGeneration.Embedded/DotMake.CommandLine.SourceGeneration.Embedded.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net7.0;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>net8.0;netstandard2.0</TargetFrameworks>
     <!-- Make sure it compiles for lowest supported LangVersion 9.0 as source may be generated in a netstandard2.0 project -->
     <LangVersion>9.0</LangVersion>
   </PropertyGroup>
@@ -14,11 +14,26 @@
     <!--
     Code should compile against DotMake.CommandLine.dll (not project due to circular dependency),
     which will be available during runtime.
-    -->
+    $(OutputPath) will be same as bin\$(Configuration)\$(TargetFramework)\
+    $(IntermediateOutputPath) will be same as obj\$(Configuration)\$(TargetFramework)\
+    
+    This does not work well, especially if you Clean and Build (or for first build) you get reference errors
+    as DotMake.CommandLine.dll is not yet produced, so better to use project reference but only from this project.
+
     <Reference Include="DotMake.CommandLine">
       <HintPath>..\DotMake.CommandLine\$(OutputPath)DotMake.CommandLine.dll</HintPath>
       <Private>false</Private>
     </Reference>
+    -->
+    <!--
+      Ensure that the .Embedded project is built after DotMake.CommandLine project only for checking compile errors,
+      otherwise .cs files are only embedded as resource in DotMake.CommandLine.SourceGeneration.dll
+    -->
+    <ProjectReference Include="..\DotMake.CommandLine\DotMake.CommandLine.csproj">
+      <ReferenceOutputAssembly>true</ReferenceOutputAssembly>
+      <Private>false</Private>
+    </ProjectReference>
+
   </ItemGroup>
 
 </Project>

src/DotMake.CommandLine.SourceGeneration/CliArgumentInfo.cs

@@ -11,7 +11,7 @@ public class CliArgumentInfo : CliSymbolInfo, IEquatable<CliArgumentInfo>
     {
         public static readonly string AttributeFullName = typeof(CliArgumentAttribute).FullName;
         public static readonly string[] Suffixes = CliCommandInfo.Suffixes.Select(s => s + "Argument").Append("Argument").ToArray();
-        public const string ArgumentClassName = "CliArgument";
+        public const string ArgumentClassName = "Argument";
         public const string ArgumentClassNamespace = "System.CommandLine";
         public const string ArgumentArityClassName = "ArgumentArity";
         public const string DiagnosticName = "CLI argument";

src/DotMake.CommandLine.SourceGeneration/CliCommandInfo.cs

@@ -12,8 +12,8 @@ public class CliCommandInfo : CliSymbolInfo, IEquatable<CliCommandInfo>
     {
         public static readonly string AttributeFullName = typeof(CliCommandAttribute).FullName;
         public static readonly string[] Suffixes = { "RootCliCommand", "RootCommand", "SubCliCommand", "SubCommand", "CliCommand", "Command", "Cli" };
-        public const string RootCommandClassName = "CliRootCommand";
-        public const string CommandClassName = "CliCommand";
+        public const string RootCommandClassName = "RootCommand";
+        public const string CommandClassName = "Command";
         public const string CommandClassNamespace = "System.CommandLine";
         public const string DiagnosticName = "CLI command";
         public const string GeneratedSubNamespace = "GeneratedCode";

src/DotMake.CommandLine.SourceGeneration/CliOptionInfo.cs

@@ -11,7 +11,7 @@ public class CliOptionInfo : CliSymbolInfo, IEquatable<CliOptionInfo>
     {
         public static readonly string AttributeFullName = typeof(CliOptionAttribute).FullName;
         public static readonly string[] Suffixes = CliCommandInfo.Suffixes.Select(s => s + "Option").Append("Option").ToArray();
-        public const string OptionClassName = "CliOption";
+        public const string OptionClassName = "Option";
         public const string OptionClassNamespace = "System.CommandLine";
         public const string DiagnosticName = "CLI option";
         public static readonly Dictionary<string, string> PropertyMappings = new Dictionary<string, string>

src/DotMake.CommandLine.SourceGeneration/DotMake.CommandLine.SourceGeneration.csproj

@@ -26,13 +26,6 @@
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" PrivateAssets="all" />
   </ItemGroup>
 
-  <ItemGroup>
-    <!-- Ensure that the .Embedded project is built together with this project (for checking compile errors) -->
-    <ProjectReference Include="..\$(MSBuildProjectName).Embedded\$(MSBuildProjectName).Embedded.csproj">
-      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
-    </ProjectReference>
-  </ItemGroup>
-
   <ItemGroup>
     <EmbeddedResource Update="Resources.resx">
       <Generator>ResXFileCodeGenerator</Generator>

src/DotMake.CommandLine/Binding/ArgumentConverter.cs

@@ -7,6 +7,7 @@
 using System.CommandLine;
 using System.CommandLine.Parsing;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 using static DotMake.CommandLine.Binding.ArgumentConversionResult;
 
@@ -16,7 +17,7 @@ internal static partial class ArgumentConverter
     {
         internal static Dictionary<Type, Func<Array, object>> CollectionConverters = new Dictionary<Type, Func<Array, object>>();
 
-        internal static TryConvertArgument? GetConverter(CliArgument argument)
+        internal static TryConvertArgument? GetConverter(Argument argument)
         {
             /*
             //We check exceptions for convert methods, so disabling this shortcut
@@ -88,10 +89,10 @@ internal static ArgumentConversionResult ConvertObject(
         {
             switch (value)
             {
-                case CliToken singleValue:
+                case Token singleValue:
                     return ConvertToken(argumentResult, type, singleValue);
 
-                case IReadOnlyList<CliToken> manyValues:
+                case IReadOnlyList<Token> manyValues:
                     return ConvertTokens(argumentResult, type, manyValues);
 
                 default:
@@ -115,7 +116,7 @@ internal static ArgumentConversionResult ConvertObject(
         private static ArgumentConversionResult ConvertToken(
             ArgumentResult argumentResult,
             Type type,
-            CliToken token)
+            Token token)
         {
             var value = token.Value;
 
@@ -159,7 +160,7 @@ private static ArgumentConversionResult ConvertToken(
         private static ArgumentConversionResult ConvertTokens(
             ArgumentResult argumentResult,
             Type type,
-            IReadOnlyList<CliToken> tokens)
+            IReadOnlyList<Token> tokens)
         {
             type = type.GetNullableUnderlyingTypeOrSelf();
             var itemType = type.GetElementTypeIfEnumerable(typeof(string)) ?? typeof(string);
@@ -279,6 +280,10 @@ private static Array CreateArray(Type itemType, int capacity)
         [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2067:UnrecognizedReflectionPattern",
             Justification = $"{nameof(CreateDefaultValueType)} is only called on a ValueType. You can always create an instance of a ValueType.")]
         private static object CreateDefaultValueType(Type type) =>
+#if NET
+            RuntimeHelpers.GetUninitializedObject(type);
+#else
             FormatterServices.GetUninitializedObject(type);
+#endif
     }
 }

src/DotMake.CommandLine/Cli.cs

@@ -67,8 +67,8 @@ public static string[] GetArgs()
         /// </summary>
         /// <typeparam name="TDefinition">The definition class for the command. A command builder for this class should be automatically generated by the source generator.</typeparam>
         /// <param name="settings">The settings for the parser's grammar and behaviors.</param>
-        /// <returns>A <see cref="CliConfiguration"/> on which the parser's grammar and behaviors are based.</returns>
-        public static CliConfiguration GetConfiguration<TDefinition>(CliSettings settings = null)
+        /// <returns>A <see cref="CommandLineConfiguration"/> on which the parser's grammar and behaviors are based.</returns>
+        public static CommandLineConfiguration GetConfiguration<TDefinition>(CliSettings settings = null)
         {
             var definitionType = typeof(TDefinition);
 
@@ -78,13 +78,13 @@ public static CliConfiguration GetConfiguration<TDefinition>(CliSettings setting
         /// <inheritdoc cref = "GetConfiguration{TDefinition}" />
         /// <param name="definitionType">The definition class type for the command. A command builder for this class should be automatically generated by the source generator.</param>
         /// <param name="settings"><inheritdoc cref="GetConfiguration{TDefinition}" path="/param[@name='settings']/node()" /></param>
-        public static CliConfiguration GetConfiguration(Type definitionType, CliSettings settings = null)
+        public static CommandLineConfiguration GetConfiguration(Type definitionType, CliSettings settings = null)
         {
             var commandBuilder = CliCommandBuilder.Get(definitionType);
             var command = commandBuilder.Build();
 
             settings ??= new CliSettings();
-            var configuration = new CliConfiguration(command)
+            var configuration = new CommandLineConfiguration(command)
             {
                 EnablePosixBundling = settings.EnablePosixBundling,
                 EnableDefaultExceptionHandler = settings.EnableDefaultExceptionHandler,
@@ -97,7 +97,7 @@ public static CliConfiguration GetConfiguration(Type definitionType, CliSettings
             if (settings.Error != null) //Console.Error is NOT being used
                 configuration.Error = settings.Error;
 
-            if (command is CliRootCommand rootCommand)
+            if (command is RootCommand rootCommand)
             {
                 //CliRootCommand constructor already adds HelpOption and VersionOption so remove them
                 foreach (var option in rootCommand.Options.Where(option => option is HelpOption or VersionOption).ToArray())
@@ -369,7 +369,7 @@ and it already trims double quote characters
             return args;
         }
 
-        private sealed class VersionOptionAction : SynchronousCliAction
+        private sealed class VersionOptionAction : SynchronousCommandLineAction
         {
             public override int Invoke(ParseResult parseResult)
             {

src/DotMake.CommandLine/CliCommandBuilder.cs

@@ -64,10 +64,10 @@ protected CliCommandBuilder()
         public bool ShortFormAutoGenerate { get; protected set; }
 
         /// <summary>
-        /// Builds a <see cref="CliCommand"/> instance, populated with sub-commands, options, arguments and settings.
+        /// Builds a <see cref="Command"/> instance, populated with sub-commands, options, arguments and settings.
         /// </summary>
-        /// <returns>A populated <see cref="CliCommand"/> instance.</returns>
-        public abstract CliCommand Build();
+        /// <returns>A populated <see cref="Command"/> instance.</returns>
+        public abstract Command Build();
 
         /// <summary>
         /// Creates a new instance of the command definition class and binds/populates the properties from the parse result.
@@ -119,7 +119,7 @@ public void Register()
         /// <summary>
         /// Registers a command builder so that it can be found by the definition class.
         /// </summary>
-        /// <param name="commandBuilder">A command builder which builds a <see cref="CliCommand"/>.</param>
+        /// <param name="commandBuilder">A command builder which builds a <see cref="Command"/>.</param>
         /// <typeparam name="TDefinition">The definition class.</typeparam>
         public static void Register<TDefinition>(CliCommandBuilder commandBuilder)
         {
@@ -132,7 +132,7 @@ public static void Register<TDefinition>(CliCommandBuilder commandBuilder)
         /// Registers a command builder so that it can be found by the definition class.
         /// </summary>
         /// <param name="definitionType">The type of the definition class.</param>
-        /// <param name="commandBuilder">A command builder which builds a <see cref="CliCommand"/>.</param>
+        /// <param name="commandBuilder">A command builder which builds a <see cref="Command"/>.</param>
         public static void Register(Type definitionType, CliCommandBuilder commandBuilder)
         {
             RegisteredDefinitionTypes[definitionType] = commandBuilder;
@@ -290,7 +290,7 @@ public static Func<ArgumentResult, TArgument> GetArgumentParser<TArgument>(Func<
         /// <param name="option">The option for which to get a value.</param>
         /// <typeparam name="T">The option type.</typeparam>
         /// <returns>The parsed value or a configured default.</returns>
-        public static T GetValueForOption<T>(ParseResult parseResult, CliOption<T> option)
+        public static T GetValueForOption<T>(ParseResult parseResult, Option<T> option)
         {
             var result = parseResult.GetResult(option);
             if (result != null)
@@ -304,7 +304,7 @@ public static T GetValueForOption<T>(ParseResult parseResult, CliOption<T> optio
         }
 
         /// <inheritdoc cref="GetValueForOption{T}"/>
-        public static object GetValueForOption(ParseResult parseResult, CliOption option)
+        public static object GetValueForOption(ParseResult parseResult, Option option)
         {
             var result = parseResult.GetResult(option);
             if (result != null)
@@ -328,7 +328,7 @@ public static object GetValueForOption(ParseResult parseResult, CliOption option
         /// <param name="argument">The argument for which to get a value.</param>
         /// <typeparam name="T">The argument type.</typeparam>
         /// <returns>The parsed value or a configured default.</returns>
-        public static T GetValueForArgument<T>(ParseResult parseResult, CliArgument<T> argument)
+        public static T GetValueForArgument<T>(ParseResult parseResult, Argument<T> argument)
         {
             var result = parseResult.GetResult(argument);
             if (result != null)
@@ -342,7 +342,7 @@ public static T GetValueForArgument<T>(ParseResult parseResult, CliArgument<T> a
         }
 
         /// <inheritdoc cref="GetValueForArgument{T}"/>
-        public static object GetValueForArgument(ParseResult parseResult, CliArgument argument)
+        public static object GetValueForArgument(ParseResult parseResult, Argument argument)
         {
             var result = parseResult.GetResult(argument);
             if (result != null)

src/DotMake.CommandLine/CliContext.cs

@@ -66,7 +66,7 @@ public  void ShowHelp()
                     }
                 };
 
-            var action = (SynchronousCliAction)helpOption.Action;
+            var action = (SynchronousCommandLineAction)helpOption.Action;
 
             action?.Invoke(ParseResult);
         }