DataflowError.withoutTrace shall not store a trace

CHANGELOG.md

@@ -1010,6 +1010,7 @@
 - [Export of non-existing symbols results in error][7960]
 - [Upgrade GraalVM to 23.1.0 JDK21][7991]
 - [Added opt-in type checks of return type][8502]
+- [DataflowError.withoutTrace doesn't store stacktrace][8608]
 - [Added text_length to Column][8606]
 
 [3227]: https://github.com/enso-org/enso/pull/3227
@@ -1162,6 +1163,7 @@
 [7960]: https://github.com/enso-org/enso/pull/7960
 [7991]: https://github.com/enso-org/enso/pull/7991
 [8502]: https://github.com/enso-org/enso/pull/8502
+[8608]: https://github.com/enso-org/enso/pull/8608
 [8606]: https://github.com/enso-org/enso/pull/8606
 
 # Enso 2.0.0-alpha.18 (2021-10-12)

distribution/lib/Standard/Visualization/0.0.0-dev/src/Preprocessor.enso

@@ -24,7 +24,7 @@ error_preprocessor x =
         message = err.to_display_text
         stack_trace = x.get_stack_trace_text.if_nothing "" . split '\n'
         truncated_message = Helpers.truncate message
-        full_message = truncated_message + if stack_trace.length > 1 then " (" + stack_trace.at 1 . trim +")" else ""
+        full_message = truncated_message + if stack_trace.length > 0 then " (" + stack_trace.at 0 . trim +")" else ""
         JS_Object.from_pairs [['kind', 'Dataflow'], ['message', full_message]] . to_json
 
     if result.is_error then result.catch else ok

engine/runtime-instrument-common/src/main/scala/org/enso/interpreter/instrument/execution/ErrorResolver.scala

@@ -1,10 +1,10 @@
 package org.enso.interpreter.instrument.execution
 
-import com.oracle.truffle.api.{TruffleStackTrace, TruffleStackTraceElement}
+import com.oracle.truffle.api.interop.InteropLibrary
 import org.enso.polyglot.runtime.Runtime.Api
+import org.enso.interpreter.node.expression.builtin.runtime.GetStackTraceNode
 
 import java.io.File
-import scala.jdk.CollectionConverters._
 import scala.jdk.OptionConverters.RichOptional
 
 /** Methods for handling exceptions in the interpreter. */
@@ -19,42 +19,50 @@ object ErrorResolver {
   def getStackTrace(
     throwable: Throwable
   )(implicit ctx: RuntimeContext): Vector[Api.StackTraceElement] = {
-    TruffleStackTrace
-      .getStackTrace(throwable)
-      .asScala
-      .flatMap(toStackElement)
-      .toVector
+    val iop = InteropLibrary.getUncached
+    val arr = GetStackTraceNode.stackTraceToArray(iop, throwable)
+    val len = iop.getArraySize(arr)
+    val stackWithOptions = for (i <- 0L until len) yield {
+      val elem = iop.readArrayElement(arr, i)
+      toStackElement(iop, elem)
+    }
+    val stack = stackWithOptions.map(op => op.get)
+    stack.toVector
   }
 
   /** Convert from the truffle stack element to the runtime API representation.
     *
+    * @param iop interop library to use
     * @param element the trufle stack trace element
     * @param ctx the runtime context
     * @return the runtime API representation of the stack trace element
     */
   private def toStackElement(
-    element: TruffleStackTraceElement
+    iop: InteropLibrary,
+    element: Any
   )(implicit ctx: RuntimeContext): Option[Api.StackTraceElement] = {
-    val node = Option(element.getLocation)
-    node.flatMap(x => {
-      x.getEncapsulatingSourceSection match {
-        case null if x.getRootNode == null =>
+    if (!iop.hasExecutableName(element)) {
+      None
+    } else {
+      val name = iop.asString(iop.getExecutableName(element))
+      if (!iop.hasSourceLocation(element)) {
+        Some(Api.StackTraceElement(name, None, None, None))
+      } else {
+        val section = iop.getSourceLocation(element)
+        if (section.getSource.isInternal) {
           None
-        case null if x.getRootNode.isInternal =>
-          None
-        case null =>
-          Some(Api.StackTraceElement(x.getRootNode.getName, None, None, None))
-        case section =>
+        } else {
           Some(
             Api.StackTraceElement(
-              element.getTarget.getRootNode.getName,
+              name,
               findFileByModuleName(section.getSource.getName),
               Some(LocationResolver.sectionToRange(section)),
               LocationResolver.getExpressionId(section).map(_.externalId)
             )
           )
+        }
       }
-    })
+    }
   }
 
   /** Find source file path by the module name.

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/error/GetAttachedStackTraceNode.java

@@ -1,26 +1,19 @@
 package org.enso.interpreter.node.expression.builtin.error;
 
+import com.oracle.truffle.api.interop.InteropLibrary;
 import com.oracle.truffle.api.nodes.Node;
 import org.enso.interpreter.dsl.AcceptsError;
 import org.enso.interpreter.dsl.BuiltinMethod;
 import org.enso.interpreter.node.expression.builtin.runtime.GetStackTraceNode;
-import org.enso.interpreter.runtime.EnsoContext;
-import org.enso.interpreter.runtime.builtin.Builtins;
-import org.enso.interpreter.runtime.data.EnsoObject;
-import org.enso.interpreter.runtime.error.PanicException;
 
 @BuiltinMethod(
     type = "Panic",
     name = "primitive_get_attached_stack_trace",
     description = "Gets the stack trace attached to the throwable.")
 public class GetAttachedStackTraceNode extends Node {
-  EnsoObject execute(@AcceptsError Object error) {
-    if (error instanceof Throwable) {
-      return GetStackTraceNode.stackTraceToArray((Throwable) error);
-    } else {
-      Builtins builtins = EnsoContext.get(this).getBuiltins();
-      throw new PanicException(
-          builtins.error().makeTypeError("Throwable", error, "throwable"), this);
-    }
+  @Child private InteropLibrary iop = InteropLibrary.getFactory().createDispatched(3);
+
+  Object execute(@AcceptsError Object error) {
+    return GetStackTraceNode.stackTraceToArray(iop, error);
   }
 }

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/error/ThrowErrorNode.java

@@ -8,7 +8,8 @@
 @BuiltinMethod(
     type = "Error",
     name = "throw",
-    description = "Returns a new value error with given payload.")
+    description = "Returns a new value error with given payload.",
+    inlineable = true)
 public class ThrowErrorNode extends Node {
   public Object execute(VirtualFrame giveMeAStackFrame, Object payload) {
     return DataflowError.withoutTrace(payload, this);

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/immutable/AtVectorNode.java

@@ -8,6 +8,7 @@
 import org.enso.interpreter.runtime.data.vector.ArrayLikeAtNode;
 import org.enso.interpreter.runtime.data.vector.ArrayLikeLengthNode;
 import org.enso.interpreter.runtime.error.DataflowError;
+import org.enso.interpreter.runtime.error.PanicException;
 
 @BuiltinMethod(
     type = "Array_Like_Helpers",
@@ -25,7 +26,7 @@ Object execute(Object arrayLike, long index) {
       var len = len(arrayLike);
       var ctx = EnsoContext.get(this);
       var payload = ctx.getBuiltins().error().makeIndexOutOfBounds(index, len);
-      return DataflowError.withoutTrace(payload, this);
+      return DataflowError.withTrace(payload, new PanicException(payload, this));
     }
   }
 

engine/runtime/src/main/java/org/enso/interpreter/node/expression/builtin/runtime/GetStackTraceNode.java

@@ -2,9 +2,14 @@
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.TruffleStackTrace;
+import com.oracle.truffle.api.TruffleStackTraceElement;
 import com.oracle.truffle.api.dsl.NeverDefault;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.InteropLibrary;
+import com.oracle.truffle.api.interop.InvalidArrayIndexException;
+import com.oracle.truffle.api.interop.UnsupportedMessageException;
 import com.oracle.truffle.api.nodes.Node;
+import java.util.List;
 import org.enso.interpreter.dsl.BuiltinMethod;
 import org.enso.interpreter.runtime.data.EnsoObject;
 import org.enso.interpreter.runtime.data.text.Text;
@@ -23,34 +28,87 @@ public static GetStackTraceNode create() {
     return new GetStackTraceNode();
   }
 
+  @CompilerDirectives.TruffleBoundary
+  private static EnsoObject wrapStackTraceElements(List<TruffleStackTraceElement> elements) {
+    var arr = new Object[elements.size()];
+    for (var i = 0; i < arr.length; i++) {
+      var e = elements.get(i);
+      arr[i] = e.getGuestObject();
+    }
+    var vector = ArrayLikeHelpers.asVectorWithCheckAt(arr);
+    try {
+      return filterStackTraceVector(InteropLibrary.getUncached(), vector);
+    } catch (UnsupportedMessageException ex) {
+      return ArrayLikeHelpers.empty();
+    }
+  }
+
+  private static boolean includeFrame(InteropLibrary iop, Object elem)
+      throws UnsupportedMessageException {
+    if (!iop.hasSourceLocation(elem)) {
+      return false;
+    }
+    var ss = iop.getSourceLocation(elem);
+    if (ss == null) {
+      return false;
+    }
+    var src = ss.getSource();
+    return src != null && src.hasCharacters() && !src.isInternal();
+  }
+
+  private static EnsoObject filterStackTraceVector(InteropLibrary iop, Object elements)
+      throws UnsupportedMessageException {
+    var size = iop.getArraySize(elements);
+    var count = 0;
+    for (long i = 0; i < size; i++) {
+      try {
+        var element = iop.readArrayElement(elements, i);
+        if (includeFrame(iop, element)) {
+          count++;
+        }
+      } catch (InvalidArrayIndexException ex) {
+      }
+    }
+    var arr = new Object[count];
+    var at = 0;
+    for (long i = 0; i < size; i++) {
+      try {
+        var element = iop.readArrayElement(elements, i);
+        if (includeFrame(iop, element)) {
+          arr[at++] = element;
+        }
+      } catch (InvalidArrayIndexException ex) {
+      }
+    }
+    return ArrayLikeHelpers.wrapObjectsWithCheckAt(arr);
+  }
+
   EnsoObject execute(VirtualFrame requestOwnStackFrame) {
     var exception = new PanicException(Text.create("Stacktrace"), this);
     TruffleStackTrace.fillIn(exception);
     return stackTraceToArray(exception);
   }
 
+  public static EnsoObject stackTraceToArray(InteropLibrary iop, Object exception) {
+    if (iop.hasExceptionStackTrace(exception)) {
+      try {
+        var elements = iop.getExceptionStackTrace(exception);
+        return filterStackTraceVector(iop, elements);
+      } catch (UnsupportedMessageException ex) {
+        // return empty
+      }
+    } else if (exception instanceof Throwable t) {
+      return stackTraceToArray(t);
+    }
+    return ArrayLikeHelpers.empty();
+  }
+
   @CompilerDirectives.TruffleBoundary
-  public static EnsoObject stackTraceToArray(Throwable exception) {
+  private static EnsoObject stackTraceToArray(Throwable exception) {
     var elements = TruffleStackTrace.getStackTrace(exception);
     if (elements == null) {
       return ArrayLikeHelpers.empty();
     }
-    int count = 0;
-    for (int i = 0; i < elements.size(); i++) {
-      var element = elements.get(i);
-      if (element.getTarget().getRootNode().isInternal()) {
-        continue;
-      }
-      count++;
-    }
-    var arr = new Object[count];
-    for (int i = 0, at = 0; i < elements.size(); i++) {
-      var element = elements.get(i);
-      if (element.getTarget().getRootNode().isInternal()) {
-        continue;
-      }
-      arr[at++] = element.getGuestObject();
-    }
-    return ArrayLikeHelpers.wrapObjectsWithCheckAt(arr);
+    return wrapStackTraceElements(elements);
   }
 }

engine/runtime/src/main/java/org/enso/interpreter/runtime/error/DataflowError.java

@@ -2,6 +2,7 @@
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.TruffleStackTrace;
+import com.oracle.truffle.api.TruffleStackTraceElement;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.exception.AbstractTruffleException;
 import com.oracle.truffle.api.interop.InteropLibrary;
@@ -13,6 +14,7 @@
 import java.util.Objects;
 import org.enso.interpreter.runtime.EnsoContext;
 import org.enso.interpreter.runtime.data.Type;
+import org.enso.interpreter.runtime.data.vector.ArrayLikeHelpers;
 import org.enso.interpreter.runtime.library.dispatch.TypesLibrary;
 
 /**
@@ -28,6 +30,7 @@ public final class DataflowError extends AbstractTruffleException {
   public static final DataflowError UNINITIALIZED = new DataflowError(null, (Node) null);
 
   private final Object payload;
+  private final boolean without;
 
   /**
    * Construct a new dataflow error with the default stack trace.
@@ -40,8 +43,7 @@ public final class DataflowError extends AbstractTruffleException {
    */
   public static DataflowError withoutTrace(Object payload, Node location) {
     assert payload != null;
-    DataflowError result = new DataflowError(payload, location);
-    TruffleStackTrace.fillIn(result);
+    var result = new DataflowError(payload, location);
     return result;
   }
 
@@ -57,17 +59,21 @@ public static DataflowError withoutTrace(Object payload, Node location) {
    */
   public static DataflowError withTrace(Object payload, AbstractTruffleException prototype) {
     assert payload != null;
-    return new DataflowError(payload, prototype);
+    var result = new DataflowError(payload, prototype);
+    TruffleStackTrace.fillIn(result);
+    return result;
   }
 
   DataflowError(Object payload, Node location) {
-    super(location);
+    super(null, null, 1, location);
     this.payload = payload;
+    this.without = true;
   }
 
   DataflowError(Object payload, AbstractTruffleException prototype) {
     super(prototype);
     this.payload = payload;
+    this.without = false;
   }
 
   /**
@@ -116,6 +122,22 @@ boolean isException() {
     return true;
   }
 
+  @ExportMessage
+  boolean hasExceptionStackTrace() {
+    var node = this.getLocation();
+    return node != null && node.getRootNode() != null && without;
+  }
+
+  @ExportMessage
+  Object getExceptionStackTrace() throws UnsupportedMessageException {
+    var node = this.getLocation();
+    if (node == null || node.getRootNode() == null || !without) {
+      throw UnsupportedMessageException.create();
+    }
+    var frame = TruffleStackTraceElement.create(node, node.getRootNode().getCallTarget(), null);
+    return ArrayLikeHelpers.asVectorWithCheckAt(frame.getGuestObject());
+  }
+
   @ExportMessage
   boolean isNull() {
     return payload == null;