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

eng/Version.Details.xml

@@ -253,13 +253,13 @@
       <Sha>2b6ab8d727ce73a78bcbf026ac75ea8a7c804daf</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.23302.1">
       <Uri>https://github.com/dotnet/command-line-api</Uri>
-      <Sha>8374d5fca634a93458c84414b1604c12f765d1ab</Sha>
+      <Sha>e678d32595c943e2c4b424eecc03b43f8265be82</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.430201">
       <Uri>https://github.com/dotnet/command-line-api</Uri>
-      <Sha>8374d5fca634a93458c84414b1604c12f765d1ab</Sha>
+      <Sha>e678d32595c943e2c4b424eecc03b43f8265be82</Sha>
       <SourceBuild RepoName="command-line-api" ManagedOnly="true" />
     </Dependency>
     <Dependency Name="Microsoft.SourceBuild.Intermediate.source-build-externals" Version="8.0.0-alpha.1.23301.1">

eng/Versions.props

@@ -39,7 +39,7 @@
     <SystemTextJsonVersion>7.0.2</SystemTextJsonVersion>
     <SystemReflectionMetadataLoadContextVersion>8.0.0-preview.6.23304.2</SystemReflectionMetadataLoadContextVersion>
     <SystemManagementPackageVersion>4.6.0</SystemManagementPackageVersion>
-    <SystemCommandLineVersion>2.0.0-beta4.22564.1</SystemCommandLineVersion>
+    <SystemCommandLineVersion>2.0.0-beta4.23302.1</SystemCommandLineVersion>
     <MicrosoftDeploymentDotNetReleasesVersion>1.0.0-preview.6.23206.1</MicrosoftDeploymentDotNetReleasesVersion>
     <MicrosoftVisualStudioSetupConfigurationInteropVersion>3.2.2146</MicrosoftVisualStudioSetupConfigurationInteropVersion>
   </PropertyGroup>

src/ApiCompat/Microsoft.DotNet.ApiCompat.Shared/ValidatePackage.cs

@@ -21,7 +21,7 @@ public static void Run(Func<ISuppressionEngine, ISuppressableLog> logFactory,
             bool enableRuleAttributesMustMatch,
             string[]? excludeAttributesFiles,
             bool enableRuleCannotChangeParameterName,
-            string packagePath,
+            string? packagePath,
             bool runApiCompat,
             bool enableStrictModeForCompatibleTfms,
             bool enableStrictModeForCompatibleFrameworksInPackage,

src/BlazorWasmSdk/Tool/Program.cs

@@ -4,8 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.CommandLine.Parsing;
 using System.IO;
 using System.IO.Compression;
 using System.Threading.Tasks;
@@ -16,23 +14,22 @@ internal static class Program
     {
         public static int Main(string[] args)
         {
-            var rootCommand = new RootCommand();
-            var brotli = new Command("brotli");
+            CliRootCommand rootCommand = new();
+            CliCommand brotli = new("brotli");
 
-            var compressionLevelOption = new Option<CompressionLevel>(
-                "-c",
-                defaultValueFactory: () => CompressionLevel.SmallestSize,
-                description: "System.IO.Compression.CompressionLevel for the Brotli compression algorithm.");
-            var sourcesOption = new Option<List<string>>(
-                "-s",
-                description: "A list of files to compress.")
+            CliOption<CompressionLevel> compressionLevelOption = new("-c")
             {
+                DefaultValueFactory = _ => CompressionLevel.SmallestSize,
+                Description = "System.IO.Compression.CompressionLevel for the Brotli compression algorithm.",
+            };
+            CliOption<List<string>> sourcesOption = new("-s")
+            {
+                Description = "A list of files to compress.",
                 AllowMultipleArgumentsPerToken = false
             };
-            var outputsOption = new Option<List<string>>(
-                "-o",
-                "The filenames to output the compressed file to.")
+            CliOption<List<string>> outputsOption = new("-o")
             {
+                Description = "The filenames to output the compressed file to.",
                 AllowMultipleArgumentsPerToken = false
             };
 
@@ -42,12 +39,11 @@ public static int Main(string[] args)
 
             rootCommand.Add(brotli);
 
-            brotli.SetHandler((InvocationContext context) =>
+            brotli.SetAction((ParseResult parseResult) =>
             {
-                var parseResults = context.ParseResult;
-                var c = parseResults.GetValue(compressionLevelOption);
-                var s = parseResults.GetValue(sourcesOption);
-                var o = parseResults.GetValue(outputsOption);
+                var c = parseResult.GetValue(compressionLevelOption);
+                var s = parseResult.GetValue(sourcesOption);
+                var o = parseResult.GetValue(outputsOption);
 
                 Parallel.For(0, s.Count, i =>
                 {
@@ -69,7 +65,7 @@ public static int Main(string[] args)
                 });
             });
 
-            return rootCommand.InvokeAsync(args).Result;
+            return rootCommand.Parse(args).Invoke();
         }
     }
 }

src/BuiltInTools/dotnet-watch/CommandLineOptions.cs

@@ -6,10 +6,8 @@
 using System;
 using System.Collections.Generic;
 using System.CommandLine;
-using System.CommandLine.Invocation;
+using System.IO;
 using System.Linq;
-
-using Microsoft.AspNetCore.Authentication;
 using Microsoft.DotNet.Watcher.Tools;
 using Microsoft.Extensions.Tools.Internal;
 
@@ -77,112 +75,131 @@ dotnet watch test
     public required IReadOnlyList<string> RemainingArguments { get; init; }
     public RunCommandLineOptions? RunOptions { get; init; }
 
-    public static CommandLineOptions? Parse(string[] args, IReporter reporter, out int errorCode, System.CommandLine.IConsole? console = null)
+    public static CommandLineOptions? Parse(string[] args, IReporter reporter, out int errorCode, TextWriter? output = null, TextWriter? error = null)
     {
-        var quietOption = new Option<bool>(new[] { "--quiet", "-q" }, "Suppresses all output except warnings and errors");
-        var verboseOption = new Option<bool>(new[] { "--verbose", "-v" }, "Show verbose output");
+        CliOption<bool> quietOption = new("--quiet", "-q")
+        {
+            Description = "Suppresses all output except warnings and errors"
+        };
 
-        verboseOption.AddValidator(v =>
+        CliOption<bool> verboseOption = new("--verbose", "-v")
         {
-            if (v.FindResultFor(quietOption) is not null && v.FindResultFor(verboseOption) is not null)
+            Description = "Show verbose output"
+        };
+
+        verboseOption.Validators.Add(v =>
+        {
+            if (v.GetResult(quietOption) is not null && v.GetResult(verboseOption) is not null)
             {
-                v.ErrorMessage = Resources.Error_QuietAndVerboseSpecified;
+                v.AddError(Resources.Error_QuietAndVerboseSpecified);
             }
         });
 
-        var listOption = new Option<bool>("--list", "Lists all discovered files without starting the watcher.");
-        var shortProjectOption = new Option<string>("-p", "The project to watch.") { IsHidden = true };
-        var longProjectOption = new Option<string>("--project", "The project to watch");
+        CliOption<bool> listOption = new("--list") { Description = "Lists all discovered files without starting the watcher." };
+        CliOption<string> shortProjectOption = new("-p") { Description = "The project to watch.", Hidden = true };
+        CliOption<string> longProjectOption = new("--project") { Description = "The project to watch" };
 
         // launch profile used by dotnet-watch
-        var launchProfileWatchOption = new Option<string>(new[] { "-lp", LaunchProfileOptionName }, "The launch profile to start the project with (case-sensitive).");
-        var noLaunchProfileWatchOption = new Option<bool>(new[] { NoLaunchProfileOptionName }, "Do not attempt to use launchSettings.json to configure the application.");
+        CliOption<string> launchProfileWatchOption = new(LaunchProfileOptionName, "-lp")
+        {
+            Description = "The launch profile to start the project with (case-sensitive)."
+        };
+        CliOption<bool> noLaunchProfileWatchOption = new(NoLaunchProfileOptionName)
+        {
+            Description = "Do not attempt to use launchSettings.json to configure the application."
+        };
 
         // launch profile used by dotnet-run
-        var launchProfileRunOption = new Option<string>(new[] { "-lp", LaunchProfileOptionName }) { IsHidden = true };
-        var noLaunchProfileRunOption = new Option<bool>(new[] { NoLaunchProfileOptionName }) { IsHidden = true };
+        CliOption<string> launchProfileRunOption = new (LaunchProfileOptionName, "-lp") { Hidden = true };
+        CliOption<bool> noLaunchProfileRunOption = new(NoLaunchProfileOptionName) { Hidden = true };
 
-        var targetFrameworkOption = new Option<string>(new[] { "-f", "--framework" }, "The target framework to run for. The target framework must also be specified in the project file.");
-        var propertyOption = new Option<string[]>(new[] { "--property" }, "Properties to be passed to MSBuild.");
+        CliOption<string> targetFrameworkOption = new("--framework", "-f")
+        {
+            Description = "The target framework to run for. The target framework must also be specified in the project file."
+        };
+        CliOption<string[]> propertyOption = new("--property")
+        {
+            Description = "Properties to be passed to MSBuild."
+        };
 
-        propertyOption.AddValidator(v =>
+        propertyOption.Validators.Add(v =>
         {
             var invalidProperty = v.GetValue(propertyOption)?.FirstOrDefault(
                 property => !(property.IndexOf('=') is > 0 and var index && index < property.Length - 1 && property[..index].Trim().Length > 0));
 
             if (invalidProperty != null)
             {
-                v.ErrorMessage = $"Invalid property format: '{invalidProperty}'. Expected 'name=value'.";
+                v.AddError($"Invalid property format: '{invalidProperty}'. Expected 'name=value'.");
             }
         });
 
-        var noHotReloadOption = new Option<bool>("--no-hot-reload", "Suppress hot reload for supported apps.");
-        var nonInteractiveOption = new Option<bool>(
-            "--non-interactive",
-            "Runs dotnet-watch in non-interactive mode. This option is only supported when running with Hot Reload enabled. " +
-            "Use this option to prevent console input from being captured.");
+        CliOption<bool> noHotReloadOption = new("--no-hot-reload") { Description = "Suppress hot reload for supported apps." };
+        CliOption<bool> nonInteractiveOption = new("--non-interactive")
+        {
+            Description = "Runs dotnet-watch in non-interactive mode. This option is only supported when running with Hot Reload enabled. " +
+            "Use this option to prevent console input from being captured."
+        };
 
-        var remainingWatchArgs = new Argument<string[]>("forwardedArgs", "Arguments to pass to the child dotnet process.");
-        var remainingRunArgs = new Argument<string[]>(name: null);
+        CliArgument<string[]> remainingWatchArgs = new("forwardedArgs") { Description = "Arguments to pass to the child dotnet process." };
+        CliArgument<string[]> remainingRunArgs = new ("remainingRunArgs");
 
-        var runCommand = new Command("run") { IsHidden = true };
-        var rootCommand = new RootCommand(Description);
-        addOptions(runCommand);
-        addOptions(rootCommand);
+        var runCommand = new CliCommand("run") { Hidden = true };
+        var rootCommand = new CliRootCommand(Description);
+        AddSymbols(runCommand);
+        AddSymbols(rootCommand);
 
-        void addOptions(Command command)
+        void AddSymbols(CliCommand command)
         {
-            command.Add(quietOption);
-            command.Add(verboseOption);
-            command.Add(noHotReloadOption);
-            command.Add(nonInteractiveOption);
-            command.Add(longProjectOption);
-            command.Add(shortProjectOption);
+            command.Options.Add(quietOption);
+            command.Options.Add(verboseOption);
+            command.Options.Add(noHotReloadOption);
+            command.Options.Add(nonInteractiveOption);
+            command.Options.Add(longProjectOption);
+            command.Options.Add(shortProjectOption);
 
             if (command == runCommand)
             {
-                command.Add(launchProfileRunOption);
-                command.Add(noLaunchProfileRunOption);
+                command.Options.Add(launchProfileRunOption);
+                command.Options.Add(noLaunchProfileRunOption);
             }
             else
             {
-                command.Add(launchProfileWatchOption);
-                command.Add(noLaunchProfileWatchOption);
+                command.Options.Add(launchProfileWatchOption);
+                command.Options.Add(noLaunchProfileWatchOption);
             }
 
-            command.Add(targetFrameworkOption);
-            command.Add(propertyOption);
+            command.Options.Add(targetFrameworkOption);
+            command.Options.Add(propertyOption);
 
-            command.Add(listOption);
+            command.Options.Add(listOption);
 
             if (command == runCommand)
             {
-                command.Add(remainingRunArgs);
+                command.Arguments.Add(remainingRunArgs);
             }
             else
             {
-                command.Add(runCommand);
-                command.Add(remainingWatchArgs);
+                command.Subcommands.Add(runCommand);
+                command.Arguments.Add(remainingWatchArgs);
             }
         };
 
         CommandLineOptions? options = null;
 
-        runCommand.SetHandler(context =>
+        runCommand.SetAction(parseResult =>
         {
-            RootHandler(context, new()
+            RootHandler(parseResult, new()
             {
-                LaunchProfileName = context.ParseResult.GetValue(launchProfileRunOption),
-                NoLaunchProfile = context.ParseResult.GetValue(noLaunchProfileRunOption),
-                RemainingArguments = context.ParseResult.GetValue(remainingRunArgs),
+                LaunchProfileName = parseResult.GetValue(launchProfileRunOption),
+                NoLaunchProfile = parseResult.GetValue(noLaunchProfileRunOption),
+                RemainingArguments = parseResult.GetValue(remainingRunArgs) ?? Array.Empty<string>(),
             });
         });
 
-        rootCommand.SetHandler(context => RootHandler(context, runOptions: null));
+        rootCommand.SetAction(parseResult => RootHandler(parseResult, runOptions: null));
 
-        void RootHandler(InvocationContext context, RunCommandLineOptions? runOptions)
+        void RootHandler(ParseResult parseResults, RunCommandLineOptions? runOptions)
         {
-            var parseResults = context.ParseResult;
             var projectValue = parseResults.GetValue(longProjectOption);
             if (string.IsNullOrEmpty(projectValue))
             {
@@ -207,12 +224,17 @@ void RootHandler(InvocationContext context, RunCommandLineOptions? runOptions)
                 TargetFramework = parseResults.GetValue(targetFrameworkOption),
                 BuildProperties = parseResults.GetValue(propertyOption)?
                     .Select(p => (p[..p.IndexOf('=')].Trim(), p[(p.IndexOf('=') + 1)..])).ToArray(),
-                RemainingArguments = parseResults.GetValue(remainingWatchArgs),
+                RemainingArguments = parseResults.GetValue(remainingWatchArgs) ?? Array.Empty<string>(),
                 RunOptions = runOptions,
             };
         }
 
-        errorCode = rootCommand.Invoke(args, console);
+        errorCode = new CliConfiguration(rootCommand)
+        {
+            Output = output ?? Console.Out,
+            Error = error ?? Console.Error
+        }.Invoke(args);
+
         return options;
     }