Merge branch 'main' into darc-main-78f666ec-96ed-4ba3-ab20-9ab127a356d0

nagilson · web-flow · commit 4f73a8548eb8 · 2025-07-14T11:47:08.000-07:00
diff --git a/src/Cli/dotnet/Commands/Run/RunCommand.cs b/src/Cli/dotnet/Commands/Run/RunCommand.cs
@@ -364,7 +364,7 @@ static void ValidatePreconditions(ProjectInstance project)
 
         static RunProperties ReadRunPropertiesFromProject(ProjectInstance project, string[] applicationArgs)
         {
-            var runProperties = RunProperties.FromProjectAndApplicationArguments(project, applicationArgs, fallbackToTargetPath: false);
+            var runProperties = RunProperties.FromProjectAndApplicationArguments(project, applicationArgs);
             if (string.IsNullOrEmpty(runProperties.RunCommand))
             {
                 ThrowUnableToRunError(project);
diff --git a/src/Cli/dotnet/Commands/Run/RunProperties.cs b/src/Cli/dotnet/Commands/Run/RunProperties.cs
@@ -8,18 +8,9 @@ namespace Microsoft.DotNet.Cli.Commands.Run;
 
 internal record RunProperties(string RunCommand, string? RunArguments, string? RunWorkingDirectory)
 {
-    internal static RunProperties FromProjectAndApplicationArguments(ProjectInstance project, string[] applicationArgs, bool fallbackToTargetPath)
+    internal static RunProperties FromProjectAndApplicationArguments(ProjectInstance project, string[] applicationArgs)
     {
         string runProgram = project.GetPropertyValue("RunCommand");
-        if (fallbackToTargetPath &&
-            (string.IsNullOrEmpty(runProgram) || !File.Exists(runProgram)))
-        {
-            // If we can't find the executable that runCommand is pointing to, we simply use TargetPath instead.
-            // In this case, we discard everything related to "Run" (i.e, RunWorkingDirectory and RunArguments) and use only TargetPath
-            runProgram = project.GetPropertyValue("TargetPath");
-            return new(runProgram, null, null);
-        }
-
         string runArguments = project.GetPropertyValue("RunArguments");
         string runWorkingDirectory = project.GetPropertyValue("RunWorkingDirectory");
 
diff --git a/src/Cli/dotnet/Commands/Test/IPC/Models/ModuleMessage.cs b/src/Cli/dotnet/Commands/Test/IPC/Models/ModuleMessage.cs
diff --git a/src/Cli/dotnet/Commands/Test/IPC/NamedPipeServer.cs b/src/Cli/dotnet/Commands/Test/IPC/NamedPipeServer.cs
@@ -53,11 +53,11 @@ public NamedPipeServer(
     }
 
     public NamedPipeServer(
-    PipeNameDescription pipeNameDescription,
-    Func<IRequest, Task<IResponse>> callback,
-    int maxNumberOfServerInstances,
-    CancellationToken cancellationToken,
-    bool skipUnknownMessages)
+        PipeNameDescription pipeNameDescription,
+        Func<IRequest, Task<IResponse>> callback,
+        int maxNumberOfServerInstances,
+        CancellationToken cancellationToken,
+        bool skipUnknownMessages)
     {
         _namedPipeServerStream = new((PipeName = pipeNameDescription).Name, PipeDirection.InOut, maxNumberOfServerInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
         _callback = callback;
diff --git a/src/Cli/dotnet/Commands/Test/IPC/Serializers/CommandLineOptionMessagesSerializer.cs b/src/Cli/dotnet/Commands/Test/IPC/Serializers/CommandLineOptionMessagesSerializer.cs
@@ -1,9 +1,6 @@
 ﻿// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#if NETCOREAPP
-#endif
-
 using System.Diagnostics;
 using Microsoft.DotNet.Cli.Commands.Test.IPC.Models;
 
diff --git a/src/Cli/dotnet/Commands/Test/IPC/Serializers/ModuleMessageSerializer.cs b/src/Cli/dotnet/Commands/Test/IPC/Serializers/ModuleMessageSerializer.cs
diff --git a/src/Cli/dotnet/Commands/Test/IPC/Serializers/RegisterSerializers.cs b/src/Cli/dotnet/Commands/Test/IPC/Serializers/RegisterSerializers.cs
@@ -28,7 +28,6 @@ public static void RegisterAllSerializers(this NamedPipeBase namedPipeBase)
     {
         namedPipeBase.RegisterSerializer(new VoidResponseSerializer(), typeof(VoidResponse));
         namedPipeBase.RegisterSerializer(new CommandLineOptionMessagesSerializer(), typeof(CommandLineOptionMessages));
-        namedPipeBase.RegisterSerializer(new ModuleMessageSerializer(), typeof(ModuleMessage));
         namedPipeBase.RegisterSerializer(new DiscoveredTestMessagesSerializer(), typeof(DiscoveredTestMessages));
         namedPipeBase.RegisterSerializer(new TestResultMessagesSerializer(), typeof(TestResultMessages));
         namedPipeBase.RegisterSerializer(new FileArtifactMessagesSerializer(), typeof(FileArtifactMessages));
diff --git a/src/Cli/dotnet/Commands/Test/Models.cs b/src/Cli/dotnet/Commands/Test/Models.cs
@@ -111,7 +111,8 @@ public bool MoveNext()
     }
 }
 
-internal sealed record TestModule(RunProperties RunProperties, string? ProjectFullPath, string? TargetFramework, bool IsTestingPlatformApplication, bool IsTestProject, ProjectLaunchSettingsModel? LaunchSettings);
+
+internal sealed record TestModule(RunProperties RunProperties, string? ProjectFullPath, string? TargetFramework, bool IsTestingPlatformApplication, bool IsTestProject, ProjectLaunchSettingsModel? LaunchSettings, string TargetPath);
 
 internal sealed record Handshake(Dictionary<byte, string>? Properties);
 
@@ -128,5 +129,3 @@ internal sealed record FlatException(string? ErrorMessage, string? ErrorType, st
 internal sealed record FileArtifact(string? FullPath, string? DisplayName, string? Description, string? TestUid, string? TestDisplayName, string? SessionUid);
 
 internal sealed record TestSession(byte? SessionType, string? SessionUid, string? ExecutionId);
-
-internal record MSBuildBuildAndRestoreSettings(string[] Commands, string Configuration, string RuntimeIdentifier, bool AllowBinLog, string BinLogFileName);
diff --git a/src/Cli/dotnet/Commands/Test/SolutionAndProjectUtility.cs b/src/Cli/dotnet/Commands/Test/SolutionAndProjectUtility.cs
@@ -230,12 +230,27 @@ public static IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModule
 
         string targetFramework = project.GetPropertyValue(ProjectProperties.TargetFramework);
         RunProperties runProperties = GetRunProperties(project, loggers);
+
+        // dotnet run throws the same if RunCommand is null or empty.
+        // In dotnet test, we are additionally checking that RunCommand is not dll.
+        // In any "default" scenario, RunCommand is never dll.
+        // If we found it to be dll, that is user explicitly setting RunCommand incorrectly.
+        if (string.IsNullOrEmpty(runProperties.RunCommand) || runProperties.RunCommand.HasExtension(CliConstants.DLLExtension))
+        {
+            throw new GracefulException(
+                string.Format(
+                    CliCommandStrings.RunCommandExceptionUnableToRun,
+                    "dotnet test",
+                    "OutputType",
+                    project.GetPropertyValue("OutputType")));
+        }
+
         string projectFullPath = project.GetPropertyValue(ProjectProperties.ProjectFullPath);
 
         // TODO: Support --launch-profile and pass it here.
         var launchSettings = TryGetLaunchProfileSettings(Path.GetDirectoryName(projectFullPath)!, project.GetPropertyValue(ProjectProperties.AppDesignerFolder), noLaunchProfile, profileName: null);
 
-        return new TestModule(runProperties, PathUtility.FixFilePath(projectFullPath), targetFramework, isTestingPlatformApplication, isTestProject, launchSettings);
+        return new TestModule(runProperties, PathUtility.FixFilePath(projectFullPath), targetFramework, isTestingPlatformApplication, isTestProject, launchSettings, project.GetPropertyValue(ProjectProperties.TargetPath));
 
         static RunProperties GetRunProperties(ProjectInstance project, ICollection<ILogger>? loggers)
         {
@@ -247,12 +262,11 @@ static RunProperties GetRunProperties(ProjectInstance project, ICollection<ILogg
             {
                 if (!project.Build(s_computeRunArgumentsTarget, loggers: null))
                 {
-                    Logger.LogTrace(() => $"The target {s_computeRunArgumentsTarget} failed to build. Falling back to TargetPath.");
-                    return new RunProperties(project.GetPropertyValue(ProjectProperties.TargetPath), null, null);
+                    throw new GracefulException(CliCommandStrings.RunCommandEvaluationExceptionBuildFailed, s_computeRunArgumentsTarget);
                 }
             }
 
-            return RunProperties.FromProjectAndApplicationArguments(project, [], fallbackToTargetPath: true);
+            return RunProperties.FromProjectAndApplicationArguments(project, []);
         }
     }
 
diff --git a/src/Cli/dotnet/Commands/Test/TestApplication.cs b/src/Cli/dotnet/Commands/Test/TestApplication.cs
@@ -8,7 +8,6 @@
 using Microsoft.DotNet.Cli.Commands.Test.IPC;
 using Microsoft.DotNet.Cli.Commands.Test.IPC.Models;
 using Microsoft.DotNet.Cli.Commands.Test.IPC.Serializers;
-using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
 
@@ -54,12 +53,13 @@ public async Task<int> RunAsync(TestOptions testOptions)
 
     private ProcessStartInfo CreateProcessStartInfo(TestOptions testOptions)
     {
-        bool isDll = Module.RunProperties.RunCommand.HasExtension(CliConstants.DLLExtension);
-
         var processStartInfo = new ProcessStartInfo
         {
-            FileName = GetFileName(testOptions, isDll),
-            Arguments = GetArguments(testOptions, isDll),
+            // We should get correct RunProperties right away.
+            // For the case of dotnet test --test-modules path/to/dll, the TestModulesFilterHandler is responsible
+            // for providing the dotnet muxer as RunCommand, and `exec "path/to/dll"` as RunArguments.
+            FileName = Module.RunProperties.RunCommand,
+            Arguments = GetArguments(testOptions),
             RedirectStandardOutput = true,
             RedirectStandardError = true
         };
@@ -87,23 +87,27 @@ private ProcessStartInfo CreateProcessStartInfo(TestOptions testOptions)
         return processStartInfo;
     }
 
-    private string GetFileName(TestOptions testOptions, bool isDll)
-        => isDll ? Environment.ProcessPath : Module.RunProperties.RunCommand;
-
-    private string GetArguments(TestOptions testOptions, bool isDll)
+    private string GetArguments(TestOptions testOptions)
     {
-        if (testOptions.HasFilterMode || !isDll || !IsArchitectureSpecified(testOptions))
+        // Keep RunArguments first.
+        // In the case of UseAppHost=false, RunArguments is set to `exec $(TargetPath)`:
+        // https://github.com/dotnet/sdk/blob/333388c31d811701e3b6be74b5434359151424dc/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.targets#L1411
+        // So, we keep that first always.
+        StringBuilder builder = new(Module.RunProperties.RunArguments);
+
+        if (testOptions.IsHelp)
         {
-            return BuildArgs(testOptions, isDll);
+            builder.Append($" {TestingPlatformOptions.HelpOption.Name} ");
         }
 
-        // If we reach here, that means we have a test project that doesn't produce an executable.
-        throw new InvalidOperationException($"A Microsoft.Testing.Platform test project should produce an executable. The file '{Module.RunProperties.RunCommand}' is dll.");
-    }
+        var args = _buildOptions.UnmatchedTokens;
+        builder.Append(args.Count != 0
+            ? args.Aggregate((a, b) => $"{a} {b}")
+            : string.Empty);
 
-    private static bool IsArchitectureSpecified(TestOptions testOptions)
-    {
-        return !string.IsNullOrEmpty(testOptions.Architecture);
+        builder.Append($" {CliConstants.ServerOptionKey} {CliConstants.ServerOptionValue} {CliConstants.DotNetTestPipeOptionKey} {_pipeNameDescription.Name}");
+
+        return builder.ToString();
     }
 
     private void WaitOnTestApplicationPipeConnectionLoop()
@@ -277,35 +281,6 @@ private bool ModulePathExists()
         return true;
     }
 
-    private string BuildArgs(TestOptions testOptions, bool isDll)
-    {
-        StringBuilder builder = new();
-
-        if (isDll)
-        {
-            builder.Append($"exec {Module.RunProperties.RunCommand} ");
-        }
-
-        AppendCommonArgs(builder, testOptions);
-
-        return builder.ToString();
-    }
-
-    private void AppendCommonArgs(StringBuilder builder, TestOptions testOptions)
-    {
-        if (testOptions.IsHelp)
-        {
-            builder.Append($" {TestingPlatformOptions.HelpOption.Name} ");
-        }
-
-        var args = _buildOptions.UnmatchedTokens;
-        builder.Append(args.Count != 0
-            ? args.Aggregate((a, b) => $"{a} {b}")
-            : string.Empty);
-
-        builder.Append($" {CliConstants.ServerOptionKey} {CliConstants.ServerOptionValue} {CliConstants.DotNetTestPipeOptionKey} {_pipeNameDescription.Name} {Module.RunProperties.RunArguments}");
-    }
-
     public void OnHandshakeMessage(HandshakeMessage handshakeMessage)
     {
         HandshakeReceived?.Invoke(this, new HandshakeArgs { Handshake = new Handshake(handshakeMessage.Properties) });
diff --git a/src/Cli/dotnet/Commands/Test/TestApplicationEventHandlers.cs b/src/Cli/dotnet/Commands/Test/TestApplicationEventHandlers.cs
@@ -26,7 +26,7 @@ public void OnHandshakeReceived(object sender, HandshakeArgs args)
             var executionId = args.Handshake.Properties[HandshakeMessagePropertyNames.ExecutionId];
             var arch = args.Handshake.Properties[HandshakeMessagePropertyNames.Architecture]?.ToLower();
             var tfm = TargetFrameworkParser.GetShortTargetFramework(args.Handshake.Properties[HandshakeMessagePropertyNames.Framework]);
-            (string ModulePath, string TargetFramework, string Architecture, string ExecutionId) appInfo = new(testApplication.Module.RunProperties.RunCommand, tfm, arch, executionId);
+            (string ModulePath, string TargetFramework, string Architecture, string ExecutionId) appInfo = new(testApplication.Module.TargetPath, tfm, arch, executionId);
             _executions[testApplication] = appInfo;
             _output.AssemblyRunStarted(appInfo.ModulePath, appInfo.TargetFramework, appInfo.Architecture, appInfo.ExecutionId);
         }
@@ -147,7 +147,7 @@ public void OnTestProcessExited(object sender, TestProcessExitEventArgs args)
         }
         else
         {
-            _output.AssemblyRunCompleted(testApplication.Module.RunProperties.RunCommand ?? testApplication.Module.ProjectFullPath, testApplication.Module.TargetFramework, architecture: null, null, args.ExitCode, string.Join(Environment.NewLine, args.OutputData), string.Join(Environment.NewLine, args.ErrorData));
+            _output.AssemblyRunCompleted(testApplication.Module.TargetPath ?? testApplication.Module.ProjectFullPath, testApplication.Module.TargetFramework, architecture: null, null, args.ExitCode, string.Join(Environment.NewLine, args.OutputData), string.Join(Environment.NewLine, args.ErrorData));
         }
 
         LogTestProcessExit(args);
diff --git a/src/Cli/dotnet/Commands/Test/TestModulesFilterHandler.cs b/src/Cli/dotnet/Commands/Test/TestModulesFilterHandler.cs
@@ -7,6 +7,7 @@
 using Microsoft.DotNet.Cli.Commands.Run;
 using Microsoft.DotNet.Cli.Commands.Test.Terminal;
 using Microsoft.DotNet.Cli.Extensions;
+using Microsoft.DotNet.Cli.Utils;
 using Microsoft.Extensions.FileSystemGlobbing;
 
 namespace Microsoft.DotNet.Cli.Commands.Test;
@@ -47,9 +48,17 @@ public bool RunWithTestModulesFilter(ParseResult parseResult)
             return false;
         }
 
+        var muxerPath = new Muxer().MuxerPath;
         foreach (string testModule in testModulePaths)
         {
-            var testApp = new ParallelizableTestModuleGroupWithSequentialInnerModules(new TestModule(new RunProperties(testModule, null, null), null, null, true, true, null));
+            // We want to produce the right RunCommand and RunArguments for TestApplication implementation to consume directly.
+            // We don't want TestApplication class to be concerned about whether it's running dll via test module or not.
+            // If we are given dll, we use dotnet exec. Otherwise, we run the executable directly.
+            RunProperties runProperties = testModule.HasExtension(CliConstants.DLLExtension)
+                ? new RunProperties(muxerPath, $@"exec ""{testModule}""", null)
+                : new RunProperties(testModule, null, null);
+
+            var testApp = new ParallelizableTestModuleGroupWithSequentialInnerModules(new TestModule(runProperties, null, null, true, true, null, testModule));
             // Write the test application to the channel
             _actionQueue.Enqueue(testApp);
         }
diff --git a/src/Containers/Microsoft.NET.Build.Containers/Tasks/CreateNewImageToolTask.cs b/src/Containers/Microsoft.NET.Build.Containers/Tasks/CreateNewImageToolTask.cs
@@ -22,17 +22,37 @@ private string DotNetPath
     {
         get
         {
+            // DOTNET_HOST_PATH, if set, is the full path to the dotnet host executable.
+            // However, not all environments/scenarios set it correctly - some set it to just the directory.
+
+            // this is the expected correct case - DOTNET_HOST_PATH is set to the full path of the dotnet host executable
             string path = Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") ?? "";
+            if (Path.IsPathRooted(path) && File.Exists(path))
+            {
+                return path;
+            }
+            // some environments set it to just the directory, so we need to check that too
+            if (Path.IsPathRooted(path) && Directory.Exists(path))
+            {
+                path = Path.Combine(path, ToolExe);
+                if (File.Exists(path))
+                {
+                    return path;
+                }
+            }
+            // last-chance fallback - use the ToolPath and ToolExe properties to try to synthesize the path
             if (string.IsNullOrEmpty(path))
             {
+                // no
                 path = string.IsNullOrEmpty(ToolPath) ? "" : ToolPath;
+                path = Path.Combine(path, ToolExe);
             }
 
             return path;
         }
     }
 
-    protected override string GenerateFullPathToTool() => Path.Combine(DotNetPath, ToolExe);
+    protected override string GenerateFullPathToTool() => DotNetPath;
 
     /// <summary>
     /// Workaround to avoid storing user/pass into the EnvironmentVariables property, which gets logged by the task.

Original file line number	Diff line number	Diff line change
`@@ -364,7 +364,7 @@ static void ValidatePreconditions(ProjectInstance project)`
`364`	`364`
`365`	`365`	`static RunProperties ReadRunPropertiesFromProject(ProjectInstance project, string[] applicationArgs)`
`366`	`366`	`{`
`367`		`- var runProperties = RunProperties.FromProjectAndApplicationArguments(project, applicationArgs, fallbackToTargetPath: false);`
	`367`	`+ var runProperties = RunProperties.FromProjectAndApplicationArguments(project, applicationArgs);`
`368`	`368`	`if (string.IsNullOrEmpty(runProperties.RunCommand))`
`369`	`369`	`{`
`370`	`370`	`ThrowUnableToRunError(project);`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,6 @@ public static void RegisterAllSerializers(this NamedPipeBase namedPipeBase)`
`28`	`28`	`{`
`29`	`29`	`namedPipeBase.RegisterSerializer(new VoidResponseSerializer(), typeof(VoidResponse));`
`30`	`30`	`namedPipeBase.RegisterSerializer(new CommandLineOptionMessagesSerializer(), typeof(CommandLineOptionMessages));`
`31`		`- namedPipeBase.RegisterSerializer(new ModuleMessageSerializer(), typeof(ModuleMessage));`
`32`	`31`	`namedPipeBase.RegisterSerializer(new DiscoveredTestMessagesSerializer(), typeof(DiscoveredTestMessages));`
`33`	`32`	`namedPipeBase.RegisterSerializer(new TestResultMessagesSerializer(), typeof(TestResultMessages));`
`34`	`33`	`namedPipeBase.RegisterSerializer(new FileArtifactMessagesSerializer(), typeof(FileArtifactMessages));`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,8 @@ public bool MoveNext()`
`111`	`111`	`}`
`112`	`112`	`}`
`113`	`113`
`114`		`-internal sealed record TestModule(RunProperties RunProperties, string? ProjectFullPath, string? TargetFramework, bool IsTestingPlatformApplication, bool IsTestProject, ProjectLaunchSettingsModel? LaunchSettings);`
	`114`	`+`
	`115`	`+internal sealed record TestModule(RunProperties RunProperties, string? ProjectFullPath, string? TargetFramework, bool IsTestingPlatformApplication, bool IsTestProject, ProjectLaunchSettingsModel? LaunchSettings, string TargetPath);`
`115`	`116`
`116`	`117`	`internal sealed record Handshake(Dictionary<byte, string>? Properties);`
`117`	`118`
`@@ -128,5 +129,3 @@ internal sealed record FlatException(string? ErrorMessage, string? ErrorType, st`
`128`	`129`	`internal sealed record FileArtifact(string? FullPath, string? DisplayName, string? Description, string? TestUid, string? TestDisplayName, string? SessionUid);`
`129`	`130`
`130`	`131`	`internal sealed record TestSession(byte? SessionType, string? SessionUid, string? ExecutionId);`
`131`		`-`
`132`		`-internal record MSBuildBuildAndRestoreSettings(string[] Commands, string Configuration, string RuntimeIdentifier, bool AllowBinLog, string BinLogFileName);`
Original file line number	Diff line number	Diff line change
`@@ -230,12 +230,27 @@ public static IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModule`
`230`	`230`
`231`	`231`	`string targetFramework = project.GetPropertyValue(ProjectProperties.TargetFramework);`
`232`	`232`	`RunProperties runProperties = GetRunProperties(project, loggers);`
	`233`	`+`
	`234`	`+ // dotnet run throws the same if RunCommand is null or empty.`
	`235`	`+ // In dotnet test, we are additionally checking that RunCommand is not dll.`
	`236`	`+ // In any "default" scenario, RunCommand is never dll.`
	`237`	`+ // If we found it to be dll, that is user explicitly setting RunCommand incorrectly.`
	`238`	`+ if (string.IsNullOrEmpty(runProperties.RunCommand) \|\| runProperties.RunCommand.HasExtension(CliConstants.DLLExtension))`
	`239`	`+ {`
	`240`	`+ throw new GracefulException(`
	`241`	`+ string.Format(`
	`242`	`+ CliCommandStrings.RunCommandExceptionUnableToRun,`
	`243`	`+ "dotnet test",`
	`244`	`+ "OutputType",`
	`245`	`+ project.GetPropertyValue("OutputType")));`
	`246`	`+ }`
	`247`	`+`
`233`	`248`	`string projectFullPath = project.GetPropertyValue(ProjectProperties.ProjectFullPath);`
`234`	`249`
`235`	`250`	`// TODO: Support --launch-profile and pass it here.`
`236`	`251`	`var launchSettings = TryGetLaunchProfileSettings(Path.GetDirectoryName(projectFullPath)!, project.GetPropertyValue(ProjectProperties.AppDesignerFolder), noLaunchProfile, profileName: null);`
`237`	`252`
`238`		`- return new TestModule(runProperties, PathUtility.FixFilePath(projectFullPath), targetFramework, isTestingPlatformApplication, isTestProject, launchSettings);`
	`253`	`+ return new TestModule(runProperties, PathUtility.FixFilePath(projectFullPath), targetFramework, isTestingPlatformApplication, isTestProject, launchSettings, project.GetPropertyValue(ProjectProperties.TargetPath));`
`239`	`254`
`240`	`255`	`static RunProperties GetRunProperties(ProjectInstance project, ICollection<ILogger>? loggers)`
`241`	`256`	`{`
`@@ -247,12 +262,11 @@ static RunProperties GetRunProperties(ProjectInstance project, ICollection<ILogg`
`247`	`262`	`{`
`248`	`263`	`if (!project.Build(s_computeRunArgumentsTarget, loggers: null))`
`249`	`264`	`{`
`250`		`- Logger.LogTrace(() => $"The target {s_computeRunArgumentsTarget} failed to build. Falling back to TargetPath.");`
`251`		`- return new RunProperties(project.GetPropertyValue(ProjectProperties.TargetPath), null, null);`
	`265`	`+ throw new GracefulException(CliCommandStrings.RunCommandEvaluationExceptionBuildFailed, s_computeRunArgumentsTarget);`
`252`	`266`	`}`
`253`	`267`	`}`
`254`	`268`
`255`		`- return RunProperties.FromProjectAndApplicationArguments(project, [], fallbackToTargetPath: true);`
	`269`	`+ return RunProperties.FromProjectAndApplicationArguments(project, []);`
`256`	`270`	`}`
`257`	`271`	`}`
`258`	`272`