Support build/restore of file-based programs (#48662)

Author: jjonescz

documentation/general/dotnet-run-file.md

@@ -257,9 +257,11 @@ but that would require changes to the native dotnet host.
 
 ## Other commands
 
-We can consider supporting other commands like `dotnet build`, `dotnet pack`, `dotnet watch`.
+Commands `dotnet restore file.cs` and `dotnet build file.cs` are needed for IDE support and hence work for file-based programs.
+We can consider supporting other commands like `dotnet pack`, `dotnet watch`,
+however the primary scenario is `dotnet run` and we might never support additional commands.
 
-These commands need to have a way to receive the target path similarly to `dotnet run`,
+All commands supporting file-based programs should have a way to receive the target path similarly to `dotnet run`,
 e.g., via options like `--directory`/`--entry` as described [above](#integration-into-the-existing-dotnet-run-command),
 or as the first argument if it makes sense for them.
 

src/Cli/dotnet/CliStrings.resx

@@ -458,6 +458,12 @@ setx PATH "%PATH%;{0}"
   <data name="SolutionOrProjectArgumentName" xml:space="preserve">
     <value>PROJECT | SOLUTION</value>
   </data>
+  <data name="SolutionOrProjectOrFileArgumentDescription" xml:space="preserve">
+    <value>The project or solution or C# (file-based program) file to operate on. If a file is not specified, the command will search the current directory for a project or solution.</value>
+  </data>
+  <data name="SolutionOrProjectOrFileArgumentName" xml:space="preserve">
+    <value>PROJECT | SOLUTION | FILE</value>
+  </data>
   <data name="CommandInteractiveOptionDescription" xml:space="preserve">
     <value>Allows the command to stop and wait for user input or action (for example to complete authentication).</value>
   </data>
@@ -797,4 +803,4 @@ For a list of locations searched, specify the "-d" option before the tool name.<
     <value>Cannot specify --version when the package argument already contains a version.</value>
     <comment>{Locked="--version"}</comment>
   </data>
-</root>
+</root>

src/Cli/dotnet/CommandBase.cs

@@ -16,6 +16,8 @@ protected CommandBase(ParseResult parseResult)
         ShowHelpOrErrorIfAppropriate(parseResult);
     }
 
+    protected CommandBase() { }
+
     protected virtual void ShowHelpOrErrorIfAppropriate(ParseResult parseResult)
     {
         parseResult.ShowHelpOrErrorIfAppropriate();

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

@@ -3,52 +3,73 @@
 
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.Restore;
+using Microsoft.DotNet.Cli.Commands.Run;
 using Microsoft.DotNet.Cli.Extensions;
 
 namespace Microsoft.DotNet.Cli.Commands.Build;
 
-public class BuildCommand(
-    IEnumerable<string> msbuildArgs,
-    bool noRestore,
-    string msbuildPath = null) : RestoringCommand(msbuildArgs, noRestore, msbuildPath)
+public static class BuildCommand
 {
-    public static BuildCommand FromArgs(string[] args, string msbuildPath = null)
+    public static CommandBase FromArgs(string[] args, string msbuildPath = null)
     {
         var parser = Parser.Instance;
         var parseResult = parser.ParseFrom("dotnet build", args);
         return FromParseResult(parseResult, msbuildPath);
     }
 
-    public static BuildCommand FromParseResult(ParseResult parseResult, string msbuildPath = null)
+    public static CommandBase FromParseResult(ParseResult parseResult, string msbuildPath = null)
     {
         PerformanceLogEventSource.Log.CreateBuildCommandStart();
 
-        var msbuildArgs = new List<string>();
-
         parseResult.ShowHelpOrErrorIfAppropriate();
 
         CommonOptions.ValidateSelfContainedOptions(
             parseResult.GetResult(BuildCommandParser.SelfContainedOption) is not null,
             parseResult.GetResult(BuildCommandParser.NoSelfContainedOption) is not null);
 
-        msbuildArgs.Add($"-consoleloggerparameters:Summary");
+        string[] fileArgument = parseResult.GetValue(BuildCommandParser.SlnOrProjectOrFileArgument) ?? [];
+
+        string[] forwardedOptions = parseResult.OptionValuesToBeForwarded(BuildCommandParser.GetCommand()).ToArray();
+
+        bool noRestore = parseResult.GetResult(BuildCommandParser.NoRestoreOption) is not null;
+
+        bool noIncremental = parseResult.GetResult(BuildCommandParser.NoIncrementalOption) is not null;
 
-        if (parseResult.GetResult(BuildCommandParser.NoIncrementalOption) is not null)
+        CommandBase command;
+
+        if (fileArgument is [{ } arg] && VirtualProjectBuildingCommand.IsValidEntryPointPath(arg))
         {
-            msbuildArgs.Add("-target:Rebuild");
+            command = new VirtualProjectBuildingCommand(
+                entryPointFileFullPath: Path.GetFullPath(arg),
+                msbuildArgs: forwardedOptions,
+                verbosity: parseResult.GetValue(CommonOptions.VerbosityOption),
+                interactive: parseResult.GetValue(CommonOptions.InteractiveMsBuildForwardOption))
+            {
+                NoRestore = noRestore,
+                NoCache = true,
+                NoIncremental = noIncremental,
+            };
         }
-        var arguments = parseResult.GetValue(BuildCommandParser.SlnOrProjectArgument) ?? [];
+        else
+        {
+            var msbuildArgs = new List<string>();
 
-        msbuildArgs.AddRange(parseResult.OptionValuesToBeForwarded(BuildCommandParser.GetCommand()));
+            msbuildArgs.Add($"-consoleloggerparameters:Summary");
 
-        msbuildArgs.AddRange(arguments);
+            if (noIncremental)
+            {
+                msbuildArgs.Add("-target:Rebuild");
+            }
 
-        bool noRestore = parseResult.GetResult(BuildCommandParser.NoRestoreOption) is not null;
+            msbuildArgs.AddRange(forwardedOptions);
 
-        BuildCommand command = new(
-            msbuildArgs,
-            noRestore,
-            msbuildPath);
+            msbuildArgs.AddRange(fileArgument);
+
+            command = new RestoringCommand(
+                msbuildArgs: msbuildArgs,
+                noRestore: noRestore,
+                msbuildPath: msbuildPath);
+        }
 
         PerformanceLogEventSource.Log.CreateBuildCommandStop();
 

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

@@ -11,9 +11,9 @@ internal static class BuildCommandParser
 {
     public static readonly string DocsLink = "https://aka.ms/dotnet-build";
 
-    public static readonly Argument<IEnumerable<string>> SlnOrProjectArgument = new(CliStrings.SolutionOrProjectArgumentName)
+    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
-        Description = CliStrings.SolutionOrProjectArgumentDescription,
+        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
         Arity = ArgumentArity.ZeroOrMore
     };
 
@@ -64,7 +64,7 @@ private static Command ConstructCommand()
     {
         DocumentedCommand command = new("build", DocsLink, CliCommandStrings.BuildAppFullName);
 
-        command.Arguments.Add(SlnOrProjectArgument);
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
         RestoreCommandParser.AddImplicitRestoreOptions(command, includeRuntimeOption: false, includeNoDependenciesOption: false);
         command.Options.Add(FrameworkOption);
         command.Options.Add(ConfigurationOption);

src/Cli/dotnet/Commands/MSBuild/MSBuildForwardingApp.cs

@@ -8,7 +8,7 @@
 
 namespace Microsoft.DotNet.Cli.Commands.MSBuild;
 
-public class MSBuildForwardingApp
+public class MSBuildForwardingApp : CommandBase
 {
     internal const string TelemetrySessionIdEnvironmentVariableName = "DOTNET_CLI_TELEMETRY_SESSIONID";
 
@@ -74,7 +74,7 @@ private void InitializeRequiredEnvironmentVariables()
 
     internal string[] GetArgumentTokensToMSBuild() => _forwardingAppWithoutLogging.GetAllArguments();
 
-    public virtual int Execute()
+    public override int Execute()
     {
         // Ignore Ctrl-C for the remainder of the command's execution
         // Forwarding commands will just spawn the child process and exit

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

@@ -3,39 +3,52 @@
 
 using System.CommandLine;
 using Microsoft.DotNet.Cli.Commands.MSBuild;
+using Microsoft.DotNet.Cli.Commands.Run;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Cli.Commands.Restore;
 
-public class RestoreCommand : MSBuildForwardingApp
+public static class RestoreCommand
 {
-    public RestoreCommand(IEnumerable<string> msbuildArgs, string msbuildPath = null)
-        : base(msbuildArgs, msbuildPath)
-    {
-        NuGetSignatureVerificationEnabler.ConditionallyEnable(this);
-    }
-
-    public static RestoreCommand FromArgs(string[] args, string msbuildPath = null)
+    public static CommandBase FromArgs(string[] args, string msbuildPath = null)
     {
         var parser = Parser.Instance;
         var result = parser.ParseFrom("dotnet restore", args);
         return FromParseResult(result, msbuildPath);
     }
 
-    public static RestoreCommand FromParseResult(ParseResult result, string msbuildPath = null)
+    public static CommandBase FromParseResult(ParseResult result, string msbuildPath = null)
     {
         result.HandleDebugSwitch();
 
         result.ShowHelpOrErrorIfAppropriate();
 
-        List<string> msbuildArgs = ["-target:Restore"];
+        string[] fileArgument = result.GetValue(RestoreCommandParser.SlnOrProjectOrFileArgument) ?? [];
 
-        msbuildArgs.AddRange(result.OptionValuesToBeForwarded(RestoreCommandParser.GetCommand()));
+        string[] forwardedOptions = result.OptionValuesToBeForwarded(RestoreCommandParser.GetCommand()).ToArray();
 
-        msbuildArgs.AddRange(result.GetValue(RestoreCommandParser.SlnOrProjectArgument) ?? []);
+        if (fileArgument is [{ } arg] && VirtualProjectBuildingCommand.IsValidEntryPointPath(arg))
+        {
+            return new VirtualProjectBuildingCommand(
+                    entryPointFileFullPath: Path.GetFullPath(arg),
+                    msbuildArgs: forwardedOptions,
+                    verbosity: result.GetValue(CommonOptions.VerbosityOption),
+                    interactive: result.GetValue(CommonOptions.InteractiveMsBuildForwardOption))
+            {
+                NoCache = true,
+                NoBuild = true,
+            };
+        }
 
-        return new RestoreCommand(msbuildArgs, msbuildPath);
+        return CreateForwarding(["-target:Restore", .. forwardedOptions, .. fileArgument], msbuildPath);
+    }
+
+    public static MSBuildForwardingApp CreateForwarding(IEnumerable<string> msbuildArgs, string? msbuildPath = null)
+    {
+        var forwardingApp = new MSBuildForwardingApp(msbuildArgs, msbuildPath);
+        NuGetSignatureVerificationEnabler.ConditionallyEnable(forwardingApp);
+        return forwardingApp;
     }
 
     public static int Run(string[] args)

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

@@ -10,9 +10,9 @@ internal static class RestoreCommandParser
 {
     public static readonly string DocsLink = "https://aka.ms/dotnet-restore";
 
-    public static readonly Argument<IEnumerable<string>> SlnOrProjectArgument = new(CliStrings.SolutionOrProjectArgumentName)
+    public static readonly Argument<string[]> SlnOrProjectOrFileArgument = new(CliStrings.SolutionOrProjectOrFileArgumentName)
     {
-        Description = CliStrings.SolutionOrProjectArgumentDescription,
+        Description = CliStrings.SolutionOrProjectOrFileArgumentDescription,
         Arity = ArgumentArity.ZeroOrMore
     };
 
@@ -62,7 +62,7 @@ private static Command ConstructCommand()
     {
         var command = new DocumentedCommand("restore", DocsLink, CliCommandStrings.RestoreAppFullName);
 
-        command.Arguments.Add(SlnOrProjectArgument);
+        command.Arguments.Add(SlnOrProjectOrFileArgument);
         command.Options.Add(CommonOptions.DisableBuildServersOption);
 
         foreach (var option in FullRestoreOptions())

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

@@ -9,7 +9,7 @@ namespace Microsoft.DotNet.Cli.Commands.Restore;
 
 public class RestoringCommand : MSBuildForwardingApp
 {
-    public RestoreCommand SeparateRestoreCommand { get; }
+    public MSBuildForwardingApp SeparateRestoreCommand { get; }
 
     private readonly bool AdvertiseWorkloadUpdates;
 
@@ -49,7 +49,7 @@ private static IEnumerable<string> GetCommandArguments(
         return Prepend("-restore", arguments);
     }
 
-    private static RestoreCommand GetSeparateRestoreCommand(
+    private static MSBuildForwardingApp GetSeparateRestoreCommand(
         IEnumerable<string> arguments,
         bool noRestore,
         string msbuildPath)
@@ -63,7 +63,7 @@ private static RestoreCommand GetSeparateRestoreCommand(
         (var newArgumentsToAdd, var existingArgumentsToForward) = ProcessForwardedArgumentsForSeparateRestore(arguments);
         restoreArguments = [.. restoreArguments, .. newArgumentsToAdd, .. existingArgumentsToForward];
 
-        return new RestoreCommand(restoreArguments, msbuildPath);
+        return RestoreCommand.CreateForwarding(restoreArguments, msbuildPath);
     }
 
     private static IEnumerable<string> Prepend(string argument, IEnumerable<string> arguments)

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

@@ -114,10 +114,7 @@ public int Execute()
         {
             if (EntryPointFileFullPath is not null)
             {
-                projectFactory = new VirtualProjectBuildingCommand
-                {
-                    EntryPointFileFullPath = EntryPointFileFullPath,
-                }.PrepareProjectInstance().CreateProjectInstance;
+                projectFactory = CreateVirtualCommand().PrepareProjectInstance().CreateProjectInstance;
             }
 
             if (NoCache)
@@ -256,19 +253,9 @@ private void EnsureProjectIsBuilt(out Func<ProjectCollection, ProjectInstance>?
         int buildResult;
         if (EntryPointFileFullPath is not null)
         {
-            var command = new VirtualProjectBuildingCommand
-            {
-                EntryPointFileFullPath = EntryPointFileFullPath,
-            };
-
-            CommonRunHelpers.AddUserPassedProperties(command.GlobalProperties, RestoreArgs);
-
+            var command = CreateVirtualCommand();
             projectFactory = command.CreateProjectInstance;
-            buildResult = command.Execute(
-                binaryLoggerArgs: RestoreArgs,
-                consoleLogger: MakeTerminalLogger(Verbosity ?? GetDefaultVerbosity()),
-                noRestore: NoRestore,
-                noCache: NoCache);
+            buildResult = command.Execute();
         }
         else
         {
@@ -289,25 +276,40 @@ private void EnsureProjectIsBuilt(out Func<ProjectCollection, ProjectInstance>?
         }
     }
 
+    private VirtualProjectBuildingCommand CreateVirtualCommand()
+    {
+        Debug.Assert(EntryPointFileFullPath != null);
+
+        return new(
+            entryPointFileFullPath: EntryPointFileFullPath,
+            msbuildArgs: RestoreArgs,
+            verbosity: Verbosity,
+            interactive: Interactive)
+        {
+            NoRestore = NoRestore,
+            NoCache = NoCache,
+        };
+    }
+
     private string[] GetRestoreArguments(IEnumerable<string> cliRestoreArgs)
     {
         List<string> args = ["-nologo"];
 
         if (Verbosity is null)
         {
-            args.Add($"-verbosity:{GetDefaultVerbosity()}");
+            args.Add($"-verbosity:{GetDefaultVerbosity(Interactive)}");
         }
 
         args.AddRange(cliRestoreArgs);
 
         return [.. args];
     }
 
-    private VerbosityOptions GetDefaultVerbosity()
+    internal static VerbosityOptions GetDefaultVerbosity(bool interactive)
     {
         // --interactive need to output guide for auth. It cannot be
         // completely "quiet"
-        return Interactive ? VerbosityOptions.minimal : VerbosityOptions.quiet;
+        return interactive ? VerbosityOptions.minimal : VerbosityOptions.quiet;
     }
 
     private ICommand GetTargetCommand(Func<ProjectCollection, ProjectInstance>? projectFactory)
@@ -394,8 +396,7 @@ static void InvokeRunArgumentsTarget(ProjectInstance project, string[] restoreAr
         }
     }
 
-
-    static ILogger MakeTerminalLogger(VerbosityOptions? verbosity)
+    internal static ILogger MakeTerminalLogger(VerbosityOptions? verbosity)
     {
         var msbuildVerbosity = ToLoggerVerbosity(verbosity);