fix: migrate PerfDiff to System.CommandLine 2.0.3

Directory.Packages.props

@@ -33,8 +33,7 @@
     <PackageVersion Include="BenchmarkDotNet" Version="0.15.8" />
     <PackageVersion Include="GetPackFromProject" Version="1.0.10" />
     <PackageVersion Include="Nerdbank.GitVersioning" Version="3.9.50" />
-    <PackageVersion Include="System.CommandLine" Version="2.0.0-beta1.21216.1" />
-    <PackageVersion Include="System.CommandLine.Rendering" Version="2.0.0-beta1.20074.1" />
+    <PackageVersion Include="System.CommandLine" Version="2.0.3" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
     <PackageVersion Include="Perfolizer" Version="0.6.1" />
     <PackageVersion Include="Microsoft.Extensions.Logging" Version="10.0.5" />

src/tools/PerfDiff/BDN/BenchmarkComparisonService.cs

@@ -23,10 +23,11 @@ public class BenchmarkComparisonService(ILogger logger)
     /// </summary>
     /// <param name="baselineFolder">The folder containing baseline results.</param>
     /// <param name="resultsFolder">The folder containing new results.</param>
+    /// <param name="cancellationToken">Token to observe for cancellation requests.</param>
     /// <returns>A <see cref="BenchmarkComparisonResult"/> indicating comparison success and regression detection.</returns>
-    public async Task<BenchmarkComparisonResult> CompareAsync(string baselineFolder, string resultsFolder)
+    public async Task<BenchmarkComparisonResult> CompareAsync(string baselineFolder, string resultsFolder, CancellationToken cancellationToken)
     {
-        BdnComparisonResult[]? comparison = await BenchmarkDotNetDiffer.TryGetBdnResultsAsync(baselineFolder, resultsFolder, logger).ConfigureAwait(false);
+        BdnComparisonResult[]? comparison = await BenchmarkDotNetDiffer.TryGetBdnResultsAsync(baselineFolder, resultsFolder, logger, cancellationToken).ConfigureAwait(false);
         if (comparison is null)
         {
             return new BenchmarkComparisonResult(CompareSucceeded: false, RegressionDetected: false);

src/tools/PerfDiff/BDN/BenchmarkDotNetDiffer.cs

@@ -24,11 +24,12 @@
     /// <param name="baselineFolder">The folder containing baseline results.</param>
     /// <param name="resultsFolder">The folder containing new results.</param>
     /// <param name="logger">Logger for reporting errors.</param>
+    /// <param name="cancellationToken">Token to observe for cancellation requests.</param>
     /// <returns>A <see cref="BenchmarkComparisonResult"/> indicating comparison success and regression detection.</returns>
-    public static async Task<BenchmarkComparisonResult> TryCompareBenchmarkDotNetResultsAsync(string baselineFolder, string resultsFolder, ILogger logger)
+    public static async Task<BenchmarkComparisonResult> TryCompareBenchmarkDotNetResultsAsync(string baselineFolder, string resultsFolder, ILogger logger, CancellationToken cancellationToken)
     {
         BenchmarkComparisonService service = new(logger);
-        return await service.CompareAsync(baselineFolder, resultsFolder).ConfigureAwait(false);
+        return await service.CompareAsync(baselineFolder, resultsFolder, cancellationToken).ConfigureAwait(false);
     }
 
     /// <summary>
@@ -37,8 +38,9 @@
     /// <param name="baselineFolder">The folder containing baseline results.</param>
     /// <param name="resultsFolder">The folder containing new results.</param>
     /// <param name="logger">Logger for reporting errors.</param>
+    /// <param name="cancellationToken">Token to observe for cancellation requests.</param>
     /// <returns>An array of <see cref="BdnComparisonResult"/> if successful; otherwise, <see langword="null"/>.</returns>
-    internal static async Task<BdnComparisonResult[]?> TryGetBdnResultsAsync(string baselineFolder, string resultsFolder, ILogger logger)
+    internal static async Task<BdnComparisonResult[]?> TryGetBdnResultsAsync(string baselineFolder, string resultsFolder, ILogger logger, CancellationToken cancellationToken)
     {
         if (!TryGetFilesToParse(baselineFolder, out string[]? baseFiles))
         {
@@ -52,19 +54,19 @@
             return null;
         }
 
-        if (!baseFiles.Any() || !resultsFiles.Any())
+        if (baseFiles.Length == 0 || resultsFiles.Length == 0)
         {
-            logger.LogError($"Provided paths contained no '{FullBdnJsonFileExtension}' files.");
+            logger.LogError("Provided paths contained no '{FileExtension}' files.", FullBdnJsonFileExtension);
             return null;
         }
 
-        (bool baseResultsSuccess, BdnResult?[] baseResults) = await BenchmarkFileReader.TryGetBdnResultAsync(baseFiles, logger).ConfigureAwait(false);
+        (bool baseResultsSuccess, BdnResult?[] baseResults) = await BenchmarkFileReader.TryGetBdnResultAsync(baseFiles, logger, cancellationToken).ConfigureAwait(false);
         if (!baseResultsSuccess)
         {
             return null;
         }
 
-        (bool resultsSuccess, BdnResult?[] diffResults) = await BenchmarkFileReader.TryGetBdnResultAsync(resultsFiles, logger).ConfigureAwait(false);
+        (bool resultsSuccess, BdnResult?[] diffResults) = await BenchmarkFileReader.TryGetBdnResultAsync(resultsFiles, logger, cancellationToken).ConfigureAwait(false);
         if (!resultsSuccess)
         {
             return null;
@@ -78,10 +80,16 @@
             .SelectMany(result => result?.Benchmarks ?? Enumerable.Empty<Benchmark>())
             .ToDictionary(benchmarkResult => benchmarkResult.FullName ?? $"Unknown-{Guid.NewGuid():N}", benchmarkResult => benchmarkResult);
 
-        return benchmarkIdToBaseResults
-            .Where(baseResult => benchmarkIdToDiffResults.ContainsKey(baseResult.Key))
-            .Select(baseResult => new BdnComparisonResult(baseResult.Key, baseResult.Value, benchmarkIdToDiffResults[baseResult.Key]))
-            .ToArray();
+        List<BdnComparisonResult> matched = [];
+        foreach (KeyValuePair<string, Benchmark> baseResult in benchmarkIdToBaseResults)
+        {
+            if (benchmarkIdToDiffResults.TryGetValue(baseResult.Key, out Benchmark? diffBenchmark))
+            {
+                matched.Add(new BdnComparisonResult(baseResult.Key, baseResult.Value, diffBenchmark));
+            }
+        }
+
+        return matched.ToArray();
     }
 
     private static bool TryGetFilesToParse(string path, [NotNullWhen(true)] out string[]? files)

src/tools/PerfDiff/BDN/BenchmarkFileReader.cs

@@ -15,18 +15,19 @@ internal static class BenchmarkFileReader
     /// </summary>
     /// <param name="paths">Array of file paths to read.</param>
     /// <param name="logger">Logger for reporting errors.</param>
+    /// <param name="cancellationToken">Token to observe for cancellation requests.</param>
     /// <returns>A <see cref="BdnResults"/> containing the loaded results and success status.</returns>
-    public static async Task<BdnResults> TryGetBdnResultAsync(string[] paths, ILogger logger)
+    public static async Task<BdnResults> TryGetBdnResultAsync(string[] paths, ILogger logger, CancellationToken cancellationToken)
     {
-        BdnResult?[] results = await Task.WhenAll(paths.Select(path => ReadFromFileAsync(path, logger))).ConfigureAwait(false);
-        return new BdnResults(!results.Any(static x => x is null), results);
+        BdnResult?[] results = await Task.WhenAll(paths.Select(path => ReadFromFileAsync(path, logger, cancellationToken))).ConfigureAwait(false);
+        return new BdnResults(Array.TrueForAll(results, static x => x is not null), results);
     }
 
-    private static async Task<BdnResult?> ReadFromFileAsync(string resultFilePath, ILogger logger)
+    private static async Task<BdnResult?> ReadFromFileAsync(string resultFilePath, ILogger logger, CancellationToken cancellationToken)
     {
         try
         {
-            return JsonConvert.DeserializeObject<BdnResult>(await File.ReadAllTextAsync(resultFilePath).ConfigureAwait(false));
+            return JsonConvert.DeserializeObject<BdnResult>(await File.ReadAllTextAsync(resultFilePath, cancellationToken).ConfigureAwait(false));
         }
         catch (Exception ex) when (ex is JsonReaderException or JsonSerializationException or IOException or UnauthorizedAccessException or SecurityException)
         {

src/tools/PerfDiff/DiffCommand.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
+using System.Collections.Frozen;
 using System.CommandLine;
+using Microsoft.Extensions.Logging;
 
 namespace PerfDiff;
 
@@ -10,43 +12,84 @@ namespace PerfDiff;
 internal static class DiffCommand
 {
     /// <summary>
-    /// Delegate for handling the diff command.
+    /// Maps verbosity strings to their corresponding log levels.
     /// </summary>
-    /// <param name="baseline">Baseline results folder.</param>
-    /// <param name="results">Results folder.</param>
-    /// <param name="verbosity">Verbosity level.</param>
-    /// <param name="failOnRegression">Whether to fail on regression.</param>
-    /// <param name="console">Console for output.</param>
-    /// <returns>Exit code.</returns>
-    internal delegate Task<int> Handler(
-        string baseline,
-        string results,
-        string? verbosity,
-        bool failOnRegression,
-        IConsole console);
+    private static readonly FrozenDictionary<string, LogLevel> VerbosityMap = new Dictionary<string, LogLevel>(10)
+    {
+        ["q"] = LogLevel.Error,
+        ["quiet"] = LogLevel.Error,
+        ["m"] = LogLevel.Warning,
+        ["minimal"] = LogLevel.Warning,
+        ["n"] = LogLevel.Information,
+        ["normal"] = LogLevel.Information,
+        ["d"] = LogLevel.Debug,
+        ["detailed"] = LogLevel.Debug,
+        ["diag"] = LogLevel.Trace,
+        ["diagnostic"] = LogLevel.Trace,
+    }.ToFrozenDictionary(StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>
+    /// Gets the baseline option.
+    /// </summary>
+    internal static Option<string> BaselineOption { get; } = CreateFilePathOption("--baseline", "folder that contains the baseline performance run data");
 
     /// <summary>
-    /// Gets the allowed verbosity levels for the command.
+    /// Gets the results option.
     /// </summary>
-    private static readonly string[] VerbosityLevels = ["q", "quiet", "m", "minimal", "n", "normal", "d", "detailed", "diag", "diagnostic"];
+    internal static Option<string> ResultsOption { get; } = CreateFilePathOption("--results", "folder that contains the performance results");
+
+    /// <summary>
+    /// Gets the verbosity option.
+    /// </summary>
+    internal static Option<string> VerbosityOption { get; } = CreateVerbosityOption();
+
+    /// <summary>
+    /// Gets the fail-on-regression option.
+    /// </summary>
+    internal static Option<bool> FailOnRegressionOption { get; } = new("--failOnRegression")
+    {
+        Description = "Should return non-zero exit code if regression detected",
+    };
+
+    private static Option<string> CreateFilePathOption(string name, string description)
+    {
+        Option<string> option = new(name) { Description = description, Required = true };
+        option.AcceptLegalFilePathsOnly();
+        return option;
+    }
+
+    /// <summary>
+    /// Returns the <see cref="LogLevel"/> for the given verbosity string.
+    /// Falls back to <see cref="LogLevel.Information"/> when the value is null or unrecognized.
+    /// </summary>
+    /// <param name="verbosity">The verbosity string from the command line.</param>
+    /// <returns>The corresponding <see cref="LogLevel"/>.</returns>
+    internal static LogLevel GetLogLevel(string? verbosity)
+        => verbosity is not null && VerbosityMap.TryGetValue(verbosity, out LogLevel level)
+            ? level
+            : LogLevel.Information;
+
+    private static Option<string> CreateVerbosityOption()
+    {
+        Option<string> option = new("--verbosity", "-v") { Description = "Set the verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic]" };
+        option.AcceptOnlyFromAmong(VerbosityMap.Keys.ToArray());
+        return option;
+    }
 
     /// <summary>
     /// Creates the root command with options for the diff command.
     /// </summary>
     /// <returns>The configured <see cref="RootCommand"/>.</returns>
     internal static RootCommand CreateCommandLineOptions()
     {
-        // Sync changes to option and argument names with the FormatCommand.Handler above.
-        RootCommand rootCommand = new RootCommand
+        RootCommand rootCommand = new RootCommand("diff two sets of performance results")
         {
-            new Option<string?>("--baseline", () => null, "folder that contains the baseline performance run data").LegalFilePathsOnly(),
-            new Option<string?>("--results", () => null, "folder that contains the performance results").LegalFilePathsOnly(),
-            new Option<string>(["--verbosity", "-v"], "Set the verbosity level. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic]").FromAmong(VerbosityLevels),
-            new Option<bool>(["--failOnRegression"], "Should return non-zero exit code if regression detected"),
+            BaselineOption,
+            ResultsOption,
+            VerbosityOption,
+            FailOnRegressionOption,
         };
 
-        rootCommand.Description = "diff two sets of performance results";
-
         return rootCommand;
     }
 }

src/tools/PerfDiff/Logging/SimpleConsoleLogger.cs

@@ -1,8 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
-using System.Collections.Immutable;
-using System.CommandLine;
-using System.CommandLine.Rendering;
+using System.Collections.Frozen;
 using Microsoft.Extensions.Logging;
 
 namespace PerfDiff.Logging;
@@ -12,14 +10,12 @@ namespace PerfDiff.Logging;
 /// </summary>
 internal sealed class SimpleConsoleLogger : ILogger
 {
-    private readonly Lock _gate = new();
+    private static readonly Lock Gate = new();
 
-    private readonly IConsole _console;
-    private readonly ITerminal _terminal;
     private readonly LogLevel _minimalLogLevel;
     private readonly LogLevel _minimalErrorLevel;
 
-    private static ImmutableDictionary<LogLevel, ConsoleColor> LogLevelColorMap => new Dictionary<LogLevel, ConsoleColor>
+    private static readonly FrozenDictionary<LogLevel, ConsoleColor> LogLevelColorMap = new Dictionary<LogLevel, ConsoleColor>
     {
         [LogLevel.Critical] = ConsoleColor.Red,
         [LogLevel.Error] = ConsoleColor.Red,
@@ -28,18 +24,15 @@ internal sealed class SimpleConsoleLogger : ILogger
         [LogLevel.Debug] = ConsoleColor.Gray,
         [LogLevel.Trace] = ConsoleColor.Gray,
         [LogLevel.None] = ConsoleColor.White,
-    }.ToImmutableDictionary();
+    }.ToFrozenDictionary();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SimpleConsoleLogger"/> class.
     /// </summary>
-    /// <param name="console">The console to write output to.</param>
     /// <param name="minimalLogLevel">The minimal log level for output.</param>
     /// <param name="minimalErrorLevel">The minimal log level for error output.</param>
-    public SimpleConsoleLogger(IConsole console, LogLevel minimalLogLevel, LogLevel minimalErrorLevel)
+    public SimpleConsoleLogger(LogLevel minimalLogLevel, LogLevel minimalErrorLevel)
     {
-        _terminal = console.GetTerminal();
-        _console = console;
         _minimalLogLevel = minimalLogLevel;
         _minimalErrorLevel = minimalErrorLevel;
     }
@@ -52,17 +45,20 @@ public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Except
             return;
         }
 
-        lock (_gate)
+        lock (Gate)
         {
             string message = formatter(state, exception);
             bool logToErrorStream = logLevel >= _minimalErrorLevel;
-            if (_terminal is null)
+            ConsoleColor messageColor = LogLevelColorMap[logLevel];
+
+            Console.ForegroundColor = messageColor;
+            try
             {
-                LogToConsole(_console, message, logToErrorStream);
+                LogToConsole(message, logToErrorStream);
             }
-            else
+            finally
             {
-                LogToTerminal(message, logLevel, logToErrorStream);
+                Console.ResetColor();
             }
         }
     }
@@ -80,25 +76,15 @@ public IDisposable BeginScope<TState>(TState state)
         return NullScope.Instance;
     }
 
-    private void LogToTerminal(string message, LogLevel logLevel, bool logToErrorStream)
-    {
-        ConsoleColor messageColor = LogLevelColorMap[logLevel];
-        _terminal.ForegroundColor = messageColor;
-
-        LogToConsole(_terminal, message, logToErrorStream);
-
-        _terminal.ResetColor();
-    }
-
-    private static void LogToConsole(IConsole console, string message, bool logToErrorStream)
+    private static void LogToConsole(string message, bool logToErrorStream)
     {
         if (logToErrorStream)
         {
-            console.Error.Write($"{message}{Environment.NewLine}");
+            Console.Error.Write($"{message}{Environment.NewLine}");
         }
         else
         {
-            console.Out.Write($"  {message}{Environment.NewLine}");
+            Console.Out.Write($"  {message}{Environment.NewLine}");
         }
     }
 }

src/tools/PerfDiff/Logging/SimpleConsoleLoggerProvider.cs

@@ -1,6 +1,5 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
 
-using System.CommandLine;
 using Microsoft.Extensions.Logging;
 
 namespace PerfDiff.Logging;
@@ -10,27 +9,22 @@ namespace PerfDiff.Logging;
 /// </summary>
 internal sealed class SimpleConsoleLoggerProvider : ILoggerProvider
 {
-    private readonly IConsole _console;
-    private readonly LogLevel _minimalLogLevel;
-    private readonly LogLevel _minimalErrorLevel;
+    private readonly SimpleConsoleLogger _logger;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SimpleConsoleLoggerProvider"/> class.
     /// </summary>
-    /// <param name="console">The console to write output to.</param>
     /// <param name="minimalLogLevel">The minimal log level for output.</param>
     /// <param name="minimalErrorLevel">The minimal log level for error output.</param>
-    public SimpleConsoleLoggerProvider(IConsole console, LogLevel minimalLogLevel, LogLevel minimalErrorLevel)
+    public SimpleConsoleLoggerProvider(LogLevel minimalLogLevel, LogLevel minimalErrorLevel)
     {
-        _console = console;
-        _minimalLogLevel = minimalLogLevel;
-        _minimalErrorLevel = minimalErrorLevel;
+        _logger = new SimpleConsoleLogger(minimalLogLevel, minimalErrorLevel);
     }
 
     /// <inheritdoc/>
     public ILogger CreateLogger(string categoryName)
     {
-        return new SimpleConsoleLogger(_console, _minimalLogLevel, _minimalErrorLevel);
+        return _logger;
     }
 
     /// <inheritdoc/>