Make DurationToMillisecondsNode a helper node

Author: eregon

src/main/java/org/truffleruby/core/cast/DurationToNanoSecondsNode.java

@@ -10,28 +10,22 @@
 package org.truffleruby.core.cast;
 
 import com.oracle.truffle.api.dsl.Cached;
-import org.truffleruby.language.Nil;
-import org.truffleruby.language.RubyBaseNodeWithExecute;
+import com.oracle.truffle.api.dsl.Fallback;
+import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.NotProvided;
-import org.truffleruby.language.RubyDynamicObject;
 import org.truffleruby.language.control.RaiseException;
 
-import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 import org.truffleruby.language.dispatch.DispatchNode;
 
 import java.util.concurrent.TimeUnit;
 
-@NodeChild(value = "duration", type = RubyBaseNodeWithExecute.class)
-public abstract class DurationToNanoSecondsNode extends RubyBaseNodeWithExecute {
+public abstract class DurationToNanoSecondsNode extends RubyBaseNode {
 
     private final ConditionProfile durationLessThanZeroProfile = ConditionProfile.create();
-    private final boolean acceptsNil;
 
-    public DurationToNanoSecondsNode(boolean acceptsNil) {
-        this.acceptsNil = acceptsNil;
-    }
+    public abstract long execute(Object duration);
 
     @Specialization
     protected long noDuration(NotProvided duration) {
@@ -48,19 +42,8 @@ protected long duration(double duration) {
         return validate((long) (duration * 1e9));
     }
 
-    @Specialization
-    protected long durationNil(Nil duration) {
-        if (acceptsNil) {
-            return noDuration(NotProvided.INSTANCE);
-        } else {
-            throw new RaiseException(
-                    getContext(),
-                    coreExceptions().typeError("TypeError: can't convert NilClass into time interval", this));
-        }
-    }
-
-    @Specialization
-    protected Object duration(RubyDynamicObject duration,
+    @Fallback
+    protected long duration(Object duration,
             @Cached DispatchNode durationToNanoSeconds,
             @Cached ToLongNode toLongNode) {
         final Object nanoseconds = durationToNanoSeconds.call(
@@ -76,5 +59,4 @@ private long validate(long durationInNanos) {
         }
         return durationInNanos;
     }
-
 }

src/main/java/org/truffleruby/core/kernel/KernelNodes.java

@@ -43,7 +43,7 @@
 import org.truffleruby.core.cast.BooleanCastNode;
 import org.truffleruby.core.cast.BooleanCastNodeGen;
 import org.truffleruby.core.cast.BooleanCastWithDefaultNode;
-import org.truffleruby.core.cast.DurationToNanoSecondsNodeGen;
+import org.truffleruby.core.cast.DurationToNanoSecondsNode;
 import org.truffleruby.core.cast.NameToJavaStringNode;
 import org.truffleruby.core.cast.ToIntNode;
 import org.truffleruby.core.cast.ToStrNode;
@@ -1602,18 +1602,13 @@ protected boolean hasSingletonMethods(Object self,
 
     }
 
-    @NodeChild(value = "duration", type = RubyBaseNodeWithExecute.class)
     @CoreMethod(names = "sleep", isModuleFunction = true, optional = 1)
-    public abstract static class SleepNode extends CoreMethodNode {
-
-        @CreateCast("duration")
-        protected RubyBaseNodeWithExecute coerceDuration(RubyBaseNodeWithExecute duration) {
-            return DurationToNanoSecondsNodeGen.create(false, duration);
-        }
+    public abstract static class SleepNode extends CoreMethodArrayArgumentsNode {
 
         @Specialization
-        protected long sleep(long durationInNanos,
-                @Cached BranchProfile errorProfile) {
+        protected long sleep(Object maybeDuration,
+                @Cached DurationToNanoSecondsNode durationToNanoSecondsNode) {
+            long durationInNanos = durationToNanoSecondsNode.execute(maybeDuration);
             assert durationInNanos >= 0;
 
             final RubyThread thread = getLanguage().getCurrentThread();

src/main/java/org/truffleruby/core/mutex/MutexNodes.java

@@ -10,24 +10,20 @@
 package org.truffleruby.core.mutex;
 
 import com.oracle.truffle.api.dsl.Cached;
-import com.oracle.truffle.api.dsl.CreateCast;
-import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.profiles.BranchProfile;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 import org.truffleruby.builtins.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
-import org.truffleruby.builtins.CoreMethodNode;
 import org.truffleruby.builtins.CoreModule;
 import org.truffleruby.builtins.UnaryCoreMethodNode;
 import org.truffleruby.builtins.YieldingCoreMethodNode;
-import org.truffleruby.core.cast.DurationToNanoSecondsNodeGen;
+import org.truffleruby.core.cast.DurationToNanoSecondsNode;
 import org.truffleruby.core.kernel.KernelNodes;
 import org.truffleruby.core.klass.RubyClass;
 import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.thread.RubyThread;
-import org.truffleruby.language.RubyBaseNodeWithExecute;
-import org.truffleruby.language.RubyNode;
+import org.truffleruby.language.NotProvided;
 import org.truffleruby.language.Visibility;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.objects.AllocationTracing;
@@ -148,19 +144,20 @@ protected Object synchronize(RubyMutex mutex, RubyProc block,
 
     }
 
-    @NodeChild(value = "mutex", type = RubyNode.class)
-    @NodeChild(value = "duration", type = RubyBaseNodeWithExecute.class)
     @CoreMethod(names = "sleep", optional = 1)
-    public abstract static class SleepNode extends CoreMethodNode {
-
-        @CreateCast("duration")
-        protected RubyBaseNodeWithExecute coerceDuration(RubyBaseNodeWithExecute duration) {
-            return DurationToNanoSecondsNodeGen.create(true, duration);
-        }
+    public abstract static class SleepNode extends CoreMethodArrayArgumentsNode {
 
         @Specialization
-        protected long sleep(RubyMutex mutex, long durationInNanos,
+        protected long sleep(RubyMutex mutex, Object maybeDuration,
+                @Cached DurationToNanoSecondsNode durationToNanoSecondsNode,
+                @Cached ConditionProfile nilProfile,
                 @Cached BranchProfile errorProfile) {
+            if (nilProfile.profile(maybeDuration == nil)) {
+                maybeDuration = NotProvided.INSTANCE;
+            }
+
+            long durationInNanos = durationToNanoSecondsNode.execute(maybeDuration);
+
             final ReentrantLock lock = mutex.lock;
             final RubyThread thread = getLanguage().getCurrentThread();