jruby · Feb 5, 2015 · Feb 5, 2015 · Feb 5, 2015 · Feb 6, 2015 · Feb 6, 2015
diff --git a/core/src/main/java/org/jruby/RubySignal.java b/core/src/main/java/org/jruby/RubySignal.java
@@ -68,15 +68,15 @@ public static Map<String, Integer> list() {
                 continue;
 
             // replace CLD with CHLD value
-            int longValue = s.intValue();
+            int signo = s.intValue();
             if (s == Signal.SIGCLD)
-                longValue = Signal.SIGCHLD.intValue();
+                signo = Signal.SIGCHLD.intValue();
 
             // omit unsupported signals
-            if (longValue >= 20000)
+            if (signo >= 20000)
                 continue;
 
-            signals.put(s.description().substring("SIG".length()), longValue);
+            signals.put(s.description().substring("SIG".length()), signo);
         }
 
         return signals;
@@ -85,7 +85,10 @@ public static Map<String, Integer> list() {
     @JRubyMethod(meta = true)
     public static IRubyObject list(ThreadContext context, IRubyObject recv) {
         Ruby runtime = recv.getRuntime();
-        RubyHash names = RubyHash.newHash(runtime, RubySignal.list(), runtime.getNil());
+        RubyHash names = RubyHash.newHash(runtime);
+        for (Map.Entry<String, Integer> sig : RubySignal.list().entrySet()) {
+            names.op_aset(context, runtime.newString(sig.getKey()), runtime.newFixnum(sig.getValue()));
+        }
         names.op_aset(context, runtime.newString("EXIT"), runtime.newFixnum(0));
         return names;
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyCallNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyCallNode.java
@@ -46,6 +46,7 @@ public class RubyCallNode extends RubyNode {
     @CompilerDirectives.CompilationFinal private boolean seenNullInUnsplat = false;
     @CompilerDirectives.CompilationFinal private boolean seenIntegerFixnumInUnsplat = false;
     @CompilerDirectives.CompilationFinal private boolean seenLongFixnumInUnsplat = false;
+    @CompilerDirectives.CompilationFinal private boolean seenFloatInUnsplat = false;
     @CompilerDirectives.CompilationFinal private boolean seenObjectInUnsplat = false;
 
     @Child private CallDispatchHeadNode respondToMissing;
@@ -136,6 +137,8 @@ private Object[] splat(Object argument) {
             return ArrayUtils.boxUntil((int[]) store, size);
         } else if (seenLongFixnumInUnsplat && store instanceof long[]) {
             return ArrayUtils.boxUntil((long[]) store, size);
+        } else if (seenFloatInUnsplat && store instanceof double[]) {
+            return ArrayUtils.boxUntil((double[]) store, size);
         } else if (seenObjectInUnsplat && store instanceof Object[]) {
             return ArrayUtils.extractRange((Object[]) store, 0, size);
         }
@@ -151,6 +154,9 @@ private Object[] splat(Object argument) {
         } else if (store instanceof long[]) {
             seenLongFixnumInUnsplat = true;
             return ArrayUtils.boxUntil((long[]) store, size);
+        } else if (store instanceof double[]) {
+            seenFloatInUnsplat = true;
+            return ArrayUtils.boxUntil((double[]) store, size);
         } else if (store instanceof Object[]) {
             seenObjectInUnsplat = true;
             return ArrayUtils.extractRange((Object[]) store, 0, size);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/array/ArrayReadDenormalizedNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/array/ArrayReadDenormalizedNode.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.nodes.array;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.dsl.NodeChild;
+import com.oracle.truffle.api.dsl.NodeChildren;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.source.SourceSection;
+import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.core.RubyArray;
+
+@NodeChildren({
+        @NodeChild(value="array", type=RubyNode.class),
+        @NodeChild(value="index", type=RubyNode.class)
+})
+public abstract class ArrayReadDenormalizedNode extends RubyNode {
+
+    @Child private ArrayReadNormalizedNode readNode;
+
+    public ArrayReadDenormalizedNode(RubyContext context, SourceSection sourceSection) {
+        super(context, sourceSection);
+    }
+
+    public ArrayReadDenormalizedNode(ArrayReadDenormalizedNode prev) {
+        super(prev);
+        readNode = prev.readNode;
+    }
+
+    public abstract Object executeRead(VirtualFrame frame, RubyArray array, int index);
+
+    @Specialization
+    public Object read(VirtualFrame frame, RubyArray array, int index) {
+        if (readNode == null) {
+            CompilerDirectives.transferToInterpreter();
+            readNode = insert(ArrayReadNormalizedNodeFactory.create(getContext(), getSourceSection(), null, null));
+        }
+
+        final int normalizedIndex = array.normaliseIndex(index);
+
+        return readNode.executeRead(frame, array, normalizedIndex);
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/array/ArrayReadNormalizedNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/array/ArrayReadNormalizedNode.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.nodes.array;
+
+import com.oracle.truffle.api.dsl.ImportGuards;
+import com.oracle.truffle.api.dsl.NodeChild;
+import com.oracle.truffle.api.dsl.NodeChildren;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.UnexpectedResultException;
+import com.oracle.truffle.api.source.SourceSection;
+import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.ArrayGuards;
+import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.core.RubyArray;
+import org.jruby.truffle.runtime.core.RubyNilClass;
+
+@NodeChildren({
+        @NodeChild(value="array", type=RubyNode.class),
+        @NodeChild(value="index", type=RubyNode.class)
+})
+@ImportGuards(ArrayGuards.class)
+public abstract class ArrayReadNormalizedNode extends RubyNode {
+
+    public ArrayReadNormalizedNode(RubyContext context, SourceSection sourceSection) {
+        super(context, sourceSection);
+    }
+
+    public ArrayReadNormalizedNode(ArrayReadNormalizedNode prev) {
+        super(prev);
+    }
+
+    public abstract Object executeRead(VirtualFrame frame, RubyArray array, int index);
+
+    @Specialization(
+            guards="isNullArray"
+    )
+    public RubyNilClass readNull(RubyArray array, int index) {
+        return getContext().getCoreLibrary().getNilObject();
+    }
+
+    @Specialization(
+            guards={"isNormalisedInBounds", "isIntegerArray"}
+    )
+    public int readIntegerInBounds(RubyArray array, int index) {
+        return ((int[]) array.getStore())[index];
+    }
+
+    @Specialization(
+            guards={"isNormalisedInBounds", "isLongArray"}
+    )
+    public long readLongInBounds(RubyArray array, int index) {
+        return ((long[]) array.getStore())[index];
+    }
+
+    @Specialization(
+            guards={"isNormalisedInBounds", "isDoubleArray"}
+    )
+    public double readDoubleInBounds(RubyArray array, int index) {
+        return ((double[]) array.getStore())[index];
+    }
+
+    @Specialization(
+            guards={"isNormalisedInBounds", "isObjectArray"}
+    )
+    public Object readObjectInBounds(RubyArray array, int index) {
+        return ((Object[]) array.getStore())[index];
+    }
+
+    @Specialization(
+            guards="!isNormalisedInBounds"
+    )
+    public RubyNilClass readOutOfBounds(RubyArray array, int index) {
+        return getContext().getCoreLibrary().getNilObject();
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/array/NewFixnumLowerNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/array/NewFixnumLowerNode.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.nodes.array;
+
+import com.oracle.truffle.api.dsl.NodeChild;
+import com.oracle.truffle.api.dsl.Specialization;
+import com.oracle.truffle.api.source.SourceSection;
+import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.core.CoreLibrary;
+
+/**
+ * Passes through {@code int} values unmodified, but will convert a {@code long} value to an {@code int}, if it fits
+ * within the range of an {@code int}. Leaves all other values unmodified. Used where a specialisation only accepts
+ * {@code int}, such as Java array indexing, but we would like to also handle {@code long} if they also fit within an
+ * {@code int}.
+ */
+@NodeChild(value="child", type=RubyNode.class)
+public abstract class NewFixnumLowerNode extends RubyNode {
+
+    public NewFixnumLowerNode(RubyContext context, SourceSection sourceSection) {
+        super(context, sourceSection);
+    }
+
+    public NewFixnumLowerNode(NewFixnumLowerNode prev) {
+        super(prev);
+    }
+
+    @Specialization
+    public int lower(int value) {
+        return value;
+    }
+
+    @Specialization(guards="canLower")
+    public int lower(long value) {
+        return (int) value;
+    }
+
+    @Specialization(guards="!canLower")
+    public long lowerFails(long value) {
+        return value;
+    }
+
+    protected static boolean canLower(long value) {
+        return CoreLibrary.fitsIntoInteger(value);
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/array/PrimitiveArrayNodeFactory.java b/truffle/src/main/java/org/jruby/truffle/nodes/array/PrimitiveArrayNodeFactory.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2015 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.nodes.array;
+
+import com.oracle.truffle.api.source.SourceSection;
+import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.literal.FixnumLiteralNode;
+import org.jruby.truffle.runtime.RubyContext;
+
+public abstract class PrimitiveArrayNodeFactory {
+
+    /**
+     * Create a node to read from an array with a constant denormalised index.
+     */
+    public static RubyNode read(RubyContext context, SourceSection sourceSection, RubyNode array, int index) {
+        final RubyNode literalIndex = new FixnumLiteralNode.IntegerFixnumLiteralNode(context, sourceSection, index);
+
+        if (index > 0) {
+            return ArrayReadNormalizedNodeFactory.create(context, sourceSection, array, literalIndex);
+        } else {
+            return ArrayReadDenormalizedNodeFactory.create(context, sourceSection, array, literalIndex);
+        }
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ArrayBuilderNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ArrayBuilderNode.java
@@ -440,6 +440,36 @@ public Object append(Object store, int index, RubyArray array) {
 
             CompilerDirectives.transferToInterpreterAndInvalidate();
 
+            if (otherStore instanceof int[]) {
+                // TODO CS 5-Feb-15 hack to get things working with empty int[] store
+
+                if (((int[]) otherStore).length > 0) {
+                    throw new UnsupportedOperationException();
+                }
+
+                return store;
+            }
+
+            if (otherStore instanceof long[]) {
+                // TODO CS 5-Feb-15 hack to get things working with empty long[] store
+
+                if (((long[]) otherStore).length > 0) {
+                    throw new UnsupportedOperationException();
+                }
+
+                return store;
+            }
+
+            if (otherStore instanceof double[]) {
+                // TODO CS 5-Feb-15 hack to get things working with empty double[] store
+
+                if (((double[]) otherStore).length > 0) {
+                    throw new UnsupportedOperationException();
+                }
+
+                return store;
+            }
+
             if (otherStore instanceof Object[]) {
                 hasAppendedObjectArray = true;
                 System.arraycopy(otherStore, 0, store, index, array.getSize());

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ArrayGuards.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ArrayGuards.java
@@ -73,4 +73,30 @@ public static boolean areBothObject(RubyArray a, RubyArray b) {
         return a.getStore() instanceof Object[] && b.getStore() instanceof Object[];
     }
 
+    // New names
+
+    public static boolean isNullArray(RubyArray array) {
+        return array.getStore() == null;
+    }
+
+    public static boolean isIntegerArray(RubyArray array) {
+        return array.getStore() instanceof int[];
+    }
+
+    public static boolean isLongArray(RubyArray array) {
+        return array.getStore() instanceof long[];
+    }
+
+    public static boolean isDoubleArray(RubyArray array) {
+        return array.getStore() instanceof double[];
+    }
+
+    public static boolean isObjectArray(RubyArray array) {
+        return array.getStore() instanceof Object[];
+    }
+
+    public static boolean isNormalisedInBounds(RubyArray array, int index) {
+        return index >= 0 && index < array.getSize();
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ArrayIndexNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ArrayIndexNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ArrayNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ArrayNodes.java
@@ -26,13 +26,14 @@
 import org.jruby.truffle.nodes.CoreSourceSection;
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.RubyRootNode;
+import org.jruby.truffle.nodes.array.ArrayReadDenormalizedNode;
+import org.jruby.truffle.nodes.array.ArrayReadDenormalizedNodeFactory;
 import org.jruby.truffle.nodes.dispatch.*;
 import org.jruby.truffle.nodes.methods.arguments.MissingArgumentBehaviour;
 import org.jruby.truffle.nodes.methods.arguments.ReadPreArgumentNode;
 import org.jruby.truffle.nodes.methods.locals.ReadLevelVariableNodeFactory;
 import org.jruby.truffle.nodes.yield.YieldDispatchHeadNode;
 import org.jruby.truffle.runtime.*;
-import org.jruby.truffle.nodes.core.ArrayNodesFactory.AtNodeFactory;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.UndefinedPlaceholder;
@@ -136,6 +137,54 @@ public RubyArray addNullObject(RubyArray a, RubyArray b) {
             return new RubyArray(getContext().getCoreLibrary().getArrayClass(), Arrays.copyOf((Object[]) b.getStore(), size), size);
         }
 
+        @Specialization(guards = "isIntegerFixnum")
+        public RubyArray addEmptyIntegerFixnum(RubyArray a, RubyArray b) {
+            // TODO CS 5-Feb-15 hack to get things working with empty int[] store
+
+            if (a.getSize() != 0) {
+                throw new UnsupportedOperationException();
+            }
+
+            final int size = b.getSize();
+            return new RubyArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.box(b.getStore()), size);
+        }
+
+        @Specialization(guards = "isLongFixnum")
+        public RubyArray addEmptyLongFixnum(RubyArray a, RubyArray b) {
+            // TODO CS 5-Feb-15 hack to get things working with empty long[] store
+
+            if (a.getSize() != 0) {
+                throw new UnsupportedOperationException();
+            }
+
+            final int size = b.getSize();
+            return new RubyArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.box(b.getStore()), size);
+        }
+
+        @Specialization(guards = "isFloat")
+        public RubyArray addEmptyDouble(RubyArray a, RubyArray b) {
+            // TODO CS 5-Feb-15 hack to get things working with empty double[] store
+
+            if (a.getSize() != 0) {
+                throw new UnsupportedOperationException();
+            }
+
+            final int size = b.getSize();
+            return new RubyArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.box(b.getStore()), size);
+        }
+
+        @Specialization(guards = "isObject")
+        public RubyArray addEmptyObject(RubyArray a, RubyArray b) {
+            // TODO CS 5-Feb-15 hack to get things working with empty Object[] store
+
+            if (a.getSize() != 0) {
+                throw new UnsupportedOperationException();
+            }
+
+            final int size = b.getSize();
+            return new RubyArray(getContext().getCoreLibrary().getArrayClass(), ArrayUtils.box(b.getStore()), size);
+        }
+
     }
 
     @CoreMethod(names = "-", required = 1)
@@ -548,124 +597,57 @@ public boolean equal(VirtualFrame frame, RubyArray a, Object b) {
     @CoreMethod(names = "at", required = 1, lowerFixnumParameters = 0)
     public abstract static class AtNode extends ArrayCoreMethodNode {
 
+        @Child private ArrayReadDenormalizedNode readNode;
+
         public AtNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
         }
 
         public AtNode(AtNode prev) {
             super(prev);
+            readNode = prev.readNode;
         }
 
-        public abstract Object executeAt(RubyArray array, int index);
-
-        @Specialization(guards = "isNull")
-        public RubyNilClass getNull(RubyArray array, int index) {
-            return getContext().getCoreLibrary().getNilObject();
-        }
-
-        @Specialization(guards = "isIntegerFixnum", rewriteOn = UnexpectedResultException.class)
-        public int getIntegerFixnumInBounds(RubyArray array, int index) throws UnexpectedResultException {
-            int normalisedIndex = array.normaliseIndex(index);
-
-            if (normalisedIndex < 0 || normalisedIndex >= array.getSize()) {
-                throw new UnexpectedResultException(getContext().getCoreLibrary().getNilObject());
-            } else {
-                return ((int[]) array.getStore())[normalisedIndex];
-            }
-        }
-
-        @Specialization(contains = "getIntegerFixnumInBounds", guards = "isIntegerFixnum")
-        public Object getIntegerFixnum(RubyArray array, int index) {
-            int normalisedIndex = array.normaliseIndex(index);
-
-            if (normalisedIndex < 0 || normalisedIndex >= array.getSize()) {
-                return getContext().getCoreLibrary().getNilObject();
-            } else {
-                return ((int[]) array.getStore())[normalisedIndex];
-            }
-        }
-
-        @Specialization(guards = "isLongFixnum", rewriteOn = UnexpectedResultException.class)
-        public long getLongFixnumInBounds(RubyArray array, int index) throws UnexpectedResultException {
-            int normalisedIndex = array.normaliseIndex(index);
-
-            if (normalisedIndex < 0 || normalisedIndex >= array.getSize()) {
-                throw new UnexpectedResultException(getContext().getCoreLibrary().getNilObject());
-            } else {
-                return ((long[]) array.getStore())[normalisedIndex];
-            }
-        }
-
-        @Specialization(contains = "getLongFixnumInBounds", guards = "isLongFixnum")
-        public Object getLongFixnum(RubyArray array, int index) {
-            int normalisedIndex = array.normaliseIndex(index);
-
-            if (normalisedIndex < 0 || normalisedIndex >= array.getSize()) {
-                return getContext().getCoreLibrary().getNilObject();
-            } else {
-                return ((long[]) array.getStore())[normalisedIndex];
-            }
-        }
-
-        @Specialization(guards = "isFloat", rewriteOn = UnexpectedResultException.class)
-        public double getFloatInBounds(RubyArray array, int index) throws UnexpectedResultException {
-            int normalisedIndex = array.normaliseIndex(index);
-
-            if (normalisedIndex < 0 || normalisedIndex >= array.getSize()) {
-                throw new UnexpectedResultException(getContext().getCoreLibrary().getNilObject());
-            } else {
-                return ((double[]) array.getStore())[normalisedIndex];
-            }
-        }
-
-        @Specialization(contains = "getFloatInBounds", guards = "isFloat")
-        public Object getFloat(RubyArray array, int index) {
-            int normalisedIndex = array.normaliseIndex(index);
-
-            if (normalisedIndex < 0 || normalisedIndex >= array.getSize()) {
-                return getContext().getCoreLibrary().getNilObject();
-            } else {
-                return ((double[]) array.getStore())[normalisedIndex];
+        @Specialization
+        public Object at(VirtualFrame frame, RubyArray array, int index) {
+            if (readNode == null) {
+                CompilerDirectives.transferToInterpreter();
+                readNode = insert(ArrayReadDenormalizedNodeFactory.create(getContext(), getSourceSection(), null, null));
             }
-        }
-
-        @Specialization(guards = "isObject")
-        public Object getObject(RubyArray array, int index) {
-            int normalisedIndex = array.normaliseIndex(index);
 
-            if (normalisedIndex < 0 || normalisedIndex >= array.getSize()) {
-                return getContext().getCoreLibrary().getNilObject();
-            } else {
-                return ((Object[]) array.getStore())[normalisedIndex];
-            }
+            return readNode.executeRead(frame, array, index);
         }
 
     }
 
     @CoreMethod(names = { "[]", "slice" }, required = 1, optional = 1, lowerFixnumParameters = { 0, 1 })
     public abstract static class IndexNode extends ArrayCoreMethodNode {
 
-        @Child protected AtNode atNode;
+        @Child protected ArrayReadDenormalizedNode readNode;
         @Child protected CallDispatchHeadNode fallbackNode;
 
         private final BranchProfile outOfBounds = BranchProfile.create();
 
         public IndexNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
-            atNode = AtNodeFactory.create(context, sourceSection, new RubyNode[] { null, null });
         }
 
         public IndexNode(IndexNode prev) {
             super(prev);
-            atNode = prev.atNode;
+            readNode = prev.readNode;
             fallbackNode = prev.fallbackNode;
         }
 
         // Simple indexing
 
         @Specialization
-        public Object index(RubyArray array, int index, UndefinedPlaceholder undefined) {
-            return atNode.executeAt(array, index);
+        public Object index(VirtualFrame frame, RubyArray array, int index, UndefinedPlaceholder undefined) {
+            if (readNode == null) {
+                CompilerDirectives.transferToInterpreter();
+                readNode = insert(ArrayReadDenormalizedNodeFactory.create(getContext(), getSourceSection(), null, null));
+            }
+
+            return readNode.executeRead(frame, array, index);
         }
 
         // Slice with two fixnums
@@ -2084,6 +2066,23 @@ public boolean includeLongFixnum(VirtualFrame frame, RubyArray array, Object val
             return false;
         }
 
+        @Specialization(guards = "isFloat")
+        public boolean includeFloat(VirtualFrame frame, RubyArray array, Object value) {
+            final double[] store = (double[]) array.getStore();
+
+            for (int n = 0; n < array.getSize(); n++) {
+                final Object stored = store[n];
+
+                notDesignedForCompilation();
+
+                if (equalNode.executeSameOrEqual(frame, stored, value)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         @Specialization(guards = "isObject")
         public boolean includeObject(VirtualFrame frame, RubyArray array, Object value) {
             final Object[] store = (Object[]) array.getStore();
@@ -3289,6 +3288,30 @@ public RubyArray pushLongFixnumSingleLongFixnum(RubyArray array, Object... value
             return array;
         }
 
+        @Specialization(guards = "isLongFixnum")
+        public RubyArray pushLongFixnum(RubyArray array, Object... values) {
+            // TODO CS 5-Feb-15 hack to get things working with empty long[] store
+
+            if (array.getSize() != 0) {
+                throw new UnsupportedOperationException();
+            }
+
+            array.setStore(values, values.length);
+            return array;
+        }
+
+        @Specialization(guards = "isFloat")
+        public RubyArray pushFloat(RubyArray array, Object... values) {
+            // TODO CS 5-Feb-15 hack to get things working with empty double[] store
+
+            if (array.getSize() != 0) {
+                throw new UnsupportedOperationException();
+            }
+
+            array.setStore(values, values.length);
+            return array;
+        }
+
         @Specialization(guards = "isObject")
         public RubyArray pushObject(RubyArray array, Object... values) {
             final int oldSize = array.getSize();

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyArray.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyArray.java
@@ -223,6 +223,25 @@ public void setStore(Object store, int size) {
 
     @CompilerDirectives.TruffleBoundary
     private static Object randomizeStorageStrategy(Object store, int size) {
+        // Use any type for empty arrays
+
+        if (size == 0) {
+            switch (random.nextInt(5)) {
+                case 0:
+                    return null;
+                case 1:
+                    return new int[]{};
+                case 2:
+                    return new long[]{};
+                case 3:
+                    return new double[]{};
+                case 4:
+                    return new Object[]{};
+                default:
+                    throw new IllegalStateException();
+            }
+        }
+
         // Convert to the canonical store type first
 
         final Object[] boxedStore = ArrayUtils.box(store);
@@ -272,7 +291,7 @@ private static Object randomizeStorageStrategy(Object store, int size) {
 
             return canonicalStore;
         } else {
-            return canonicalStore;
+            throw new UnsupportedOperationException();
         }
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/translator/BodyTranslator.java b/truffle/src/main/java/org/jruby/truffle/translator/BodyTranslator.java
@@ -23,6 +23,7 @@
 import org.jruby.truffle.nodes.*;
 import org.jruby.truffle.nodes.DefinedNode;
 import org.jruby.truffle.nodes.ForNode;
+import org.jruby.truffle.nodes.array.PrimitiveArrayNodeFactory;
 import org.jruby.truffle.nodes.cast.*;
 import org.jruby.truffle.nodes.cast.LambdaNode;
 import org.jruby.truffle.nodes.control.AndNode;
@@ -38,7 +39,6 @@
 import org.jruby.truffle.nodes.control.ReturnNode;
 import org.jruby.truffle.nodes.control.WhileNode;
 import org.jruby.truffle.nodes.core.*;
-import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
 import org.jruby.truffle.nodes.globals.*;
 import org.jruby.truffle.nodes.literal.*;
 import org.jruby.truffle.nodes.methods.*;
@@ -1801,7 +1801,7 @@ public RubyNode visitMultipleAsgnNode(org.jruby.ast.MultipleAsgn19Node node) {
              */
 
             for (int n = 0; n < preArray.size(); n++) {
-                final ArrayIndexNode assignedValue = ArrayIndexNodeFactory.create(context, sourceSection, n, environment.findLocalVarNode(tempName, sourceSection));
+                final RubyNode assignedValue = PrimitiveArrayNodeFactory.read(context, sourceSection, environment.findLocalVarNode(tempName, sourceSection), n);
 
                 sequence.add(translateDummyAssignment(preArray.get(n), assignedValue));
             }
@@ -1920,7 +1920,7 @@ public RubyNode visitMultipleAsgnNode(org.jruby.ast.MultipleAsgn19Node node) {
             }
 
             for (int n = 0; n < postArray.size(); n++) {
-                final ArrayIndexNode assignedValue = ArrayIndexNodeFactory.create(context, sourceSection, -(postArray.size() - n), environment.findLocalVarNode(tempName, sourceSection));
+                final RubyNode assignedValue = PrimitiveArrayNodeFactory.read(context, sourceSection, environment.findLocalVarNode(tempName, sourceSection), -(postArray.size() - n));
 
                 sequence.add(translateDummyAssignment(postArray.get(n), assignedValue));
             }

diff --git a/truffle/src/main/java/org/jruby/truffle/translator/LoadArgumentsTranslator.java b/truffle/src/main/java/org/jruby/truffle/translator/LoadArgumentsTranslator.java
@@ -18,11 +18,10 @@
 import org.jruby.lexer.yacc.ISourcePosition;
 import org.jruby.truffle.nodes.ReadNode;
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.array.PrimitiveArrayNodeFactory;
 import org.jruby.truffle.nodes.cast.ArrayCastNodeFactory;
-import org.jruby.truffle.nodes.cast.BooleanCastNodeFactory;
 import org.jruby.truffle.nodes.control.IfNode;
 import org.jruby.truffle.nodes.control.SequenceNode;
-import org.jruby.truffle.nodes.core.ArrayIndexNodeFactory;
 import org.jruby.truffle.nodes.core.ArraySliceNodeFactory;
 import org.jruby.truffle.nodes.literal.ArrayLiteralNode;
 import org.jruby.truffle.nodes.literal.NilLiteralNode;
@@ -209,7 +208,7 @@ public RubyNode visitArgumentNode(org.jruby.ast.ArgumentNode node) {
 
     private RubyNode readArgument(SourceSection sourceSection) {
         if (useArray()) {
-            return ArrayIndexNodeFactory.create(context, sourceSection, index, loadArray(sourceSection));
+            return PrimitiveArrayNodeFactory.read(context, sourceSection, loadArray(sourceSection), index);
         } else {
             if (state == State.PRE) {
                 return new ReadPreArgumentNode(context, sourceSection, index, isBlock ? MissingArgumentBehaviour.NIL : MissingArgumentBehaviour.RUNTIME_ERROR);
@@ -278,7 +277,7 @@ private RubyNode translateLocalAssignment(ISourcePosition sourcePosition, String
                 // Multiple assignment
 
                 if (useArray()) {
-                    readNode = ArrayIndexNodeFactory.create(context, sourceSection, index, loadArray(sourceSection));
+                    readNode = PrimitiveArrayNodeFactory.read(context, sourceSection, loadArray(sourceSection), index);
                 } else {
                     readNode = readArgument(sourceSection);
                 }