SplatCastNode and ArrayDupNode do not need the frame

Author: eregon

src/main/java/org/truffleruby/core/array/ArrayDupNode.java

@@ -17,7 +17,6 @@
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.Specialization;
-import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
 import org.truffleruby.language.objects.AllocationTracing;
@@ -26,7 +25,7 @@
 @ImportStatic(ArrayGuards.class)
 public abstract class ArrayDupNode extends RubyContextNode {
 
-    public abstract RubyArray executeDup(VirtualFrame frame, RubyArray array);
+    public abstract RubyArray executeDup(RubyArray array);
 
     @Specialization(
             guards = {

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

@@ -24,7 +24,6 @@
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
-import com.oracle.truffle.api.frame.VirtualFrame;
 
 import static org.truffleruby.language.dispatch.DispatchConfiguration.PRIVATE_RETURN_MISSING;
 
@@ -59,7 +58,7 @@ public void doNotCopy() {
     public abstract RubyNode getChild();
 
     @Specialization
-    protected Object splatNil(VirtualFrame frame, Nil nil) {
+    protected Object splatNil(Nil nil) {
         switch (nilBehavior) {
             case EMPTY_ARRAY:
                 return createEmptyArray();
@@ -68,7 +67,7 @@ protected Object splatNil(VirtualFrame frame, Nil nil) {
                 return createArray(new Object[]{ nil });
 
             case CONVERT:
-                return callToA(frame, nil);
+                return callToA(nil);
 
             case NIL:
                 return nil;
@@ -79,18 +78,18 @@ protected Object splatNil(VirtualFrame frame, Nil nil) {
     }
 
     @Specialization
-    protected RubyArray splat(VirtualFrame frame, RubyArray array) {
+    protected RubyArray splat(RubyArray array) {
         // TODO(cs): is it necessary to dup here in all cases?
         // It is needed at least for [*ary] (parsed as just a SplatParseNode) and b = *ary.
         if (copy) {
-            return executeDup(frame, array);
+            return executeDup(array);
         } else {
             return array;
         }
     }
 
     @Specialization(guards = { "!isNil(object)", "!isRubyArray(object)" })
-    protected RubyArray splat(VirtualFrame frame, Object object,
+    protected RubyArray splat(Object object,
             @Cached DispatchNode toArrayNode) {
         final Object array = toArrayNode.call(
                 coreLibrary().truffleTypeModule,
@@ -102,27 +101,27 @@ protected RubyArray splat(VirtualFrame frame, Object object,
             return createArray(new Object[]{ object });
         } else {
             if (copy) {
-                return executeDup(frame, (RubyArray) array);
+                return executeDup((RubyArray) array);
             } else {
                 return (RubyArray) array;
             }
         }
     }
 
-    private Object callToA(VirtualFrame frame, Object nil) {
+    private Object callToA(Object nil) {
         if (toA == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
             toA = insert(DispatchNode.create(PRIVATE_RETURN_MISSING));
         }
         return toA.call(nil, "to_a");
     }
 
-    private RubyArray executeDup(VirtualFrame frame, RubyArray array) {
+    private RubyArray executeDup(RubyArray array) {
         if (dup == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
             dup = insert(ArrayDupNodeGen.create());
         }
-        return dup.executeDup(frame, array);
+        return dup.executeDup(array);
     }
 
 }