Adding the ability to evaluate arbitrary expressions while debugging (#797)

wk8 · ignatov · commit 004db3639401 · 2017-06-12T15:15:25.000+03:00
This patch allows users to evaluate arbitrary Erlang expressions while debugging. Part of the support had been added (at least on the Erlang side) in 9b6f4e1, but seems it was never properly hooked up to the Java side.
diff --git a/resources/debugger/beams/debugnode.beam b/resources/debugger/beams/debugnode.beam
diff --git a/resources/debugger/beams/remote_debugger.beam b/resources/debugger/beams/remote_debugger.beam
diff --git a/resources/debugger/beams/remote_debugger_listener.beam b/resources/debugger/beams/remote_debugger_listener.beam
diff --git a/resources/debugger/beams/remote_debugger_notifier.beam b/resources/debugger/beams/remote_debugger_notifier.beam
diff --git a/resources/debugger/src/remote_debugger_listener.erl b/resources/debugger/src/remote_debugger_listener.erl
@@ -8,7 +8,7 @@
 -include("remote_debugger_messages.hrl").
 -include("trace_utils.hrl").
 
--record(state, {interpreted_modules = []}).
+-record(state, {interpreted_modules = [] :: [module()]}).
 
 run(Debugger) ->
   register(?RDEBUG_LISTENER, self()),
@@ -60,9 +60,9 @@ process_message({step_out, Pid}) when is_pid(Pid) ->
   step_out(Pid);
 process_message({continue, Pid}) when is_pid(Pid) ->
   continue(Pid);
-process_message({evaluate, Pid, Expression}) when is_pid(Pid),
-                                                  is_list(Expression) ->
-  evaluate(Pid, Expression);
+process_message({evaluate, Pid, Expression, MaybeStackPointer}) when is_pid(Pid),
+                                                                     is_list(Expression) ->
+  evaluate(Pid, Expression, MaybeStackPointer);
 % responses from interpreter
 process_message({_Meta, {eval_rsp, EvalResponse}}) ->
   evaluate_response(EvalResponse);
@@ -108,12 +108,17 @@ step_out(Pid) ->
 continue(Pid) ->
   int:continue(Pid).
 
-evaluate(Pid, Expression) ->
+evaluate(Pid, Expression, MaybeStackPointer) ->
   {ok, Meta} = dbg_iserver:call({get_meta, Pid}),
-  int:meta(Meta, eval, {undefined, Expression}). % Current module should be passed instead of 'undefined'
+  MetaArgsList = [?MODULE, Expression],
+  MetaArgsListWithSP = case MaybeStackPointer =:= undefined of
+    true -> MetaArgsList;
+    false -> MetaArgsList ++ [MaybeStackPointer]
+  end,
+  int:meta(Meta, eval, list_to_tuple(MetaArgsListWithSP)).
 
-evaluate_response(Response) ->
-  ?RDEBUG_NOTIFIER ! #evaluate_response{result = Response}.
+evaluate_response(EvalResponse) ->
+  ?RDEBUG_NOTIFIER ! #evaluate_response{result = EvalResponse}.
 
 parse_args(ArgsString) ->
   case erl_scan:string(ArgsString ++ ".") of
@@ -165,4 +170,4 @@ send_interpret_modules_response(Node, IntResults) ->
               ({Module, {module, _}}) -> {Module, ok};
               ({Module, error}) -> {Module, int:interpretable(Module)}
             end, IntResults),
-  ?RDEBUG_NOTIFIER ! #interpret_modules_response{node = Node, statuses = Statuses}.
+  ?RDEBUG_NOTIFIER ! #interpret_modules_response{node = Node, statuses = Statuses}.
diff --git a/resources/debugger/src/remote_debugger_messages.hrl b/resources/debugger/src/remote_debugger_messages.hrl
@@ -9,7 +9,7 @@
 -record(step_over, {pid}).
 -record(step_out, {pid}).
 -record(continue, {pid}).
--record(evaluate, {pid, expression}). % TODO consider adding a stack pointer as third param
+-record(evaluate, {pid, expression, maybeStackPointer}).
 
 % Messages which can be sent to remote debugger.
 % Debugger implementation should handle all messages listed here.
diff --git a/resources/debugger/src/remote_debugger_notifier.erl b/resources/debugger/src/remote_debugger_notifier.erl
@@ -44,4 +44,4 @@ do_get_stackframes(Pid) ->
   end.
 
 get_bindings(MetaPid, SP) ->
-  int:meta(MetaPid, bindings, SP).
+  int:meta(MetaPid, bindings, SP).
diff --git a/src/org/intellij/erlang/debugger/node/ErlangDebuggerEventListener.java b/src/org/intellij/erlang/debugger/node/ErlangDebuggerEventListener.java
@@ -16,6 +16,7 @@
 
 package org.intellij.erlang.debugger.node;
 
+import com.ericsson.otp.erlang.OtpErlangObject;
 import com.ericsson.otp.erlang.OtpErlangPid;
 
 import java.util.List;
@@ -29,4 +30,5 @@ public interface ErlangDebuggerEventListener {
   void breakpointIsSet(String module, int line);
   void breakpointReached(OtpErlangPid pid, List<ErlangProcessSnapshot> snapshots);
   void debuggerStopped();
+  void handleEvaluationResponse(OtpErlangObject response);
 }
diff --git a/src/org/intellij/erlang/debugger/node/ErlangDebuggerNode.java b/src/org/intellij/erlang/debugger/node/ErlangDebuggerNode.java
@@ -117,6 +117,10 @@ public void resume() {
     addCommand(ErlangDebuggerCommandsProducer.getContinueCommand(myLastSuspendedPid));
   }
 
+  public void evaluate(@NotNull String expression, @NotNull ErlangTraceElement traceElement) {
+    addCommand(ErlangDebuggerCommandsProducer.getEvaluateCommand(myLastSuspendedPid, expression, traceElement));
+  }
+
   private void addCommand(ErlangDebuggerCommandsProducer.ErlangDebuggerCommand command) {
     synchronized (myCommandsQueue) {
       myCommandsQueue.add(command);
diff --git a/src/org/intellij/erlang/debugger/node/ErlangTraceElement.java b/src/org/intellij/erlang/debugger/node/ErlangTraceElement.java
@@ -17,24 +17,31 @@
 package org.intellij.erlang.debugger.node;
 
 import com.ericsson.otp.erlang.OtpErlangList;
+import com.ericsson.otp.erlang.OtpErlangObject;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.Collection;
 
 public class ErlangTraceElement {
+  private final OtpErlangObject myStackPointer;
   private final String myModule;
   private final String myFunction;
   private final OtpErlangList myFunctionArgs;
   private final Collection<ErlangVariableBinding> myBindings;
 
-  public ErlangTraceElement(@NotNull String module, @NotNull String function, @NotNull OtpErlangList functionArgs,
-                            @NotNull Collection<ErlangVariableBinding> bindings) {
+  public ErlangTraceElement(@Nullable OtpErlangObject stackPointer, @NotNull String module, @NotNull String function,
+                            @NotNull OtpErlangList functionArgs, @NotNull Collection<ErlangVariableBinding> bindings) {
+    myStackPointer = stackPointer;
     myModule = module;
     myFunction = function;
     myFunctionArgs = functionArgs;
     myBindings = bindings;
   }
 
+  @Nullable
+  public OtpErlangObject getStackPointer() { return myStackPointer; }
+
   @NotNull
   public String getModule() {
     return myModule;
diff --git a/src/org/intellij/erlang/debugger/node/commands/ErlangDebuggerCommandsProducer.java b/src/org/intellij/erlang/debugger/node/commands/ErlangDebuggerCommandsProducer.java
@@ -18,6 +18,7 @@
 
 import com.ericsson.otp.erlang.*;
 import com.intellij.openapi.util.text.StringUtil;
+import org.intellij.erlang.debugger.node.ErlangTraceElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -72,6 +73,11 @@ public static ErlangDebuggerCommand getContinueCommand(@NotNull OtpErlangPid pid
     return new ContinueCommand(pid);
   }
 
+  @NotNull
+  public static ErlangDebuggerCommand getEvaluateCommand(@NotNull OtpErlangPid pid, @NotNull String expression, @NotNull ErlangTraceElement traceElement) {
+    return new EvaluateCommand(pid, expression, traceElement);
+  }
+
   private static class StepOverCommand extends AbstractPidCommand {
     public StepOverCommand(@NotNull OtpErlangPid pid) {
       super("step_over", pid);
@@ -216,6 +222,34 @@ public OtpErlangTuple toMessage() {
     }
   }
 
+  private static class EvaluateCommand implements ErlangDebuggerCommand {
+    private final OtpErlangPid myPid;
+    private final String myExpression;
+    private final ErlangTraceElement myTraceElement;
+
+    public EvaluateCommand(@NotNull OtpErlangPid pid, @NotNull String expression, @NotNull ErlangTraceElement traceElement) {
+      myPid = pid;
+      myExpression = expression;
+      myTraceElement = traceElement;
+    }
+
+    @NotNull
+    @Override
+    public OtpErlangTuple toMessage() {
+      OtpErlangObject stackPointer = myTraceElement.getStackPointer();
+      if (stackPointer == null) {
+        stackPointer = new OtpErlangAtom("undefined");
+      }
+
+      return new OtpErlangTuple(new OtpErlangObject[] {
+        new OtpErlangAtom("evaluate"),
+        myPid,
+        new OtpErlangList(myExpression),
+        stackPointer
+      });
+    }
+  }
+
   public interface ErlangDebuggerCommand {
     @NotNull
     OtpErlangTuple toMessage();
diff --git a/src/org/intellij/erlang/debugger/node/events/BreakpointReachedEvent.java b/src/org/intellij/erlang/debugger/node/events/BreakpointReachedEvent.java
@@ -48,7 +48,7 @@ public BreakpointReachedEvent(OtpErlangTuple breakpointReachedMessage) throws De
       OtpErlangTuple snapshotTuple = getTupleValue(snapshot); // {Pid, Function, Status, Info, Stack}
 
       OtpErlangPid pid = getPidValue(elementAt(snapshotTuple, 0));
-      ErlangTraceElement init = getTraceElement(getTupleValue(elementAt(snapshotTuple, 1)), null);
+      ErlangTraceElement init = getTraceElement(getTupleValue(elementAt(snapshotTuple, 1)), null, null);
       String status = getAtomText(elementAt(snapshotTuple, 2));
       OtpErlangObject info = elementAt(snapshotTuple, 3);
       List<ErlangTraceElement> stack = getStack(getListValue(elementAt(snapshotTuple, 4)));
@@ -86,10 +86,10 @@ private static List<ErlangTraceElement> getStack(@Nullable OtpErlangList traceEl
     List<ErlangTraceElement> stack = new ArrayList<>(traceElementsList.arity());
     for (OtpErlangObject traceElementObject : traceElementsList) {
       OtpErlangTuple traceElementTuple = getTupleValue(traceElementObject);
-      // ignoring SP at 0
+      OtpErlangObject stackPointer = getTupleValue(elementAt(traceElementTuple, 0));
       OtpErlangTuple moduleFunctionArgsTuple = getTupleValue(elementAt(traceElementTuple, 1));
       OtpErlangList bindingsList = getListValue(elementAt(traceElementTuple, 2));
-      ErlangTraceElement traceElement = getTraceElement(moduleFunctionArgsTuple, bindingsList);
+      ErlangTraceElement traceElement = getTraceElement(moduleFunctionArgsTuple, stackPointer, bindingsList);
       if (traceElement == null) return null;
       stack.add(traceElement);
     }
@@ -98,13 +98,14 @@ private static List<ErlangTraceElement> getStack(@Nullable OtpErlangList traceEl
 
   @Nullable
   private static ErlangTraceElement getTraceElement(@Nullable OtpErlangTuple moduleFunctionArgsTuple,
+                                                    @Nullable OtpErlangObject stackPointer,
                                                     @Nullable OtpErlangList bindingsList) {
     String moduleName = getAtomText(elementAt(moduleFunctionArgsTuple, 0));
     String functionName = getAtomText(elementAt(moduleFunctionArgsTuple, 1));
     OtpErlangList args = getListValue(elementAt(moduleFunctionArgsTuple, 2));
     Collection<ErlangVariableBinding> bindings = getBindings(bindingsList);
     if (moduleName == null || functionName == null || args == null) return null; // bindings are not necessarily present
-    return new ErlangTraceElement(moduleName, functionName, args, bindings);
+    return new ErlangTraceElement(stackPointer, moduleName, functionName, args, bindings);
   }
 
   @NotNull
diff --git a/src/org/intellij/erlang/debugger/node/events/ErlangDebuggerEvent.java b/src/org/intellij/erlang/debugger/node/events/ErlangDebuggerEvent.java
@@ -34,10 +34,18 @@ public static ErlangDebuggerEvent create(OtpErlangObject message) {
     if (messageName == null) return null;
 
     try {
-      if (InterpretModulesResponseEvent.NAME.equals(messageName)) return new InterpretModulesResponseEvent(messageTuple);
-      if (SetBreakpointResponseEvent.NAME.equals(messageName)) return new SetBreakpointResponseEvent(messageTuple);
-      if (BreakpointReachedEvent.NAME.equals(messageName)) return new BreakpointReachedEvent(messageTuple);
-      if (DebugRemoteNodeResponseEvent.NAME.equals(messageName)) return new DebugRemoteNodeResponseEvent(messageTuple);
+      switch (messageName) {
+        case InterpretModulesResponseEvent.NAME:
+          return new InterpretModulesResponseEvent(messageTuple);
+        case SetBreakpointResponseEvent.NAME:
+          return new SetBreakpointResponseEvent(messageTuple);
+        case BreakpointReachedEvent.NAME:
+          return new BreakpointReachedEvent(messageTuple);
+        case DebugRemoteNodeResponseEvent.NAME:
+          return new DebugRemoteNodeResponseEvent(messageTuple);
+        case EvaluateResponseEvent.NAME:
+          return new EvaluateResponseEvent(messageTuple);
+      }
     } catch (DebuggerEventFormatException e) {
       return new UnknownMessageEvent(messageTuple);
     }
diff --git a/src/org/intellij/erlang/debugger/node/events/EvaluateResponseEvent.java b/src/org/intellij/erlang/debugger/node/events/EvaluateResponseEvent.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2012-2014 Sergey Ignatov
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.intellij.erlang.debugger.node.events;
+
+import com.ericsson.otp.erlang.OtpErlangObject;
+import com.ericsson.otp.erlang.OtpErlangTuple;
+import org.intellij.erlang.debugger.node.ErlangDebuggerEventListener;
+import org.intellij.erlang.debugger.node.ErlangDebuggerNode;
+
+class EvaluateResponseEvent extends ErlangDebuggerEvent {
+  public static final String NAME = "evaluate_response";
+  private final OtpErlangObject myResponse;
+
+  public EvaluateResponseEvent(OtpErlangTuple receivedMessage) throws DebuggerEventFormatException {
+    OtpErlangObject[] elements = receivedMessage.elements();
+    if (elements.length != 2) {
+      throw new DebuggerEventFormatException();
+    }
+
+    myResponse = elements[1];
+  }
+
+  @Override
+  public void process(ErlangDebuggerNode debuggerNode, ErlangDebuggerEventListener eventListener) {
+    eventListener.handleEvaluationResponse(myResponse);
+  }
+}
diff --git a/src/org/intellij/erlang/debugger/xdebug/ErlangExecutionStack.java b/src/org/intellij/erlang/debugger/xdebug/ErlangExecutionStack.java
@@ -27,13 +27,13 @@
 import java.util.List;
 
 public class ErlangExecutionStack extends XExecutionStack {
-  private final ErlangDebugLocationResolver myResolver;
+  private final ErlangXDebugProcess myDebugProcess;
   private final ErlangProcessSnapshot myProcessSnapshot;
   private final List<ErlangStackFrame> myStack;
 
-  public ErlangExecutionStack(ErlangDebugLocationResolver resolver, ErlangProcessSnapshot snapshot) {
+  public ErlangExecutionStack(ErlangXDebugProcess debugProcess, ErlangProcessSnapshot snapshot) {
     super(snapshot.getPidString());
-    myResolver = resolver;
+    myDebugProcess = debugProcess;
     myProcessSnapshot = snapshot;
     myStack = new ArrayList<>(snapshot.getStack().size());
   }
@@ -51,8 +51,8 @@ public void computeStackFrames(int firstFrameIndex, XStackFrameContainer contain
       for (ErlangTraceElement traceElement : traceElements) {
         boolean isTopStackFrame = myStack.isEmpty(); // if it's a top stack frame we can set a line that's being executed.
         ErlangStackFrame stackFrame = isTopStackFrame ?
-          new ErlangStackFrame(myResolver, traceElement, ErlangSourcePosition.create(myResolver, myProcessSnapshot)) :
-          new ErlangStackFrame(myResolver, traceElement);
+          new ErlangStackFrame(myDebugProcess, traceElement, ErlangSourcePosition.create(myDebugProcess.getLocationResolver(), myProcessSnapshot)) :
+          new ErlangStackFrame(myDebugProcess, traceElement);
         myStack.add(stackFrame);
       }
       container.addStackFrames(myStack, true);
diff --git a/src/org/intellij/erlang/debugger/xdebug/ErlangStackFrame.java b/src/org/intellij/erlang/debugger/xdebug/ErlangStackFrame.java
@@ -22,6 +22,7 @@
 import com.intellij.ui.ColoredTextContainer;
 import com.intellij.ui.SimpleTextAttributes;
 import com.intellij.xdebugger.XSourcePosition;
+import com.intellij.xdebugger.evaluation.XDebuggerEvaluator;
 import com.intellij.xdebugger.frame.XCompositeNode;
 import com.intellij.xdebugger.frame.XStackFrame;
 import com.intellij.xdebugger.frame.XValue;
@@ -37,23 +38,36 @@
 import org.jetbrains.annotations.Nullable;
 
 public class ErlangStackFrame extends XStackFrame {
-  private final ErlangDebugLocationResolver myResolver;
+  private final ErlangXDebugProcess myDebugProcess;
   private final ErlangTraceElement myTraceElement;
   private final ErlangSourcePosition mySourcePosition;
 
-  public ErlangStackFrame(@NotNull ErlangDebugLocationResolver resolver,
+  public ErlangStackFrame(@NotNull ErlangXDebugProcess debugProcess,
                           @NotNull ErlangTraceElement traceElement) {
-    this(resolver, traceElement, ErlangSourcePosition.create(resolver, traceElement));
+    this(debugProcess, traceElement, ErlangSourcePosition.create(debugProcess.getLocationResolver(), traceElement));
   }
 
-  public ErlangStackFrame(@NotNull ErlangDebugLocationResolver resolver,
+  public ErlangStackFrame(@NotNull ErlangXDebugProcess debugProcess,
                           @NotNull ErlangTraceElement traceElement,
                           @Nullable ErlangSourcePosition sourcePosition) {
-    myResolver = resolver;
+    myDebugProcess = debugProcess;
     myTraceElement = traceElement;
     mySourcePosition = sourcePosition;
   }
 
+  @Nullable
+  @Override
+  public XDebuggerEvaluator getEvaluator() {
+    return new XDebuggerEvaluator() {
+      @Override
+      public void evaluate(@NotNull String expression,
+                           @NotNull XEvaluationCallback callback,
+                           @Nullable XSourcePosition expressionPosition) {
+        myDebugProcess.evaluateExpression(expression, callback, myTraceElement);
+      }
+    };
+  }
+
   @Nullable
   @Override
   public XSourcePosition getSourcePosition() {
@@ -65,7 +79,7 @@ public XSourcePosition getSourcePosition() {
   public void customizePresentation(@NotNull ColoredTextContainer component) {
     String functionName = mySourcePosition != null ? mySourcePosition.getFunctionName() : null;
     if (functionName != null) {
-      ErlangFile module = myResolver.findPsi(mySourcePosition.getSourcePosition().getFile());
+      ErlangFile module = myDebugProcess.getLocationResolver().findPsi(mySourcePosition.getSourcePosition().getFile());
       ErlangFunction function = module != null ? module.getFunction(functionName, mySourcePosition.getFunctionArity()) : null;
       if (function != null) {
         String title = ErlangPsiImplUtil.getQualifiedFunctionName(function);
diff --git a/src/org/intellij/erlang/debugger/xdebug/ErlangSuspendContext.java b/src/org/intellij/erlang/debugger/xdebug/ErlangSuspendContext.java
@@ -29,7 +29,7 @@ public class ErlangSuspendContext extends XSuspendContext {
   private final XExecutionStack[] myExecutionStacks;
   private final int myActiveStackIdx;
 
-  public ErlangSuspendContext(@NotNull ErlangDebugLocationResolver resolver,
+  public ErlangSuspendContext(@NotNull ErlangXDebugProcess debugProcess,
                               @NotNull OtpErlangPid activePid,
                               @NotNull List<ErlangProcessSnapshot> snapshots) {
     myExecutionStacks = new XExecutionStack[snapshots.size()];
@@ -39,7 +39,7 @@ public ErlangSuspendContext(@NotNull ErlangDebugLocationResolver resolver,
       if (snapshot.getPid().equals(activePid)) {
         activeStackIdx = i;
       }
-      myExecutionStacks[i] = new ErlangExecutionStack(resolver, snapshot);
+      myExecutionStacks[i] = new ErlangExecutionStack(debugProcess, snapshot);
     }
     myActiveStackIdx = activeStackIdx;
   }
diff --git a/src/org/intellij/erlang/debugger/xdebug/ErlangXDebugProcess.java b/src/org/intellij/erlang/debugger/xdebug/ErlangXDebugProcess.java
