Do not set IsDebuggedProcess for legacy WASM debugger (#9804)

* Do not set IsDebuggedProcess for legacy WASM debugger

* Fix

* Disable trace listener

Author: tmat

src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/FeatureFlagNames.cs

@@ -27,4 +27,9 @@ internal static class FeatureFlagNames
     /// or out via the <c>AccelerateBuildsInVisualStudio</c> MSBuild property.
     /// </summary>
     public const string EnableBuildAccelerationByDefault = "ManagedProjectSystem.EnableBuildAccelerationByDefault";
+
+    /// <summary>
+    /// Enables new WASM debugger.
+    /// </summary>
+    public const string EnableCorDebugWebAssemblyDebugger = "Debugger.NewMonoDebugEngine";
 }

src/Microsoft.VisualStudio.ProjectSystem.Managed.VS/ProjectSystem/VS/ProjectSystemOptions.cs

@@ -89,6 +89,9 @@ public ValueTask<bool> IsBuildAccelerationEnabledByDefaultAsync(CancellationToke
         return IsFlagEnabledAsync(FeatureFlagNames.EnableBuildAccelerationByDefault, defaultValue: false, cancellationToken);
     }
 
+    public ValueTask<bool> IsCorDebugWebAssemblyDebuggerEnabledAsync(CancellationToken cancellationToken)
+        => IsFlagEnabledAsync(FeatureFlagNames.EnableCorDebugWebAssemblyDebugger, defaultValue: false, cancellationToken);
+
     private async ValueTask<bool> IsFlagEnabledAsync(string featureName, bool defaultValue, CancellationToken cancellationToken)
     {
         IVsFeatureFlags featureFlags = await _featureFlagsService.GetValueAsync(cancellationToken);

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/HotReload/ProjectHotReloadAgent.cs

@@ -11,6 +11,7 @@ namespace Microsoft.VisualStudio.ProjectSystem.HotReload;
 internal sealed class ProjectHotReloadAgent(
     Lazy<IHotReloadAgentManagerClient> hotReloadAgentManagerClient,
     Lazy<IHotReloadDiagnosticOutputService> hotReloadDiagnosticOutputService,
+    IProjectSystemOptions projectSystemOptions,
     [Import(AllowDefault = true)] IHotReloadDebugStateProvider? debugStateProvider) // allow default until VS Code is updated: https://devdiv.visualstudio.com/DevDiv/_workitems/edit/2571211
         : IProjectHotReloadAgent 
 {
@@ -33,6 +34,7 @@ public IProjectHotReloadSession CreateHotReloadSession(
             configuredProject: configuredProject,
             launchProfile: launchProfile,
             debugLaunchOptions: debugLaunchOptions,
+            projectSystemOptions,
             debugStateProvider ?? DefaultDebugStateProvider.Instance);
     }
 

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/HotReload/ProjectHotReloadSession.cs

@@ -23,6 +23,7 @@ internal sealed class ProjectHotReloadSession : IProjectHotReloadSessionInternal
     private readonly IProjectHotReloadBuildManager _buildManager;
     private readonly ILaunchProfile _launchProfile;
     private readonly DebugLaunchOptions _debugLaunchOptions;
+    private readonly IProjectSystemOptions _projectSystemOptions;
     private readonly IHotReloadDebugStateProvider _debugStateProvider;
     private readonly IProjectHotReloadLaunchProvider _launchProvider;
 
@@ -40,6 +41,7 @@ public ProjectHotReloadSession(
         ConfiguredProject configuredProject,
         ILaunchProfile launchProfile,
         DebugLaunchOptions debugLaunchOptions,
+        IProjectSystemOptions projectSystemOptions,
         IHotReloadDebugStateProvider debugStateProvider)
     {
         Name = name;
@@ -53,6 +55,7 @@ public ProjectHotReloadSession(
         _buildManager = buildManager;
         _launchProvider = launchProvider;
         _debugLaunchOptions = debugLaunchOptions;
+        _projectSystemOptions = projectSystemOptions;
         _debugStateProvider = debugStateProvider;
     }
 
@@ -156,8 +159,6 @@ public async Task StartSessionAsync(CancellationToken cancellationToken)
             throw new InvalidOperationException("Attempting to start a Hot Reload session that is already running.");
         }
 
-        HotReloadAgentFlags flags = _debugLaunchOptions.HasFlag(DebugLaunchOptions.NoDebug) ? HotReloadAgentFlags.None : HotReloadAgentFlags.IsDebuggedProcess;
-
         string targetFramework = await _configuredProject.GetProjectPropertyValueAsync(ConfigurationGeneral.TargetFrameworkProperty);
         bool hotReloadAutoRestart = await _configuredProject.GetProjectPropertyBoolAsync(ConfigurationGeneral.HotReloadAutoRestartProperty);
 
@@ -174,6 +175,14 @@ public async Task StartSessionAsync(CancellationToken cancellationToken)
         DebugTrace($"Start session for project '{_configuredProject.UnconfiguredProject.FullPath}' with TFM '{targetFramework}' and HotReloadRestart {runningProjectInfo.RestartAutomatically}");
 
         var processInfo = new ManagedEditAndContinueProcessInfo();
+
+        // If the debugger uses ICorDebug, the debugger is responsible for applying deltas to the process and the Hot Reload client receives empty deltas.
+        // Otherwise, the Hot Reload client is responsible for applying deltas and needs to receive them from the debugger.
+        // This is controlled by IsDebuggedProcess flag.
+        var flags = _debugLaunchOptions.HasFlag(DebugLaunchOptions.NoDebug) || await UsingLegacyWebAssemblyDebugEngineAsync(cancellationToken)
+            ? HotReloadAgentFlags.None
+            : HotReloadAgentFlags.IsDebuggedProcess;
+
         await _hotReloadAgentManagerClient.Value.AgentStartedAsync(this, flags, processInfo, runningProjectInfo, cancellationToken);
 
         WriteToOutputWindow(Resources.HotReloadStartSession, default);
@@ -186,6 +195,31 @@ public async Task StartSessionAsync(CancellationToken cancellationToken)
         _sessionActive = true;
     }
 
+    private async ValueTask<bool> UsingLegacyWebAssemblyDebugEngineAsync(CancellationToken cancellationToken)
+    {
+        if (_callback is not IProjectHotReloadSessionWebAssemblyCallback)
+        {
+            // not a WASM app:
+            return false;
+        }
+
+        if (await _projectSystemOptions.IsCorDebugWebAssemblyDebuggerEnabledAsync(cancellationToken) &&
+            await IsCorDebugWebAssemblyDebuggerSupportedByProjectAsync())
+        {
+            // using new debugger:
+            return false;
+        }
+
+        // using old debugger:
+        return true;
+
+        async ValueTask<bool> IsCorDebugWebAssemblyDebuggerSupportedByProjectAsync()
+        {
+            var targetFrameworkMoniker = await _configuredProject.GetProjectPropertyValueAsync(ConfigurationGeneral.TargetFrameworkMonikerProperty);
+            return new FrameworkName(targetFrameworkMoniker).Version.Major >= 9;
+        }
+    }
+
     public async Task StopSessionAsync(CancellationToken cancellationToken)
     {
         if (_sessionActive && _lazyDeltaApplier is not null)

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/IProjectSystemOptions.cs

@@ -65,4 +65,9 @@ internal interface IProjectSystemOptions
     ///     or out via the <c>AccelerateBuildsInVisualStudio</c> MSBuild property.
     /// </summary>
     ValueTask<bool> IsBuildAccelerationEnabledByDefaultAsync(CancellationToken cancellationToken);
+
+    /// <summary>
+    ///     True if the WASM debugger engine uses ICorDebug.
+    /// </summary>
+    ValueTask<bool> IsCorDebugWebAssemblyDebuggerEnabledAsync(CancellationToken cancellationToken);
 }

tests/Common/Test/App.config

@@ -4,6 +4,7 @@
     <add key="xunit.methodDisplay" value="method" />
     <add key="xunit.shadowCopy" value="false"/>
   </appSettings>
+  <!-- TODO: https://github.com/dotnet/project-system/issues/9805
   <system.diagnostics>
     <trace>
       <listeners>
@@ -12,4 +13,5 @@
       </listeners>
     </trace>
   </system.diagnostics>
+  -->
 </configuration>

tests/Microsoft.VisualStudio.ProjectSystem.Managed.UnitTests/Mocks/IProjectHotReloadSessionWebAssemblyCallbackFactory.cs

@@ -0,0 +1,26 @@
+// Licensed to the .NET Foundation under one or more agreements. The .NET Foundation licenses this file to you under the MIT license. See the LICENSE.md file in the project root for more information.
+
+using Microsoft.DotNet.HotReload;
+using Microsoft.Extensions.Logging;
+using Microsoft.VisualStudio.ProjectSystem.VS.HotReload;
+
+namespace Microsoft.VisualStudio.ProjectSystem.VS;
+
+internal static class IProjectHotReloadSessionWebAssemblyCallbackFactory
+{
+    public static IProjectHotReloadSessionWebAssemblyCallback Create()
+    {
+        var mock = new Mock<IProjectHotReloadSessionWebAssemblyCallback>();
+
+        var middlewarePath = Path.GetTempPath();
+        var logger = new Mock<ILogger>().Object;
+        var loggerFactory = new Mock<ILoggerFactory>().Object;
+
+        var server = new Mock<AbstractBrowserRefreshServer>(middlewarePath, logger, loggerFactory).Object;
+
+        mock.Setup(session => session.BrowserRefreshServerAccessor)
+            .Returns(new TestBrowserRefreshServerAccessor(server));
+
+        return mock.Object;
+    }
+}

tests/Microsoft.VisualStudio.ProjectSystem.Managed.UnitTests/Mocks/IProjectSystemOptionsFactory.cs

@@ -44,4 +44,13 @@ public static IProjectSystemOptions ImplementGetPreferSingleTargetBuildsForStart
 
         return mock.Object;
     }
+
+    public static IProjectSystemOptions ImplementIsCorDebugWebAssemblyDebuggerEnabledAsync(bool value)
+    {
+        var mock = new Mock<IProjectSystemOptions>();
+        mock.Setup(o => o.IsCorDebugWebAssemblyDebuggerEnabledAsync(It.IsAny<CancellationToken>()))
+            .ReturnsAsync(value);
+
+        return mock.Object;
+    }
 }

tests/Microsoft.VisualStudio.ProjectSystem.Managed.UnitTests/Mocks/TestBrowserRefreshServerAccessor.cs

@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements. The .NET Foundation licenses this file to you under the MIT license. See the LICENSE.md file in the project root for more information.
+
+using Microsoft.DotNet.HotReload;
+using Microsoft.VisualStudio.ProjectSystem.HotReload;
+
+namespace Microsoft.VisualStudio.ProjectSystem.VS;
+
+internal class TestBrowserRefreshServerAccessor(AbstractBrowserRefreshServer server) : AbstractBrowserRefreshServerAccessor
+{
+    internal override AbstractBrowserRefreshServer Server => server;
+}

tests/Microsoft.VisualStudio.ProjectSystem.Managed.UnitTests/ProjectSystem/HotReload/ProjectHotReloadSessionTests.cs

@@ -140,7 +140,10 @@ public async Task StartSessionAsync_VerifiesCorrectProcessInfoAndProjectInfo()
         const string expectedProjectPath = "C:\\Test\\Project.csproj";
         const string expectedTf = "net6.0";
 
-        var configuredProject = CreateConfiguredProjectWithCommonProperties(expectedTf, expectedProjectPath);
+        var configuredProject = CreateConfiguredProjectWithCommonProperties(
+            projectPath: expectedProjectPath,
+            targetFrameworkIdentifier: ".NETCoreApp",
+            targetFrameworkVersion: "6.0");
 
         var session = CreateInstance(
             hotReloadAgentManagerClient: new Lazy<IHotReloadAgentManagerClient>(() => hotReloadAgentManagerClient.Object),
@@ -193,7 +196,11 @@ public async Task StartSessionAsync_CallsAgentStartedWithCorrectParameters()
     {
         // Arrange
         var hotReloadAgentManagerClient = new Mock<IHotReloadAgentManagerClient>();
-        var configuredProject = CreateConfiguredProjectWithCommonProperties("net6.0", "C:\\Test\\Project.csproj");
+        var configuredProject = CreateConfiguredProjectWithCommonProperties(
+            "C:\\Test\\Project.csproj",
+            targetFrameworkIdentifier: ".NETCoreApp",
+            targetFrameworkVersion: "6.0");
+
         var cancellationToken = CancellationToken.None;
 
         RunningProjectInfo capturedProjectInfo = default;
@@ -245,18 +252,36 @@ public async Task StartSessionAsync_CallsAgentStartedWithCorrectParameters()
             Times.Once);
     }
 
-    [Fact]
-    public async Task StartSessionAsync_WithDebugger_SetsCorrectFlags()
+    [Theory]
+    // not debugging:
+    [InlineData(false, true, false, "6.0", HotReloadAgentFlags.None)]
+    [InlineData(false, true, true, "6.0", HotReloadAgentFlags.None)]
+    // debugging non-wasm project:
+    [InlineData(true, false, false, "6.0", HotReloadAgentFlags.IsDebuggedProcess)]
+    // debugging wasm project using legacy debugger:
+    [InlineData(true, true, false, "6.0", HotReloadAgentFlags.None)]
+    [InlineData(true, true, true, "6.0", HotReloadAgentFlags.None)]
+    [InlineData(true, true, true, "7.0", HotReloadAgentFlags.None)]
+    [InlineData(true, true, true, "8.0", HotReloadAgentFlags.None)]
+    // debugging wasm project using new debugger:
+    [InlineData(true, true, true, "9.0", HotReloadAgentFlags.IsDebuggedProcess)]
+    [InlineData(true, true, true, "10.0", HotReloadAgentFlags.IsDebuggedProcess)]
+    public async Task StartSessionAsync_WithDebugger_SetsCorrectFlags(bool isDebugging, bool isWasmProject, bool isWasmCorDebugEnabled, string targetFrameworkVersion, HotReloadAgentFlags expectedFlags)
     {
         // Arrange
         var hotReloadAgentManagerClient = new Mock<IHotReloadAgentManagerClient>();
-        var configuredProject = CreateConfiguredProjectWithCommonProperties();
+        var configuredProject = CreateConfiguredProjectWithCommonProperties(
+            targetFrameworkIdentifier: ".NETCoreApp",
+            targetFrameworkVersion: targetFrameworkVersion);
+
         var cancellationToken = CancellationToken.None;
 
         var session = CreateInstance(
             hotReloadAgentManagerClient: new Lazy<IHotReloadAgentManagerClient>(() => hotReloadAgentManagerClient.Object),
             configuredProject: configuredProject,
-            debugLaunchOptions: 0);
+            debugLaunchOptions: isDebugging ? 0 : DebugLaunchOptions.NoDebug,
+            projectSystemOptions: IProjectSystemOptionsFactory.ImplementIsCorDebugWebAssemblyDebuggerEnabledAsync(isWasmCorDebugEnabled),
+            callback: isWasmProject ? IProjectHotReloadSessionWebAssemblyCallbackFactory.Create() : null);
 
         // Act
         await session.StartSessionAsync(cancellationToken);
@@ -265,7 +290,7 @@ public async Task StartSessionAsync_WithDebugger_SetsCorrectFlags()
         hotReloadAgentManagerClient.Verify(
             client => client.AgentStartedAsync(
                 session,
-                HotReloadAgentFlags.IsDebuggedProcess,
+                expectedFlags,
                 It.IsAny<ManagedEditAndContinueProcessInfo>(),
                 It.IsAny<RunningProjectInfo>(),
                 cancellationToken),
@@ -561,7 +586,8 @@ private static ProjectHotReloadSession CreateInstance(
         DebugLaunchOptions debugLaunchOptions = DebugLaunchOptions.NoDebug,
         IProjectHotReloadBuildManager? buildManager = null,
         IProjectHotReloadLaunchProvider? launchProvider = null,
-        IHotReloadDebugStateProvider? debugStateProvider = null)
+        IHotReloadDebugStateProvider? debugStateProvider = null,
+        IProjectSystemOptions? projectSystemOptions = null)
     {
         hotReloadAgentManagerClient ??= new(Mock.Of<IHotReloadAgentManagerClient>);
         hotReloadOutputService ??= new(Mock.Of<IHotReloadDiagnosticOutputService>);
@@ -586,6 +612,7 @@ private static ProjectHotReloadSession CreateInstance(
         buildManager ??= new Mock<IProjectHotReloadBuildManager>().Object;
         launchProvider ??= new Mock<IProjectHotReloadLaunchProvider>().Object;
         configuredProject ??= CreateConfiguredProjectWithCommonProperties();
+        projectSystemOptions ??= new Mock<IProjectSystemOptions>().Object;
 
         return new ProjectHotReloadSession(
             name,
@@ -598,15 +625,36 @@ private static ProjectHotReloadSession CreateInstance(
             configuredProject,
             launchProfile,
             debugLaunchOptions,
+            projectSystemOptions,
             debugStateProvider);
     }
 
-    private static ConfiguredProject CreateConfiguredProjectWithCommonProperties(string targetFramework = "net6.0", string projectPath = "C:\\Test\\Project.csproj")
+    private static ConfiguredProject CreateConfiguredProjectWithCommonProperties(
+        string projectPath = "C:\\Test\\Project.csproj",
+        string targetFrameworkIdentifier = ".NETCoreApp",
+        string targetFrameworkVersion = "6.0",
+        string webAssemblyHotReloadCapabilities = "Baseline")
     {
+        var targetFramework = targetFrameworkIdentifier switch
+        {
+            ".NETCoreApp" => "net" + targetFrameworkVersion,
+            ".NETFramework" => "net" + targetFrameworkVersion.Replace(".", ""),
+            ".NETStandard" => "netstandard" + targetFrameworkVersion,
+            _ => throw new ArgumentException()
+        };
+
+        var targetFrameworkMoniker = $"{targetFrameworkIdentifier}, Version=v{targetFrameworkVersion}";
+
         var commonProperties = new Mock<IProjectProperties>();
         commonProperties.Setup(p => p.GetEvaluatedPropertyValueAsync(ConfigurationGeneral.TargetFrameworkProperty))
             .ReturnsAsync(targetFramework);
 
+        commonProperties.Setup(p => p.GetEvaluatedPropertyValueAsync(ConfigurationGeneral.TargetFrameworkMonikerProperty))
+            .ReturnsAsync(targetFrameworkMoniker);
+
+        commonProperties.Setup(p => p.GetEvaluatedPropertyValueAsync("WebAssemblyHotReloadCapabilities"))
+            .ReturnsAsync(webAssemblyHotReloadCapabilities);
+
         var projectPropertiesProvider = new Mock<IProjectPropertiesProvider>();
         projectPropertiesProvider.Setup(p => p.GetCommonProperties())
             .Returns(commonProperties.Object);