Improving the expression evaluator

 * right after evaluating an expression, the erlang debugger will trigger a new
   "breakpoint reached" event; unfortunately, that means this plugin will try to
   concurrently render the new state of the bindings as well as the result from
   the evaluation, which Intellij doesn't seem to handle too well, resulting in
   the debugging session losing track of what the current frame is... so to fix
   that we just ignore the next "breakpoint reached" event occuring in an Erlang
   process right after evaluating an expression in that process. Better ideas
   welcome!
 * checking whether the evaluation resulted in an error, and nicely formatting
   it in if that's the case

Author: wk8

src/org/intellij/erlang/debugger/node/ErlangDebuggerNode.java

@@ -69,6 +69,8 @@ public int getLocalDebuggerPort() {
     return myLocalDebuggerPort;
   }
 
+  public OtpErlangPid getLastSuspendedPid() { return myLastSuspendedPid; }
+
   public void stop() {
     myStopped.set(true);
   }

src/org/intellij/erlang/debugger/xdebug/ErlangXDebugProcess.java

@@ -16,8 +16,10 @@
 
 package org.intellij.erlang.debugger.xdebug;
 
+import com.ericsson.otp.erlang.OtpErlangAtom;
 import com.ericsson.otp.erlang.OtpErlangObject;
 import com.ericsson.otp.erlang.OtpErlangPid;
+import com.ericsson.otp.erlang.OtpErlangTuple;
 import com.intellij.execution.ExecutionException;
 import com.intellij.execution.configurations.GeneralCommandLine;
 import com.intellij.execution.process.OSProcessHandler;
@@ -72,7 +74,6 @@
 import static org.intellij.erlang.debugger.ErlangDebuggerLog.LOG;
 
 public class ErlangXDebugProcess extends XDebugProcess implements ErlangDebuggerEventListener {
-  private final XDebugSession mySession;
   private final ExecutionEnvironment myExecutionEnvironment;
   private final ErlangRunningState myRunningState;
   private final ErlangDebuggerNode myDebuggerNode;
@@ -83,11 +84,16 @@ public class ErlangXDebugProcess extends XDebugProcess implements ErlangDebugger
   private ConcurrentHashMap<ErlangSourcePosition, XLineBreakpoint<ErlangLineBreakpointProperties>> myPositionToLineBreakpointMap =
     new ConcurrentHashMap<>();
   private XDebuggerEvaluator.XEvaluationCallback myEvalCallback = null;
+  // right after evaluating an expression, the erlang debugger will trigger a new "breakpoint reached" event
+  // unfortunately, that means this plugin will try to concurrently render the new state of the bindings as
+  // well as the result from the evaluation, which Intellij doesn't seem to handle too well, resulting in
+  // the debugging session losing track of what the current frame is... so we just ignore the next "breakpoint
+  // reached" event in the same process right after evaluating an expression - better ideas welcome!
+  private OtpErlangPid ignoreNextBreakpointReachedEventFor = null;
 
   public ErlangXDebugProcess(@NotNull XDebugSession session, ExecutionEnvironment env) throws ExecutionException {
     //TODO add debug build targets and make sure the project is built using them.
     super(session);
-    mySession = session;
 
     session.setPauseActionSupported(false);
 
@@ -124,20 +130,48 @@ public ErlangDebugLocationResolver getLocationResolver() {
   public synchronized void evaluateExpression(@NotNull String expression,
                                               @NotNull XDebuggerEvaluator.XEvaluationCallback callback,
                                               @NotNull ErlangTraceElement traceElement) {
-    // need to pause the debugging session otherwise the callback might get invalidated
-    mySession.pause();
     myEvalCallback = callback;
+    // see the comment about ignoreNextBreakpointReachedEventFor
+    ignoreNextBreakpointReachedEventFor = myDebuggerNode.getLastSuspendedPid();
     myDebuggerNode.evaluate(expression, traceElement);
   }
 
   @Override
   public synchronized void handleEvaluationResponse(OtpErlangObject response) {
     if (myEvalCallback != null) {
-      myEvalCallback.evaluated(ErlangXValueFactory.create(response));
-      mySession.resume();
+      String error = maybeExtractErrorFromEvaluationResponse(response);
+
+      if (error == null) {
+        myEvalCallback.evaluated(ErlangXValueFactory.create(response));
+      }
+      else {
+        myEvalCallback.errorOccurred(error);
+      }
     }
   }
 
+  // Parses the response from an evaluation and determines whether it's an error
+  // response or not; if it is an error, formats it as a displayable string, if
+  // it's not, just returns null
+  private static String maybeExtractErrorFromEvaluationResponse(OtpErlangObject response) {
+    // is it a parsing error?
+    if (response instanceof OtpErlangAtom && ((OtpErlangAtom) response).atomValue().equals("Parse error")) {
+      return "Parse error";
+    }
+
+    // is it an uncaught exception?
+    if (response instanceof OtpErlangTuple) {
+      OtpErlangObject[] elements = ((OtpErlangTuple) response).elements();
+      if (elements.length == 2
+          && elements[0] instanceof OtpErlangAtom
+          && ((OtpErlangAtom) elements[0]).atomValue().equals("EXIT")) {
+        return "Uncaught exception: " + elements[1];
+      }
+    }
+
+    return null;
+  }
+
   @Override
   public void debuggerStarted() {
     getSession().reportMessage("Debug process started", MessageType.INFO);
@@ -177,7 +211,13 @@ public void breakpointIsSet(String module, int line) {
   }
 
   @Override
-  public void breakpointReached(final OtpErlangPid pid, List<ErlangProcessSnapshot> snapshots) {
+  public synchronized void breakpointReached(final OtpErlangPid pid, List<ErlangProcessSnapshot> snapshots) {
+    if (pid.equals(ignoreNextBreakpointReachedEventFor)) {
+      // see the comment about ignoreNextBreakpointReachedEventFor
+      ignoreNextBreakpointReachedEventFor = null;
+      return;
+    }
+
     ErlangProcessSnapshot processInBreakpoint = ContainerUtil.find(snapshots, erlangProcessSnapshot -> erlangProcessSnapshot.getPid().equals(pid));
     assert processInBreakpoint != null;
     ErlangSourcePosition breakPosition = ErlangSourcePosition.create(myLocationResolver, processInBreakpoint);