Reuse CSC arguments in file-based app runs (#50635)

Author: jjonescz

documentation/general/dotnet-run-file.md

@@ -295,7 +295,8 @@ We always need to re-run MSBuild if implicit build files like `Directory.Build.p
 from `.cs` files, the only relevant MSBuild inputs are the `#:` directives,
 hence we can first check the `.cs` file timestamps and for those that have changed, compare the sets of `#:` directives.
 If only `.cs` files change, it is enough to invoke `csc.exe` (directly or via a build server)
-re-using command-line arguments that the last MSBuild invocation passed to the compiler.
+re-using command-line arguments that the last MSBuild invocation passed to the compiler
+(you can opt out of this via an MSBuild property `FileBasedProgramCanSkipMSBuild=false`).
 If no inputs change, it is enough to start the target executable without invoking the build at all.
 
 ## Alternatives and future work

src/Cli/Microsoft.DotNet.Cli.Utils/Constants.cs

@@ -26,6 +26,15 @@ public static class Constants
     public static readonly string EnableDefaultEmbeddedResourceItems = nameof(EnableDefaultEmbeddedResourceItems);
     public static readonly string EnableDefaultNoneItems = nameof(EnableDefaultNoneItems);
 
+    // MSBuild targets
+    public const string Build = nameof(Build);
+    public const string ComputeRunArguments = nameof(ComputeRunArguments);
+    public const string CoreCompile = nameof(CoreCompile);
+
+    // MSBuild item metadata
+    public const string Identity = nameof(Identity);
+    public const string FullPath = nameof(FullPath);
+
     public static readonly string ProjectArgumentName = "<PROJECT>";
     public static readonly string SolutionArgumentName = "<SLN_FILE>";
     public static readonly string ToolPackageArgumentName = "<PACKAGE_ID>";

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

@@ -50,6 +50,20 @@ internal sealed partial class CSharpCompilerCommand
     public required string ArtifactsPath { get; init; }
     public required bool CanReuseAuxiliaryFiles { get; init; }
 
+    public string BaseDirectory => field ??= Path.GetDirectoryName(EntryPointFileFullPath)!;
+
+    /// <summary>
+    /// Compiler command line arguments to use. If empty, default arguments are used.
+    /// These should be already properly escaped.
+    /// </summary>
+    public required ImmutableArray<string> CscArguments { get; init; }
+
+    /// <summary>
+    /// Path to the <c>bin/Program.dll</c> file. If specified,
+    /// the compiled output (<c>obj/Program.dll</c>) will be copied to this location.
+    /// </summary>
+    public required string? BuildResultFile { get; init; }
+
     /// <param name="fallbackToNormalBuild">
     /// Whether the returned error code should not cause the build to fail but instead fallback to full MSBuild.
     /// </param>
@@ -64,7 +78,7 @@ public int Execute(out bool fallbackToNormalBuild)
             requestId: EntryPointFileFullPath,
             language: RequestLanguage.CSharpCompile,
             arguments: ["/noconfig", "/nologo", $"@{EscapeSingleArg(rspPath)}"],
-            workingDirectory: Environment.CurrentDirectory,
+            workingDirectory: BaseDirectory,
             tempDirectory: Path.GetTempPath(),
             keepAlive: null,
             libDirectory: null,
@@ -87,7 +101,18 @@ public int Execute(out bool fallbackToNormalBuild)
             cancellationToken: default);
 
         // Process the response.
-        return ProcessBuildResponse(responseTask.Result, out fallbackToNormalBuild);
+        var exitCode = ProcessBuildResponse(responseTask.Result, out fallbackToNormalBuild);
+
+        // Copy from obj to bin.
+        if (BuildResultFile != null &&
+            CSharpCommandLineParser.Default.Parse(CscArguments, BaseDirectory, sdkDirectory: null) is { OutputFileName: { } outputFileName } parsedArgs)
+        {
+            var objFile = parsedArgs.GetOutputFilePath(outputFileName);
+            Reporter.Verbose.WriteLine($"Copying '{objFile}' to '{BuildResultFile}'.");
+            File.Copy(objFile, BuildResultFile, overwrite: true);
+        }
+
+        return exitCode;
 
         static string GetCompilerCommitHash()
         {
@@ -129,6 +154,14 @@ static int ProcessBuildResponse(BuildResponse response, out bool fallbackToNorma
 
     private void PrepareAuxiliaryFiles(out string rspPath)
     {
+        rspPath = Path.Join(ArtifactsPath, "csc.rsp");
+
+        if (!CscArguments.IsDefaultOrEmpty)
+        {
+            File.WriteAllLines(rspPath, CscArguments);
+            return;
+        }
+
         string fileDirectory = Path.GetDirectoryName(EntryPointFileFullPath) ?? string.Empty;
         string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(EntryPointFileFullPath);
 
@@ -283,7 +316,6 @@ private void PrepareAuxiliaryFiles(out string rspPath)
                 """);
         }
 
-        rspPath = Path.Join(ArtifactsPath, "csc.rsp");
         if (ShouldEmit(rspPath))
         {
             IEnumerable<string> args = GetCscArguments(
@@ -315,18 +347,18 @@ private static string EscapeSingleArg(string arg)
     {
         if (IsPathOption(arg, out var colonIndex))
         {
-            return arg[..(colonIndex + 1)] + EscapeCore(arg[(colonIndex + 1)..]);
+            return arg[..(colonIndex + 1)] + EscapePathArgument(arg[(colonIndex + 1)..]);
         }
 
-        return EscapeCore(arg);
+        return EscapePathArgument(arg);
+    }
 
-        static string EscapeCore(string arg)
+    internal static string EscapePathArgument(string arg)
+    {
+        return ArgumentEscaper.EscapeSingleArg(arg, additionalShouldSurroundWithQuotes: static (string arg) =>
         {
-            return ArgumentEscaper.EscapeSingleArg(arg, additionalShouldSurroundWithQuotes: static (string arg) =>
-            {
-                return arg.ContainsAny(s_additionalShouldSurroundWithQuotes);
-            });
-        }
+            return arg.ContainsAny(s_additionalShouldSurroundWithQuotes);
+        });
     }
 
     public static bool IsPathOption(string arg, out int colonIndex)

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

@@ -338,8 +338,8 @@ private VirtualProjectBuildingCommand CreateVirtualCommand()
         Debug.Assert(EntryPointFileFullPath != null);
 
         var args = MSBuildArgs.RequestedTargets is null or []
-            ? MSBuildArgs.CloneWithAdditionalTargets("Build", ComputeRunArgumentsTarget)
-            : MSBuildArgs.CloneWithAdditionalTargets(ComputeRunArgumentsTarget);
+            ? MSBuildArgs.CloneWithAdditionalTargets(Constants.Build, Constants.ComputeRunArguments, Constants.CoreCompile)
+            : MSBuildArgs.CloneWithAdditionalTargets(Constants.ComputeRunArguments, Constants.CoreCompile);
 
         return new(
             entryPointFileFullPath: EntryPointFileFullPath,
@@ -378,6 +378,14 @@ private MSBuildArgs SetupSilentBuildArgs(MSBuildArgs msbuildArgs)
 
     internal ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? projectFactory, RunProperties? cachedRunProperties)
     {
+        if (cachedRunProperties != null)
+        {
+            // We can skip project evaluation if we already evaluated the project during virtual build
+            // or we have cached run properties in previous run (and this is a --no-build or skip-msbuild run).
+            Reporter.Verbose.WriteLine("Getting target command: from cache.");
+            return CreateCommandFromRunProperties(cachedRunProperties.WithApplicationArguments(ApplicationArgs));
+        }
+
         if (projectFactory is null && ProjectFileFullPath is null)
         {
             // If we are running a file-based app and projectFactory is null, it means csc was used instead of full msbuild.
@@ -387,14 +395,6 @@ internal ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? pro
             return CreateCommandForCscBuiltProgram(EntryPointFileFullPath);
         }
 
-        if (cachedRunProperties != null)
-        {
-            // We can also skip project evaluation if we already evaluated the project during virtual build
-            // or we have cached run properties in previous run (and this is a --no-build run).
-            Reporter.Verbose.WriteLine("Getting target command: from cache.");
-            return CreateCommandFromRunProperties(cachedRunProperties.WithApplicationArguments(ApplicationArgs));
-        }
-
         Reporter.Verbose.WriteLine("Getting target command: evaluating project.");
         FacadeLogger? logger = LoggerUtility.DetermineBinlogger([.. MSBuildArgs.OtherMSBuildArgs], "dotnet-run");
         var project = EvaluateProject(ProjectFileFullPath, projectFactory, MSBuildArgs, logger);
@@ -487,15 +487,13 @@ static void InvokeRunArgumentsTarget(ProjectInstance project, bool noBuild, Faca
                 loggersForBuild.Add(binaryLogger);
             }
 
-            if (!project.Build([ComputeRunArgumentsTarget], loggers: loggersForBuild, remoteLoggers: null, out _))
+            if (!project.Build([Constants.ComputeRunArguments], loggers: loggersForBuild, remoteLoggers: null, out _))
             {
-                throw new GracefulException(CliCommandStrings.RunCommandEvaluationExceptionBuildFailed, ComputeRunArgumentsTarget);
+                throw new GracefulException(CliCommandStrings.RunCommandEvaluationExceptionBuildFailed, Constants.ComputeRunArguments);
             }
         }
     }
 
-    static readonly string ComputeRunArgumentsTarget = "ComputeRunArguments";
-
     internal static void ThrowUnableToRunError(ProjectInstance project)
     {
         string targetFrameworks = project.GetPropertyValue("TargetFrameworks");