[GR-17066] Get the TruffleStackTrace of non-Ruby exceptions in ExceptionTranslatingNode.

PullRequest: truffleruby/941

Author: eregon

src/main/java/org/truffleruby/core/exception/CoreExceptions.java

@@ -246,6 +246,13 @@ public DynamicObject runtimeError(String fullMessage, Node currentNode, Throwabl
         return ExceptionOperations.createRubyException(context, exceptionClass, errorMessage, currentNode, javaThrowable);
     }
 
+    @TruffleBoundary
+    public DynamicObject runtimeError(String fullMessage, Backtrace backtrace) {
+        DynamicObject exceptionClass = context.getCoreLibrary().getRuntimeErrorClass();
+        DynamicObject errorMessage = StringOperations.createString(context, StringOperations.encodeRope(fullMessage, UTF8Encoding.INSTANCE));
+        return ExceptionOperations.createRubyException(context, exceptionClass, errorMessage, backtrace);
+    }
+
     // SystemStackError
 
     @TruffleBoundary

src/main/java/org/truffleruby/core/exception/ExceptionOperations.java

@@ -71,7 +71,7 @@ public static DynamicObject createSystemCallError(RubyContext context, DynamicOb
 
     // because the factory is not constant
     @TruffleBoundary
-    private static DynamicObject createRubyException(RubyContext context, DynamicObject rubyClass, Object message, Backtrace backtrace) {
+    public static DynamicObject createRubyException(RubyContext context, DynamicObject rubyClass, Object message, Backtrace backtrace) {
         final DynamicObject cause = ThreadGetExceptionNode.getLastException(context);
         context.getCoreExceptions().showExceptionIfDebug(rubyClass, message, backtrace);
         return Layouts.CLASS.getInstanceFactory(rubyClass).newInstance(Layouts.EXCEPTION.build(message, null, backtrace, cause));

src/main/java/org/truffleruby/language/backtrace/Backtrace.java

@@ -45,6 +45,24 @@ public Backtrace(Node location, SourceSection sourceLocation, int omitted, Throw
         this.javaThrowable = javaThrowable;
     }
 
+    public Backtrace(TruffleException exception) {
+        this.location = exception.getLocation();
+        this.sourceLocation = exception.getSourceLocation();
+        this.omitted = 0;
+        this.javaThrowable = null;
+
+        this.activations = getActivations((Throwable) exception);
+    }
+
+    public Backtrace(Throwable exception) {
+        this.location = null;
+        this.sourceLocation = null;
+        this.omitted = 0;
+        this.javaThrowable = null;
+
+        this.activations = getActivations(exception);
+    }
+
     public Backtrace copy(RubyContext context, DynamicObject exception) {
         Backtrace copy = new Backtrace(location, sourceLocation, omitted, javaThrowable);
         // A Backtrace is 1-1-1 with a RaiseException and a Ruby exception
@@ -81,15 +99,15 @@ public Activation[] getActivations() {
     }
 
     @TruffleBoundary
-    public Activation[] getActivations(TruffleException truffleException) {
+    public Activation[] getActivations(Throwable truffleException) {
         if (this.activations == null) {
             if (truffleException == null) {
                 truffleException = new GetBacktraceException(location, GetBacktraceException.UNLIMITED);
             }
 
             // The stacktrace is computed here if it was not already computed and stored in the
             // TruffleException with TruffleStackTraceElement.fillIn().
-            final List<TruffleStackTraceElement> stackTrace = TruffleStackTrace.getStackTrace((Throwable) truffleException);
+            final List<TruffleStackTraceElement> stackTrace = TruffleStackTrace.getStackTrace(truffleException);
 
             final List<Activation> activations = new ArrayList<>();
             final RubyContext context = RubyLanguage.getCurrentContext();

src/main/java/org/truffleruby/language/methods/ExceptionTranslatingNode.java

@@ -11,6 +11,7 @@
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.TruffleException;
+import com.oracle.truffle.api.TruffleStackTrace;
 import com.oracle.truffle.api.dsl.UnsupportedSpecializationException;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.ControlFlowException;
@@ -19,6 +20,7 @@
 import org.truffleruby.Layouts;
 import org.truffleruby.language.RubyGuards;
 import org.truffleruby.language.RubyNode;
+import org.truffleruby.language.backtrace.Backtrace;
 import org.truffleruby.language.backtrace.BacktraceFormatter;
 import org.truffleruby.language.backtrace.BacktraceFormatter.FormattingFlags;
 import org.truffleruby.language.control.JavaException;
@@ -261,13 +263,19 @@ private DynamicObject translateThrowable(Throwable throwable) {
 
         final StringBuilder builder = new StringBuilder();
         boolean firstException = true;
+        Backtrace lastBacktrace = null;
 
         while (t != null) {
             if (t.getClass().getSimpleName().equals("LazyStackTrace")) {
                 // Truffle's lazy stracktrace support, not a real exception
                 break;
             }
 
+            if (lastBacktrace != null) {
+                appendTruffleStackTrace(builder, lastBacktrace);
+                lastBacktrace = null;
+            }
+
             if (!firstException) {
                 builder.append("Caused by:\n");
             }
@@ -285,13 +293,17 @@ private DynamicObject translateThrowable(Throwable throwable) {
                 // Java exception, print it formatted like a Ruby exception
                 final String message = t.getMessage();
                 builder.append(message != null ? message : "<no message>");
-
                 builder.append(" (").append(t.getClass().getSimpleName()).append(")\n");
 
-                // Print the first 10 lines of backtrace
-                final StackTraceElement[] stackTrace = t.getStackTrace();
-                for (int i = 0; i < Math.min(stackTrace.length, 10); i++) {
-                    stackTraceElementToRuby(builder, stackTrace[i]);
+                if (t instanceof TruffleException) {
+                    lastBacktrace = new Backtrace((TruffleException) t);
+                } else {
+                    // Print the first 10 lines of the Java stacktrace
+                    appendJavaStackTrace(t, builder, 10);
+
+                    if (TruffleStackTrace.getStackTrace(t) != null) {
+                        lastBacktrace = new Backtrace(t);
+                    }
                 }
             }
 
@@ -302,11 +314,24 @@ private DynamicObject translateThrowable(Throwable throwable) {
         // When printing the backtrace of the exception, make it clear it's not a cause
         builder.append("Translated to internal error");
 
-        return coreExceptions().runtimeError(builder.toString(), this, throwable);
+        if (lastBacktrace != null) {
+            return coreExceptions().runtimeError(builder.toString(), lastBacktrace);
+        } else {
+            return coreExceptions().runtimeError(builder.toString(), this, throwable);
+        }
+    }
+
+    private void appendTruffleStackTrace(StringBuilder builder, Backtrace backtrace) {
+        final BacktraceFormatter formatter = new BacktraceFormatter(getContext(), EnumSet.noneOf(FormattingFlags.class));
+        final String formattedBacktrace = formatter.formatBacktrace(null, backtrace);
+        builder.append(formattedBacktrace).append('\n');
     }
 
-    private void stackTraceElementToRuby(StringBuilder builder, StackTraceElement stackTraceElement) {
-        builder.append('\t').append("from ").append(stackTraceElement).append('\n');
+    private void appendJavaStackTrace(Throwable t, StringBuilder builder, int limit) {
+        final StackTraceElement[] stackTrace = t.getStackTrace();
+        for (int i = 0; i < Math.min(stackTrace.length, limit); i++) {
+            builder.append('\t').append("from ").append(stackTrace[i]).append('\n');
+        }
     }
 
 }