async Task GetDetails(MessageId msg_id, MonoCommands cmd, CancellationToken token)
{
var res = await SendMonoCommand(msg_id, cmd, token);
//if we fail we just buble that to the IDE (and let it panic over it)
if (res.IsErr)
{
SendResponse(msg_id, res, token);
return;
}
try {
var values = res.Value?["result"]?["value"]?.Values <JObject>().ToArray() ?? Array.Empty <JObject>();
var var_list = new List <JObject>();
// Trying to inspect the stack frame for DotNetDispatcher::InvokeSynchronously
// results in a "Memory access out of bounds", causing 'values' to be null,
// so skip returning variable values in that case.
for (int i = 0; i < values.Length; i += 2)
{
string fieldName = FormatFieldName((string)values[i]["name"]);
var value = values [i + 1]? ["value"];
if (((string)value ["description"]) == null)
{
value ["description"] = value ["value"]?.ToString();
}
var_list.Add(JObject.FromObject(new {
name = fieldName,
value
}));
}
var response = JObject.FromObject(new
{
result = var_list
});
SendResponse(msg_id, Result.Ok(response), token);
} catch (Exception e) {
Log("verbose", $"failed to parse {res.Value} - {e.Message}");
SendResponse(msg_id, Result.Exception(e), token);
}
}
async Task <Breakpoint> SetMonoBreakpoint(SessionId sessionId, string reqId, SourceLocation location, CancellationToken token)
{
var bp = new Breakpoint(reqId, location, BreakpointState.Pending);
var asm_name = bp.Location.CliLocation.Method.Assembly.Name;
var method_token = bp.Location.CliLocation.Method.Token;
var il_offset = bp.Location.CliLocation.Offset;
var res = await SendMonoCommand(sessionId, MonoCommands.SetBreakpoint(asm_name, method_token, il_offset), token);
var ret_code = res.Value? ["result"]? ["value"]?.Value <int> ();
if (ret_code.HasValue)
{
bp.RemoteId = ret_code.Value;
bp.State = BreakpointState.Active;
//Log ("verbose", $"BP local id {bp.LocalId} enabled with remote id {bp.RemoteId}");
}
return(bp);
}
async Task <DebugStore> LoadStore(SessionId sessionId, CancellationToken token)
{
var context = GetContext(sessionId);
if (Interlocked.CompareExchange(ref context.store, new DebugStore(logger), null) != null)
{
return(await context.Source.Task);
}
try {
var loaded_pdbs = await SendMonoCommand(sessionId, MonoCommands.GetLoadedFiles(), token);
var the_value = loaded_pdbs.Value? ["result"]? ["value"];
var the_pdbs = the_value?.ToObject <string[]> ();
await foreach (var source in context.store.Load(sessionId, the_pdbs, token).WithCancellation(token))
{
var scriptSource = JObject.FromObject(source.ToScriptSource(context.Id, context.AuxData));
Log("verbose", $"\tsending {source.Url} {context.Id} {sessionId.sessionId}");
SendEvent(sessionId, "Debugger.scriptParsed", scriptSource, token);
foreach (var req in context.BreakpointRequests.Values)
{
if (req.TryResolve(source))
{
await SetBreakpoint(sessionId, context.store, req, token);
}
}
}
} catch (Exception e) {
context.Source.SetException(e);
}
if (!context.Source.Task.IsCompleted)
{
context.Source.SetResult(context.store);
}
return(context.store);
}
async Task <DebugStore> RuntimeReady(SessionId sessionId, CancellationToken token)
{
var context = GetContext(sessionId);
if (Interlocked.CompareExchange(ref context.ready, new TaskCompletionSource <DebugStore> (), null) != null)
{
return(await context.ready.Task);
}
var clear_result = await SendMonoCommand(sessionId, MonoCommands.ClearAllBreakpoints(), token);
if (clear_result.IsErr)
{
Log("verbose", $"Failed to clear breakpoints due to {clear_result}");
}
var store = await LoadStore(sessionId, token);
context.ready.SetResult(store);
SendEvent(sessionId, "Mono.runtimeReady", new JObject(), token);
return(store);
}
async Task <Result> GetScopeProperties(MessageId msg_id, int scope_id, CancellationToken token)
{
try {
var ctx = GetContext(msg_id);
var scope = ctx.CallStack.FirstOrDefault(s => s.Id == scope_id);
if (scope == null)
{
return(Result.Err(JObject.FromObject(new { message = $"Could not find scope with id #{scope_id}" })));
}
var var_ids = scope.Method.GetLiveVarsAt(scope.Location.CliLocation.Offset);
var res = await SendMonoCommand(msg_id, MonoCommands.GetScopeVariables(scope.Id, var_ids), token);
//if we fail we just buble that to the IDE (and let it panic over it)
if (res.IsErr)
{
return(res);
}
var values = res.Value? ["result"]? ["value"]?.Values <JObject> ().ToArray();
if (values == null || values.Length == 0)
{
return(Result.OkFromObject(new { result = Array.Empty <object> () }));
}
foreach (var value in values)
{
ctx.LocalsCache [value ["name"]?.Value <string> ()] = value;
}
return(Result.OkFromObject(new { result = values }));
} catch (Exception exception) {
Log("verbose", $"Error resolving scope properties {exception.Message}");
return(Result.Exception(exception));
}
}
async Task <Result> RuntimeGetProperties(MessageId id, DotnetObjectId objectId, JToken args, CancellationToken token)
{
if (objectId.Scheme == "scope")
{
return(await GetScopeProperties(id, int.Parse(objectId.Value), token));
}
var res = await SendMonoCommand(id, MonoCommands.GetDetails(objectId, args), token);
if (res.IsErr)
{
return(res);
}
if (objectId.Scheme == "cfo_res")
{
// Runtime.callFunctionOn result object
var value_json_str = res.Value ["result"]?["value"]?["__value_as_json_string__"]?.Value <string> ();
if (value_json_str != null)
{
res = Result.OkFromObject(new {
result = JArray.Parse(value_json_str.Replace(@"\""", "\""))
});
}
else
{
res = Result.OkFromObject(new { result = new {} });
}
}
else
{
res = Result.Ok(JObject.FromObject(new { result = res.Value ["result"] ["value"] }));
}
return(res);
}
internal async Task <JToken> TryGetVariableValue(MessageId msg_id, int scope_id, string expression, bool only_search_on_this, CancellationToken token)
{
JToken thisValue = null;
var context = GetContext(msg_id);
if (context.CallStack == null)
{
return(null);
}
if (TryFindVariableValueInCache(context, expression, only_search_on_this, out JToken obj))
{
return(obj);
}
var scope = context.CallStack.FirstOrDefault(s => s.Id == scope_id);
var vars = scope.Method.GetLiveVarsAt(scope.Location.CliLocation.Offset);
//get_this
int [] var_ids = { };
var res = await SendMonoCommand(msg_id, MonoCommands.GetScopeVariables(scope.Id, var_ids), token);
var values = res.Value? ["result"]? ["value"]?.Values <JObject> ().ToArray();
thisValue = values.FirstOrDefault(v => v ["name"].Value <string> () == "this");
if (!only_search_on_this)
{
if (thisValue != null && expression == "this")
{
return(thisValue);
}
//search in locals
var var_id = vars.SingleOrDefault(v => v.Name == expression);
if (var_id != null)
{
res = await SendMonoCommand(msg_id, MonoCommands.GetScopeVariables(scope.Id, new int [] { var_id.Index }), token);
values = res.Value? ["result"]? ["value"]?.Values <JObject> ().ToArray();
return(values [0]);
}
}
//search in scope
if (thisValue != null)
{
var objectId = thisValue ["value"] ["objectId"].Value <string> ();
var parts = objectId.Split(new char [] { ':' });
res = await SendMonoCommand(msg_id, MonoCommands.GetObjectProperties(int.Parse(parts [2]), expandValueTypes: false), token);
values = res.Value? ["result"]? ["value"]?.Values <JObject> ().ToArray();
var foundValue = values.FirstOrDefault(v => v ["name"].Value <string> () == expression);
if (foundValue != null)
{
foundValue["fromThis"] = true;
context.LocalsCache[foundValue ["name"].Value <string> ()] = foundValue;
return(foundValue);
}
}
return(null);
}
//static int frame_id=0;
async Task <bool> OnBreakpointHit(SessionId sessionId, JObject args, CancellationToken token)
{
//FIXME we should send release objects every now and then? Or intercept those we inject and deal in the runtime
var res = await SendMonoCommand(sessionId, MonoCommands.GetCallStack(), token);
var orig_callframes = args? ["callFrames"]?.Values <JObject> ();
var context = GetContext(sessionId);
if (res.IsErr)
{
//Give up and send the original call stack
return(false);
}
//step one, figure out where did we hit
var res_value = res.Value? ["result"]? ["value"];
if (res_value == null || res_value is JValue)
{
//Give up and send the original call stack
return(false);
}
Log("verbose", $"call stack (err is {res.Error} value is:\n{res.Value}");
var bp_id = res_value? ["breakpoint_id"]?.Value <int> ();
Log("verbose", $"We just hit bp {bp_id}");
if (!bp_id.HasValue)
{
//Give up and send the original call stack
return(false);
}
var bp = context.BreakpointRequests.Values.SelectMany(v => v.Locations).FirstOrDefault(b => b.RemoteId == bp_id.Value);
var callFrames = new List <object> ();
foreach (var frame in orig_callframes)
{
var function_name = frame ["functionName"]?.Value <string> ();
var url = frame ["url"]?.Value <string> ();
if ("mono_wasm_fire_bp" == function_name || "_mono_wasm_fire_bp" == function_name)
{
var frames = new List <Frame> ();
int frame_id = 0;
var the_mono_frames = res.Value? ["result"]? ["value"]? ["frames"]?.Values <JObject> ();
foreach (var mono_frame in the_mono_frames)
{
++frame_id;
var il_pos = mono_frame ["il_pos"].Value <int> ();
var method_token = mono_frame ["method_token"].Value <uint> ();
var assembly_name = mono_frame ["assembly_name"].Value <string> ();
var store = await LoadStore(sessionId, token);
var asm = store.GetAssemblyByName(assembly_name);
if (asm == null)
{
Log("info", $"Unable to find assembly: {assembly_name}");
continue;
}
var method = asm.GetMethodByToken(method_token);
if (method == null)
{
Log("info", $"Unable to find il offset: {il_pos} in method token: {method_token} assembly name: {assembly_name}");
continue;
}
var location = method?.GetLocationByIl(il_pos);
// When hitting a breakpoint on the "IncrementCount" method in the standard
// Blazor project template, one of the stack frames is inside mscorlib.dll
// and we get location==null for it. It will trigger a NullReferenceException
// if we don't skip over that stack frame.
if (location == null)
{
continue;
}
Log("info", $"frame il offset: {il_pos} method token: {method_token} assembly name: {assembly_name}");
Log("info", $"\tmethod {method.Name} location: {location}");
frames.Add(new Frame(method, location, frame_id - 1));
callFrames.Add(new {
functionName = method.Name,
callFrameId = $"dotnet:scope:{frame_id-1}",
functionLocation = method.StartLocation.AsLocation(),
location = location.AsLocation(),
url = store.ToUrl(location),
scopeChain = new [] {
new {
type = "local",
@object = new {
@type = "object",
className = "Object",
description = "Object",
objectId = $"dotnet:scope:{frame_id-1}",
},
name = method.Name,
startLocation = method.StartLocation.AsLocation(),
endLocation = method.EndLocation.AsLocation(),
}
}
});
context.CallStack = frames;
}
}
else if (!(function_name.StartsWith("wasm-function", StringComparison.Ordinal) ||
url.StartsWith("wasm://wasm/", StringComparison.Ordinal)))
{
callFrames.Add(frame);
}
}
var bp_list = new string [bp == null ? 0 : 1];
if (bp != null)
{
bp_list [0] = bp.StackId;
}
var o = JObject.FromObject(new {
callFrames,
reason = "other", //other means breakpoint
hitBreakpoints = bp_list,
});
SendEvent(sessionId, "Debugger.paused", o, token);
return(true);
}
internal Task <Result> SendMonoCommand(SessionId id, MonoCommands cmd, CancellationToken token) => SendCommand(id, "Runtime.evaluate", JObject.FromObject(cmd), token);
protected override async Task <bool> AcceptCommand(MessageId id, string method, JObject args, CancellationToken token)
{
if (!contexts.TryGetValue(id, out var context))
{
return(false);
}
switch (method)
{
case "Debugger.enable": {
var resp = await SendCommand(id, method, args, token);
context.DebuggerId = resp.Value ["debuggerId"]?.ToString();
if (await IsRuntimeAlreadyReadyAlready(id, token))
{
await RuntimeReady(id, token);
}
SendResponse(id, resp, token);
return(true);
}
case "Debugger.getScriptSource": {
var script = args? ["scriptId"]?.Value <string> ();
return(await OnGetScriptSource(id, script, token));
}
case "Runtime.compileScript": {
var exp = args? ["expression"]?.Value <string> ();
if (exp.StartsWith("//dotnet:", StringComparison.Ordinal))
{
OnCompileDotnetScript(id, token);
return(true);
}
break;
}
case "Debugger.getPossibleBreakpoints": {
var resp = await SendCommand(id, method, args, token);
if (resp.IsOk && resp.Value["locations"].HasValues)
{
SendResponse(id, resp, token);
return(true);
}
var start = SourceLocation.Parse(args? ["start"] as JObject);
//FIXME support variant where restrictToFunction=true and end is omitted
var end = SourceLocation.Parse(args? ["end"] as JObject);
if (start != null && end != null && await GetPossibleBreakpoints(id, start, end, token))
{
return(true);
}
SendResponse(id, resp, token);
return(true);
}
case "Debugger.setBreakpoint": {
break;
}
case "Debugger.setBreakpointByUrl": {
var resp = await SendCommand(id, method, args, token);
if (!resp.IsOk)
{
SendResponse(id, resp, token);
return(true);
}
var bpid = resp.Value["breakpointId"]?.ToString();
var request = BreakpointRequest.Parse(bpid, args);
context.BreakpointRequests[bpid] = request;
if (await IsRuntimeAlreadyReadyAlready(id, token))
{
var store = await RuntimeReady(id, token);
Log("verbose", $"BP req {args}");
await SetBreakpoint(id, store, request, token);
}
SendResponse(id, Result.OkFromObject(request.AsSetBreakpointByUrlResponse()), token);
return(true);
}
case "Debugger.removeBreakpoint": {
return(await RemoveBreakpoint(id, args, token));
}
case "Debugger.resume": {
await OnResume(id, token);
break;
}
case "Debugger.stepInto": {
return(await Step(id, StepKind.Into, token));
}
case "Debugger.stepOut": {
return(await Step(id, StepKind.Out, token));
}
case "Debugger.stepOver": {
return(await Step(id, StepKind.Over, token));
}
case "Debugger.evaluateOnCallFrame": {
var objId = args? ["callFrameId"]?.Value <string> ();
if (objId.StartsWith("dotnet:", StringComparison.Ordinal))
{
var parts = objId.Split(new char [] { ':' });
if (parts.Length < 3)
{
return(true);
}
switch (parts [1])
{
case "scope": {
await GetEvaluateOnCallFrame(id, int.Parse(parts [2]), args? ["expression"]?.Value <string> (), token);
break;
}
}
return(true);
}
return(false);
}
case "Runtime.getProperties": {
var objId = args? ["objectId"]?.Value <string> ();
if (objId.StartsWith("dotnet:", StringComparison.Ordinal))
{
var parts = objId.Split(new char [] { ':' });
if (parts.Length < 3)
{
return(true);
}
switch (parts[1])
{
case "scope": {
await GetScopeProperties(id, int.Parse(parts[2]), token);
break;
}
case "object": {
await GetDetails(id, MonoCommands.GetObjectProperties(int.Parse(parts[2]), expandValueTypes: false), token);
break;
}
case "array": {
await GetArrayDetails(id, objId, parts, token);
break;
}
case "valuetype": {
await GetDetailsForValueType(id, objId,
get_props_cmd_fn : () => {
if (parts.Length < 4)
{
return(null);
}
var containerObjId = int.Parse(parts[2]);
return(MonoCommands.GetObjectProperties(containerObjId, expandValueTypes: true));
}, token);
break;
}
}
return(true);
}
break;
}
// Protocol extensions
case "Dotnet-test.setBreakpointByMethod": {
Console.WriteLine("set-breakpoint-by-method: " + id + " " + args);
var store = await RuntimeReady(id, token);
string aname = args ["assemblyName"]?.Value <string> ();
string typeName = args ["typeName"]?.Value <string> ();
string methodName = args ["methodName"]?.Value <string> ();
if (aname == null || typeName == null || methodName == null)
{
SendResponse(id, Result.Err("Invalid protocol message '" + args + "'."), token);
return(true);
}
// GetAssemblyByName seems to work on file names
var assembly = store.GetAssemblyByName(aname);
if (assembly == null)
{
assembly = store.GetAssemblyByName(aname + ".exe");
}
if (assembly == null)
{
assembly = store.GetAssemblyByName(aname + ".dll");
}
if (assembly == null)
{
SendResponse(id, Result.Err("Assembly '" + aname + "' not found."), token);
return(true);
}
var type = assembly.GetTypeByName(typeName);
if (type == null)
{
SendResponse(id, Result.Err($"Type '{typeName}' not found."), token);
return(true);
}
var methodInfo = type.Methods.FirstOrDefault(m => m.Name == methodName);
if (methodInfo == null)
{
SendResponse(id, Result.Err($"Method '{typeName}:{methodName}' not found."), token);
return(true);
}
bpIdGenerator++;
string bpid = "by-method-" + bpIdGenerator.ToString();
var request = new BreakpointRequest(bpid, methodInfo);
context.BreakpointRequests[bpid] = request;
var loc = methodInfo.StartLocation;
var bp = await SetMonoBreakpoint(id, bpid, loc, token);
if (bp.State != BreakpointState.Active)
{
// FIXME:
throw new NotImplementedException();
}
var resolvedLocation = new {
breakpointId = bpid,
location = loc.AsLocation()
};
SendEvent(id, "Debugger.breakpointResolved", JObject.FromObject(resolvedLocation), token);
SendResponse(id, Result.OkFromObject(new {
result = new { breakpointId = bpid, locations = new object [] { loc.AsLocation() } }
}), token);
return(true);
}
}
return(false);
}
async Task <bool> IsRuntimeAlreadyReadyAlready(SessionId sessionId, CancellationToken token)
{
var res = await SendMonoCommand(sessionId, MonoCommands.IsRuntimeReady(), token);
return(res.Value? ["result"]? ["value"]?.Value <bool> () ?? false);
}
protected override async Task <bool> AcceptCommand(MessageId id, string method, JObject args, CancellationToken token)
{
// Inspector doesn't use the Target domain or sessions
// so we try to init immediately
if (hideWebDriver && id == SessionId.Null)
{
await DeleteWebDriver(id, token);
}
if (!contexts.TryGetValue(id, out var context))
{
return(false);
}
switch (method)
{
case "Target.attachToTarget": {
var resp = await SendCommand(id, method, args, token);
await DeleteWebDriver(new SessionId (resp.Value ["sessionId"]?.ToString()), token);
break;
}
case "Debugger.enable": {
var resp = await SendCommand(id, method, args, token);
context.DebuggerId = resp.Value ["debuggerId"]?.ToString();
if (await IsRuntimeAlreadyReadyAlready(id, token))
{
await RuntimeReady(id, token);
}
SendResponse(id, resp, token);
return(true);
}
case "Debugger.getScriptSource": {
var script = args? ["scriptId"]?.Value <string> ();
return(await OnGetScriptSource(id, script, token));
}
case "Runtime.compileScript": {
var exp = args? ["expression"]?.Value <string> ();
if (exp.StartsWith("//dotnet:", StringComparison.Ordinal))
{
OnCompileDotnetScript(id, token);
return(true);
}
break;
}
case "Debugger.getPossibleBreakpoints": {
var resp = await SendCommand(id, method, args, token);
if (resp.IsOk && resp.Value["locations"].HasValues)
{
SendResponse(id, resp, token);
return(true);
}
var start = SourceLocation.Parse(args? ["start"] as JObject);
//FIXME support variant where restrictToFunction=true and end is omitted
var end = SourceLocation.Parse(args? ["end"] as JObject);
if (start != null && end != null && await GetPossibleBreakpoints(id, start, end, token))
{
return(true);
}
SendResponse(id, resp, token);
return(true);
}
case "Debugger.setBreakpoint": {
break;
}
case "Debugger.setBreakpointByUrl": {
var resp = await SendCommand(id, method, args, token);
if (!resp.IsOk)
{
SendResponse(id, resp, token);
return(true);
}
var bpid = resp.Value["breakpointId"]?.ToString();
var locations = resp.Value["locations"]?.Values <object>();
var request = BreakpointRequest.Parse(bpid, args);
// is the store done loading?
var loaded = context.Source.Task.IsCompleted;
if (!loaded)
{
// Send and empty response immediately if not
// and register the breakpoint for resolution
context.BreakpointRequests [bpid] = request;
SendResponse(id, resp, token);
}
if (await IsRuntimeAlreadyReadyAlready(id, token))
{
var store = await RuntimeReady(id, token);
Log("verbose", $"BP req {args}");
await SetBreakpoint(id, store, request, !loaded, token);
}
if (loaded)
{
// we were already loaded so we should send a response
// with the locations included and register the request
context.BreakpointRequests [bpid] = request;
var result = Result.OkFromObject(request.AsSetBreakpointByUrlResponse(locations));
SendResponse(id, result, token);
}
return(true);
}
case "Debugger.removeBreakpoint": {
await RemoveBreakpoint(id, args, token);
break;
}
case "Debugger.resume": {
await OnResume(id, token);
break;
}
case "Debugger.stepInto": {
return(await Step(id, StepKind.Into, token));
}
case "Debugger.stepOut": {
return(await Step(id, StepKind.Out, token));
}
case "Debugger.stepOver": {
return(await Step(id, StepKind.Over, token));
}
case "Debugger.evaluateOnCallFrame": {
if (!DotnetObjectId.TryParse(args? ["callFrameId"], out var objectId))
{
return(false);
}
switch (objectId.Scheme)
{
case "scope":
return(await OnEvaluateOnCallFrame(id,
int.Parse(objectId.Value),
args? ["expression"]?.Value <string> (), token));
default:
return(false);
}
}
case "Runtime.getProperties": {
if (!DotnetObjectId.TryParse(args? ["objectId"], out var objectId))
{
break;
}
var result = await RuntimeGetProperties(id, objectId, args, token);
SendResponse(id, result, token);
return(true);
}
case "Runtime.releaseObject": {
if (!(DotnetObjectId.TryParse(args ["objectId"], out var objectId) && objectId.Scheme == "cfo_res"))
{
break;
}
await SendMonoCommand(id, MonoCommands.ReleaseObject(objectId), token);
SendResponse(id, Result.OkFromObject(new{}), token);
return(true);
}
// Protocol extensions
case "Dotnet-test.setBreakpointByMethod": {
Console.WriteLine("set-breakpoint-by-method: " + id + " " + args);
var store = await RuntimeReady(id, token);
string aname = args ["assemblyName"]?.Value <string> ();
string typeName = args ["typeName"]?.Value <string> ();
string methodName = args ["methodName"]?.Value <string> ();
if (aname == null || typeName == null || methodName == null)
{
SendResponse(id, Result.Err("Invalid protocol message '" + args + "'."), token);
return(true);
}
// GetAssemblyByName seems to work on file names
var assembly = store.GetAssemblyByName(aname);
if (assembly == null)
{
assembly = store.GetAssemblyByName(aname + ".exe");
}
if (assembly == null)
{
assembly = store.GetAssemblyByName(aname + ".dll");
}
if (assembly == null)
{
SendResponse(id, Result.Err("Assembly '" + aname + "' not found."), token);
return(true);
}
var type = assembly.GetTypeByName(typeName);
if (type == null)
{
SendResponse(id, Result.Err($"Type '{typeName}' not found."), token);
return(true);
}
var methodInfo = type.Methods.FirstOrDefault(m => m.Name == methodName);
if (methodInfo == null)
{
SendResponse(id, Result.Err($"Method '{typeName}:{methodName}' not found."), token);
return(true);
}
bpIdGenerator++;
string bpid = "by-method-" + bpIdGenerator.ToString();
var request = new BreakpointRequest(bpid, methodInfo);
context.BreakpointRequests[bpid] = request;
var loc = methodInfo.StartLocation;
var bp = await SetMonoBreakpoint(id, bpid, loc, token);
if (bp.State != BreakpointState.Active)
{
// FIXME:
throw new NotImplementedException();
}
var resolvedLocation = new {
breakpointId = bpid,
location = loc.AsLocation()
};
SendEvent(id, "Debugger.breakpointResolved", JObject.FromObject(resolvedLocation), token);
SendResponse(id, Result.OkFromObject(new {
result = new { breakpointId = bpid, locations = new object [] { loc.AsLocation() } }
}), token);
return(true);
}
case "Runtime.callFunctionOn": {
if (!DotnetObjectId.TryParse(args ["objectId"], out var objectId))
{
return(false);
}
var silent = args ["silent"]?.Value <bool> () ?? false;
if (objectId.Scheme == "scope")
{
var fail = silent ? Result.OkFromObject(new { result = new { } }) : Result.Exception(new ArgumentException($"Runtime.callFunctionOn not supported with scope ({objectId})."));
SendResponse(id, fail, token);
return(true);
}
var returnByValue = args ["returnByValue"]?.Value <bool> () ?? false;
var res = await SendMonoCommand(id, MonoCommands.CallFunctionOn(args), token);
if (!returnByValue &&
DotnetObjectId.TryParse(res.Value?["result"]?["value"]?["objectId"], out var resultObjectId) &&
resultObjectId.Scheme == "cfo_res")
{
res = Result.OkFromObject(new { result = res.Value ["result"]["value"] });
}
if (res.IsErr && silent)
{
res = Result.OkFromObject(new { result = new { } });
}
SendResponse(id, res, token);
return(true);
}
}
return(false);
}
protected override async Task <bool> AcceptCommand(MessageId id, string method, JObject args, CancellationToken token)
{
if (!contexts.TryGetValue(id, out var context))
{
return(false);
}
switch (method)
{
case "Debugger.enable": {
var resp = await SendCommand(id, method, args, token);
context.DebuggerId = resp.Value ["debuggerId"]?.ToString();
if (await IsRuntimeAlreadyReadyAlready(id, token))
{
await RuntimeReady(id, token);
}
SendResponse(id, resp, token);
return(true);
}
case "Debugger.getScriptSource": {
var script = args? ["scriptId"]?.Value <string> ();
return(await OnGetScriptSource(id, script, token));
}
case "Runtime.compileScript": {
var exp = args? ["expression"]?.Value <string> ();
if (exp.StartsWith("//dotnet:", StringComparison.Ordinal))
{
OnCompileDotnetScript(id, token);
return(true);
}
break;
}
case "Debugger.getPossibleBreakpoints": {
var resp = await SendCommand(id, method, args, token);
if (resp.IsOk && resp.Value["locations"].HasValues)
{
SendResponse(id, resp, token);
return(true);
}
var start = SourceLocation.Parse(args? ["start"] as JObject);
//FIXME support variant where restrictToFunction=true and end is omitted
var end = SourceLocation.Parse(args? ["end"] as JObject);
if (start != null && end != null && await GetPossibleBreakpoints(id, start, end, token))
{
return(true);
}
SendResponse(id, resp, token);
return(true);
}
case "Debugger.setBreakpoint": {
break;
}
case "Debugger.setBreakpointByUrl": {
var resp = await SendCommand(id, method, args, token);
if (!resp.IsOk)
{
SendResponse(id, resp, token);
return(true);
}
var bpid = resp.Value["breakpointId"]?.ToString();
var request = BreakpointRequest.Parse(bpid, args);
context.BreakpointRequests[bpid] = request;
if (await IsRuntimeAlreadyReadyAlready(id, token))
{
var store = await RuntimeReady(id, token);
Log("verbose", $"BP req {args}");
await SetBreakpoint(id, store, request, token);
}
SendResponse(id, Result.OkFromObject(request.AsSetBreakpointByUrlResponse()), token);
return(true);
}
case "Debugger.removeBreakpoint": {
return(await RemoveBreakpoint(id, args, token));
}
case "Debugger.resume": {
await OnResume(id, token);
break;
}
case "Debugger.stepInto": {
return(await Step(id, StepKind.Into, token));
}
case "Debugger.stepOut": {
return(await Step(id, StepKind.Out, token));
}
case "Debugger.stepOver": {
return(await Step(id, StepKind.Over, token));
}
case "Debugger.evaluateOnCallFrame": {
var objId = args? ["callFrameId"]?.Value <string> ();
if (objId.StartsWith("dotnet:", StringComparison.Ordinal))
{
var parts = objId.Split(new char [] { ':' });
if (parts.Length < 3)
{
return(true);
}
switch (parts [1])
{
case "scope": {
await GetEvaluateOnCallFrame(id, int.Parse(parts [2]), args? ["expression"]?.Value <string> (), token);
break;
}
}
return(true);
}
return(false);
}
case "Runtime.getProperties": {
var objId = args? ["objectId"]?.Value <string> ();
if (objId.StartsWith("dotnet:", StringComparison.Ordinal))
{
var parts = objId.Split(new char [] { ':' });
if (parts.Length < 3)
{
return(true);
}
switch (parts[1])
{
case "scope": {
await GetScopeProperties(id, int.Parse(parts[2]), token);
break;
}
case "object": {
await GetDetails(id, MonoCommands.GetObjectProperties(int.Parse(parts[2]), expandValueTypes: false), token);
break;
}
case "array": {
await GetArrayDetails(id, objId, parts, token);
break;
}
case "valuetype": {
await GetDetailsForValueType(id, objId,
get_props_cmd_fn : () => {
if (parts.Length < 4)
{
return(null);
}
var containerObjId = int.Parse(parts[2]);
return(MonoCommands.GetObjectProperties(containerObjId, expandValueTypes: true));
}, token);
break;
}
}
return(true);
}
break;
}
}
return(false);
}
async Task GetScopeProperties(MessageId msg_id, int scope_id, CancellationToken token)
{
try {
var scope = GetContext(msg_id).CallStack.FirstOrDefault(s => s.Id == scope_id);
var vars = scope.Method.GetLiveVarsAt(scope.Location.CliLocation.Offset);
var var_ids = vars.Select(v => v.Index).ToArray();
var res = await SendMonoCommand(msg_id, MonoCommands.GetScopeVariables(scope.Id, var_ids), token);
//if we fail we just buble that to the IDE (and let it panic over it)
if (res.IsErr)
{
SendResponse(msg_id, res, token);
return;
}
var values = res.Value? ["result"]? ["value"]?.Values <JObject> ().ToArray();
if (values == null)
{
SendResponse(msg_id, Result.OkFromObject(new { result = Array.Empty <object> () }), token);
return;
}
var var_list = new List <object> ();
int i = 0;
// Trying to inspect the stack frame for DotNetDispatcher::InvokeSynchronously
// results in a "Memory access out of bounds", causing 'values' to be null,
// so skip returning variable values in that case.
while (i < vars.Length && i < values.Length)
{
var value = values [i] ["value"];
if (((string)value ["description"]) == null)
{
value ["description"] = value ["value"]?.ToString();
}
var_list.Add(new {
name = vars [i].Name,
value
});
i++;
}
//Async methods are special in the way that local variables can be lifted to generated class fields
//value of "this" comes here either
while (i < values.Length)
{
String name = values [i] ["name"].ToString();
if (name.IndexOf(">", StringComparison.Ordinal) > 0)
{
name = name.Substring(1, name.IndexOf(">", StringComparison.Ordinal) - 1);
}
var value = values [i + 1] ["value"];
if (((string)value ["description"]) == null)
{
value ["description"] = value ["value"]?.ToString();
}
var_list.Add(new {
name,
value
});
i = i + 2;
}
SendResponse(msg_id, Result.OkFromObject(new { result = var_list }), token);
} catch (Exception exception) {
Log("verbose", $"Error resolving scope properties {exception.Message}");
SendResponse(msg_id, Result.Exception(exception), token);
}
}