[Truffle] Create helpers in RubyNode for creating arrays.

jruby · May 29, 2015 · 2d8876d · 2d8876d
1 parent 74d26f9
commit 2d8876d
Showing 29 changed files with 179 additions and 175 deletions.
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java
@@ -24,6 +24,7 @@
 import jnr.ffi.provider.MemoryManager;
 import jnr.posix.POSIX;
 
+import org.jruby.truffle.nodes.core.array.ArrayNodes;
 import org.jruby.truffle.nodes.instrument.RubyWrapperNode;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
@@ -58,7 +59,7 @@ public Object isDefined(VirtualFrame frame) {
         return getContext().makeString("expression");
     }
 
-    // Execute without returing the result
+    // Execute without returning the result
 
     public void executeVoid(VirtualFrame frame) {
         execute(frame);
@@ -242,6 +243,26 @@ protected RubyBasicObject nil() {
         return getContext().getCoreLibrary().getNilObject();
     }
 
+    protected RubyArray createEmptyArray() {
+        return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+    }
+
+    protected RubyArray createArray(int[] store, int size) {
+        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, size);
+    }
+
+    protected RubyArray createArray(long[] store, int size) {
+        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, size);
+    }
+
+    protected RubyArray createArray(double[] store, int size) {
+        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, size);
+    }
+
+    protected RubyArray createArray(Object[] store, int size) {
+        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, size);
+    }
+
     protected POSIX posix() {
         return getContext().getPosix();
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/ArrayCastNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/ArrayCastNode.java
@@ -82,7 +82,7 @@ public RubyArray cast(RubyArray array) {
     public Object cast(Object nil) {
         switch (nilBehavior) {
             case EMPTY_ARRAY:
-                return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+                return createEmptyArray();
 
             case ARRAY_WITH_NIL:
                 return ArrayNodes.fromObject(getContext().getCoreLibrary().getArrayClass(), nil());

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/SplatCastNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/SplatCastNode.java
@@ -64,7 +64,7 @@ public SplatCastNode(RubyContext context, SourceSection sourceSection, NilBehavi
     public RubyArray splat(Object nil) {
         switch (nilBehavior) {
             case EMPTY_ARRAY:
-                return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+                return createEmptyArray();
 
             case ARRAY_WITH_NIL:
                 return ArrayNodes.fromObject(getContext().getCoreLibrary().getArrayClass(), nil());

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BignumNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BignumNodes.java
@@ -536,7 +536,7 @@ public RubyArray coerce(RubyBasicObject a, int b) {
             // TODO (eregon, 16 Feb. 2015): This is NOT spec, but let's try to see if we can make it work.
             // b is converted to a Bignum here in other implementations.
             Object[] store = new Object[] { b, a };
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, store.length);
+            return createArray(store, store.length);
         }
 
         @Specialization
@@ -546,15 +546,15 @@ public RubyArray coerce(RubyBasicObject a, long b) {
             // TODO (eregon, 16 Feb. 2015): This is NOT spec, but let's try to see if we can make it work.
             // b is converted to a Bignum here in other implementations.
             Object[] store = new Object[] { b, a };
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, store.length);
+            return createArray(store, store.length);
         }
 
         @Specialization(guards = "isRubyBignum(b)")
         public RubyArray coerce(RubyBasicObject a, RubyBasicObject b) {
             CompilerDirectives.transferToInterpreter();
 
             Object[] store = new Object[] { b, a };
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, store.length);
+            return createArray(store, store.length);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BindingNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BindingNodes.java
@@ -243,7 +243,7 @@ public LocalVariablesNode(RubyContext context, SourceSection sourceSection) {
         @TruffleBoundary
         @Specialization
         public RubyArray localVariables(RubyBinding binding) {
-            final RubyArray array = ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            final RubyArray array = createEmptyArray();
 
             MaterializedFrame frame = binding.getFrame();
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingNodes.java
@@ -279,7 +279,7 @@ public RubyArray list() {
 
             final RubyEncoding[] encodings = RubyEncoding.cloneEncodingList();
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), encodings, encodings.length);
+            return createArray(encodings, encodings.length);
         }
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/GeneralDivModNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/GeneralDivModNode.java
@@ -109,13 +109,13 @@ private RubyArray divMod(long a, long b) {
 
         if (integerDiv instanceof Long && ((long) integerDiv) >= Integer.MIN_VALUE && ((long) integerDiv) <= Integer.MAX_VALUE && mod >= Integer.MIN_VALUE && mod <= Integer.MAX_VALUE) {
             useFixnumPairProfile.enter();
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new int[]{(int) (long) integerDiv, (int) mod}, 2);
+            return createArray(new int[]{(int) (long) integerDiv, (int) mod}, 2);
         } else if (integerDiv instanceof Long) {
             useObjectPairProfile.enter();
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new Object[]{integerDiv, mod}, 2);
+            return createArray(new Object[]{integerDiv, mod}, 2);
         } else {
             useObjectPairProfile.enter();
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new Object[]{
+            return createArray(new Object[]{
                     fixnumOrBignumQuotient.fixnumOrBignum((BigInteger) integerDiv),
                     mod}, 2);
         }
@@ -141,7 +141,7 @@ private RubyArray divMod(double a, double b) {
             mod += b;
         }
 
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new Object[]{
+        return createArray(new Object[]{
                 fixnumOrBignumQuotient.fixnumOrBignum(div),
                 mod}, 2);
     }
@@ -161,7 +161,7 @@ private RubyArray divMod(BigInteger a, BigInteger b) {
             bigIntegerResults[1] = b.add(bigIntegerResults[1]);
         }
 
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new Object[]{
+        return createArray(new Object[]{
                 fixnumOrBignumQuotient.fixnumOrBignum(bigIntegerResults[0]),
                 fixnumOrBignumRemainder.fixnumOrBignum(bigIntegerResults[1])}, 2);
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/IntegerNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/IntegerNodes.java
@@ -143,7 +143,7 @@ public RubyArray times(VirtualFrame frame, int n, NotProvided block) {
                 array[i] = i;
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), array, n);
+            return createArray(array, n);
         }
 
         @Specialization

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/KernelNodes.java
@@ -330,7 +330,7 @@ public RubyArray callerLocations(int omit, int length) {
                 locations[n] = ThreadBacktraceLocationNodes.createRubyThreadBacktraceLocation(threadBacktraceLocationClass, activation);
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), locations, locations.length);
+            return createArray(locations, locations.length);
         }
     }
 
@@ -907,7 +907,7 @@ public RubyArray instanceVariables(RubyBasicObject self) {
 
             Arrays.sort(instanceVariableNames);
 
-            final RubyArray array = ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            final RubyArray array = createEmptyArray();
 
             for (Object name : instanceVariableNames) {
                 if (name instanceof String) {
@@ -1007,7 +1007,7 @@ public LocalVariablesNode(RubyContext context, SourceSection sourceSection) {
         public RubyArray localVariables() {
             CompilerDirectives.transferToInterpreter();
 
-            final RubyArray array = ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            final RubyArray array = createEmptyArray();
 
             for (Object name : Truffle.getRuntime().getCallerFrame().getFrame(FrameInstance.FrameAccess.READ_ONLY, false).getFrameDescriptor().getIdentifiers()) {
                 if (name instanceof String) {
@@ -1540,7 +1540,7 @@ public RubyArray singletonMethods(VirtualFrame frame, Object self, boolean inclu
             RubyClass metaClass = metaClassNode.executeMetaClass(frame, self);
 
             if (!metaClass.isSingleton()) {
-                return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+                return createEmptyArray();
             }
 
             CompilerDirectives.transferToInterpreter();

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/MatchDataNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/MatchDataNodes.java
@@ -61,7 +61,7 @@ public Object getIndex(RubyMatchData matchData, int index, int length) {
             final Object[] values = matchData.getValues();
             final int normalizedIndex = ArrayNodes.normalizeIndex(values.length, index);
             final Object[] store = Arrays.copyOfRange(values, normalizedIndex, normalizedIndex + length);
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, length);
+            return createArray(store, length);
         }
 
         @Specialization
@@ -118,7 +118,7 @@ public Object getIndex(VirtualFrame frame, RubyMatchData matchData, RubyRange.In
             final int length = exclusiveEnd - normalizedIndex;
 
             final Object[] store = Arrays.copyOfRange(values, normalizedIndex, normalizedIndex + length);
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, length);
+            return createArray(store, length);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/MathNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/MathNodes.java
@@ -360,7 +360,7 @@ public RubyArray frexp(double a) {
                 for (; mantissa >= 1.0; mantissa *= 0.5, exponent +=1) { }
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new Object[]{sign * mantissa, exponent}, 2);
+            return createArray(new Object[]{sign * mantissa, exponent}, 2);
         }
 
         @Fallback
@@ -589,7 +589,7 @@ public RubyArray lgamma(double a) {
 
             final RubyMath.NemesLogGamma l = new RubyMath.NemesLogGamma(a);
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new Object[]{l.value, l.sign}, 2);
+            return createArray(new Object[]{l.value, l.sign}, 2);
         }
 
         @Fallback

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/RangeNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/RangeNodes.java
@@ -411,15 +411,15 @@ public RubyArray toA(RubyRange.IntegerFixnumRange range) {
             final int length = range.getExclusiveEnd() - begin;
 
             if (length < 0) {
-                return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+                return createEmptyArray();
             } else {
                 final int[] values = new int[length];
 
                 for (int n = 0; n < length; n++) {
                     values[n] = begin + n;
                 }
 
-                return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), values, length);
+                return createArray(values, length);
             }
         }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/StringNodes.java
@@ -684,7 +684,7 @@ public RubyArray bytes(RubyString string) {
                 store[n] = ((int) bytes[n]) & 0xFF;
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, bytes.length);
+            return createArray(store, bytes.length);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/SymbolNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/SymbolNodes.java
@@ -70,7 +70,7 @@ public AllSymbolsNode(RubyContext context, SourceSection sourceSection) {
         @TruffleBoundary
         @Specialization
         public RubyArray allSymbols() {
-            final RubyArray array = ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            final RubyArray array = createEmptyArray();
 
             for (RubySymbol s : getContext().getSymbolTable().allSymbols()) {
                 ArrayNodes.slowPush(array, s);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/TrufflePrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/TrufflePrimitiveNodes.java
@@ -279,7 +279,7 @@ public RubyHash coverageResult() {
 
             for (Map.Entry<Source, Long[]> source : getContext().getCoverageTracker().getCounts().entrySet()) {
                 final Object[] store = lineCountsStore(source.getValue());
-                final RubyArray array = ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, store.length);
+                final RubyArray array = createArray(store, store.length);
                 keyValues.add(new KeyValue(getContext().makeString(source.getKey().getPath()), array));
             }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayDropTailNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayDropTailNode.java
@@ -35,17 +35,17 @@ public ArrayDropTailNode(RubyContext context, SourceSection sourceSection, int i
     public RubyArray getHeadNull(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
-        return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+        return createEmptyArray();
     }
 
     @Specialization(guards = "isIntegerFixnum(array)")
     public RubyArray getHeadIntegerFixnum(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
         if (index >= ArrayNodes.getSize(array)) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((int[]) ArrayNodes.getStore(array), 0, ArrayNodes.getSize(array) - index), ArrayNodes.getSize(array) - index);
+            return createArray(ArrayUtils.extractRange((int[]) ArrayNodes.getStore(array), 0, ArrayNodes.getSize(array) - index), ArrayNodes.getSize(array) - index);
         }
     }
 
@@ -54,10 +54,10 @@ public RubyArray geHeadLongFixnum(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
         if (index >= ArrayNodes.getSize(array)) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
             final int size = ArrayNodes.getSize(array) - index;
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((long[]) ArrayNodes.getStore(array), 0, size), size);
+            return createArray(ArrayUtils.extractRange((long[]) ArrayNodes.getStore(array), 0, size), size);
         }
     }
 
@@ -66,10 +66,10 @@ public RubyArray getHeadFloat(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
         if (index >= ArrayNodes.getSize(array)) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
             final int size = ArrayNodes.getSize(array) - index;
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((double[]) ArrayNodes.getStore(array), 0, size), size);
+            return createArray(ArrayUtils.extractRange((double[]) ArrayNodes.getStore(array), 0, size), size);
         }
     }
 
@@ -78,10 +78,10 @@ public RubyArray getHeadObject(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
         if (index >= ArrayNodes.getSize(array)) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
             final int size = ArrayNodes.getSize(array) - index;
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((Object[]) ArrayNodes.getStore(array), 0, size), size);
+            return createArray(ArrayUtils.extractRange((Object[]) ArrayNodes.getStore(array), 0, size), size);
         }
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayDupNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayDupNode.java
@@ -36,27 +36,27 @@ public ArrayDupNode(RubyContext context, SourceSection sourceSection) {
 
     @Specialization(guards = "isNull(from)")
     public RubyArray dupNull(RubyArray from) {
-        return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+        return createEmptyArray();
     }
 
     @Specialization(guards = "isIntegerFixnum(from)")
     public RubyArray dupIntegerFixnum(RubyArray from) {
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), Arrays.copyOf((int[]) ArrayNodes.getStore(from), ArrayNodes.getSize(from)), ArrayNodes.getSize(from));
+        return createArray(Arrays.copyOf((int[]) ArrayNodes.getStore(from), ArrayNodes.getSize(from)), ArrayNodes.getSize(from));
     }
 
     @Specialization(guards = "isLongFixnum(from)")
     public RubyArray dupLongFixnum(RubyArray from) {
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), Arrays.copyOf((long[]) ArrayNodes.getStore(from), ArrayNodes.getSize(from)), ArrayNodes.getSize(from));
+        return createArray(Arrays.copyOf((long[]) ArrayNodes.getStore(from), ArrayNodes.getSize(from)), ArrayNodes.getSize(from));
     }
 
     @Specialization(guards = "isFloat(from)")
     public RubyArray dupFloat(RubyArray from) {
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), Arrays.copyOf((double[]) ArrayNodes.getStore(from), ArrayNodes.getSize(from)), ArrayNodes.getSize(from));
+        return createArray(Arrays.copyOf((double[]) ArrayNodes.getStore(from), ArrayNodes.getSize(from)), ArrayNodes.getSize(from));
     }
 
     @Specialization(guards = "isObject(from)")
     public RubyArray dupObject(RubyArray from) {
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), Arrays.copyOf((Object[]) ArrayNodes.getStore(from), ArrayNodes.getSize(from)), ArrayNodes.getSize(from));
+        return createArray(Arrays.copyOf((Object[]) ArrayNodes.getStore(from), ArrayNodes.getSize(from)), ArrayNodes.getSize(from));
     }
 
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayGetTailNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayGetTailNode.java
@@ -35,17 +35,17 @@ public ArrayGetTailNode(RubyContext context, SourceSection sourceSection, int in
     public RubyArray getTailNull(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
-        return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+        return createEmptyArray();
     }
 
     @Specialization(guards = "isIntegerFixnum(array)")
     public RubyArray getTailIntegerFixnum(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
         if (index >= ArrayNodes.getSize(array)) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((int[]) ArrayNodes.getStore(array), index, ArrayNodes.getSize(array)), ArrayNodes.getSize(array) - index);
+            return createArray(ArrayUtils.extractRange((int[]) ArrayNodes.getStore(array), index, ArrayNodes.getSize(array)), ArrayNodes.getSize(array) - index);
         }
     }
 
@@ -54,9 +54,9 @@ public RubyArray getTailLongFixnum(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
         if (index >= ArrayNodes.getSize(array)) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((long[]) ArrayNodes.getStore(array), index, ArrayNodes.getSize(array)), ArrayNodes.getSize(array) - index);
+            return createArray(ArrayUtils.extractRange((long[]) ArrayNodes.getStore(array), index, ArrayNodes.getSize(array)), ArrayNodes.getSize(array) - index);
         }
     }
 
@@ -65,9 +65,9 @@ public RubyArray getTailFloat(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
         if (index >= ArrayNodes.getSize(array)) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((double[]) ArrayNodes.getStore(array), index, ArrayNodes.getSize(array)), ArrayNodes.getSize(array) - index);
+            return createArray(ArrayUtils.extractRange((double[]) ArrayNodes.getStore(array), index, ArrayNodes.getSize(array)), ArrayNodes.getSize(array) - index);
         }
     }
 
@@ -76,9 +76,9 @@ public RubyArray getTailObject(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
         if (index >= ArrayNodes.getSize(array)) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((Object[]) ArrayNodes.getStore(array), index, ArrayNodes.getSize(array)), ArrayNodes.getSize(array) - index);
+            return createArray(ArrayUtils.extractRange((Object[]) ArrayNodes.getStore(array), index, ArrayNodes.getSize(array)), ArrayNodes.getSize(array) - index);
         }
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayLiteralNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayLiteralNode.java
@@ -89,7 +89,7 @@ public EmptyArrayLiteralNode(RubyContext context, SourceSection sourceSection, R
 
         @Override
         public RubyArray executeRubyArray(VirtualFrame frame) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         }
 
     }
@@ -113,7 +113,7 @@ public RubyArray executeRubyArray(VirtualFrame frame) {
                 }
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), executedValues, values.length);
+            return createArray(executedValues, values.length);
         }
 
         private RubyArray makeGeneric(VirtualFrame frame,
@@ -148,7 +148,7 @@ public RubyArray executeRubyArray(VirtualFrame frame) {
                 }
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), executedValues, values.length);
+            return createArray(executedValues, values.length);
         }
 
         private RubyArray makeGeneric(VirtualFrame frame,
@@ -183,7 +183,7 @@ public RubyArray executeRubyArray(VirtualFrame frame) {
                 }
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), executedValues, values.length);
+            return createArray(executedValues, values.length);
         }
 
         private RubyArray makeGeneric(VirtualFrame frame,
@@ -214,7 +214,7 @@ public RubyArray executeRubyArray(VirtualFrame frame) {
                 executedValues[n] = values[n].execute(frame);
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), executedValues, values.length);
+            return createArray(executedValues, values.length);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayNodes.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayPushNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArrayPushNode.java
@@ -36,7 +36,7 @@ public Object execute(VirtualFrame frame) {
 
         final RubyArray originalArray = (RubyArray) arrayObject;
 
-        final RubyArray newArray = ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayNodes.slowToArray(originalArray), ArrayNodes.getSize(originalArray));
+        final RubyArray newArray = createArray(ArrayNodes.slowToArray(originalArray), ArrayNodes.getSize(originalArray));
         ArrayNodes.slowPush(newArray, pushed.execute(frame));
         return newArray;
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArraySliceNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/array/ArraySliceNode.java
@@ -39,7 +39,7 @@ public ArraySliceNode(RubyContext context, SourceSection sourceSection, int from
     public RubyArray sliceNull(RubyArray array) {
         CompilerDirectives.transferToInterpreter();
 
-        return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+        return createEmptyArray();
     }
 
     @Specialization(guards = "isIntegerFixnum(array)")
@@ -48,9 +48,9 @@ public RubyArray sliceIntegerFixnum(RubyArray array) {
         final int to = ArrayNodes.getSize(array) + this.to;
 
         if (from >= to) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((int[]) ArrayNodes.getStore(array), from, to), to - from);
+            return createArray(ArrayUtils.extractRange((int[]) ArrayNodes.getStore(array), from, to), to - from);
         }
     }
 
@@ -60,9 +60,9 @@ public RubyArray sliceLongFixnum(RubyArray array) {
         final int to = ArrayNodes.getSize(array) + this.to;
 
         if (from >= to) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((long[]) ArrayNodes.getStore(array), from, to), to - from);
+            return createArray(ArrayUtils.extractRange((long[]) ArrayNodes.getStore(array), from, to), to - from);
         }
     }
 
@@ -72,9 +72,9 @@ public RubyArray sliceFloat(RubyArray array) {
         final int to = ArrayNodes.getSize(array) + this.to;
 
         if (from >= to) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((double[]) ArrayNodes.getStore(array), from, to), to - from);
+            return createArray(ArrayUtils.extractRange((double[]) ArrayNodes.getStore(array), from, to), to - from);
         }
     }
 
@@ -84,9 +84,9 @@ public RubyArray sliceObject(RubyArray array) {
         final int to = ArrayNodes.getSize(array) + this.to;
 
         if (from >= to) {
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         } else {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.extractRange((Object[]) ArrayNodes.getStore(array), from, to), to - from);
+            return createArray(ArrayUtils.extractRange((Object[]) ArrayNodes.getStore(array), from, to), to - from);
         }
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/hash/HashNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/hash/HashNodes.java
@@ -675,7 +675,7 @@ public RubyHash eachPackedArray(VirtualFrame frame, RubyHash hash, RubyProc bloc
                     }
 
                     if (n < size) {
-                        yield(frame, block, ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new Object[]{PackedArrayStrategy.getKey(store, n), PackedArrayStrategy.getValue(store, n)}, 2));
+                        yield(frame, block, createArray(new Object[]{PackedArrayStrategy.getKey(store, n), PackedArrayStrategy.getValue(store, n)}, 2));
                     }
                 }
             } finally {
@@ -692,7 +692,7 @@ public RubyHash eachBuckets(VirtualFrame frame, RubyHash hash, RubyProc block) {
             assert HashOperations.verifyStore(hash);
 
             for (KeyValue keyValue : verySlowToKeyValues(hash)) {
-                yield(frame, block, ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new Object[]{keyValue.getKey(), keyValue.getValue()}, 2));
+                yield(frame, block, createArray(new Object[]{keyValue.getKey(), keyValue.getValue()}, 2));
             }
 
             return hash;
@@ -853,7 +853,7 @@ public MapNode(RubyContext context, SourceSection sourceSection) {
         public RubyArray mapNull(VirtualFrame frame, RubyHash hash, RubyProc block) {
             assert HashOperations.verifyStore(hash);
 
-            return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            return createEmptyArray();
         }
 
         @ExplodeLoop
@@ -886,7 +886,7 @@ public RubyArray mapPackedArray(VirtualFrame frame, RubyHash hash, RubyProc bloc
                 }
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), result, size);
+            return createArray(result, size);
         }
 
         @Specialization(guards = "isBucketsStorage(hash)")
@@ -895,7 +895,7 @@ public RubyArray mapBuckets(VirtualFrame frame, RubyHash hash, RubyProc block) {
 
             assert HashOperations.verifyStore(hash);
 
-            final RubyArray array = ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
+            final RubyArray array = createEmptyArray();
 
             for (KeyValue keyValue : HashOperations.verySlowToKeyValues(hash)) {
                 ArrayNodes.slowPush(array, yield(frame, block, keyValue.getKey(), keyValue.getValue()));

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/EncodingConverterPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/EncodingConverterPrimitiveNodes.java
@@ -269,7 +269,7 @@ public Object encodingConverterLastError(RubyEncodingConverter encodingConverter
                 ret[4] = getContext().makeString(new ByteList(ec.lastError.getErrorBytes(), ec.lastError.getErrorBytesP() + ec.lastError.getErrorBytesLength(), ec.lastError.getReadAgainLength()));
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), ret, ret.length);
+            return createArray(ret, ret.length);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/FixnumPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/FixnumPrimitiveNodes.java
@@ -45,12 +45,12 @@ public FixnumCoercePrimitiveNode(RubyContext context, SourceSection sourceSectio
 
         @Specialization
         public RubyArray coerce(int a, int b) {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new int[]{b, a}, 2);
+            return createArray(new int[]{b, a}, 2);
         }
 
         @Specialization
         public RubyArray coerce(long a, int b) {
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new long[]{b, a}, 2);
+            return createArray(new long[]{b, a}, 2);
         }
 
         @Specialization(guards = "!isInteger(b)")

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/IOPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/IOPrimitiveNodes.java
@@ -641,7 +641,7 @@ private RubyArray getSetObjects(Object[] objects, int[] fds, FDSet set) {
                 }
             }
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), setObjects, setFdsCount);
+            return createArray(setObjects, setFdsCount);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/RubiniusSingleBlockArgNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/RubiniusSingleBlockArgNode.java
@@ -50,7 +50,7 @@ public Object execute(VirtualFrame frame) {
             } else {
                 Object[] extractedArguments = RubyArguments.extractUserArguments(frame.getArguments());
 
-                return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), extractedArguments, userArgumentCount);
+                return createArray(extractedArguments, userArgumentCount);
             }
         }
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/TimePrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/TimePrimitiveNodes.java
@@ -183,7 +183,7 @@ public RubyArray timeDecompose(RubyTime time) {
             }
 
             final Object[] decomposed = new Object[]{sec, min, hour, day, month, year, wday, yday, isdst, zone};
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), decomposed, decomposed.length);
+            return createArray(decomposed, decomposed.length);
         }
 
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/VMPrimitiveNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/rubinius/VMPrimitiveNodes.java
@@ -417,7 +417,7 @@ public RubyArray times() {
             final double tutime = 0;
             final double tstime = 0;
 
-            return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), new double[]{
+            return createArray(new double[]{
                     utime,
                     stime,
                     cutime,