jruby · Aug 17, 2015 · Aug 17, 2015 · Aug 17, 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
@@ -11,14 +11,12 @@
 
 import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.object.DynamicObject;
-import org.jruby.truffle.nodes.core.*;
-import org.jruby.truffle.nodes.core.array.ArrayNodes;
-import org.jruby.truffle.nodes.core.hash.HashNodes;
-import org.jruby.truffle.nodes.ext.BigDecimalNodes;
-import org.jruby.truffle.nodes.rubinius.ByteArrayNodes;
-import org.jruby.truffle.nodes.rubinius.PointerNodes;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.ThreadLocalObject;
+import org.jruby.truffle.runtime.layouts.Layouts;
+import org.jruby.truffle.runtime.layouts.ThreadLayoutImpl;
+import org.jruby.truffle.runtime.layouts.TimeLayoutImpl;
+import org.jruby.truffle.runtime.layouts.rubinius.ByteArrayLayoutImpl;
 
 public abstract class RubyGuards {
 
@@ -43,203 +41,179 @@ public static boolean isDouble(Object value) {
     // Ruby types
 
     public static boolean isRubyBasicObject(Object object) {
-        return BasicObjectNodes.BASIC_OBJECT_LAYOUT.isBasicObject(object);
+        return Layouts.BASIC_OBJECT.isBasicObject(object);
     }
 
     public static boolean isRubyBignum(Object value) {
-        return (value instanceof DynamicObject) && isRubyBignum((DynamicObject) value);
+        return Layouts.BIGNUM.isBignum(value);
     }
 
     public static boolean isRubyBignum(DynamicObject value) {
-        return BignumNodes.BIGNUM_LAYOUT.isBignum(value);
+        return Layouts.BIGNUM.isBignum(value);
     }
 
     public static boolean isRubyBigDecimal(DynamicObject value) {
-        return BigDecimalNodes.BIG_DECIMAL_LAYOUT.isBigDecimal(value);
+        return Layouts.BIG_DECIMAL.isBigDecimal(value);
     }
 
     public static boolean isIntegerFixnumRange(Object object) {
-        return (object instanceof DynamicObject) && isIntegerFixnumRange((DynamicObject) object);
+        return Layouts.INTEGER_FIXNUM_RANGE.isIntegerFixnumRange(object);
     }
 
     public static boolean isIntegerFixnumRange(DynamicObject object) {
-        return RangeNodes.INTEGER_FIXNUM_RANGE_LAYOUT.isIntegerFixnumRange(object);
+        return Layouts.INTEGER_FIXNUM_RANGE.isIntegerFixnumRange(object);
     }
 
     public static boolean isLongFixnumRange(Object object) {
-        return (object instanceof DynamicObject) && isLongFixnumRange((DynamicObject) object);
+        return Layouts.LONG_FIXNUM_RANGE.isLongFixnumRange(object);
     }
 
     public static boolean isLongFixnumRange(DynamicObject object) {
-        return RangeNodes.LONG_FIXNUM_RANGE_LAYOUT.isLongFixnumRange(object);
+        return Layouts.LONG_FIXNUM_RANGE.isLongFixnumRange(object);
     }
 
     public static boolean isObjectRange(Object object) {
-        return (object instanceof DynamicObject) && isObjectRange((DynamicObject) object);
+        return Layouts.OBJECT_RANGE.isObjectRange(object);
     }
 
     public static boolean isObjectRange(DynamicObject object) {
-        return RangeNodes.OBJECT_RANGE_LAYOUT.isObjectRange(object);
+        return Layouts.OBJECT_RANGE.isObjectRange(object);
     }
 
     public static boolean isRubyRange(Object value) {
         return isIntegerFixnumRange(value) || isLongFixnumRange(value) || isObjectRange(value);
     }
 
     public static boolean isRubyArray(Object value) {
-        return (value instanceof DynamicObject) && isRubyArray((DynamicObject) value);
+        return Layouts.ARRAY.isArray(value);
     }
 
     public static boolean isRubyArray(DynamicObject value) {
-        return ArrayNodes.ARRAY_LAYOUT.isArray(value);
+        return Layouts.ARRAY.isArray(value);
     }
 
     public static boolean isRubyBinding(DynamicObject object) {
-        return BindingNodes.BINDING_LAYOUT.isBinding(object);
+        return Layouts.BINDING.isBinding(object);
     }
 
     public static boolean isRubyClass(Object value) {
-        return (value instanceof DynamicObject) && isRubyClass((DynamicObject) value);
+        return Layouts.CLASS.isClass(value);
     }
 
     public static boolean isRubyClass(DynamicObject value) {
-        return ClassNodes.CLASS_LAYOUT.isClass(value);
+        return Layouts.CLASS.isClass(value);
     }
 
     public static boolean isRubyHash(Object value) {
-        return (value instanceof DynamicObject) && isRubyHash((DynamicObject) value);
+        return Layouts.HASH.isHash(value);
     }
 
     public static boolean isRubyHash(DynamicObject value) {
-        return HashNodes.HASH_LAYOUT.isHash(value);
+        return Layouts.HASH.isHash(value);
     }
 
     public static boolean isRubyModule(Object value) {
-        return (value instanceof DynamicObject) && isRubyModule((DynamicObject) value);
+        return Layouts.MODULE.isModule(value);
     }
 
     public static boolean isRubyModule(DynamicObject value) {
-        return ModuleNodes.MODULE_LAYOUT.isModule(value);
+        return Layouts.MODULE.isModule(value);
     }
 
     public static boolean isRubyRegexp(Object value) {
-        return (value instanceof DynamicObject) && isRubyRegexp((DynamicObject) value);
+        return Layouts.REGEXP.isRegexp(value);
     }
 
     public static boolean isRubyRegexp(DynamicObject value) {
-        return RegexpNodes.REGEXP_LAYOUT.isRegexp(value);
+        return Layouts.REGEXP.isRegexp(value);
     }
 
     public static boolean isRubyString(Object value) {
-        return (value instanceof DynamicObject) && isRubyString((DynamicObject) value);
+        return Layouts.STRING.isString(value);
     }
 
     public static boolean isRubyString(DynamicObject value) {
-        return StringNodes.STRING_LAYOUT.isString(value);
+        return Layouts.STRING.isString(value);
     }
 
     public static boolean isRubyEncoding(Object object) {
-        return (object instanceof DynamicObject) && isRubyEncoding((DynamicObject) object);
+        return Layouts.ENCODING.isEncoding(object);
     }
 
     public static boolean isRubyEncoding(DynamicObject object) {
-        return EncodingNodes.ENCODING_LAYOUT.isEncoding(object);
+        return Layouts.ENCODING.isEncoding(object);
     }
 
     public static boolean isRubySymbol(Object value) {
-        return (value instanceof DynamicObject) && isRubySymbol((DynamicObject) value);
+        return Layouts.SYMBOL.isSymbol(value);
     }
 
     public static boolean isRubySymbol(DynamicObject value) {
-        return SymbolNodes.SYMBOL_LAYOUT.isSymbol(value);
+        return Layouts.SYMBOL.isSymbol(value);
     }
 
     public static boolean isRubyMethod(Object value) {
-        return (value instanceof DynamicObject) && isRubyMethod((DynamicObject) value);
+        return Layouts.METHOD.isMethod(value);
     }
 
     public static boolean isRubyMethod(DynamicObject value) {
-        return MethodNodes.METHOD_LAYOUT.isMethod(value);
+        return Layouts.METHOD.isMethod(value);
     }
 
     public static boolean isRubyUnboundMethod(Object value) {
-        return (value instanceof DynamicObject) && isRubyUnboundMethod((DynamicObject) value);
+        return Layouts.UNBOUND_METHOD.isUnboundMethod(value);
     }
 
     public static boolean isRubyUnboundMethod(DynamicObject value) {
-        return UnboundMethodNodes.UNBOUND_METHOD_LAYOUT.isUnboundMethod(value);
-    }
-
-    public static boolean isRubyMutex(DynamicObject value) {
-        return MutexNodes.MUTEX_LAYOUT.isMutex(value);
+        return Layouts.UNBOUND_METHOD.isUnboundMethod(value);
     }
 
     public static boolean isDynamicObject(Object value) {
         return value instanceof DynamicObject;
     }
 
-    public static boolean isRubyPointer(Object value) {
-        return (value instanceof DynamicObject) && isRubyPointer((DynamicObject) value);
-    }
-
     public static boolean isRubyPointer(DynamicObject value) {
-        return PointerNodes.POINTER_LAYOUT.isPointer(value);
-    }
-
-    public static boolean isRubiniusByteArray(Object value) {
-        return (value instanceof DynamicObject) && isRubiniusByteArray((DynamicObject) value);
+        return Layouts.POINTER.isPointer(value);
     }
 
     public static boolean isRubiniusByteArray(DynamicObject value) {
-        return ByteArrayNodes.BYTE_ARRAY_LAYOUT.isByteArray(value);
+        return Layouts.BYTE_ARRAY.isByteArray(value);
     }
 
     public static boolean isRubyProc(Object object) {
-        return (object instanceof DynamicObject) && isRubyProc((DynamicObject) object);
+        return Layouts.PROC.isProc(object);
     }
 
     public static boolean isRubyProc(DynamicObject object) {
-        return ProcNodes.PROC_LAYOUT.isProc(object);
+        return Layouts.PROC.isProc(object);
     }
 
     public static boolean isRubyEncodingConverter(DynamicObject encodingConverter) {
-        return EncodingConverterNodes.ENCODING_CONVERTER_LAYOUT.isEncodingConverter(encodingConverter);
+        return Layouts.ENCODING_CONVERTER.isEncodingConverter(encodingConverter);
     }
 
     public static boolean isRubyTime(DynamicObject object) {
-        return TimeNodes.TIME_LAYOUT.isTime(object);
-    }
-
-    public static boolean isRubyException(Object value) {
-        return (value instanceof DynamicObject) && isRubyException((DynamicObject) value);
+        return Layouts.TIME.isTime(object);
     }
 
     public static boolean isRubyException(DynamicObject object) {
-        return ExceptionNodes.EXCEPTION_LAYOUT.isException(object);
-    }
-
-    public static boolean isRubyFiber(Object object) {
-        return (object instanceof DynamicObject) && isRubyFiber((DynamicObject) object);
+        return Layouts.EXCEPTION.isException(object);
     }
 
     public static boolean isRubyFiber(DynamicObject object) {
-        return FiberNodes.FIBER_LAYOUT.isFiber(object);
-    }
-
-    public static boolean isRubyThread(Object object) {
-        return (object instanceof DynamicObject) && isRubyThread((DynamicObject) object);
+        return Layouts.FIBER.isFiber(object);
     }
 
     public static boolean isRubyThread(DynamicObject object) {
-        return ThreadNodes.THREAD_LAYOUT.isThread(object);
+        return ThreadLayoutImpl.INSTANCE.isThread(object);
     }
 
     public static boolean isRubyMatchData(Object object) {
-        return (object instanceof DynamicObject) && isRubyMatchData((DynamicObject) object);
+        return Layouts.MATCH_DATA.isMatchData(object);
     }
 
     public static boolean isRubyMatchData(DynamicObject object) {
-        return MatchDataNodes.MATCH_DATA_LAYOUT.isMatchData(object);
+        return Layouts.MATCH_DATA.isMatchData(object);
     }
 
     // Internal types

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,16 +24,14 @@
 import jnr.ffi.provider.MemoryManager;
 import jnr.posix.POSIX;
 import org.jcodings.Encoding;
-import org.jruby.truffle.nodes.core.BignumNodes;
 import org.jruby.truffle.nodes.core.BindingNodes;
-import org.jruby.truffle.nodes.core.ClassNodes;
 import org.jruby.truffle.nodes.core.StringNodes;
-import org.jruby.truffle.nodes.core.array.ArrayNodes;
 import org.jruby.truffle.nodes.dispatch.DispatchNode;
 import org.jruby.truffle.nodes.instrument.RubyWrapperNode;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.truffle.runtime.sockets.NativeSockets;
 import org.jruby.util.ByteList;
 
@@ -194,19 +192,19 @@ protected DynamicObject createString(ByteList bytes) {
     }
 
     protected DynamicObject createEmptyArray() {
-        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), null, 0);
+        return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), null, 0);
     }
 
     protected DynamicObject createArrayWith(Object... store) {
-        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), store, store.length);
+        return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), store, store.length);
     }
 
     protected DynamicObject createArray(Object store, int size) {
-        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), store, size);
+        return Layouts.ARRAY.createArray(getContext().getCoreLibrary().getArrayFactory(), store, size);
     }
 
     protected DynamicObject createBignum(BigInteger value) {
-        return BignumNodes.BIGNUM_LAYOUT.createBignum(getContext().getCoreLibrary().getBignumFactory(), value);
+        return Layouts.BIGNUM.createBignum(getContext().getCoreLibrary().getBignumFactory(), value);
     }
 
     protected POSIX posix() {
@@ -224,7 +222,7 @@ protected static int getCacheLimit() {
     // Helper methods for caching
 
     protected DynamicObjectFactory getInstanceFactory(DynamicObject rubyClass) {
-        return ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass);
+        return Layouts.CLASS.getInstanceFactory(rubyClass);
     }
 
     // Instrumentation

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/StringCachingGuards.java b/truffle/src/main/java/org/jruby/truffle/nodes/StringCachingGuards.java
@@ -11,22 +11,22 @@
 package org.jruby.truffle.nodes;
 
 import com.oracle.truffle.api.object.DynamicObject;
-import org.jruby.truffle.nodes.core.StringNodes;
+import org.jruby.truffle.runtime.layouts.Layouts;
 import org.jruby.util.ByteList;
 
 public abstract class StringCachingGuards {
 
     public static ByteList privatizeByteList(DynamicObject string) {
         if (RubyGuards.isRubyString(string)) {
-            return StringNodes.getByteList(string).dup();
+            return Layouts.STRING.getByteList(string).dup();
         } else {
             return null;
         }
     }
 
     public static boolean byteListsEqual(DynamicObject string, ByteList byteList) {
         if (RubyGuards.isRubyString(string)) {
-            return StringNodes.getByteList(string).equal(byteList);
+            return Layouts.STRING.getByteList(string).equal(byteList);
         } else {
             return false;
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadKeywordRestArgumentNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadKeywordRestArgumentNode.java
@@ -20,6 +20,7 @@
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.hash.BucketsStrategy;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -77,7 +78,7 @@ private Object lookupRestKeywordArgumentHash(VirtualFrame frame) {
             entries.add(keyValue);
         }
 
-        return BucketsStrategy.create(getContext().getCoreLibrary().getHashClass(), entries, HashNodes.isCompareByIdentity(hash));
+        return BucketsStrategy.create(getContext().getCoreLibrary().getHashClass(), entries, Layouts.HASH.getCompareByIdentity(hash));
     }
 
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/CmpIntNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/CmpIntNode.java
@@ -29,12 +29,11 @@
 import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyNode;
-import org.jruby.truffle.nodes.core.BignumNodes;
-import org.jruby.truffle.nodes.core.ModuleNodes;
 import org.jruby.truffle.nodes.dispatch.CallDispatchHeadNode;
 import org.jruby.truffle.nodes.dispatch.DispatchHeadNodeFactory;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
+import org.jruby.truffle.runtime.layouts.Layouts;
 
 /**
  * This is a port of MRI's rb_cmpint, as taken from RubyComparable and broken out into specialized nodes.
@@ -84,7 +83,7 @@ public int cmpLong(long value, Object receiver, Object other) {
 
     @Specialization(guards = "isRubyBignum(value)")
     public int cmpBignum(DynamicObject value, Object receiver, Object other) {
-        return BignumNodes.getBigIntegerValue(value).signum();
+        return Layouts.BIGNUM.getValue(value).signum();
     }
 
     @TruffleBoundary
@@ -93,8 +92,8 @@ public int cmpNil(Object nil, Object receiver, Object other) {
         throw new RaiseException(
             getContext().getCoreLibrary().argumentError(
                 String.format("comparison of %s with %s failed",
-                        ModuleNodes.getFields(getContext().getCoreLibrary().getLogicalClass(receiver)).getName(),
-                        ModuleNodes.getFields(getContext().getCoreLibrary().getLogicalClass(other)).getName()), this)
+                        Layouts.MODULE.getFields(getContext().getCoreLibrary().getLogicalClass(receiver)).getName(),
+                        Layouts.MODULE.getFields(getContext().getCoreLibrary().getLogicalClass(other)).getName()), this)
         );
     }