[main] Update dependencies from dotnet/command-line-api

eng/Version.Details.xml

@@ -245,13 +245,13 @@
       <Sha>1dc431ec828e9cc816fc69f89ad9b8286e74d707</Sha>
       <SourceBuild RepoName="roslyn-analyzers" ManagedOnly="true" />
     </Dependency>
-    <Dependency Name="System.CommandLine" Version="2.0.0-beta4.22564.1">
+    <Dependency Name="System.CommandLine" Version="2.0.0-beta4.23181.5">
       <Uri>https://github.com/dotnet/command-line-api</Uri>
-      <Sha>8374d5fca634a93458c84414b1604c12f765d1ab</Sha>
+      <Sha>e26fc94b029143e312d0aafdef2df99b9a5bdc31</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.SourceBuild.Intermediate.command-line-api" Version="0.1.356401">
+    <Dependency Name="Microsoft.SourceBuild.Intermediate.command-line-api" Version="0.1.418105">
       <Uri>https://github.com/dotnet/command-line-api</Uri>
-      <Sha>8374d5fca634a93458c84414b1604c12f765d1ab</Sha>
+      <Sha>e26fc94b029143e312d0aafdef2df99b9a5bdc31</Sha>
       <SourceBuild RepoName="command-line-api" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-externals" Version="8.0.0-alpha.1.23106.1">

eng/Versions.props

@@ -42,7 +42,7 @@
     <SystemTextJsonVersion>6.0.0</SystemTextJsonVersion>
     <SystemReflectionMetadataLoadContextVersion>8.0.0-preview.2.23108.11</SystemReflectionMetadataLoadContextVersion>
     <SystemManagementPackageVersion>4.6.0</SystemManagementPackageVersion>
-    <SystemCommandLineVersion>2.0.0-beta4.22564.1</SystemCommandLineVersion>
+    <SystemCommandLineVersion>2.0.0-beta4.23181.5</SystemCommandLineVersion>
     <MicrosoftDeploymentDotNetReleasesVersion>1.0.0-preview5.1.22263.1</MicrosoftDeploymentDotNetReleasesVersion>
     <MicrosoftVisualStudioSetupConfigurationInteropVersion>3.0.4496</MicrosoftVisualStudioSetupConfigurationInteropVersion>
   </PropertyGroup>

src/ApiCompat/Microsoft.DotNet.ApiCompat.Tool/Program.cs

@@ -117,14 +117,14 @@ static int Main(string[] args)
             rootCommand.AddGlobalOption(excludeAttributesFilesOption);
             rootCommand.AddGlobalOption(enableRuleCannotChangeParameterNameOption);
 
-            rootCommand.AddOption(leftAssembliesOption);
-            rootCommand.AddOption(rightAssembliesOption);
-            rootCommand.AddOption(strictModeOption);
-            rootCommand.AddOption(leftAssembliesReferencesOption);
-            rootCommand.AddOption(rightAssembliesReferencesOption);
-            rootCommand.AddOption(createWorkItemPerAssemblyOption);
-            rootCommand.AddOption(leftAssembliesTransformationPatternOption);
-            rootCommand.AddOption(rightAssembliesTransformationPatternOption);
+            rootCommand.Options.Add(leftAssembliesOption);
+            rootCommand.Options.Add(rightAssembliesOption);
+            rootCommand.Options.Add(strictModeOption);
+            rootCommand.Options.Add(leftAssembliesReferencesOption);
+            rootCommand.Options.Add(rightAssembliesReferencesOption);
+            rootCommand.Options.Add(createWorkItemPerAssemblyOption);
+            rootCommand.Options.Add(leftAssembliesTransformationPatternOption);
+            rootCommand.Options.Add(rightAssembliesTransformationPatternOption);
 
             rootCommand.SetHandler((InvocationContext context) =>
             {
@@ -217,15 +217,15 @@ static int Main(string[] args)
             };
 
             Command packageCommand = new("package", "Validates the compatibility of package assets");
-            packageCommand.AddArgument(packageArgument);
-            packageCommand.AddOption(runtimeGraphOption);
-            packageCommand.AddOption(runApiCompatOption);
-            packageCommand.AddOption(enableStrictModeForCompatibleTfmsOption);
-            packageCommand.AddOption(enableStrictModeForCompatibleFrameworksInPackageOption);
-            packageCommand.AddOption(enableStrictModeForBaselineValidationOption);
-            packageCommand.AddOption(baselinePackageOption);
-            packageCommand.AddOption(packageAssemblyReferencesOption);
-            packageCommand.AddOption(baselinePackageAssemblyReferencesOption);
+            packageCommand.Arguments.Add(packageArgument);
+            packageCommand.Options.Add(runtimeGraphOption);
+            packageCommand.Options.Add(runApiCompatOption);
+            packageCommand.Options.Add(enableStrictModeForCompatibleTfmsOption);
+            packageCommand.Options.Add(enableStrictModeForCompatibleFrameworksInPackageOption);
+            packageCommand.Options.Add(enableStrictModeForBaselineValidationOption);
+            packageCommand.Options.Add(baselinePackageOption);
+            packageCommand.Options.Add(packageAssemblyReferencesOption);
+            packageCommand.Options.Add(baselinePackageAssemblyReferencesOption);
             packageCommand.SetHandler((InvocationContext context) =>
             {
                 // If a roslyn assemblies path isn't provided, use the compiled against version from a subfolder.
@@ -276,7 +276,7 @@ static int Main(string[] args)
                 roslynResolver.Unregister();
             });
 
-            rootCommand.AddCommand(packageCommand);
+            rootCommand.Subcommands.Add(packageCommand);
             return rootCommand.Invoke(args);
         }
 

src/BuiltInTools/dotnet-watch/Program.cs

@@ -138,7 +138,7 @@ internal static RootCommand CreateRootCommand(Func<CommandLineOptions, Task<int>
                 new[] { "--verbose", "-v" },
                 "Show verbose output");
 
-            verbose.AddValidator(v =>
+            verbose.Validators.Add(v =>
             {
                 if (v.FindResultFor(quiet) is not null && v.FindResultFor(verbose) is not null)
                 {

src/Cli/Microsoft.TemplateEngine.Cli/CliTemplateParameter.cs

@@ -5,6 +5,7 @@
 using System.CommandLine;
 using System.CommandLine.Help;
 using System.CommandLine.Parsing;
+using System.Diagnostics;
 using System.Globalization;
 using System.Text;
 using Microsoft.TemplateEngine.Abstractions;
@@ -150,7 +151,24 @@ internal Option GetOption(IReadOnlySet<string> aliases)
                 if (!string.IsNullOrWhiteSpace(DefaultValue)
                     || (Type == ParameterType.String || Type == ParameterType.Choice) && DefaultValue != null)
                 {
-                    option.SetDefaultValue(DefaultValue);
+                    switch (option)
+                    {
+                        case Option<string> stringOption:
+                            stringOption.SetDefaultValue(DefaultValue);
+                            break;
+                        case Option<bool> booleanOption:
+                            booleanOption.SetDefaultValue(bool.Parse(DefaultValue));
+                            break;
+                        case Option<long> integerOption:
+                            integerOption.SetDefaultValue(long.Parse(DefaultValue));
+                            break;
+                        case Option<float> floatOption:
+                            floatOption.SetDefaultValue(float.Parse(DefaultValue));
+                            break;
+                        default:
+                            Debug.Fail($"Unexpected Option type: {option.GetType()}");
+                            break;
+                    }
                 }
             }
             option.Description = GetOptionDescription();

src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs

@@ -192,7 +192,7 @@ protected IReadOnlyDictionary<FilterOptionDefinition, Option> SetupFilterOptions
             foreach (FilterOptionDefinition filterDef in filtersToSetup)
             {
                 Option newOption = GetFilterOption(filterDef);
-                this.AddOption(newOption);
+                this.Options.Add(newOption);
                 options[filterDef] = newOption;
             }
             return options;
@@ -203,8 +203,8 @@ protected IReadOnlyDictionary<FilterOptionDefinition, Option> SetupFilterOptions
         /// </summary>
         protected void SetupTabularOutputOptions(ITabularOutputCommand command)
         {
-            this.AddOption(command.ColumnsAllOption);
-            this.AddOption(command.ColumnsOption);
+            this.Options.Add(command.ColumnsAllOption);
+            this.Options.Add(command.ColumnsOption);
         }
 
         private static async Task HandleGlobalOptionsAsync(

src/Cli/Microsoft.TemplateEngine.Cli/Commands/Extensions.cs

@@ -4,6 +4,7 @@
 
 using System.CommandLine;
 using System.CommandLine.Parsing;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Abstractions.Constraints;
 using Microsoft.TemplateEngine.Edge;
@@ -25,24 +26,15 @@ internal static class Extensions
         /// <summary>
         /// Checks if <paramref name="parseResult"/> contains an error for <paramref name="option"/>.
         /// </summary>
-        internal static bool HasErrorFor(this ParseResult parseResult, Option option)
+        internal static bool HasErrorFor(this ParseResult parseResult, Option option, [NotNullWhen(true)] out ParseError? error)
         {
-            if (!parseResult.Errors.Any())
-            {
-                return false;
-            }
+            error = parseResult.Errors.FirstOrDefault(e => IsOptionResult(e.SymbolResult, option)
+                || IsOptionResult(e.SymbolResult?.Parent, option));
 
-            if (parseResult.Errors.Any(e => e.SymbolResult?.Symbol == option))
-            {
-                return true;
-            }
-
-            if (parseResult.Errors.Any(e => e.SymbolResult?.Parent?.Symbol == option))
-            {
-                return true;
-            }
+            return error is not null;
 
-            return false;
+            static bool IsOptionResult(SymbolResult? symbolResult, Option option)
+                => symbolResult is OptionResult optionResult && optionResult.Option == option;
         }
 
         /// <summary>
@@ -51,8 +43,8 @@ internal static bool HasErrorFor(this ParseResult parseResult, Option option)
         internal static void FromAmongCaseInsensitive(this Option<string> option, string[]? allowedValues = null, string? allowedHiddenValue = null)
         {
             allowedValues ??= Array.Empty<string>();
-            option.AddValidator(optionResult => ValidateAllowedValues(optionResult, allowedValues, allowedHiddenValue));
-            option.AddCompletions(allowedValues);
+            option.Validators.Add(optionResult => ValidateAllowedValues(optionResult, allowedValues, allowedHiddenValue));
+            option.CompletionSources.Add(allowedValues);
         }
 
         /// <summary>

src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs

@@ -54,15 +54,15 @@ internal void AddNoLegacyUsageValidators(Command command, params Symbol[] except
             {
                 if (!except.Contains(option))
                 {
-                    command.AddValidator(symbolResult => ValidateOptionUsage(symbolResult, option));
+                    command.Validators.Add(symbolResult => ValidateOptionUsage(symbolResult, option));
                 }
             }
 
             foreach (Argument argument in argumentsToVerify)
             {
                 if (!except.Contains(argument))
                 {
-                    command.AddValidator(symbolResult => ValidateArgumentUsage(symbolResult, argument));
+                    command.Validators.Add(symbolResult => ValidateArgumentUsage(symbolResult, argument));
                 }
             }
         }
@@ -79,7 +79,12 @@ internal void ValidateArgumentsAreNotUsed(CommandResult commandResult)
 
         internal void ValidateOptionUsage(CommandResult commandResult, Option option)
         {
-            OptionResult? optionResult = commandResult.Parent?.Children.FirstOrDefault(symbol => symbol.Symbol == option) as OptionResult;
+            if (commandResult.Parent is not CommandResult parentResult)
+            {
+                return;
+            }
+
+            OptionResult? optionResult = parentResult.Children.OfType<OptionResult>().FirstOrDefault(result => result.Option == option);
             if (optionResult != null)
             {
                 List<string> wrongTokens = new List<string>();
@@ -101,10 +106,15 @@ internal void ValidateOptionUsage(CommandResult commandResult, Option option)
 
         private static void ValidateArgumentUsage(CommandResult commandResult, params Argument[] arguments)
         {
+            if (commandResult.Parent is not CommandResult parentResult)
+            {
+                return;
+            }
+
             List<string> wrongTokens = new List<string>();
             foreach (Argument argument in arguments)
             {
-                var newCommandArgument = commandResult.Parent?.Children.FirstOrDefault(symbol => symbol.Symbol == argument) as ArgumentResult;
+                var newCommandArgument = parentResult.Children.OfType<ArgumentResult>().FirstOrDefault(result => result.Argument == argument);
                 if (newCommandArgument == null)
                 {
                     continue;
@@ -126,22 +136,22 @@ private static void ValidateArgumentUsage(CommandResult commandResult, params Ar
 
         private void BuildLegacySymbols(Func<ParseResult, ITemplateEngineHost> hostBuilder)
         {
-            this.AddArgument(ShortNameArgument);
-            this.AddArgument(RemainingArguments);
+            this.Arguments.Add(ShortNameArgument);
+            this.Arguments.Add(RemainingArguments);
 
             //legacy options
             Dictionary<FilterOptionDefinition, Option> options = new Dictionary<FilterOptionDefinition, Option>();
             foreach (var filterDef in LegacyFilterDefinitions)
             {
                 options[filterDef] = filterDef.OptionFactory().AsHidden();
-                this.AddOption(options[filterDef]);
+                this.Options.Add(options[filterDef]);
             }
             LegacyFilters = options;
 
-            this.AddOption(InteractiveOption);
-            this.AddOption(AddSourceOption);
-            this.AddOption(ColumnsAllOption);
-            this.AddOption(ColumnsOption);
+            this.Options.Add(InteractiveOption);
+            this.Options.Add(AddSourceOption);
+            this.Options.Add(ColumnsAllOption);
+            this.Options.Add(ColumnsOption);
 
             this.TreatUnmatchedTokensAsErrors = true;
 

src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs

@@ -37,12 +37,12 @@ internal NewCommand(
             this.AddGlobalOption(DebugRebuildCacheOption);
             this.AddGlobalOption(DebugShowConfigOption);
 
-            this.AddOption(SharedOptions.OutputOption);
-            this.AddOption(SharedOptions.NameOption);
-            this.AddOption(SharedOptions.DryRunOption);
-            this.AddOption(SharedOptions.ForceOption);
-            this.AddOption(SharedOptions.NoUpdateCheckOption);
-            this.AddOption(SharedOptions.ProjectPathOption);
+            this.Options.Add(SharedOptions.OutputOption);
+            this.Options.Add(SharedOptions.NameOption);
+            this.Options.Add(SharedOptions.DryRunOption);
+            this.Options.Add(SharedOptions.ForceOption);
+            this.Options.Add(SharedOptions.NoUpdateCheckOption);
+            this.Options.Add(SharedOptions.ProjectPathOption);
         }
 
         internal static Option<string?> DebugCustomSettingsLocationOption { get; } = new("--debug:custom-hive")

src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs

@@ -22,23 +22,23 @@ internal InstantiateCommand(
             Func<ParseResult, ITemplateEngineHost> hostBuilder)
             : base(hostBuilder, "create", SymbolStrings.Command_Instantiate_Description)
         {
-            this.AddArgument(ShortNameArgument);
-            this.AddArgument(RemainingArguments);
+            this.Arguments.Add(ShortNameArgument);
+            this.Arguments.Add(RemainingArguments);
 
-            this.AddOption(SharedOptions.OutputOption);
-            this.AddOption(SharedOptions.NameOption);
-            this.AddOption(SharedOptions.DryRunOption);
-            this.AddOption(SharedOptions.ForceOption);
-            this.AddOption(SharedOptions.NoUpdateCheckOption);
-            this.AddOption(SharedOptions.ProjectPathOption);
+            this.Options.Add(SharedOptions.OutputOption);
+            this.Options.Add(SharedOptions.NameOption);
+            this.Options.Add(SharedOptions.DryRunOption);
+            this.Options.Add(SharedOptions.ForceOption);
+            this.Options.Add(SharedOptions.NoUpdateCheckOption);
+            this.Options.Add(SharedOptions.ProjectPathOption);
 
             parentCommand.AddNoLegacyUsageValidators(this);
-            this.AddValidator(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.OutputOption));
-            this.AddValidator(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.NameOption));
-            this.AddValidator(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.DryRunOption));
-            this.AddValidator(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.ForceOption));
-            this.AddValidator(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.NoUpdateCheckOption));
-            this.AddValidator(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.ProjectPathOption));
+            this.Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.OutputOption));
+            this.Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.NameOption));
+            this.Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.DryRunOption));
+            this.Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.ForceOption));
+            this.Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.NoUpdateCheckOption));
+            this.Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.ProjectPathOption));
         }
 
         internal static Argument<string> ShortNameArgument { get; } = new Argument<string>("template-short-name")
@@ -272,7 +272,7 @@ private static async Task<NewCommandStatus> HandleTemplateInstantationAsync(
             if (candidates.Count == 1)
             {
                 TemplateCommand templateCommandToRun = candidates.Single();
-                args.Command.AddCommand(templateCommandToRun);
+                args.Command.Subcommands.Add(templateCommandToRun);
 
                 ParseResult updatedParseResult = args.ParseResult.Parser.Parse(args.ParseResult.Tokens.Select(t => t.Value).ToList());
                 return await candidates.Single().InvokeAsync(updatedParseResult, cancellationToken).ConfigureAwait(false);

src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InvalidTemplateOptionResult.cs

@@ -83,13 +83,8 @@ public bool Equals(InvalidTemplateOptionResult? other)
             return this.Equals(other as object);
         }
 
-        internal static new InvalidTemplateOptionResult FromParseResult(TemplateOption option, ParseResult parseResult)
+        internal static InvalidTemplateOptionResult FromParseError(TemplateOption option, ParseResult parseResult, ParseError error)
         {
-            if (!parseResult.HasErrorFor(option.Option))
-            {
-                throw new ArgumentException($"{nameof(option)} does not have an error in {nameof(parseResult)}");
-            }
-
             OptionResult? optionResult = parseResult.FindResultFor(option.Option);
             if (optionResult == null)
             {
@@ -103,23 +98,7 @@ public bool Equals(InvalidTemplateOptionResult? other)
                 optionValue = string.Join(", ", optionResult.Tokens.Select(t => t.Value));
             }
 
-            string? errorMessage = null;
-            if (!string.IsNullOrWhiteSpace(optionResult.ErrorMessage))
-            {
-                errorMessage = optionResult.ErrorMessage;
-            }
-            else
-            {
-                foreach (var result in optionResult.Children)
-                {
-                    if (string.IsNullOrWhiteSpace(result.ErrorMessage))
-                    {
-                        continue;
-                    }
-                    errorMessage = result.ErrorMessage;
-                    break;
-                }
-            }
+            string errorMessage = !string.IsNullOrWhiteSpace(optionResult.ErrorMessage) ? optionResult.ErrorMessage : error.Message;
 
             return new InvalidTemplateOptionResult(
                     option,