Support binlog in build/restore of file-based programs (#49009)

Author: jjonescz

src/Cli/dotnet/Commands/Build/BuildCommand.cs

@@ -29,7 +29,9 @@ public static CommandBase FromParseResult(ParseResult parseResult, string msbuil
             parseResult.GetResult(BuildCommandParser.SelfContainedOption) is not null,
             parseResult.GetResult(BuildCommandParser.NoSelfContainedOption) is not null);
 
-        string[] fileArgument = parseResult.GetValue(BuildCommandParser.SlnOrProjectOrFileArgument) ?? [];
+        string[] args = parseResult.GetValue(BuildCommandParser.SlnOrProjectOrFileArgument) ?? [];
+
+        LoggerUtility.SeparateBinLogArguments(args, out var binLogArgs, out var nonBinLogArgs);
 
         string[] forwardedOptions = parseResult.OptionValuesToBeForwarded(BuildCommandParser.GetCommand()).ToArray();
 
@@ -39,11 +41,11 @@ public static CommandBase FromParseResult(ParseResult parseResult, string msbuil
 
         CommandBase command;
 
-        if (fileArgument is [{ } arg] && VirtualProjectBuildingCommand.IsValidEntryPointPath(arg))
+        if (nonBinLogArgs is [{ } arg] && VirtualProjectBuildingCommand.IsValidEntryPointPath(arg))
         {
             command = new VirtualProjectBuildingCommand(
                 entryPointFileFullPath: Path.GetFullPath(arg),
-                msbuildArgs: forwardedOptions,
+                msbuildArgs: [.. forwardedOptions, .. binLogArgs],
                 verbosity: parseResult.GetValue(CommonOptions.VerbosityOption),
                 interactive: parseResult.GetValue(CommonOptions.InteractiveMsBuildForwardOption))
             {
@@ -65,7 +67,7 @@ public static CommandBase FromParseResult(ParseResult parseResult, string msbuil
 
             msbuildArgs.AddRange(forwardedOptions);
 
-            msbuildArgs.AddRange(fileArgument);
+            msbuildArgs.AddRange(args);
 
             command = new RestoringCommand(
                 msbuildArgs: msbuildArgs,

src/Cli/dotnet/Commands/Restore/RestoreCommand.cs

@@ -24,15 +24,17 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
 
         result.ShowHelpOrErrorIfAppropriate();
 
-        string[] fileArgument = result.GetValue(RestoreCommandParser.SlnOrProjectOrFileArgument) ?? [];
+        string[] args = result.GetValue(RestoreCommandParser.SlnOrProjectOrFileArgument) ?? [];
+
+        LoggerUtility.SeparateBinLogArguments(args, out var binLogArgs, out var nonBinLogArgs);
 
         string[] forwardedOptions = result.OptionValuesToBeForwarded(RestoreCommandParser.GetCommand()).ToArray();
 
-        if (fileArgument is [{ } arg] && VirtualProjectBuildingCommand.IsValidEntryPointPath(arg))
+        if (nonBinLogArgs is [{ } arg] && VirtualProjectBuildingCommand.IsValidEntryPointPath(arg))
         {
             return new VirtualProjectBuildingCommand(
                     entryPointFileFullPath: Path.GetFullPath(arg),
-                    msbuildArgs: forwardedOptions,
+                    msbuildArgs: [.. forwardedOptions, ..binLogArgs],
                     verbosity: result.GetValue(CommonOptions.VerbosityOption),
                     interactive: result.GetValue(CommonOptions.InteractiveMsBuildForwardOption))
             {
@@ -41,7 +43,7 @@ public static CommandBase FromParseResult(ParseResult result, string? msbuildPat
             };
         }
 
-        return CreateForwarding(["-target:Restore", .. forwardedOptions, .. fileArgument], msbuildPath);
+        return CreateForwarding(["-target:Restore", .. forwardedOptions, .. args], msbuildPath);
     }
 
     public static MSBuildForwardingApp CreateForwarding(IEnumerable<string> msbuildArgs, string? msbuildPath = null)

src/Cli/dotnet/Commands/Run/RunCommand.cs

@@ -515,24 +515,12 @@ public static RunCommand FromParseResult(ParseResult parseResult)
         // bl information to synchronize the restore and build logger configurations
         var applicationArguments = parseResult.GetValue(RunCommandParser.ApplicationArguments)?.ToList();
 
-        var binlogArgs = new List<string>();
-        var nonBinLogArgs = new List<string>();
-        foreach (var arg in applicationArguments ?? [])
-        {
-            if (LoggerUtility.IsBinLogArgument(arg))
-            {
-                binlogArgs.Add(arg);
-            }
-            else
-            {
-                nonBinLogArgs.Add(arg);
-            }
-        }
+        LoggerUtility.SeparateBinLogArguments(applicationArguments, out var binLogArgs, out var nonBinLogArgs);
 
         var restoreArgs = parseResult.OptionValuesToBeForwarded(RunCommandParser.GetCommand()).ToList();
-        if (binlogArgs.Count > 0)
+        if (binLogArgs.Count > 0)
         {
-            restoreArgs.AddRange(binlogArgs);
+            restoreArgs.AddRange(binLogArgs);
         }
 
         var command = new RunCommand(

src/Cli/dotnet/Commands/Test/MSBuildUtility.cs

@@ -61,20 +61,7 @@ public static (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModul
 
     public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOfParallelism)
     {
-        var binLogArgs = new List<string>();
-        var otherArgs = new List<string>();
-
-        foreach (var arg in parseResult.UnmatchedTokens)
-        {
-            if (LoggerUtility.IsBinLogArgument(arg))
-            {
-                binLogArgs.Add(arg);
-            }
-            else
-            {
-                otherArgs.Add(arg);
-            }
-        }
+        LoggerUtility.SeparateBinLogArguments(parseResult.UnmatchedTokens, out var binLogArgs, out var otherArgs);
 
         var msbuildArgs = parseResult.OptionValuesToBeForwarded(TestCommandParser.GetCommand())
             .Concat(binLogArgs);

src/Cli/dotnet/LoggerUtility.cs

@@ -61,6 +61,23 @@ private static FacadeLogger ConfigureDispatcher(List<BinaryLogger> binaryLoggers
         return new FacadeLogger(dispatcher);
     }
 
+    internal static void SeparateBinLogArguments(IEnumerable<string>? args, out List<string> binLogArgs, out List<string> nonBinLogArgs)
+    {
+        binLogArgs = new List<string>();
+        nonBinLogArgs = new List<string>();
+        foreach (var arg in args ?? [])
+        {
+            if (IsBinLogArgument(arg))
+            {
+                binLogArgs.Add(arg);
+            }
+            else
+            {
+                nonBinLogArgs.Add(arg);
+            }
+        }
+    }
+
     internal static bool IsBinLogArgument(string arg)
     {
         const StringComparison comp = StringComparison.OrdinalIgnoreCase;

test/dotnet.Tests/CommandTests/Run/RunFileTests.cs

@@ -573,6 +573,27 @@ public void BinaryLog(bool beforeFile)
             .Should().BeEquivalentTo(["msbuild.binlog", "msbuild-dotnet-run.binlog"]);
     }
 
+    [Theory, CombinatorialData]
+    public void BinaryLog_Build([CombinatorialValues("restore", "build")] string command, bool beforeFile)
+    {
+        var testInstance = _testAssetsManager.CreateTestDirectory();
+        File.WriteAllText(Path.Join(testInstance.Path, "Program.cs"), s_program);
+
+        string[] args = beforeFile
+            ? [command, "-bl", "Program.cs"]
+            : [command, "Program.cs", "-bl"];
+
+        new DotnetCommand(Log, args)
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass();
+
+        new DirectoryInfo(testInstance.Path)
+            .EnumerateFiles("*.binlog", SearchOption.TopDirectoryOnly)
+            .Select(f => f.Name)
+            .Should().BeEquivalentTo(["msbuild.binlog"]);
+    }
+
     [Theory]
     [InlineData("-bl")]
     [InlineData("-BL")]