Create SignalHandler directly instead of converting from Runnable

* Makes it easier to debug signal handling.

Author: eregon

src/main/java/org/truffleruby/core/VMPrimitiveNodes.java

@@ -90,6 +90,7 @@
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
 import sun.misc.Signal;
+import sun.misc.SignalHandler;
 
 @CoreModule(value = "VMPrimitives", isClass = true)
 public abstract class VMPrimitiveNodes {
@@ -229,34 +230,34 @@ public static abstract class VMWatchSignalNode extends PrimitiveArrayArgumentsNo
 
         @TruffleBoundary
         @Specialization
-        protected boolean restoreDefault(RubyString signalName, RubyString action) {
+        protected boolean restoreDefault(RubyString signalString, RubyString action) {
             final String actionString = StringOperations.getString(action);
-            final String signal = StringOperations.getString(signalName);
+            final String signalName = StringOperations.getString(signalString);
 
             switch (actionString) {
                 case "DEFAULT":
-                    return restoreDefaultHandler(signal);
+                    return restoreDefaultHandler(signalName);
                 case "SYSTEM_DEFAULT":
-                    return restoreSystemHandler(signal);
+                    return restoreSystemHandler(signalName);
                 case "IGNORE":
-                    return registerIgnoreHandler(signal);
+                    return registerIgnoreHandler(signalName);
                 default:
                     throw new UnsupportedOperationException(actionString);
             }
         }
 
         @TruffleBoundary
         @Specialization
-        protected boolean watchSignalProc(RubyString signalName, RubyProc action) {
+        protected boolean watchSignalProc(RubyString signalString, RubyProc action) {
             if (getContext().getThreadManager().getCurrentThread() != getContext().getThreadManager().getRootThread()) {
                 // The proc will be executed on the main thread
                 SharedObjects.writeBarrier(getContext(), action);
             }
 
             final RubyContext context = getContext();
 
-            final String signal = StringOperations.getString(signalName);
-            return registerHandler(signal, () -> {
+            String signalName = StringOperations.getString(signalString);
+            return registerHandler(signalName, signal -> {
                 if (context.getOptions().SINGLE_THREADED) {
                     RubyLanguage.LOGGER.severe(
                             "signal " + signal + " caught but can't create a thread to handle it so ignoring");
@@ -279,9 +280,9 @@ protected boolean watchSignalProc(RubyString signalName, RubyProc action) {
                     printStream.println(
                             "[ruby] SEVERE: signal " + signal +
                                     " caught but can't attach a thread to handle it so restoring the default handler and re-raising the signal");
-                    Signals.restoreDefaultHandler(signal);
+                    Signals.restoreDefaultHandler(signalName);
                     try {
-                        Signal.raise(new Signal(signal));
+                        Signal.raise(signal);
                     } catch (IllegalArgumentException illegalArgumentException) {
                         illegalArgumentException.printStackTrace(printStream);
                     }
@@ -351,7 +352,7 @@ private boolean registerIgnoreHandler(String signalName) {
         }
 
         @TruffleBoundary
-        private boolean registerHandler(String signalName, Runnable newHandler) {
+        private boolean registerHandler(String signalName, SignalHandler newHandler) {
             if (getContext().getOptions().EMBEDDED) {
                 RubyLanguage.LOGGER.warning(
                         "trapping signal " + signalName +

src/main/java/org/truffleruby/platform/Signals.java

@@ -20,9 +20,9 @@ public class Signals {
     // Use String and not Signal as key to work around SVM not allowing new Signal("PROF")
     private static final ConcurrentMap<String, SignalHandler> DEFAULT_HANDLERS = new ConcurrentHashMap<>();
 
-    public static void registerHandler(Runnable newHandler, String signalName) {
+    public static void registerHandler(SignalHandler newHandler, String signalName) {
         final Signal signal = new Signal(signalName);
-        final SignalHandler oldHandler = Signal.handle(signal, s -> newHandler.run());
+        final SignalHandler oldHandler = Signal.handle(signal, newHandler);
         DEFAULT_HANDLERS.putIfAbsent(signalName, oldHandler);
     }