[GR-24983] Backports for 20.2.0.

PullRequest: truffleruby/1791

Author: gilles-duboscq

.gitattributes

@@ -1,7 +1,3 @@
-# Merge options
-
-/CHANGELOG.md merge=union
-
 # Rules for GitHub's Linguist language-classification system. We're abusing the
 # 'vendored' attribute to exclude files as a lot of this isn't really vendored,
 # and a whole lot of actually vendored code isn't listed! What we want to do is

CHANGELOG.md

@@ -66,11 +66,10 @@ Compatibility:
 * Implemented `Digest::Instance#new` (#2040).
 * Implemented `ONIGENC_MBC_CASE_FOLD`.
 * Fixed `Thread#raise` to call the exception class' constructor with no arguments when given no message (#2045).
-* Fixed `refine + super` compatibility (#2039, @ssnickolay)
+* Fixed `refine + super` compatibility (#2039, #2048, @ssnickolay)
 * Make the top-level exception handler more compatible with MRI (#2047).
 * Implemented `rb_enc_codelen`.
 * Implemented `Ripper` by using the C extension (#1585).
-* Fixed `refine + super` compatibility (#2039, #2048, @ssnickolay)
 
 Changes:
 

spec/ruby/core/thread/backtrace/location/absolute_path_spec.rb

@@ -10,6 +10,13 @@
     @frame.absolute_path.should == File.realpath(__FILE__)
   end
 
+  it 'returns an absolute path when using a relative main script path' do
+    script = fixture(__FILE__, 'absolute_path_main.rb')
+    Dir.chdir(File.dirname(script)) do
+      ruby_exe('absolute_path_main.rb').should == "absolute_path_main.rb\n#{script}\n"
+    end
+  end
+
   context "when used in eval with a given filename" do
     it "returns filename" do
       code = "caller_locations(0)[0].absolute_path"

spec/ruby/core/thread/backtrace/location/fixtures/absolute_path_main.rb

@@ -0,0 +1,2 @@
+puts __FILE__
+puts caller_locations(0)[0].absolute_path

spec/tags/core/thread/backtrace/location/absolute_path_tags.txt

@@ -0,0 +1 @@
+slow:Thread::Backtrace::Location#absolute_path returns an absolute path when using a relative main script path

spec/tags/truffle/java_exception_tags.txt

@@ -0,0 +1 @@
+slow:Java exceptions AssertionError in another Thread is rethrown on the main Ruby Thread

spec/truffle/java_exception_spec.rb

@@ -61,4 +61,18 @@
     }
   end
 
+  it "AssertionError in another Thread is rethrown on the main Ruby Thread" do
+    code = <<-RUBY
+    Thread.new do
+      Truffle::Debug.throw_assertion_error('custom_assertion_error_message')
+    end
+    sleep
+    RUBY
+
+    out = ruby_exe(code, args: "2>&1")
+    $?.exitstatus.should == 1
+    out.should.include?('terminated with internal error')
+    out.should.include?('Caused by:')
+    out.should.include?('custom_assertion_error_message (AssertionError)')
+  end
 end

src/main/java/org/truffleruby/core/thread/ThreadBacktraceLocationNodes.java

@@ -9,8 +9,6 @@
  */
 package org.truffleruby.core.thread;
 
-import java.io.File;
-
 import org.jcodings.specific.UTF8Encoding;
 import org.truffleruby.Layouts;
 import org.truffleruby.RubyContext;
@@ -22,14 +20,15 @@
 import org.truffleruby.core.string.StringNodes;
 import org.truffleruby.core.string.StringOperations;
 import org.truffleruby.language.backtrace.Backtrace;
+import org.truffleruby.language.backtrace.BacktraceFormatter;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.TruffleStackTraceElement;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
-import org.truffleruby.language.backtrace.BacktraceFormatter;
 
 @CoreModule(value = "Thread::Backtrace::Location", isClass = true)
 public class ThreadBacktraceLocationNodes {
@@ -56,16 +55,17 @@ protected DynamicObject absolutePath(DynamicObject threadBacktraceLocation,
             if (sourceSection == null) {
                 return coreStrings().UNKNOWN.createInstance();
             } else {
-                final String path = RubyContext.getPath(sourceSection.getSource());
-                if (new File(path).isAbsolute()) { // A normal file
+                final Source source = sourceSection.getSource();
+                final String path = RubyContext.getPath(source);
+                if (source.getPath() != null) { // A normal file
                     final String canonicalPath = getContext().getFeatureLoader().canonicalize(path);
                     final Rope cachedRope = getContext()
                             .getRopeCache()
                             .getRope(StringOperations.encodeRope(canonicalPath, UTF8Encoding.INSTANCE));
                     return makeStringNode.fromRope(cachedRope);
                 } else { // eval()
                     return makeStringNode
-                            .fromRope(getContext().getPathToRopeCache().getCachedPath(sourceSection.getSource()));
+                            .fromRope(getContext().getPathToRopeCache().getCachedPath(source));
                 }
             }
         }

src/main/java/org/truffleruby/core/thread/ThreadManager.java

@@ -328,20 +328,26 @@ private void threadMain(DynamicObject thread, Node currentNode, Supplier<Object>
             // Handlers in the same order as in FiberManager
         } catch (KillException e) {
             setThreadValue(context, thread, Nil.INSTANCE);
-        } catch (ExitException e) {
-            rethrowOnMainThread(currentNode, e);
-            setThreadValue(context, thread, Nil.INSTANCE);
         } catch (RaiseException e) {
             setException(context, thread, e.getException(), currentNode);
         } catch (DynamicReturnException e) {
             setException(context, thread, context.getCoreExceptions().unexpectedReturn(currentNode), currentNode);
+        } catch (ExitException e) {
+            rethrowOnMainThread(currentNode, e);
+            setThreadValue(context, thread, Nil.INSTANCE);
+        } catch (Throwable e) {
+            final String message = StringUtils
+                    .format("%s terminated with internal error:", Thread.currentThread().getName());
+            final RuntimeException runtimeException = new RuntimeException(message, e);
+            rethrowOnMainThread(currentNode, runtimeException);
+            setThreadValue(context, thread, Nil.INSTANCE);
         } finally {
             assert Layouts.THREAD.getValue(thread) != null || Layouts.THREAD.getException(thread) != null;
             cleanup(thread, Thread.currentThread());
         }
     }
 
-    private void rethrowOnMainThread(Node currentNode, ExitException e) {
+    private void rethrowOnMainThread(Node currentNode, RuntimeException e) {
         context.getSafepointManager().pauseRubyThreadAndExecute(
                 getRootThread(),
                 currentNode,

src/main/java/org/truffleruby/debug/TruffleDebugNodes.java

@@ -401,9 +401,9 @@ static void warning(String message) {
     public abstract static class ThrowJavaExceptionNode extends CoreMethodArrayArgumentsNode {
 
         @TruffleBoundary
-        @Specialization
-        protected Object throwJavaException(Object message) {
-            callingMethod(message.toString());
+        @Specialization(guards = "isRubyString(message)")
+        protected Object throwJavaException(DynamicObject message) {
+            callingMethod(StringOperations.getString(message));
             return nil;
         }
 
@@ -423,21 +423,32 @@ private static void throwingMethod(String message) {
     public abstract static class ThrowJavaExceptionWithCauseNode extends CoreMethodArrayArgumentsNode {
 
         @TruffleBoundary
-        @Specialization
-        protected DynamicObject throwJavaExceptionWithCause(Object message) {
+        @Specialization(guards = "isRubyString(message)")
+        protected Object throwJavaExceptionWithCause(DynamicObject message) {
             throw new RuntimeException(
-                    message.toString(),
+                    StringOperations.getString(message),
                     new RuntimeException("cause 1", new RuntimeException("cause 2")));
         }
 
     }
 
+    @CoreMethod(names = "throw_assertion_error", onSingleton = true, required = 1)
+    public abstract static class ThrowAssertionErrorNode extends CoreMethodArrayArgumentsNode {
+
+        @TruffleBoundary
+        @Specialization(guards = "isRubyString(message)")
+        protected Object throwAssertionError(DynamicObject message) {
+            throw new AssertionError(StringOperations.getString(message));
+        }
+
+    }
+
     @CoreMethod(names = "assert", onSingleton = true, required = 1)
     public abstract static class AssertNode extends CoreMethodArrayArgumentsNode {
 
         @TruffleBoundary
         @Specialization
-        protected Object throwJavaException(boolean condition) {
+        protected Object doAssert(boolean condition) {
             assert condition;
             return nil;
         }
@@ -805,7 +816,7 @@ protected String toDisplayString(boolean allowSideEffects) {
         @TruffleBoundary
         @Specialization(guards = "isRubyString(string)")
         protected Object foreignString(DynamicObject string) {
-            return new ForeignString(string.toString());
+            return new ForeignString(StringOperations.getString(string));
         }
 
     }