[wasm][debugger] Stepping into hidden function. (#61312)

ilonatommy · web-flow · commit 49c5643dc92b · 2021-11-26T08:26:36.000+01:00
* Add test for ignoring stepping into hidden function.

* Corrected test to match Console App behaviour.

* Corrected test logic.

* Applied Thays's fix so that step into would work as step over in a hidden method.

* Revert debugging changes.

* Test for Debugger.Break().

* Col fix + checing the location after command execution.

* Correct value of VisibleMethod entry line.

* Move the breakpoint to the line 846.

* Create tests that match behaviour of Console App.

* Draft of Debugger.Break behaviour correction.

* Draft: 2 pauses on hidden method with Debugger.Break inside.

* Changed required behaviour to 2 pauses on the hidden method call.
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs b/src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs
@@ -287,7 +287,7 @@ public ExecutionContext(MonoSDBHelper sdbAgent, int id, object auxData)
 
         public TaskCompletionSource<DebugStore> ready;
         public bool IsRuntimeReady => ready != null && ready.Task.IsCompleted;
-
+        public bool IsSkippingHiddenMethod { get; set; }
         public int ThreadId { get; set; }
         public int Id { get; set; }
         public object AuxData { get; set; }
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs b/src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs
@@ -735,7 +735,7 @@ private async Task<bool> SendBreakpointsOfMethodUpdated(SessionId sessionId, Exe
             return true;
         }
 
-        private async Task<bool> SendCallStack(SessionId sessionId, ExecutionContext context, string reason, int thread_id, Breakpoint bp, JObject data, IEnumerable<JObject> orig_callframes, CancellationToken token)
+        private async Task<bool> SendCallStack(SessionId sessionId, ExecutionContext context, string reason, int thread_id, Breakpoint bp, JObject data, IEnumerable<JObject> orig_callframes, EventKind event_kind, CancellationToken token)
         {
             var callFrames = new List<object>();
             var frames = new List<Frame>();
@@ -754,6 +754,26 @@ private async Task<bool> SendCallStack(SessionId sessionId, ExecutionContext con
                 DebugStore store = await LoadStore(sessionId, token);
                 var method = await context.SdbAgent.GetMethodInfo(methodId, token);
 
+                if (context.IsSkippingHiddenMethod == true)
+                {
+                    context.IsSkippingHiddenMethod = false;
+                    if (event_kind != EventKind.UserBreak)
+                    {
+                        await context.SdbAgent.Step(context.ThreadId, StepKind.Over, token);
+                        await SendCommand(sessionId, "Debugger.resume", new JObject(), token);
+                        return true;
+                    }
+                }
+
+                if (j == 0 && method?.Info.IsHiddenFromDebugger == true)
+                {
+                    if (event_kind == EventKind.Step)
+                        context.IsSkippingHiddenMethod = true;
+                    await context.SdbAgent.Step(context.ThreadId, StepKind.Out, token);
+                    await SendCommand(sessionId, "Debugger.resume", new JObject(), token);
+                    return true;
+                }
+
                 SourceLocation location = method?.Info.GetLocationByIl(il_pos);
 
                 // When hitting a breakpoint on the "IncrementCount" method in the standard
@@ -881,7 +901,7 @@ private async Task<bool> OnReceiveDebuggerAgentEvent(SessionId sessionId, JObjec
                             objectId = $"dotnet:object:{object_id}"
                         });
 
-                        var ret = await SendCallStack(sessionId, context, reason, thread_id, null, data, args?["callFrames"]?.Values<JObject>(), token);
+                        var ret = await SendCallStack(sessionId, context, reason, thread_id, null, data, args?["callFrames"]?.Values<JObject>(), event_kind, token);
                         return ret;
                     }
                     case EventKind.UserBreak:
@@ -893,7 +913,7 @@ private async Task<bool> OnReceiveDebuggerAgentEvent(SessionId sessionId, JObjec
                         int methodId = 0;
                         if (event_kind != EventKind.UserBreak)
                             methodId = retDebuggerCmdReader.ReadInt32();
-                        var ret = await SendCallStack(sessionId, context, reason, thread_id, bp, null, args?["callFrames"]?.Values<JObject>(), token);
+                        var ret = await SendCallStack(sessionId, context, reason, thread_id, bp, null, args?["callFrames"]?.Values<JObject>(), event_kind, token);
                         return ret;
                     }
                 }
diff --git a/src/mono/wasm/debugger/BrowserDebugProxy/MonoSDBHelper.cs b/src/mono/wasm/debugger/BrowserDebugProxy/MonoSDBHelper.cs
@@ -1147,7 +1147,7 @@ public async Task<bool> Step(int thread_id, StepKind kind, CancellationToken tok
             commandParamsWriter.Write(thread_id);
             commandParamsWriter.Write((int)StepSize.Line);
             commandParamsWriter.Write((int)kind);
-            commandParamsWriter.Write((int)(StepFilter.StaticCtor | StepFilter.DebuggerHidden)); //filter
+            commandParamsWriter.Write((int)(StepFilter.StaticCtor)); //filter
             using var retDebuggerCmdReader = await SendDebuggerAgentCommand(CmdEventRequest.Set, commandParamsWriter, token);
             if (retDebuggerCmdReader.HasError)
                 return false;
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/BreakpointTests.cs
@@ -651,12 +651,38 @@ public async Task DebuggerAttributeNoStopInDebuggerHidden()
             var bp_visible = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "VisibleMethod", 1);
             Assert.Empty(bp_hidden.Value["locations"]);
             await EvaluateAndCheck(
-                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:VisibleMethod'); }, 1);",
+                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:Run'); }, 1);",
                 "dotnet://debugger-test.dll/debugger-test.cs",
                 bp_visible.Value["locations"][0]["lineNumber"].Value<int>(),
                 bp_visible.Value["locations"][0]["columnNumber"].Value<int>(),
                 "VisibleMethod"
             );
         }
+
+        [Fact]
+        public async Task DebuggerAttributeStopOnDebuggerHiddenCallWithDebuggerBreakCall()
+        {
+            var bp_init = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "RunDebuggerBreak", 0);
+            var init_location = await EvaluateAndCheck(
+                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:RunDebuggerBreak'); }, 1);",
+                "dotnet://debugger-test.dll/debugger-test.cs",
+                bp_init.Value["locations"][0]["lineNumber"].Value<int>(),
+                bp_init.Value["locations"][0]["columnNumber"].Value<int>(),
+                "RunDebuggerBreak"
+            );
+            var pause_location = await SendCommandAndCheck(null, "Debugger.resume",
+                "dotnet://debugger-test.dll/debugger-test.cs",
+                bp_init.Value["locations"][0]["lineNumber"].Value<int>() + 1,
+                8,
+                "RunDebuggerBreak");
+            Assert.Equal(init_location["callFrames"][0]["functionName"], pause_location["callFrames"][0]["functionName"]);
+            var id = pause_location["callFrames"][0]["callFrameId"].Value<string>();
+            await EvaluateOnCallFrame(id, "local_var", false);
+            await SendCommandAndCheck(null, "Debugger.resume",
+                "dotnet://debugger-test.dll/debugger-test.cs",
+                835,
+                8,
+                "VisibleMethodDebuggerBreak");
+        }
     }
 }
diff --git a/src/mono/wasm/debugger/DebuggerTestSuite/SteppingTests.cs b/src/mono/wasm/debugger/DebuggerTestSuite/SteppingTests.cs
@@ -948,5 +948,77 @@ await EvaluateAndCheck(
             pause_location = await StepAndCheck(StepKind.Over, "dotnet://debugger-test.dll/debugger-test.cs", 806, 8, "Increment");
             Assert.Equal(pause_location["callFrames"][0]["callFrameId"], "dotnet:scope:1");
         }
+
+        [Fact]
+        public async Task DebuggerAttributeIgnoreStepIntoDebuggerHidden()
+        {
+            var pause_location = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "Run", 1);
+            await EvaluateAndCheck(
+                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:Run'); }, 1);",
+                "dotnet://debugger-test.dll/debugger-test.cs",
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
+                pause_location.Value["locations"][0]["columnNumber"].Value<int>(),
+                "Run"
+            );
+            var step_into = await SendCommandAndCheck(null, $"Debugger.stepInto", null, -1, -1, null);
+
+            Assert.Equal(
+                step_into["callFrames"][0]["location"]["lineNumber"].Value<int>(), 
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>() + 1
+                );
+            
+        }
+
+        [Fact]
+        public async Task DebuggerAttributeIgnoreStepIntoDebuggerHiddenWithDebuggerBreakCall()
+        {
+            var pause_location = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "RunDebuggerBreak", 1);
+            await EvaluateAndCheck(
+                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:RunDebuggerBreak'); }, 1);",
+                "dotnet://debugger-test.dll/debugger-test.cs",
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
+                pause_location.Value["locations"][0]["columnNumber"].Value<int>(),
+                "RunDebuggerBreak"
+            );
+            var step_into1 = await SendCommandAndCheck(null, $"Debugger.stepInto", null, -1, -1, null);
+
+            Assert.Equal( 
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
+                step_into1["callFrames"][0]["location"]["lineNumber"].Value<int>()
+                );
+
+            var step_into2 = await SendCommandAndCheck(null, $"Debugger.stepInto", null, -1, -1, null);
+
+            Assert.Equal(
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>() + 1,
+                step_into2["callFrames"][0]["location"]["lineNumber"].Value<int>()
+                );
+            
+        }
+
+        [Fact]
+        public async Task DebuggerAttributeIgnoreStepOverDebuggerHiddenWithDebuggerBreakCall()
+        {
+            var pause_location = await SetBreakpointInMethod("debugger-test.dll", "DebuggerAttribute", "RunDebuggerBreak", 1);
+            await EvaluateAndCheck(
+                "window.setTimeout(function() { invoke_static_method('[debugger-test] DebuggerAttribute:RunDebuggerBreak'); 1});",
+                "dotnet://debugger-test.dll/debugger-test.cs",
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
+                pause_location.Value["locations"][0]["columnNumber"].Value<int>(),
+                "RunDebuggerBreak"
+            );
+            var step_over1 = await SendCommandAndCheck(null, $"Debugger.stepOver", null, -1, -1, null);
+            Assert.Equal(
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>(),
+                step_over1["callFrames"][0]["location"]["lineNumber"].Value<int>()
+                );
+
+            var step_over2 = await SendCommandAndCheck(null, $"Debugger.stepOver", null, -1, -1, null);
+
+            Assert.Equal(
+                pause_location.Value["locations"][0]["lineNumber"].Value<int>() + 1,
+                step_over2["callFrames"][0]["location"]["lineNumber"].Value<int>()
+                );
+        }
     }
 }
diff --git a/src/mono/wasm/debugger/tests/debugger-test/debugger-test.cs b/src/mono/wasm/debugger/tests/debugger-test/debugger-test.cs
@@ -818,14 +818,34 @@ public static void HiddenMethod()
         currentCount++;
     }
 
+    [System.Diagnostics.DebuggerHidden]
+    public static void HiddenMethodDebuggerBreak()
+    {
+        var local_var = 12;
+        System.Diagnostics.Debugger.Break();
+        currentCount++;
+    }
+
     public static void VisibleMethod()
     {
         currentCount++;
     }
 
+    public static void VisibleMethodDebuggerBreak()
+    {
+        System.Diagnostics.Debugger.Break();
+        currentCount++;
+    }
+
     public static void Run()
     {
         HiddenMethod();
         VisibleMethod();
     }
+
+    public static void RunDebuggerBreak()
+    {
+        HiddenMethodDebuggerBreak();
+        VisibleMethodDebuggerBreak();
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -818,14 +818,34 @@ public static void HiddenMethod()`
`818`	`818`	`currentCount++;`
`819`	`819`	`}`
`820`	`820`
	`821`	`+ [System.Diagnostics.DebuggerHidden]`
	`822`	`+ public static void HiddenMethodDebuggerBreak()`
	`823`	`+ {`
	`824`	`+ var local_var = 12;`
	`825`	`+ System.Diagnostics.Debugger.Break();`
	`826`	`+ currentCount++;`
	`827`	`+ }`
	`828`	`+`
`821`	`829`	`public static void VisibleMethod()`
`822`	`830`	`{`
`823`	`831`	`currentCount++;`
`824`	`832`	`}`
`825`	`833`
	`834`	`+ public static void VisibleMethodDebuggerBreak()`
	`835`	`+ {`
	`836`	`+ System.Diagnostics.Debugger.Break();`
	`837`	`+ currentCount++;`
	`838`	`+ }`
	`839`	`+`
`826`	`840`	`public static void Run()`
`827`	`841`	`{`
`828`	`842`	`HiddenMethod();`
`829`	`843`	`VisibleMethod();`
`830`	`844`	`}`
	`845`	`+`
	`846`	`+ public static void RunDebuggerBreak()`
	`847`	`+ {`
	`848`	`+ HiddenMethodDebuggerBreak();`
	`849`	`+ VisibleMethodDebuggerBreak();`
	`850`	`+ }`
`831`	`851`	`}`