Pass :IGNORE as a String too to :vm_watch_signal for consistency

* Simplifies logic a bit.

Author: eregon

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

@@ -280,21 +280,21 @@ public static abstract class VMWatchSignalPrimitiveNode extends PrimitiveArrayAr
         @Specialization(guards = { "isRubyString(signalName)", "isRubyString(action)" })
         public boolean restoreDefault(DynamicObject signalName, DynamicObject action) {
             final String actionString = StringOperations.getString(action);
+            final String signal = StringOperations.getString(signalName);
+
             switch (actionString) {
                 case "DEFAULT":
-                    return restoreDefaultHandler(StringOperations.getString(signalName));
+                    return restoreDefaultHandler(signal);
                 case "SYSTEM_DEFAULT":
-                    return restoreSystemHandler(StringOperations.getString(signalName));
+                    return restoreSystemHandler(signal);
+                case "IGNORE":
+                    return registerIgnoreHandler(signal);
                 default:
                     throw new UnsupportedOperationException(actionString);
             }
         }
 
-        @Specialization(guards = { "isRubyString(signalName)", "isNil(nil)" })
-        public boolean ignoreSignal(DynamicObject signalName, Object nil) {
-            return registerHandler(StringOperations.getString(signalName), null);
-        }
-
+        @TruffleBoundary
         @Specialization(guards = { "isRubyString(signalNameString)", "isRubyProc(proc)" })
         public boolean watchSignalProc(DynamicObject signalNameString, DynamicObject proc) {
             if (getContext().getThreadManager().getCurrentThread() != getContext().getThreadManager().getRootThread()) {
@@ -358,6 +358,20 @@ private boolean restoreSystemHandler(String signalName) {
             return true;
         }
 
+        @TruffleBoundary
+        private boolean registerIgnoreHandler(String signalName) {
+            if (getContext().getOptions().EMBEDDED) {
+                RubyLanguage.LOGGER.warning("ignoring signal " + signalName + " in embedded mode may interfere with other embedded contexts or the host system");
+            }
+
+            try {
+                Signals.registerIgnoreHandler(signalName);
+            } catch (IllegalArgumentException e) {
+                throw new RaiseException(getContext(), coreExceptions().argumentError(e.getMessage(), this));
+            }
+            return true;
+        }
+
         @TruffleBoundary
         private boolean registerHandler(String signalName, Runnable newHandler) {
             if (getContext().getOptions().EMBEDDED) {

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

@@ -13,25 +13,27 @@
 import java.util.concurrent.ConcurrentMap;
 
 import sun.misc.Signal;
+import sun.misc.SignalHandler;
 
 public class Signals {
 
     // Use String and not Signal as key to work around SVM not allowing new Signal("PROF")
-    private static final ConcurrentMap<String, sun.misc.SignalHandler> DEFAULT_HANDLERS = new ConcurrentHashMap<>();
+    private static final ConcurrentMap<String, SignalHandler> DEFAULT_HANDLERS = new ConcurrentHashMap<>();
 
     public static void registerHandler(Runnable newHandler, String signalName) {
         final Signal signal = new Signal(signalName);
-        final sun.misc.SignalHandler oldSunHandler;
-        if (newHandler == null) {
-            oldSunHandler = Signal.handle(signal, sun.misc.SignalHandler.SIG_IGN);
-        } else {
-            oldSunHandler = Signal.handle(signal, s -> newHandler.run());
-        }
-        DEFAULT_HANDLERS.putIfAbsent(signalName, oldSunHandler);
+        final SignalHandler oldHandler = Signal.handle(signal, s -> newHandler.run());
+        DEFAULT_HANDLERS.putIfAbsent(signalName, oldHandler);
+    }
+
+    public static void registerIgnoreHandler(String signalName) {
+        final Signal signal = new Signal(signalName);
+        final SignalHandler oldHandler = Signal.handle(signal, SignalHandler.SIG_IGN);
+        DEFAULT_HANDLERS.putIfAbsent(signalName, oldHandler);
     }
 
     public static boolean restoreDefaultHandler(String signalName) {
-        final sun.misc.SignalHandler defaultHandler = Signals.DEFAULT_HANDLERS.get(signalName);
+        final SignalHandler defaultHandler = Signals.DEFAULT_HANDLERS.get(signalName);
         if (defaultHandler == null) {
             // it is already the default signal
             return false;
@@ -44,7 +46,7 @@ public static boolean restoreDefaultHandler(String signalName) {
 
     public static void restoreSystemHandler(String signalName) {
         final Signal signal = new Signal(signalName);
-        Signal.handle(signal, sun.misc.SignalHandler.SIG_DFL);
+        Signal.handle(signal, SignalHandler.SIG_DFL);
     }
 
 }

src/main/ruby/truffleruby/core/signal.rb

@@ -92,7 +92,7 @@ def self.trap(signal, handler=nil, &block)
       handler = 'SYSTEM_DEFAULT'
     when 'IGNORE', 'SIG_IGN'
       handler = 'IGNORE'
-    when nil
+    when nil # Same as 'IGNORE', except that it is kept as null in @handlers
       handler = nil
     when 'EXIT'
       handler = proc { exit }
@@ -114,8 +114,7 @@ def self.trap(signal, handler=nil, &block)
     end
 
     if number != Names['EXIT']
-      handler = handler == 'IGNORE' ? nil : handler
-      ret = Truffle.invoke_primitive :vm_watch_signal, signame, handler
+      ret = Truffle.invoke_primitive(:vm_watch_signal, signame, handler || 'IGNORE')
       if handler == 'DEFAULT' && !ret
         return +'SYSTEM_DEFAULT'
       end