Fix handling of KillException thrown on thread enter

* Thread enter does the context enter and then a poll(), before running
  the Runnable given to createThread(). That poll() can then throw a
  KillException if Thread#kill was used on that Thread. So we cannot
  catch it in threadMain() and we must use the uncaughtExceptionHandler().
* Also we need to set the thread value to non-null before disposeThread()
  runs and `thread.finishedLatch.countDown();` (used by Thread#{join,value}).
  We choose to just set it to nil initially for simplicity, and so the
  value field only needs to be set for the non-exception path.

Author: eregon

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

@@ -62,7 +62,7 @@ public final class RubyThread extends RubyDynamicObject implements ObjectGraphNo
     /** Either nil or long */
     public volatile Object nativeThreadId = Nil.INSTANCE;
     volatile RubyException exception = null;
-    volatile Object value = null;
+    volatile Object value = Nil.INSTANCE;
     public final AtomicBoolean wakeUp = new AtomicBoolean(false);
     volatile int priority = Thread.NORM_PRIORITY;
     ThreadLocalBuffer ioBuffer;

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

@@ -212,6 +212,14 @@ private Thread createJavaThread(Runnable runnable, RubyThread rubyThread, String
     private static Thread.UncaughtExceptionHandler uncaughtExceptionHandler(RubyFiber fiber) {
         assert fiber != null;
         return (javaThread, throwable) -> {
+            if (throwable instanceof KillException) {
+                // The exception killed the thread, as expected, do not print anything.
+                // We cannot just catch (KillException e) in threadMain() because it can also happen
+                // on the poll() done just after the thread enters the context and
+                // *before* running the Runnable, i.e. before running threadMain().
+                return;
+            }
+
             printInternalError(throwable);
             try {
                 fiber.uncaughtException = throwable;
@@ -307,28 +315,25 @@ public void initialize(RubyThread rubyThread, Node currentNode, String info, Str
     }
 
     /** {@link RubyLanguage#initializeThread(RubyContext, Thread)} runs before this, and
-     * {@link RubyLanguage#disposeThread(RubyContext, Thread)} runs after this. */
+     * {@link RubyLanguage#disposeThread(RubyContext, Thread)} runs after this. Note this is NOT guaranteed to run, an
+     * exception might happen in the poll() done when the thread enters the context. */
     private void threadMain(RubyThread thread, Node currentNode, Supplier<Object> task) {
         try {
             final Object result = task.get();
             setThreadValue(thread, result);
             // Handlers in the same order as in FiberManager
-            // Each catch must either setThreadValue() (before rethrowing) or setException()
-        } catch (KillException e) {
-            setThreadValue(thread, Nil.INSTANCE);
-        } catch (ThreadDeath e) { // Context#close(true)
-            setThreadValue(thread, Nil.INSTANCE);
+        } catch (KillException e) { // handled in uncaughtExceptionHandler()
+            throw e;
+        } catch (ThreadDeath e) { // Context#close(true), handled by Truffle
             throw e;
         } catch (RaiseException e) {
             setException(thread, e.getException(), currentNode);
         } catch (DynamicReturnException e) {
             setException(thread, context.getCoreExceptions().unexpectedReturn(currentNode), currentNode);
         } catch (ExitException e) {
-            setThreadValue(thread, Nil.INSTANCE);
             rethrowOnMainThread(currentNode, e);
         } catch (Throwable e) {
             final RuntimeException runtimeException = printInternalError(e);
-            setThreadValue(thread, Nil.INSTANCE);
             rethrowOnMainThread(currentNode, runtimeException);
         } finally {
             assert thread.value != null || thread.exception != null;

src/main/java/org/truffleruby/language/control/KillException.java

@@ -24,7 +24,7 @@ public final class KillException extends AbstractTruffleException {
 
     @TruffleBoundary
     private static RuntimeException javaStacktrace() {
-        return new RuntimeException();
+        return new RuntimeException("stacktrace:");
     }
 
     public KillException(Node location) {