Fix pause behavior (now showing correctly, pause on breakpoint, pause…

… while stepping)

Start implementing evaluate expressions, working correctly on VSCode.

src/mono/wasm/debugger/BrowserDebugProxy/DevToolsHelper.cs

@@ -124,10 +124,11 @@ public struct Result
     {
         public JObject Value { get; private set; }
         public JObject Error { get; private set; }
+        public JObject FullContent { get; private set; }
 
         public bool IsOk => Error == null;
 
-        private Result(JObject resultOrError, bool isError)
+        private Result(JObject resultOrError, bool isError, JObject fullContent = null)
         {
             bool resultHasError = isError || string.Equals((resultOrError?["result"] as JObject)?["subtype"]?.Value<string>(), "error");
             if (resultHasError)
@@ -140,6 +141,7 @@ private Result(JObject resultOrError, bool isError)
                 Value = resultOrError;
                 Error = null;
             }
+            FullContent = fullContent;
         }
         public static Result FromJson(JObject obj)
         {
@@ -214,9 +216,9 @@ public static Result FromJsonFirefox(JObject obj)
             bool resultHasError = obj["hasException"] != null && obj["hasException"].Value<bool>();
             if (resultHasError)
             {
-                return new Result(obj["hasException"]["result"] as JObject, resultHasError);
+                return new Result(obj["exception"] as JObject, resultHasError, obj);
             }
-            return new Result(o, false);
+            return new Result(o, false, obj);
         }
 
         public static Result Ok(JObject ok) => new Result(ok, false);
@@ -390,6 +392,13 @@ public ExecutionContext(MonoSDBHelper sdbAgent, int id, object auxData)
         public bool IsResumedAfterBp { get; set; }
         public int ThreadId { get; set; }
         public int Id { get; set; }
+
+        private int evaluateExpressionResultId;
+
+        public bool PausedOnWasm { get; set; }
+
+        public string PauseKind { get; set; }
+
         public object AuxData { get; set; }
 
         public PauseOnExceptionsKind PauseOnExceptions { get; set; }
@@ -416,6 +425,11 @@ public DebugStore Store
             }
         }
 
+        public int GetResultID()
+        {
+            return Interlocked.Increment(ref evaluateExpressionResultId);
+        }
+
         public PerScopeCache GetCacheForScope(int scopeId)
         {
             if (perScopeCaches.TryGetValue(scopeId, out PerScopeCache cache))

src/mono/wasm/debugger/BrowserDebugProxy/FirefoxMonoProxy.cs

@@ -38,7 +38,6 @@ internal class FirefoxMonoProxy : MonoProxy
         private int portBrowser;
         private TcpClient ide;
         private TcpClient browser;
-        private bool pausedOnWasm;
         private string actorName = "";
         private string threadName = "";
         private string globalName = "";
@@ -204,7 +203,8 @@ internal override async Task OnCommand(MessageId id, JObject parms, Cancellation
             {
                 if (!await AcceptCommand(id, parms, token))
                 {
-                    await SendCommandInternal(id, parms["type"]?.Value<string>(), parms, token);
+                    var ret = await SendCommandInternal(id, parms["type"]?.Value<string>(), parms, token);
+                    await SendEvent(id, "", ret.FullContent, token);
                 }
             }
             catch (Exception e)
@@ -273,8 +273,10 @@ internal override Task ProcessBrowserMessage(string msg, CancellationToken token
                 {
                     var id = int.Parse(res["resultID"].Value<string>().Split('-')[1]);
                     var msgId = new MessageIdFirefox(null, id + 1, "");
-
-                    OnResponse(msgId, Result.FromJsonFirefox(res));
+                    if (pending_cmds.ContainsKey(msgId))
+                        OnResponse(msgId, Result.FromJsonFirefox(res));
+                    else
+                        return SendCommandInternal(msgId, "", res, token);
                     return null;
                 }
                 //{"type":"evaluationResult","resultID":"1634575904746-0","hasException":false,"input":"ret = 10","result":10,"startTime":1634575904746,"timestamp":1634575904748,"from":"server1.conn21.child10/consoleActor2"}
@@ -372,17 +374,18 @@ protected override async Task<bool> AcceptEvent(SessionId sessionId, JObject arg
             {
                 case "paused":
                     {
+                        ExecutionContext ctx = GetContext(sessionId);
                         var topFunc = args["frame"]["displayName"].Value<string>();
                         switch (topFunc)
                         {
                             case "mono_wasm_fire_debugger_agent_message":
                             case "_mono_wasm_fire_debugger_agent_message":
                                 {
-                                    pausedOnWasm = true;
+                                    ctx.PausedOnWasm = true;
                                     return await OnReceiveDebuggerAgentEvent(sessionId, args, token);
                                 }
                             default:
-                                pausedOnWasm = false;
+                                ctx.PausedOnWasm = false;
                                 return false;
                         }
                     }
@@ -392,6 +395,15 @@ protected override async Task<bool> AcceptEvent(SessionId sessionId, JObject arg
                         var messages = args["resources"].Value<JArray>();
                         foreach (var message in messages)
                         {
+                            if (message["resourceType"].Value<string>() == "thread-state" && message["state"].Value<string>() == "paused")
+                            {
+                                ExecutionContext ctx = GetContext(sessionId);
+                                if (ctx.PausedOnWasm)
+                                {
+                                    await SendPauseToBrowser(sessionId, args, token);
+                                    return true;
+                                }
+                            }
                             if (message["resourceType"].Value<string>() != "console-message")
                                 continue;
                             var messageArgs = message["message"]?["arguments"]?.Value<JArray>();
@@ -428,6 +440,7 @@ protected override async Task<bool> AcceptCommand(MessageId sessionId, JObject a
                     {
                         if (!contexts.TryGetValue(sessionId, out ExecutionContext context))
                             return false;
+                        context.PausedOnWasm = false;
                         if (context.CallStack == null)
                             return false;
                         if (args["resumeLimit"] == null || args["resumeLimit"].Type == JTokenType.Null)
@@ -521,12 +534,6 @@ protected override async Task<bool> AcceptCommand(MessageId sessionId, JObject a
                             Log("verbose", $"BP req {args}");
                             await SetBreakpoint(sessionId, store, request, !loaded, token);
                         }
-
-                        var o = JObject.FromObject(new
-                        {
-                            from = args["to"].Value<string>()
-                        });
-                        //SendEventInternal(id, "", o, token);
                         return true;
                     }
                 case "removeBreakpoint":
@@ -664,11 +671,11 @@ protected override async Task<bool> AcceptCommand(MessageId sessionId, JObject a
                     }
                 case "frames":
                     {
-                        if (pausedOnWasm)
+                        ExecutionContext ctx = GetContext(sessionId);
+                        if (ctx.PausedOnWasm)
                         {
                             try
                             {
-                                ExecutionContext ctx = GetContext(sessionId);
                                 await GetFrames(sessionId, ctx, args, token);
                                 return true;
                             }
@@ -678,8 +685,56 @@ protected override async Task<bool> AcceptCommand(MessageId sessionId, JObject a
                                 return true;
                             }
                         }
+                        //var ret = await SendCommand(sessionId, "frames", args, token);
+                        //await SendEvent(sessionId, "", ret.Value["result"]["fullContent"] as JObject, token);
                         return false;
                     }
+                case "evaluateJSAsync":
+                    {
+                        ExecutionContext context = GetContext(sessionId);
+                        if (context.CallStack != null)
+                        {
+                            var resultID = $"runtimeResult-{context.GetResultID()}";
+                            var o = JObject.FromObject(new
+                            {
+                                resultID,
+                                from = args["to"].Value<string>()
+                            });
+                            await SendEvent(sessionId, "", o, token);
+
+                            Frame scope = context.CallStack.First<Frame>();
+
+                            var resolver = new MemberReferenceResolver(this, context, sessionId, scope.Id, logger);
+
+                            JObject retValue = await resolver.Resolve(args?["text"]?.Value<string>(), token);
+                            if (retValue == null)
+                            {
+                                retValue = await EvaluateExpression.CompileAndRunTheExpression(args?["text"]?.Value<string>(), resolver, token);
+                            }
+                            var osend = JObject.FromObject(new
+                            {
+                                type = "evaluationResult",
+                                resultID,
+                                hasException = false,
+                                input = args?["text"],
+                                result = retValue["value"],
+                                from = args["to"].Value<string>()
+                            });
+                            await SendEvent(sessionId, "", osend, token);
+                        }
+                        else
+                        {
+                            var ret = await SendCommand(sessionId, "evaluateJSAsync", args, token);
+                            var o = JObject.FromObject(new
+                            {
+                                resultID = ret.FullContent["resultID"],
+                                from = args["to"].Value<string>()
+                            });
+                            await SendEvent(sessionId, "", o, token);
+                            await SendEvent(sessionId, "", ret.FullContent, token);
+                        }
+                        return true;
+                    }
                 case "DotnetDebugger.getMethodLocation":
                     {
                         var ret = await GetMethodLocation(sessionId, args, token);
@@ -693,6 +748,29 @@ protected override async Task<bool> AcceptCommand(MessageId sessionId, JObject a
             return false;
         }
 
+        private async Task<bool> SendPauseToBrowser(SessionId sessionId, JObject args, CancellationToken token)
+        {
+            Result res = await SendMonoCommand(sessionId, MonoCommands.GetDebuggerAgentBufferReceived(RuntimeId), token);
+            if (!res.IsOk)
+                return false;
+
+            ExecutionContext context = GetContext(sessionId);
+            byte[] newBytes = Convert.FromBase64String(res.Value?["result"]?["value"]?["value"]?.Value<string>());
+            using var retDebuggerCmdReader = new MonoBinaryReader(newBytes);
+            retDebuggerCmdReader.ReadBytes(11);
+            retDebuggerCmdReader.ReadByte();
+            var number_of_events = retDebuggerCmdReader.ReadInt32();
+            var event_kind = (EventKind)retDebuggerCmdReader.ReadByte();
+            if (event_kind == EventKind.Step)
+                context.PauseKind = "resumeLimit";
+            else if (event_kind == EventKind.Breakpoint)
+                context.PauseKind = "breakpoint";
+
+            args["resources"][0]["why"]["type"] = context.PauseKind;
+            await SendEvent(sessionId, "", args, token);
+            return true;
+        }
+
         private JObject GetPrototype(DotnetObjectId objectId, JObject args)
         {
             var o = JObject.FromObject(new
@@ -874,7 +952,11 @@ protected override async Task<bool> SendCallStack(SessionId sessionId, Execution
                 await SendResume(sessionId, token);
                 return true;
             }
-            return false;
+
+            args["why"]["type"] = context.PauseKind;
+
+            await SendEvent(sessionId, "", args, token);
+            return true;
         }
 
         protected async Task<bool> GetFrames(SessionId sessionId, ExecutionContext context, JObject args, CancellationToken token)
@@ -944,6 +1026,7 @@ protected async Task<bool> GetFrames(SessionId sessionId, ExecutionContext conte
                 frames = callFrames,
                 from = threadName
             });
+
             await SendEvent(sessionId, "", o, token);
             return false;
         }

src/mono/wasm/debugger/BrowserDebugProxy/MonoProxy.cs

@@ -1081,6 +1081,10 @@ internal async Task<bool> OnReceiveDebuggerAgentEvent(SessionId sessionId, JObje
                     case EventKind.Step:
                     case EventKind.Breakpoint:
                     {
+                        if (event_kind == EventKind.Step)
+                            context.PauseKind = "resumeLimit";
+                        else if (event_kind == EventKind.Breakpoint)
+                            context.PauseKind = "breakpoint";
                         Breakpoint bp = context.BreakpointRequests.Values.SelectMany(v => v.Locations).FirstOrDefault(b => b.RemoteId == request_id);
                         if (request_id == context.TempBreakpointForSetNextIP)
                         {

src/mono/wasm/debugger/DebuggerTestSuite/PointerTests.cs

@@ -22,7 +22,7 @@ public class PointerTests : DebuggerTests
                 { $"invoke_static_method_async ('[debugger-test] DebuggerTests.PointerTests:LocalPointersAsync');", "DebuggerTests.PointerTests", "LocalPointersAsync", 32, "LocalPointersAsync", true }
             };
 
-        [Theory]
+        [ConditionalTheory(nameof(RunningOnChrome))]
         [MemberDataAttribute(nameof(PointersTestData))]
         public async Task InspectLocalPointersToPrimitiveTypes(string eval_fn, string type, string method, int line_offset, string bp_function_name, bool use_cfo) => await CheckInspectLocalsAtBreakpointSite(
             type, method, line_offset, bp_function_name,

src/mono/wasm/runtime/debug.ts

@@ -85,7 +85,7 @@ export function mono_wasm_send_dbg_command(id: number, command_set: number, comm
 }
 
 export function mono_wasm_get_dbg_command_info(): CommandResponseResult {
-    const { res_ok, res } = commands_received.remove(0);
+    const { res_ok, res } = commands_received.get(0);
 
     if (!res_ok)
         throw new Error("Failed on mono_wasm_get_dbg_command_info");