Fix and test more dotnet file precedence cases (#49510)

jjonescz · web-flow · commit acbb54724ca7 · 2025-06-20T14:20:15.000-05:00
diff --git a/src/Cli/dotnet/CommandFactory/CommandFactoryUsingResolver.cs b/src/Cli/dotnet/CommandFactory/CommandFactoryUsingResolver.cs
@@ -74,6 +74,12 @@ public static Command Create(
             applicationName: applicationName,
             currentWorkingDirectory: currentWorkingDirectory);
 
+        return CreateOrThrow(commandName, commandSpec);
+    }
+
+#nullable enable
+    public static Command CreateOrThrow(string commandName, CommandSpec? commandSpec)
+    {
         if (commandSpec == null)
         {
             if (_knownCommandsAvailableAsDotNetTool.Contains(commandName, StringComparer.OrdinalIgnoreCase))
@@ -90,6 +96,7 @@ public static Command Create(
 
         return command;
     }
+#nullable disable
 
     public static Command Create(CommandSpec commandSpec)
     {
diff --git a/src/Cli/dotnet/Program.cs b/src/Cli/dotnet/Program.cs
@@ -7,6 +7,7 @@
 using System.CommandLine.Parsing;
 using System.Diagnostics;
 using Microsoft.DotNet.Cli.CommandFactory;
+using Microsoft.DotNet.Cli.CommandFactory.CommandResolution;
 using Microsoft.DotNet.Cli.Commands.Run;
 using Microsoft.DotNet.Cli.Commands.Workload;
 using Microsoft.DotNet.Cli.Extensions;
@@ -129,22 +130,6 @@ internal static int ProcessArgs(string[] args, TimeSpan startupTime)
         using (new PerformanceMeasurement(performanceData, "Parse Time"))
         {
             parseResult = Parser.Instance.Parse(args);
-            // If we didn't match any built-in commands, and a C# file path is the first argument,
-            // parse as `dotnet run file.cs ..rest_of_args` instead.
-            if (parseResult.CommandResult.Command is RootCommand
-                && parseResult.GetValue(Parser.DotnetSubCommand) is { } unmatchedCommandOrFile
-                && VirtualProjectBuildingCommand.IsValidEntryPointPath(unmatchedCommandOrFile))
-            {
-                List<string> otherTokens = new(parseResult.Tokens.Count - 1);
-                foreach (var token in parseResult.Tokens)
-                {
-                    if (token.Type != TokenType.Argument || token.Value != unmatchedCommandOrFile)
-                    {
-                        otherTokens.Add(token.Value);
-                    }
-                }
-                parseResult = Parser.Instance.Parse(["run", unmatchedCommandOrFile, .. otherTokens]);
-            }
 
             // Avoid create temp directory with root permission and later prevent access in non sudo
             // This method need to be run very early before temp folder get created
@@ -251,36 +236,35 @@ internal static int ProcessArgs(string[] args, TimeSpan startupTime)
         int exitCode;
         if (parseResult.CanBeInvoked())
         {
-            PerformanceLogEventSource.Log.BuiltInCommandStart();
-
-            try
-            {
-                exitCode = parseResult.Invoke();
-                exitCode = AdjustExitCode(parseResult, exitCode);
-            }
-            catch (Exception exception)
-            {
-                exitCode = Parser.ExceptionHandler(exception, parseResult);
-            }
-
-            PerformanceLogEventSource.Log.BuiltInCommandStop();
+            InvokeBuiltInCommand(parseResult, out exitCode);
         }
         else
         {
             PerformanceLogEventSource.Log.ExtensibleCommandResolverStart();
             try
             {
-                var resolvedCommand = CommandFactoryUsingResolver.Create(
-                        "dotnet-" + parseResult.GetValue(Parser.DotnetSubCommand),
-                        args.GetSubArguments(),
-                        FrameworkConstants.CommonFrameworks.NetStandardApp15);
-                PerformanceLogEventSource.Log.ExtensibleCommandResolverStop();
+                string commandName = "dotnet-" + parseResult.GetValue(Parser.DotnetSubCommand);
+                var resolvedCommandSpec = CommandResolver.TryResolveCommandSpec(
+                    new DefaultCommandResolverPolicy(),
+                    commandName,
+                    args.GetSubArguments(),
+                    FrameworkConstants.CommonFrameworks.NetStandardApp15);
+
+                if (resolvedCommandSpec is null && TryRunFileBasedApp(parseResult) is { } fileBasedAppExitCode)
+                {
+                    exitCode = fileBasedAppExitCode;
+                }
+                else
+                {
+                    var resolvedCommand = CommandFactoryUsingResolver.CreateOrThrow(commandName, resolvedCommandSpec);
+                    PerformanceLogEventSource.Log.ExtensibleCommandResolverStop();
 
-                PerformanceLogEventSource.Log.ExtensibleCommandStart();
-                var result = resolvedCommand.Execute();
-                PerformanceLogEventSource.Log.ExtensibleCommandStop();
+                    PerformanceLogEventSource.Log.ExtensibleCommandStart();
+                    var result = resolvedCommand.Execute();
+                    PerformanceLogEventSource.Log.ExtensibleCommandStop();
 
-                exitCode = result.ExitCode;
+                    exitCode = result.ExitCode;
+                }
             }
             catch (CommandUnknownException e)
             {
@@ -297,6 +281,50 @@ internal static int ProcessArgs(string[] args, TimeSpan startupTime)
         TelemetryClient.Dispose();
 
         return exitCode;
+
+        static int? TryRunFileBasedApp(ParseResult parseResult)
+        {
+            // If we didn't match any built-in commands, and a C# file path is the first argument,
+            // parse as `dotnet run file.cs ..rest_of_args` instead.
+            if (parseResult.CommandResult.Command is RootCommand
+                && parseResult.GetValue(Parser.DotnetSubCommand) is { } unmatchedCommandOrFile
+                && VirtualProjectBuildingCommand.IsValidEntryPointPath(unmatchedCommandOrFile))
+            {
+                List<string> otherTokens = new(parseResult.Tokens.Count - 1);
+                foreach (var token in parseResult.Tokens)
+                {
+                    if (token.Type != TokenType.Argument || token.Value != unmatchedCommandOrFile)
+                    {
+                        otherTokens.Add(token.Value);
+                    }
+                }
+                parseResult = Parser.Instance.Parse(["run", unmatchedCommandOrFile, .. otherTokens]);
+
+                InvokeBuiltInCommand(parseResult, out var exitCode);
+                return exitCode;
+            }
+
+            return null;
+        }
+
+        static void InvokeBuiltInCommand(ParseResult parseResult, out int exitCode)
+        {
+            Debug.Assert(parseResult.CanBeInvoked());
+
+            PerformanceLogEventSource.Log.BuiltInCommandStart();
+
+            try
+            {
+                exitCode = parseResult.Invoke();
+                exitCode = AdjustExitCode(parseResult, exitCode);
+            }
+            catch (Exception exception)
+            {
+                exitCode = Parser.ExceptionHandler(exception, parseResult);
+            }
+
+            PerformanceLogEventSource.Log.BuiltInCommandStop();
+        }
     }
 
     private static int AdjustExitCode(ParseResult parseResult, int exitCode)
diff --git a/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs b/test/dotnet.Tests/CommandTests/Run/RunFileTests.cs
@@ -220,6 +220,119 @@ public void FilePath_AsProjectArgument()
             .And.HaveStdErrContaining(CliCommandStrings.RunCommandException);
     }
 
+    /// <summary>
+    /// Even if there is a file-based app <c>./build</c>, <c>dotnet build</c> should not execute that.
+    /// </summary>
+    [Theory]
+    // error MSB1003: Specify a project or solution file. The current working directory does not contain a project or solution file.
+    [InlineData("build", "MSB1003")]
+    // dotnet watch: Could not find a MSBuild project file in '...'. Specify which project to use with the --project option.
+    [InlineData("watch", "--project")]
+    public void Precedence_BuiltInCommand(string cmd, string error)
+    {
+        var testInstance = _testAssetsManager.CreateTestDirectory();
+        File.WriteAllText(Path.Join(testInstance.Path, cmd), """
+            #!/usr/bin/env dotnet
+            Console.WriteLine("hello 1");
+            """);
+        File.WriteAllText(Path.Join(testInstance.Path, $"dotnet-{cmd}"), """
+            #!/usr/bin/env dotnet
+            Console.WriteLine("hello 2");
+            """);
+
+        // dotnet build -> built-in command
+        new DotnetCommand(Log, cmd)
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Fail()
+            .And.HaveStdOutContaining(error);
+
+        // dotnet ./build -> file-based app
+        new DotnetCommand(Log, $"./{cmd}")
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass()
+            .And.HaveStdOut("hello 1");
+
+        // dotnet run build -> file-based app
+        new DotnetCommand(Log, "run", cmd)
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass()
+            .And.HaveStdOut("hello 1");
+    }
+
+    /// <summary>
+    /// Even if there is a file-based app <c>./test.dll</c>, <c>dotnet test.dll</c> should not execute that.
+    /// </summary>
+    [Theory]
+    [InlineData("test.dll")]
+    [InlineData("./test.dll")]
+    public void Precedence_Dll(string arg)
+    {
+        var testInstance = _testAssetsManager.CreateTestDirectory();
+        File.WriteAllText(Path.Join(testInstance.Path, "test.dll"), """
+            #!/usr/bin/env dotnet
+            Console.WriteLine("hello world");
+            """);
+
+        // dotnet [./]test.dll -> exec the dll
+        new DotnetCommand(Log, arg)
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Fail()
+            // A fatal error was encountered. The library 'hostpolicy.dll' required to execute the application was not found in ...
+            .And.HaveStdErrContaining("hostpolicy");
+
+        // dotnet run [./]test.dll -> file-based app
+        new DotnetCommand(Log, "run", arg)
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass()
+            .And.HaveStdOut("hello world");
+    }
+
+    [Fact]
+    public void Precedence_NuGetTool()
+    {
+        var testInstance = _testAssetsManager.CreateTestDirectory();
+        File.WriteAllText(Path.Join(testInstance.Path, "complog"), """
+            #!/usr/bin/env dotnet
+            Console.WriteLine("hello world");
+            """);
+
+        new DotnetCommand(Log, "new", "tool-manifest")
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass();
+
+        new DotnetCommand(Log, "tool", "install", "complog@0.7.0")
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass();
+
+        // dotnet complog -> NuGet tool
+        new DotnetCommand(Log, "complog")
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass()
+            .And.HaveStdOutContaining("complog");
+
+        // dotnet ./complog -> file-based app
+        new DotnetCommand(Log, "./complog")
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass()
+            .And.HaveStdOut("hello world");
+
+        // dotnet run complog -> file-based app
+        new DotnetCommand(Log, "run", "complog")
+            .WithWorkingDirectory(testInstance.Path)
+            .Execute()
+            .Should().Pass()
+            .And.HaveStdOut("hello world");
+    }
+
     /// <summary>
     /// <c>dotnet run -</c> reads the C# code from stdin.
     /// </summary>

Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,12 @@ public static Command Create(`
`74`	`74`	`applicationName: applicationName,`
`75`	`75`	`currentWorkingDirectory: currentWorkingDirectory);`
`76`	`76`
	`77`	`+ return CreateOrThrow(commandName, commandSpec);`
	`78`	`+ }`
	`79`	`+`
	`80`	`+#nullable enable`
	`81`	`+ public static Command CreateOrThrow(string commandName, CommandSpec? commandSpec)`
	`82`	`+ {`
`77`	`83`	`if (commandSpec == null)`
`78`	`84`	`{`
`79`	`85`	`if (_knownCommandsAvailableAsDotNetTool.Contains(commandName, StringComparer.OrdinalIgnoreCase))`
`@@ -90,6 +96,7 @@ public static Command Create(`
`90`	`96`
`91`	`97`	`return command;`
`92`	`98`	`}`
	`99`	`+#nullable disable`
`93`	`100`
`94`	`101`	`public static Command Create(CommandSpec commandSpec)`
`95`	`102`	`{`