jruby · Jun 5, 2015 · Jun 5, 2015 · Jun 5, 2015 · Jun 5, 2015 · Jun 5, 2015
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyGuards.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyGuards.java
@@ -10,11 +10,7 @@
 package org.jruby.truffle.nodes;
 
 import com.oracle.truffle.api.interop.TruffleObject;
-import org.jruby.truffle.nodes.core.BigDecimalNodes;
-import org.jruby.truffle.nodes.core.MethodNodes;
-import org.jruby.truffle.nodes.core.StringNodes;
-import org.jruby.truffle.nodes.core.UnboundMethodNodes;
-import org.jruby.truffle.nodes.core.array.ArrayNodes;
+import org.jruby.truffle.nodes.core.*;
 import org.jruby.truffle.nodes.core.hash.HashNodes;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.ThreadLocalObject;
@@ -43,7 +39,11 @@ public static boolean isDouble(Object value) {
     // Ruby types
 
     public static boolean isRubyBignum(Object value) {
-        return value instanceof RubyBignum;
+        return (value instanceof RubyBasicObject) && isRubyBignum((RubyBasicObject) value);
+    }
+
+    public static boolean isRubyBignum(RubyBasicObject value) {
+        return value.getDynamicObject().getShape().getObjectType() == BignumNodes.BIGNUM_TYPE;
     }
 
     public static boolean isRubyBigDecimal(RubyBasicObject value) {
@@ -66,6 +66,7 @@ public static boolean isRubyArray(RubyBasicObject value) {
         //return value.getDynamicObject().getShape().getObjectType() == ArrayNodes.ARRAY_TYPE;
         return value instanceof RubyArray;
     }
+
     public static boolean isRubyBinding(Object value) {
         return value instanceof RubyBinding;
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java
@@ -109,16 +109,6 @@ public long executeLong(VirtualFrame frame) throws UnexpectedResultException {
         }
     }
 
-    public RubyBignum executeRubyBignum(VirtualFrame frame) throws UnexpectedResultException {
-        final Object value = execute(frame);
-
-        if (value instanceof RubyBignum) {
-            return (RubyBignum) value;
-        } else {
-            throw new UnexpectedResultException(value);
-        }
-    }
-
     public RubyRange.IntegerFixnumRange executeIntegerFixnumRange(VirtualFrame frame) throws UnexpectedResultException {
         final Object value = execute(frame);
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/control/TraceNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/control/TraceNode.java
@@ -22,7 +22,6 @@
 import org.jruby.truffle.runtime.core.RubyBasicObject;
 import org.jruby.truffle.runtime.core.RubyBinding;
 import org.jruby.truffle.runtime.core.RubyProc;
-import org.jruby.truffle.runtime.core.RubyString;
 
 public class TraceNode extends RubyNode {
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BigDecimalNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BigDecimalNodes.java
@@ -15,21 +15,20 @@
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.object.*;
 import com.oracle.truffle.api.source.SourceSection;
-
 import com.oracle.truffle.api.utilities.ConditionProfile;
+import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.cast.IntegerCastNode;
 import org.jruby.truffle.nodes.cast.IntegerCastNodeGen;
 import org.jruby.truffle.nodes.coerce.ToIntNode;
 import org.jruby.truffle.nodes.coerce.ToIntNodeGen;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
 import org.jruby.truffle.nodes.objects.Allocator;
+import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.RubyBasicObject;
-import org.jruby.truffle.runtime.core.RubyBignum;
 import org.jruby.truffle.runtime.core.RubyClass;
-import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.object.BasicObjectType;
 
 import java.math.BigDecimal;
@@ -73,30 +72,34 @@ public static BigDecimal getBigDecimalValue(double v) {
         return BigDecimal.valueOf(v);
     }
 
-    public static BigDecimal getBigDecimalValue(RubyBignum v) {
+    public static BigDecimal getBignumBigDecimalValue(RubyBasicObject v) {
         return new BigDecimal(BignumNodes.getBigIntegerValue(v));
     }
 
-    public static BigDecimal getBigDecimalValue(RubyBasicObject bignum) {
-        assert bignum.getDynamicObject().getShape().hasProperty(VALUE_IDENTIFIER);
-        return (BigDecimal) VALUE_PROPERTY.get(bignum.getDynamicObject(), true);
+    public static BigDecimal getBigDecimalValue(RubyBasicObject bigdecimal) {
+        assert RubyGuards.isRubyBigDecimal(bigdecimal);
+        assert bigdecimal.getDynamicObject().getShape().hasProperty(VALUE_IDENTIFIER);
+        return (BigDecimal) VALUE_PROPERTY.get(bigdecimal.getDynamicObject(), true);
     }
 
-    public static Type getBigDecimalType(RubyBasicObject bignum) {
-        assert bignum.getDynamicObject().getShape().hasProperty(TYPE_IDENTIFIER);
-        return (Type) TYPE_PROPERTY.get(bignum.getDynamicObject(), true);
+    public static Type getBigDecimalType(RubyBasicObject bigdecimal) {
+        assert RubyGuards.isRubyBigDecimal(bigdecimal);
+        assert bigdecimal.getDynamicObject().getShape().hasProperty(TYPE_IDENTIFIER);
+        return (Type) TYPE_PROPERTY.get(bigdecimal.getDynamicObject(), true);
     }
 
-    private static void setBigDecimalValue(RubyBasicObject bignum, BigDecimal value) {
-        assert bignum.getDynamicObject().getShape().hasProperty(VALUE_IDENTIFIER);
-        VALUE_PROPERTY.setSafe(bignum.getDynamicObject(), value, null);
-        TYPE_PROPERTY.setSafe(bignum.getDynamicObject(), Type.NORMAL, null);
+    private static void setBigDecimalValue(RubyBasicObject bigdecimal, BigDecimal value) {
+        assert RubyGuards.isRubyBigDecimal(bigdecimal);
+        assert bigdecimal.getDynamicObject().getShape().hasProperty(VALUE_IDENTIFIER);
+        VALUE_PROPERTY.setSafe(bigdecimal.getDynamicObject(), value, null);
+        TYPE_PROPERTY.setSafe(bigdecimal.getDynamicObject(), Type.NORMAL, null);
     }
 
-    private static void setBigDecimalValue(RubyBasicObject bignum, Type type) {
-        assert bignum.getDynamicObject().getShape().hasProperty(TYPE_IDENTIFIER);
-        VALUE_PROPERTY.setSafe(bignum.getDynamicObject(), BigDecimal.ZERO, null);
-        TYPE_PROPERTY.setSafe(bignum.getDynamicObject(), type, null);
+    private static void setBigDecimalValue(RubyBasicObject bigdecimal, Type type) {
+        assert RubyGuards.isRubyBigDecimal(bigdecimal);
+        assert bigdecimal.getDynamicObject().getShape().hasProperty(TYPE_IDENTIFIER);
+        VALUE_PROPERTY.setSafe(bigdecimal.getDynamicObject(), BigDecimal.ZERO, null);
+        TYPE_PROPERTY.setSafe(bigdecimal.getDynamicObject(), type, null);
     }
 
     public static RubyBasicObject createRubyBigDecimal(RubyClass rubyClass, Type type) {
@@ -203,14 +206,14 @@ public RubyBasicObject initialize(RubyBasicObject self, double value, NotProvide
             return self;
         }
 
-        @Specialization()
-        public RubyBasicObject initialize(RubyBasicObject self, RubyBignum value, NotProvided digits) {
-            setBigDecimalValue(self, getBigDecimalValue(value));
+        @Specialization(guards = "isRubyBignum(value)")
+        public RubyBasicObject initializeBignum(RubyBasicObject self, RubyBasicObject value, NotProvided digits) {
+            setBigDecimalValue(self, getBignumBigDecimalValue(value));
             return self;
         }
 
         @Specialization(guards = "isRubyBigDecimal(value)")
-        public RubyBasicObject initialize(RubyBasicObject self, RubyBasicObject value, NotProvided digits) {
+        public RubyBasicObject initializeBigDecimal(RubyBasicObject self, RubyBasicObject value, NotProvided digits) {
             setBigDecimalValue(self, getBigDecimalValue(value));
             return self;
         }
@@ -288,9 +291,9 @@ public Object add(RubyBasicObject a, double b) {
             return addBigDecimal(a, getBigDecimalValue(b));
         }
 
-        @Specialization(guards = "isNormal(a)")
-        public Object add(RubyBasicObject a, RubyBignum b) {
-            return addBigDecimal(a, getBigDecimalValue(b));
+        @Specialization(guards = {"isNormal(a)", "isRubyBignum(b)"})
+        public Object addBignum(RubyBasicObject a, RubyBasicObject b) {
+            return addBigDecimal(a, getBignumBigDecimalValue(b));
         }
 
         @Specialization(guards = {
@@ -311,9 +314,9 @@ public Object addSpecial(RubyBasicObject a, double b) {
             return addSpecial(a, createRubyBigDecimal(getBigDecimalValue(b)));
         }
 
-        @Specialization(guards = "!isNormal(a)")
-        public Object addSpecial(RubyBasicObject a, RubyBignum b) {
-            return addSpecial(a, createRubyBigDecimal(getBigDecimalValue(b)));
+        @Specialization(guards = {"!isNormal(a)", "isRubyBignum(b)"})
+        public Object addSpecialBignum(RubyBasicObject a, RubyBasicObject b) {
+            return addSpecial(a, createRubyBigDecimal(getBignumBigDecimalValue(b)));
         }
 
         @Specialization(guards = {
@@ -366,9 +369,9 @@ public Object add(RubyBasicObject a, double b, int precision) {
             return addBigDecimal(a, getBigDecimalValue(b), precision);
         }
 
-        @Specialization(guards = "isNormal(a)")
-        public Object add(RubyBasicObject a, RubyBignum b, int precision) {
-            return addBigDecimal(a, getBigDecimalValue(b), precision);
+        @Specialization(guards = {"isNormal(a)", "isRubyBignum(b)"})
+        public Object addBignum(RubyBasicObject a, RubyBasicObject b, int precision) {
+            return addBigDecimal(a, getBignumBigDecimalValue(b), precision);
         }
 
         @Specialization(guards = {
@@ -403,9 +406,9 @@ public Object sub(RubyBasicObject a, double b) {
             return subBigDecimal(a, getBigDecimalValue(b));
         }
 
-        @Specialization(guards = "isNormal(a)")
-        public Object sub(RubyBasicObject a, RubyBignum b) {
-            return subBigDecimal(a, getBigDecimalValue(b));
+        @Specialization(guards = {"isNormal(a)", "isRubyBignum(b)"})
+        public Object subBignum(RubyBasicObject a, RubyBasicObject b) {
+            return subBigDecimal(a, getBignumBigDecimalValue(b));
         }
 
         @Specialization(guards = {
@@ -426,9 +429,9 @@ public Object subSpecial(RubyBasicObject a, double b) {
             return subSpecial(a, createRubyBigDecimal(getBigDecimalValue(b)));
         }
 
-        @Specialization(guards = "!isNormal(a)")
-        public Object subSpecial(RubyBasicObject a, RubyBignum b) {
-            return subSpecial(a, createRubyBigDecimal(getBigDecimalValue(b)));
+        @Specialization(guards = {"!isNormal(a)", "isRubyBignum(b)"})
+        public Object subSpecialBignum(RubyBasicObject a, RubyBasicObject b) {
+            return subSpecial(a, createRubyBigDecimal(getBignumBigDecimalValue(b)));
         }
 
         @Specialization(guards = {
@@ -520,9 +523,9 @@ public Object sub(RubyBasicObject a, double b, int precision) {
             return subBigDecimal(a, getBigDecimalValue(b), precision);
         }
 
-        @Specialization(guards = "isNormal(a)")
-        public Object sub(RubyBasicObject a, RubyBignum b, int precision) {
-            return subBigDecimal(a, getBigDecimalValue(b), precision);
+        @Specialization(guards = {"isNormal(a)", "isRubyBignum(b)"})
+        public Object subBignum(RubyBasicObject a, RubyBasicObject b, int precision) {
+            return subBigDecimal(a, getBignumBigDecimalValue(b), precision);
         }
 
         @Specialization(guards = {
@@ -560,9 +563,9 @@ public Object mult(RubyBasicObject a, double b) {
             return multBigDecimal(a, getBigDecimalValue(b));
         }
 
-        @Specialization(guards = "isNormal(a)")
-        public Object mult(RubyBasicObject a, RubyBignum b) {
-            return multBigDecimal(a, getBigDecimalValue(b));
+        @Specialization(guards = {"isNormal(a)", "isRubyBignum(b)"})
+        public Object multBignum(RubyBasicObject a, RubyBasicObject b) {
+            return multBigDecimal(a, getBignumBigDecimalValue(b));
         }
 
         @Specialization(guards = {
@@ -591,9 +594,9 @@ public Object multSpecialNormal(RubyBasicObject a, double b) {
             return multSpecialNormal(a, createRubyBigDecimal(getBigDecimalValue(b)));
         }
 
-        @Specialization(guards = "!isNormal(a)")
-        public Object multSpecialNormal(RubyBasicObject a, RubyBignum b) {
-            return multSpecialNormal(a, createRubyBigDecimal(getBigDecimalValue(b)));
+        @Specialization(guards = {"!isNormal(a)", "isRubyBignum(b)"})
+        public Object multSpecialNormalBignum(RubyBasicObject a, RubyBasicObject b) {
+            return multSpecialNormal(a, createRubyBigDecimal(getBignumBigDecimalValue(b)));
         }
 
         @Specialization(guards = {
@@ -683,9 +686,9 @@ public Object mult(RubyBasicObject a, double b, int precision) {
             return mulBigDecimal(a, getBigDecimalValue(b), precision);
         }
 
-        @Specialization(guards = "isNormal(a)")
-        public Object mult(RubyBasicObject a, RubyBignum b, int precision) {
-            return mulBigDecimal(a, getBigDecimalValue(b), precision);
+        @Specialization(guards = {"isNormal(a)", "isRubyBignum(b)"})
+        public Object multBignum(RubyBasicObject a, RubyBasicObject b, int precision) {
+            return mulBigDecimal(a, getBignumBigDecimalValue(b), precision);
         }
 
         @Specialization(guards = {
@@ -738,9 +741,9 @@ public Object div(RubyBasicObject a, double b) {
             return div(a, getBigDecimalValue(b));
         }
 
-        @Specialization(guards = "isNormal(a)")
-        public Object div(RubyBasicObject a, RubyBignum b) {
-            return div(a, getBigDecimalValue(b));
+        @Specialization(guards = {"isNormal(a)", "isRubyBignum(b)"})
+        public Object divBignum(RubyBasicObject a, RubyBasicObject b) {
+            return div(a, getBignumBigDecimalValue(b));
         }
 
         @Specialization(guards = {
@@ -799,9 +802,9 @@ public Object divSpecialNormal(RubyBasicObject a, double b) {
             return divSpecialNormal(a, createRubyBigDecimal(getBigDecimalValue(b)));
         }
 
-        @Specialization(guards = "!isNormal(a)")
-        public Object divSpecialNormal(RubyBasicObject a, RubyBignum b) {
-            return divSpecialNormal(a, createRubyBigDecimal(getBigDecimalValue(b)));
+        @Specialization(guards = {"!isNormal(a)", "isRubyBignum(b)"})
+        public Object divSpecialNormalBignum(RubyBasicObject a, RubyBasicObject b) {
+            return divSpecialNormal(a, createRubyBigDecimal(getBignumBigDecimalValue(b)));
         }
 
         @Specialization(guards = {
@@ -890,9 +893,9 @@ public int compare(RubyBasicObject a, double b) {
             return compareBigDecimal(a, getBigDecimalValue(b));
         }
 
-        @Specialization(guards = "isNormal(a)")
-        public int compare(RubyBasicObject a, RubyBignum b) {
-            return compareBigDecimal(a, getBigDecimalValue(b));
+        @Specialization(guards = {"isNormal(a)", "isRubyBignum(b)"})
+        public int compare(RubyBasicObject a, RubyBasicObject b) {
+            return compareBigDecimal(a, getBignumBigDecimalValue(b));
         }
 
         @Specialization(guards = {
@@ -913,9 +916,9 @@ public Object compareSpecial(RubyBasicObject a, double b) {
             return compareSpecial(a, createRubyBigDecimal(getBigDecimalValue(b)));
         }
 
-        @Specialization(guards = "!isNormal(a)")
-        public Object compareSpecial(RubyBasicObject a, RubyBignum b) {
-            return compareSpecial(a, createRubyBigDecimal(getBigDecimalValue(b)));
+        @Specialization(guards = {"!isNormal(a)", "isRubyBignum(b)"})
+        public Object compareSpecialBignum(RubyBasicObject a, RubyBasicObject b) {
+            return compareSpecial(a, createRubyBigDecimal(getBignumBigDecimalValue(b)));
         }
 
         @Specialization(guards = {

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
@@ -25,9 +25,8 @@
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.RubyBasicObject;
-import org.jruby.truffle.runtime.core.RubyBignum;
 import org.jruby.truffle.runtime.core.RubyClass;
-import org.jruby.truffle.runtime.core.RubyString;
+import org.jruby.truffle.runtime.object.BasicObjectType;
 
 import java.math.BigInteger;
 import java.util.EnumSet;
@@ -38,20 +37,26 @@ public abstract class BignumNodes {
     public static final BigInteger LONG_MAX = BigInteger.valueOf(Long.MAX_VALUE);
     public static final BigInteger LONG_MIN = BigInteger.valueOf(Long.MIN_VALUE);
 
+    public static class BignumType extends BasicObjectType {
+
+    }
+
+    public static final BignumType BIGNUM_TYPE = new BignumType();
+
     private static final HiddenKey VALUE_IDENTIFIER = new HiddenKey("value");
     public static final Property VALUE_PROPERTY;
     private static final DynamicObjectFactory BIGNUM_FACTORY;
 
     static {
         final Shape.Allocator allocator = RubyBasicObject.LAYOUT.createAllocator();
         VALUE_PROPERTY = Property.create(VALUE_IDENTIFIER, allocator.locationForType(BigInteger.class, EnumSet.of(LocationModifier.Final, LocationModifier.NonNull)), 0);
-        final Shape shape = RubyBasicObject.EMPTY_SHAPE.addProperty(VALUE_PROPERTY);
+        final Shape shape = RubyBasicObject.LAYOUT.createShape(BIGNUM_TYPE).addProperty(VALUE_PROPERTY);
         BIGNUM_FACTORY = shape.createFactory();
     }
 
     public static RubyBasicObject createRubyBignum(RubyClass rubyClass, BigInteger value) {
         assert value.compareTo(LONG_MIN) < 0 || value.compareTo(LONG_MAX) > 0 : String.format("%s not in Bignum range", value);
-        return new RubyBignum(rubyClass, BIGNUM_FACTORY.newInstance(value));
+        return new RubyBasicObject(rubyClass, BIGNUM_FACTORY.newInstance(value));
     }
 
     public static BigInteger getBigIntegerValue(RubyBasicObject bignum) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/FloatNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/FloatNodes.java
@@ -22,7 +22,6 @@
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.RubyBasicObject;
-import org.jruby.truffle.runtime.core.RubyString;
 
 @CoreClass(name = "Float")
 public abstract class FloatNodes {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/InteroplatedRegexpNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/InteroplatedRegexpNode.java
@@ -12,8 +12,6 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.source.SourceSection;
-import org.jcodings.specific.ASCIIEncoding;
-import org.jcodings.specific.USASCIIEncoding;
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;

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
@@ -21,7 +21,6 @@
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.utilities.ConditionProfile;
-
 import org.jcodings.Encoding;
 import org.jcodings.specific.USASCIIEncoding;
 import org.jcodings.specific.UTF8Encoding;

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java
@@ -23,7 +23,6 @@
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.utilities.ConditionProfile;
-
 import org.jcodings.Encoding;
 import org.jruby.runtime.Visibility;
 import org.jruby.truffle.nodes.RubyNode;