jruby · Jul 23, 2015 · Jul 23, 2015 · Jul 24, 2015 · Jul 24, 2015 · Jul 24, 2015
Showing 306 changed files with 7,788 additions and 6,255 deletions.
diff --git a/spec/truffle/specs/truffle/runtime/java_class_of_spec.rb b/spec/truffle/specs/truffle/runtime/java_class_of_spec.rb
@@ -34,8 +34,8 @@
     Truffle::Runtime.java_class_of(3.14).should == 'Double'
   end
 
-  it "returns 'RubyString' for a String" do
-    Truffle::Runtime.java_class_of('test').should == 'RubyString'
+  it "returns 'DynamicObject*' for a String" do
+    Truffle::Runtime.java_class_of('test').start_with?('DynamicObject').should be_true
   end
 
 end
diff --git a/spec/truffle/tags/core/module/prepend_tags.txt b/spec/truffle/tags/core/module/prepend_tags.txt
@@ -0,0 +1 @@
+fails:Module#prepend keeps the module in the chain when dupping the class
diff --git a/truffle/pom.rb b/truffle/pom.rb
@@ -30,17 +30,22 @@
           'source' => [ '${base.java.version}', '1.7' ],
           'target' => [ '${base.javac.version}', '1.7' ],
           'useIncrementalCompilation' =>  'false' ) do
+    execute_goals( 'compile',
+                   :id => 'anno',
+                   :phase => 'process-resources',
+                   'includes' => [ 'org/jruby/truffle/om/dsl/processor/OMProcessor.java' ],
+                   'compilerArgs' => [ '-J-ea' ] )
     execute_goals( 'compile',
                    :id => 'default-compile',
                    :phase => 'compile',
-                   'annotationProcessors' => [
-                     'com.oracle.truffle.dsl.processor.TruffleProcessor',
-                     'com.oracle.truffle.dsl.processor.LanguageRegistrationProcessor'
-                    ],
+                   'annotationProcessors' => [ 'org.jruby.truffle.om.dsl.processor.OMProcessor',
+                                               'com.oracle.truffle.dsl.processor.TruffleProcessor',
+                                              'com.oracle.truffle.dsl.processor.LanguageRegistrationProcessor' ],
                    'generatedSourcesDirectory' =>  'target/generated-sources',
                    'compilerArgs' => [ '-XDignore.symbol.file=true',
                                        '-J-Duser.language=en',
-                                       '-J-Dfile.encoding=UTF-8' ] )
+                                       '-J-Dfile.encoding=UTF-8',
+                                       '-J-ea' ] )
   end
 
   plugin :shade do

diff --git a/truffle/pom.xml b/truffle/pom.xml
@@ -71,6 +71,21 @@ DO NOT MODIFIY - GENERATED CODE
       <plugin>
         <artifactId>maven-compiler-plugin</artifactId>
         <executions>
+          <execution>
+            <id>anno</id>
+            <phase>process-resources</phase>
+            <goals>
+              <goal>compile</goal>
+            </goals>
+            <configuration>
+              <includes>
+                <include>org/jruby/truffle/om/dsl/processor/OMProcessor.java</include>
+              </includes>
+              <compilerArgs>
+                <compilerArg>-J-ea</compilerArg>
+              </compilerArgs>
+            </configuration>
+          </execution>
           <execution>
             <id>default-compile</id>
             <phase>compile</phase>
@@ -79,6 +94,7 @@ DO NOT MODIFIY - GENERATED CODE
             </goals>
             <configuration>
               <annotationProcessors>
+                <annotationProcessor>org.jruby.truffle.om.dsl.processor.OMProcessor</annotationProcessor>
                 <annotationProcessor>com.oracle.truffle.dsl.processor.TruffleProcessor</annotationProcessor>
                 <annotationProcessor>com.oracle.truffle.dsl.processor.LanguageRegistrationProcessor</annotationProcessor>
               </annotationProcessors>
@@ -87,6 +103,7 @@ DO NOT MODIFIY - GENERATED CODE
                 <compilerArg>-XDignore.symbol.file=true</compilerArg>
                 <compilerArg>-J-Duser.language=en</compilerArg>
                 <compilerArg>-J-Dfile.encoding=UTF-8</compilerArg>
+                <compilerArg>-J-ea</compilerArg>
               </compilerArgs>
             </configuration>
           </execution>

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/LazyRubyRootNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/LazyRubyRootNode.java
@@ -10,6 +10,7 @@
 import com.oracle.truffle.api.nodes.DirectCallNode;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
+import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jcodings.specific.UTF8Encoding;
@@ -18,7 +19,6 @@
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.RubyLanguage;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
 import org.jruby.truffle.translator.NodeWrapper;
 import org.jruby.truffle.translator.TranslatorDriver;
 
@@ -27,7 +27,7 @@ public class LazyRubyRootNode extends RootNode {
     private final Source source;
 
     @CompilationFinal private RubyContext cachedContext;
-    @CompilationFinal private RubyBasicObject mainObject;
+    @CompilationFinal private DynamicObject mainObject;
 
     @Child private Node findContextNode;
     @Child private DirectCallNode callNode;

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,14 +10,15 @@
 package org.jruby.truffle.nodes;
 
 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.core.*;
 
 public abstract class RubyGuards {
 
@@ -41,152 +42,204 @@ public static boolean isDouble(Object value) {
 
     // Ruby types
 
+    public static boolean isRubyBasicObject(Object object) {
+        return BasicObjectNodes.BASIC_OBJECT_LAYOUT.isBasicObject(object);
+    }
+
     public static boolean isRubyBignum(Object value) {
-        return (value instanceof RubyBasicObject) && isRubyBignum((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubyBignum((DynamicObject) value);
+    }
+
+    public static boolean isRubyBignum(DynamicObject value) {
+        return BignumNodes.BIGNUM_LAYOUT.isBignum(value);
+    }
+
+    public static boolean isRubyBigDecimal(DynamicObject value) {
+        return BigDecimalNodes.BIG_DECIMAL_LAYOUT.isBigDecimal(value);
+    }
+
+    public static boolean isIntegerFixnumRange(Object object) {
+        return (object instanceof DynamicObject) && isIntegerFixnumRange((DynamicObject) object);
     }
 
-    public static boolean isRubyBignum(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == BignumNodes.BIGNUM_TYPE;
+    public static boolean isIntegerFixnumRange(DynamicObject object) {
+        return RangeNodes.INTEGER_FIXNUM_RANGE_LAYOUT.isIntegerFixnumRange(object);
     }
 
-    public static boolean isRubyBigDecimal(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == BigDecimalNodes.BIG_DECIMAL_TYPE;
+    public static boolean isLongFixnumRange(Object object) {
+        return (object instanceof DynamicObject) && isLongFixnumRange((DynamicObject) object);
     }
 
-    public static boolean isIntegerFixnumRange(Object value) {
-        return value instanceof RubyIntegerFixnumRange;
+    public static boolean isLongFixnumRange(DynamicObject object) {
+        return RangeNodes.LONG_FIXNUM_RANGE_LAYOUT.isLongFixnumRange(object);
     }
 
-    public static boolean isLongFixnumRange(Object value) {
-        return value instanceof RubyLongFixnumRange;
+    public static boolean isObjectRange(Object object) {
+        return (object instanceof DynamicObject) && isObjectRange((DynamicObject) object);
     }
 
-    public static boolean isObjectRange(Object value) {
-        return value instanceof RubyObjectRange;
+    public static boolean isObjectRange(DynamicObject object) {
+        return RangeNodes.OBJECT_RANGE_LAYOUT.isObjectRange(object);
     }
 
     public static boolean isRubyRange(Object value) {
         return isIntegerFixnumRange(value) || isLongFixnumRange(value) || isObjectRange(value);
     }
 
     public static boolean isRubyArray(Object value) {
-        return (value instanceof RubyBasicObject) && isRubyArray((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubyArray((DynamicObject) value);
     }
 
-    public static boolean isRubyArray(RubyBasicObject value) {
-        //return value.getDynamicObject().getShape().getObjectType() == ArrayNodes.ARRAY_TYPE;
-        return value instanceof RubyArray;
+    public static boolean isRubyArray(DynamicObject value) {
+        return ArrayNodes.ARRAY_LAYOUT.isArray(value);
     }
 
-    public static boolean isRubyBinding(Object value) {
-        return value instanceof RubyBinding;
+    public static boolean isRubyBinding(DynamicObject object) {
+        return BindingNodes.BINDING_LAYOUT.isBinding(object);
     }
 
     public static boolean isRubyClass(Object value) {
-        return value instanceof RubyClass;
+        return (value instanceof DynamicObject) && isRubyClass((DynamicObject) value);
+    }
+
+    public static boolean isRubyClass(DynamicObject value) {
+        return ClassNodes.CLASS_LAYOUT.isClass(value);
     }
 
     public static boolean isRubyHash(Object value) {
-        return (value instanceof RubyBasicObject) && isRubyHash((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubyHash((DynamicObject) value);
     }
 
-    public static boolean isRubyHash(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == HashNodes.HASH_TYPE;
+    public static boolean isRubyHash(DynamicObject value) {
+        return HashNodes.HASH_LAYOUT.isHash(value);
     }
 
     public static boolean isRubyModule(Object value) {
-        return value instanceof RubyModule;
+        return (value instanceof DynamicObject) && isRubyModule((DynamicObject) value);
+    }
+
+    public static boolean isRubyModule(DynamicObject value) {
+        return ModuleNodes.MODULE_LAYOUT.isModule(value);
     }
 
     public static boolean isRubyRegexp(Object value) {
-        return value instanceof RubyRegexp;
+        return (value instanceof DynamicObject) && isRubyRegexp((DynamicObject) value);
+    }
+
+    public static boolean isRubyRegexp(DynamicObject value) {
+        return RegexpNodes.REGEXP_LAYOUT.isRegexp(value);
     }
 
     public static boolean isRubyString(Object value) {
-        return (value instanceof RubyBasicObject) && isRubyString((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubyString((DynamicObject) value);
     }
 
-    public static boolean isRubyString(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == StringNodes.STRING_TYPE;
+    public static boolean isRubyString(DynamicObject value) {
+        return StringNodes.STRING_LAYOUT.isString(value);
     }
 
-    public static boolean isRubyEncoding(Object value) {
-        return value instanceof RubyEncoding;
+    public static boolean isRubyEncoding(Object object) {
+        return (object instanceof DynamicObject) && isRubyEncoding((DynamicObject) object);
+    }
+
+    public static boolean isRubyEncoding(DynamicObject object) {
+        return EncodingNodes.ENCODING_LAYOUT.isEncoding(object);
     }
 
     public static boolean isRubySymbol(Object value) {
-        return (value instanceof RubyBasicObject) && isRubySymbol((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubySymbol((DynamicObject) value);
     }
 
-    public static boolean isRubySymbol(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == SymbolNodes.SYMBOL_TYPE;
+    public static boolean isRubySymbol(DynamicObject value) {
+        return SymbolNodes.SYMBOL_LAYOUT.isSymbol(value);
     }
 
     public static boolean isRubyMethod(Object value) {
-        return (value instanceof RubyBasicObject) && isRubyMethod((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubyMethod((DynamicObject) value);
     }
 
-    public static boolean isRubyMethod(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == MethodNodes.METHOD_TYPE;
+    public static boolean isRubyMethod(DynamicObject value) {
+        return MethodNodes.METHOD_LAYOUT.isMethod(value);
     }
 
     public static boolean isRubyUnboundMethod(Object value) {
-        return (value instanceof RubyBasicObject) && isRubyUnboundMethod((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubyUnboundMethod((DynamicObject) value);
     }
 
-    public static boolean isRubyUnboundMethod(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == UnboundMethodNodes.UNBOUND_METHOD_TYPE;
+    public static boolean isRubyUnboundMethod(DynamicObject value) {
+        return UnboundMethodNodes.UNBOUND_METHOD_LAYOUT.isUnboundMethod(value);
     }
 
-    public static boolean isRubyMutex(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == MutexNodes.MUTEX_TYPE;
+    public static boolean isRubyMutex(DynamicObject value) {
+        return MutexNodes.MUTEX_LAYOUT.isMutex(value);
     }
 
-    public static boolean isRubyBasicObject(Object value) {
-        return value instanceof RubyBasicObject;
+    public static boolean isDynamicObject(Object value) {
+        return value instanceof DynamicObject;
     }
 
     public static boolean isRubyPointer(Object value) {
-        return (value instanceof RubyBasicObject) && isRubyPointer((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubyPointer((DynamicObject) value);
     }
 
-    public static boolean isRubyPointer(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == PointerNodes.POINTER_TYPE;
+    public static boolean isRubyPointer(DynamicObject value) {
+        return PointerNodes.POINTER_LAYOUT.isPointer(value);
     }
 
     public static boolean isRubiniusByteArray(Object value) {
-        return (value instanceof RubyBasicObject) && isRubiniusByteArray((RubyBasicObject) value);
+        return (value instanceof DynamicObject) && isRubiniusByteArray((DynamicObject) value);
+    }
+
+    public static boolean isRubiniusByteArray(DynamicObject value) {
+        return ByteArrayNodes.BYTE_ARRAY_LAYOUT.isByteArray(value);
     }
 
-    public static boolean isRubiniusByteArray(RubyBasicObject value) {
-        return value.getDynamicObject().getShape().getObjectType() == ByteArrayNodes.BYTE_ARRAY_TYPE;
+    public static boolean isRubyProc(Object object) {
+        return (object instanceof DynamicObject) && isRubyProc((DynamicObject) object);
     }
 
-    public static boolean isRubyProc(Object value) {
-        return value instanceof RubyProc;
+    public static boolean isRubyProc(DynamicObject object) {
+        return ProcNodes.PROC_LAYOUT.isProc(object);
     }
-    public static boolean isRubyEncodingConverter(RubyBasicObject encodingConverter) {
-        return encodingConverter instanceof RubyEncodingConverter;
+
+    public static boolean isRubyEncodingConverter(DynamicObject encodingConverter) {
+        return EncodingConverterNodes.ENCODING_CONVERTER_LAYOUT.isEncodingConverter(encodingConverter);
+    }
+
+    public static boolean isRubyTime(DynamicObject object) {
+        return TimeNodes.TIME_LAYOUT.isTime(object);
     }
 
-    public static boolean isRubyTime(RubyBasicObject time) {
-        return time instanceof RubyTime;
+    public static boolean isRubyException(Object value) {
+        return (value instanceof DynamicObject) && isRubyException((DynamicObject) value);
     }
 
-    public static boolean isRubyException(Object object) {
-        return object instanceof RubyException;
+    public static boolean isRubyException(DynamicObject object) {
+        return ExceptionNodes.EXCEPTION_LAYOUT.isException(object);
     }
 
-    public static boolean isRubyFiber(Object fiber) {
-        return fiber instanceof RubyFiber;
+    public static boolean isRubyFiber(Object object) {
+        return (object instanceof DynamicObject) && isRubyFiber((DynamicObject) object);
+    }
+
+    public static boolean isRubyFiber(DynamicObject object) {
+        return FiberNodes.FIBER_LAYOUT.isFiber(object);
     }
 
     public static boolean isRubyThread(Object object) {
-        return object instanceof RubyThread;
+        return (object instanceof DynamicObject) && isRubyThread((DynamicObject) object);
+    }
+
+    public static boolean isRubyThread(DynamicObject object) {
+        return ThreadNodes.THREAD_LAYOUT.isThread(object);
     }
 
     public static boolean isRubyMatchData(Object object) {
-        return object instanceof RubyMatchData;
+        return (object instanceof DynamicObject) && isRubyMatchData((DynamicObject) object);
+    }
+
+    public static boolean isRubyMatchData(DynamicObject object) {
+        return MatchDataNodes.MATCH_DATA_LAYOUT.isMatchData(object);
     }
 
     // Internal types
@@ -196,7 +249,7 @@ public static boolean isThreadLocal(Object value) {
     }
 
     public static boolean isForeignObject(Object object) {
-        return (object instanceof TruffleObject) && !(object instanceof RubyBasicObject);
+        return (object instanceof TruffleObject) && !(object instanceof DynamicObject);
     }
 
     // Sentinels

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java
@@ -18,23 +18,26 @@
 import com.oracle.truffle.api.instrument.ProbeNode;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.UnexpectedResultException;
+import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 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.core.RubyBasicObject;
-import org.jruby.truffle.runtime.core.RubyHash;
+import com.oracle.truffle.api.object.DynamicObject;
 import org.jruby.truffle.runtime.sockets.NativeSockets;
 import org.jruby.util.ByteList;
 
+import java.math.BigInteger;
 import java.nio.ByteBuffer;
 
 @TypeSystemReference(RubyTypes.class)
@@ -122,23 +125,11 @@ public double executeDouble(VirtualFrame frame) throws UnexpectedResultException
         }
     }
 
-    // If you try to make this RubyBasicObject things break in the DSL
-
-    public RubyHash executeRubyHash(VirtualFrame frame) throws UnexpectedResultException {
-        final Object value = execute(frame);
-
-        if (RubyGuards.isRubyHash(value)) {
-            return (RubyHash) value;
-        } else {
-            throw new UnexpectedResultException(value);
-        }
-    }
-
-    public RubyBasicObject executeRubyBasicObject(VirtualFrame frame) throws UnexpectedResultException {
+    public DynamicObject executeDynamicObject(VirtualFrame frame) throws UnexpectedResultException {
         final Object value = execute(frame);
 
-        if (value instanceof RubyBasicObject) {
-            return (RubyBasicObject) value;
+        if (value instanceof DynamicObject) {
+            return (DynamicObject) value;
         } else {
             throw new UnexpectedResultException(value);
         }
@@ -166,64 +157,56 @@ protected boolean isRubiniusUndefined(Object value) {
 
     // Helpers methods for terseness
 
-    protected RubyBasicObject nil() {
+    protected DynamicObject nil() {
         return getContext().getCoreLibrary().getNilObject();
     }
 
-    public RubyBasicObject getSymbol(String name) {
+    public DynamicObject getSymbol(String name) {
         return getContext().getSymbol(name);
     }
 
-    public RubyBasicObject getSymbol(ByteList name) {
+    public DynamicObject getSymbol(ByteList name) {
         return getContext().getSymbol(name);
     }
 
-    protected RubyBasicObject createEmptyString() {
+    protected DynamicObject createEmptyString() {
         return StringNodes.createEmptyString(getContext().getCoreLibrary().getStringClass());
     }
 
-    protected RubyBasicObject createString(String string) {
+    protected DynamicObject createString(String string) {
         return StringNodes.createString(getContext().getCoreLibrary().getStringClass(), string);
     }
 
-    protected RubyBasicObject createString(String string, Encoding encoding) {
+    protected DynamicObject createString(String string, Encoding encoding) {
         return StringNodes.createString(getContext().getCoreLibrary().getStringClass(), string, encoding);
     }
 
-    protected RubyBasicObject createString(byte[] bytes) {
+    protected DynamicObject createString(byte[] bytes) {
         return StringNodes.createString(getContext().getCoreLibrary().getStringClass(), bytes);
     }
 
-    protected RubyBasicObject createString(ByteBuffer bytes) {
+    protected DynamicObject createString(ByteBuffer bytes) {
         return StringNodes.createString(getContext().getCoreLibrary().getStringClass(), bytes);
     }
 
-    protected RubyBasicObject createString(ByteList bytes) {
-        return StringNodes.createString(getContext().getCoreLibrary().getStringClass(), bytes);
-    }
-
-    protected RubyBasicObject createEmptyArray() {
-        return ArrayNodes.createEmptyArray(getContext().getCoreLibrary().getArrayClass());
-    }
-
-    protected RubyBasicObject createArray(Object... store) {
-        return createArray(store, store.length);
+    protected DynamicObject createString(ByteList bytes) {
+        return StringNodes.createString(getContext().getCoreLibrary().getStringFactory(), bytes);
     }
 
-    protected RubyBasicObject createArray(int[] store, int size) {
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, size);
+    protected DynamicObject createEmptyArray() {
+        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), null, 0);
     }
 
-    protected RubyBasicObject createArray(long[] store, int size) {
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, size);
+    protected DynamicObject createArrayWith(Object... store) {
+        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), store, store.length);
     }
 
-    protected RubyBasicObject createArray(double[] store, int size) {
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, size);
+    protected DynamicObject createArray(Object store, int size) {
+        return ArrayNodes.ARRAY_LAYOUT.createArray(getContext().getCoreLibrary().getArrayFactory(), store, size);
     }
 
-    protected RubyBasicObject createArray(Object[] store, int size) {
-        return ArrayNodes.createArray(getContext().getCoreLibrary().getArrayClass(), store, size);
+    protected DynamicObject createBignum(BigInteger value) {
+        return BignumNodes.BIGNUM_LAYOUT.createBignum(getContext().getCoreLibrary().getBignumFactory(), value);
     }
 
     protected POSIX posix() {
@@ -238,6 +221,12 @@ protected static int getCacheLimit() {
         return DispatchNode.DISPATCH_POLYMORPHIC_MAX;
     }
 
+    // Helper methods for caching
+
+    protected DynamicObjectFactory getInstanceFactory(DynamicObject rubyClass) {
+        return ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass);
+    }
+
     // Instrumentation
 
     @Override
@@ -281,7 +270,7 @@ protected Object ruby(VirtualFrame frame, String expression, Object... arguments
     protected Object rubyWithSelf(VirtualFrame frame, Object self, String expression, Object... arguments) {
         final MaterializedFrame evalFrame = setupFrame(RubyArguments.getSelf(frame.getArguments()), arguments);
 
-        final RubyBasicObject binding = BindingNodes.createRubyBinding(
+        final DynamicObject binding = BindingNodes.createRubyBinding(
                 getContext().getCoreLibrary().getBindingClass(),
                 self,
                 evalFrame);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyRootNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyRootNode.java
@@ -14,11 +14,16 @@
 import com.oracle.truffle.api.frame.FrameDescriptor;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.instrument.Probe;
+import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.nodes.RootNode;
+import com.oracle.truffle.api.object.DynamicObject;
 import com.oracle.truffle.api.source.SourceSection;
+import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.methods.SharedMethodInfo;
 
+import java.util.Arrays;
+
 /**
  * The root node in an AST for a method. Unlike {@link RubyNode}, this has a single entry point,
  * {@link #execute}, which Truffle knows about and can create a {@link CallTarget} from.
@@ -85,4 +90,5 @@ public void applyInstrumentation() {
     public boolean needsDeclarationFrame() {
         return needsDeclarationFrame;
     }
+
 }
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,19 +11,25 @@
 package org.jruby.truffle.nodes;
 
 import org.jruby.truffle.nodes.core.StringNodes;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 import org.jruby.util.ByteList;
 
 public abstract class StringCachingGuards {
 
-    public static ByteList privatizeByteList(RubyBasicObject string) {
-        assert RubyGuards.isRubyString(string);
-        return StringNodes.getByteList(string).dup();
+    public static ByteList privatizeByteList(DynamicObject string) {
+        if (RubyGuards.isRubyString(string)) {
+            return StringNodes.getByteList(string).dup();
+        } else {
+            return null;
+        }
     }
 
-    public static boolean byteListsEqual(RubyBasicObject string, ByteList byteList) {
-        assert RubyGuards.isRubyString(string);
-        return StringNodes.getByteList(string).equal(byteList);
+    public static boolean byteListsEqual(DynamicObject string, ByteList byteList) {
+        if (RubyGuards.isRubyString(string)) {
+            return StringNodes.getByteList(string).equal(byteList);
+        } else {
+            return false;
+        }
     }
 
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/ThreadLocalObjectNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/ThreadLocalObjectNode.java
@@ -13,7 +13,7 @@
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.core.ThreadNodes;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 public class ThreadLocalObjectNode extends RubyNode {
 
@@ -22,12 +22,12 @@ public ThreadLocalObjectNode(RubyContext context, SourceSection sourceSection) {
     }
 
     @Override
-    public RubyBasicObject executeRubyBasicObject(VirtualFrame frame) {
+    public DynamicObject executeDynamicObject(VirtualFrame frame) {
         return ThreadNodes.getThreadLocals(getContext().getThreadManager().getCurrentThread());
     }
 
     @Override
     public Object execute(VirtualFrame frame) {
-        return executeRubyBasicObject(frame);
+        return executeDynamicObject(frame);
     }
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/arguments/CheckArityNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/arguments/CheckArityNode.java
@@ -11,15 +11,17 @@
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.interop.TruffleObject;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.core.hash.HashNodes;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 import org.jruby.truffle.runtime.methods.Arity;
 
+import java.util.Arrays;
 import java.util.Map;
 
 /**
@@ -46,7 +48,7 @@ public CheckArityNode(RubyContext context, SourceSection sourceSection, Arity ar
     public void executeVoid(VirtualFrame frame) {
         final Object[] frameArguments = frame.getArguments();
         final int given;
-        final RubyBasicObject keywordArguments;
+        final DynamicObject keywordArguments;
 
         //TODO (MS): Check merge
         if (RubyArguments.isKwOptimized(frame.getArguments())) {
@@ -77,7 +79,7 @@ public void executeVoid(VirtualFrame frame) {
         }
     }
 
-    private boolean checkArity(VirtualFrame frame, int given, RubyBasicObject keywordArguments) {
+    private boolean checkArity(VirtualFrame frame, int given, DynamicObject keywordArguments) {
         if (keywordArguments != null) {
             given -= 1;
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadBlockNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadBlockNode.java
@@ -14,7 +14,7 @@
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Read the block as a {@code Proc}.
@@ -30,7 +30,7 @@ public ReadBlockNode(RubyContext context, SourceSection sourceSection, Object va
 
     @Override
     public Object execute(VirtualFrame frame) {
-        final RubyBasicObject block = RubyArguments.getBlock(frame.getArguments());
+        final DynamicObject block = RubyArguments.getBlock(frame.getArguments());
 
         if (block == null) {
             return valueIfNotPresent;

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadKeywordArgumentNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadKeywordArgumentNode.java
@@ -19,7 +19,7 @@
 import org.jruby.truffle.nodes.core.hash.HashNodes;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 import java.util.Map;
 
@@ -56,7 +56,7 @@ public Object execute(VirtualFrame frame) {
                 return kwarg;
             }
         } else {
-            final RubyBasicObject hash = RubyArguments.getUserKeywordsHash(frame.getArguments(), minimum);
+            final DynamicObject hash = RubyArguments.getUserKeywordsHash(frame.getArguments(), minimum);
 
             if (defaultProfile.profile(hash == null)) {
                 return defaultValue.execute(frame);
@@ -73,7 +73,7 @@ public Object execute(VirtualFrame frame) {
     }
 
     @TruffleBoundary
-    private Object lookupKeywordInHash(RubyBasicObject hash) {
+    private Object lookupKeywordInHash(DynamicObject hash) {
         assert RubyGuards.isRubyHash(hash);
 
         for (Map.Entry<Object, Object> keyValue : HashNodes.iterableKeyValues(hash)) {

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
@@ -18,7 +18,7 @@
 import org.jruby.truffle.nodes.methods.MarkerNode;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 import org.jruby.truffle.runtime.hash.BucketsStrategy;
 
 import java.util.ArrayList;
@@ -59,7 +59,7 @@ public Object execute(VirtualFrame frame) {
     private Object lookupRestKeywordArgumentHash(VirtualFrame frame) {
         CompilerDirectives.transferToInterpreter();
 
-        final RubyBasicObject hash = RubyArguments.getUserKeywordsHash(frame.getArguments(), minimum);
+        final DynamicObject hash = RubyArguments.getUserKeywordsHash(frame.getArguments(), minimum);
 
         if (hash == null) {
             return HashNodes.createEmptyHash(getContext().getCoreLibrary().getHashClass());

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadRestArgumentNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ReadRestArgumentNode.java
@@ -18,7 +18,7 @@
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.array.ArrayUtils;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Read the rest of arguments after a certain point into an array.
@@ -41,7 +41,7 @@ public ReadRestArgumentNode(RubyContext context, SourceSection sourceSection, in
 
     @Override
     public Object execute(VirtualFrame frame) {
-        final RubyBasicObject arrayClass = getContext().getCoreLibrary().getArrayClass();
+        final DynamicObject arrayClass = getContext().getCoreLibrary().getArrayClass();
 
         int count = RubyArguments.getUserArgumentsCount(frame.getArguments());
 

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
@@ -23,7 +23,7 @@
 import org.jruby.truffle.nodes.dispatch.MissingBehavior;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /*
  * TODO(CS): could probably unify this with SplatCastNode with some final configuration options.
@@ -48,32 +48,32 @@ public ArrayCastNode(RubyContext context, SourceSection sourceSection, SplatCast
     protected abstract RubyNode getChild();
 
     @Specialization
-    public RubyBasicObject cast(boolean value) {
+    public DynamicObject cast(boolean value) {
         return nil();
     }
 
     @Specialization
-    public RubyBasicObject cast(int value) {
+    public DynamicObject cast(int value) {
         return nil();
     }
 
     @Specialization
-    public RubyBasicObject cast(long value) {
+    public DynamicObject cast(long value) {
         return nil();
     }
 
     @Specialization
-    public RubyBasicObject cast(double value) {
+    public DynamicObject cast(double value) {
         return nil();
     }
 
     @Specialization(guards = "isRubyBignum(value)")
-    public RubyBasicObject castBignum(RubyBasicObject value) {
+    public DynamicObject castBignum(DynamicObject value) {
         return nil();
     }
 
     @Specialization(guards = "isRubyArray(array)")
-    public RubyBasicObject castArray(RubyBasicObject array) {
+    public DynamicObject castArray(DynamicObject array) {
         return array;
     }
 
@@ -96,7 +96,7 @@ public Object cast(Object nil) {
     }
 
     @Specialization(guards = {"!isNil(object)", "!isRubyBignum(object)", "!isRubyArray(object)"})
-    public Object cast(VirtualFrame frame, RubyBasicObject object) {
+    public Object cast(VirtualFrame frame, DynamicObject object) {
         final Object result = toArrayNode.call(frame, object, "to_ary", null, new Object[]{});
 
         if (result == DispatchNode.MISSING) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/BooleanCastNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/BooleanCastNode.java
@@ -15,7 +15,7 @@
 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.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Casts a value into a boolean.
@@ -55,7 +55,7 @@ public boolean doFloat(double value) {
     }
 
     @Specialization(guards = "!isNil(object)")
-    public boolean doBasicObject(RubyBasicObject object) {
+    public boolean doBasicObject(DynamicObject object) {
         return true;
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/BooleanCastWithDefaultNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/BooleanCastWithDefaultNode.java
@@ -16,7 +16,7 @@
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Casts a value into a boolean and defaults to the given value if not provided.
@@ -64,7 +64,7 @@ public boolean doFloat(double value) {
     }
 
     @Specialization(guards = "!isNil(object)")
-    public boolean doBasicObject(RubyBasicObject object) {
+    public boolean doBasicObject(DynamicObject object) {
         return true;
     }
 

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
@@ -34,7 +34,7 @@
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * This is a port of MRI's rb_cmpint, as taken from RubyComparable and broken out into specialized nodes.
@@ -83,7 +83,7 @@ public int cmpLong(long value, Object receiver, Object other) {
     }
 
     @Specialization(guards = "isRubyBignum(value)")
-    public int cmpBignum(RubyBasicObject value, Object receiver, Object other) {
+    public int cmpBignum(DynamicObject value, Object receiver, Object other) {
         return BignumNodes.getBigIntegerValue(value).signum();
     }
 
@@ -93,8 +93,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.getModel(getContext().getCoreLibrary().getLogicalClass(receiver)).getName(),
-                        ModuleNodes.getModel(getContext().getCoreLibrary().getLogicalClass(other)).getName()), this)
+                        ModuleNodes.getFields(getContext().getCoreLibrary().getLogicalClass(receiver)).getName(),
+                        ModuleNodes.getFields(getContext().getCoreLibrary().getLogicalClass(other)).getName()), this)
         );
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/HashCastNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/HashCastNode.java
@@ -22,7 +22,7 @@
 import org.jruby.truffle.nodes.dispatch.MissingBehavior;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 // TODO(CS): copy and paste of ArrayCastNode
 
@@ -39,42 +39,42 @@ public HashCastNode(RubyContext context, SourceSection sourceSection) {
     protected abstract RubyNode getChild();
 
     @Specialization
-    public RubyBasicObject cast(boolean value) {
+    public DynamicObject cast(boolean value) {
         return nil();
     }
 
     @Specialization
-    public RubyBasicObject cast(int value) {
+    public DynamicObject cast(int value) {
         return nil();
     }
 
     @Specialization
-    public RubyBasicObject cast(long value) {
+    public DynamicObject cast(long value) {
         return nil();
     }
 
     @Specialization
-    public RubyBasicObject cast(double value) {
+    public DynamicObject cast(double value) {
         return nil();
     }
 
     @Specialization(guards = "isNil(nil)")
-    public RubyBasicObject castNil(RubyBasicObject nil) {
+    public DynamicObject castNil(DynamicObject nil) {
         return nil();
     }
 
     @Specialization(guards = "isRubyBignum(value)")
-    public RubyBasicObject castBignum(RubyBasicObject value) {
+    public DynamicObject castBignum(DynamicObject value) {
         return nil();
     }
 
     @Specialization(guards = "isRubyHash(hash)")
-    public RubyBasicObject castHash(RubyBasicObject hash) {
+    public DynamicObject castHash(DynamicObject hash) {
         return hash;
     }
 
     @Specialization(guards = {"!isNil(object)", "!isRubyBignum(object)", "!isRubyHash(object)"})
-    public Object cast(VirtualFrame frame, RubyBasicObject object) {
+    public Object cast(VirtualFrame frame, DynamicObject object) {
         final Object result = toHashNode.call(frame, object, "to_hash", null, new Object[]{});
 
         if (result == DispatchNode.MISSING) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/NumericToFloatNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/NumericToFloatNode.java
@@ -23,7 +23,7 @@
 import org.jruby.truffle.nodes.dispatch.MissingBehavior;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Casts a value into a Ruby Float (double).
@@ -42,9 +42,9 @@ public NumericToFloatNode(RubyContext context, SourceSection sourceSection, Stri
         this.method = method;
     }
 
-    public abstract double executeDouble(VirtualFrame frame, RubyBasicObject value);
+    public abstract double executeDouble(VirtualFrame frame, DynamicObject value);
 
-    private Object callToFloat(VirtualFrame frame, RubyBasicObject value) {
+    private Object callToFloat(VirtualFrame frame, DynamicObject value) {
         if (toFloatCallNode == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
             toFloatCallNode = insert(DispatchHeadNodeFactory.createMethodCall(getContext(), MissingBehavior.RETURN_MISSING));
@@ -53,7 +53,7 @@ private Object callToFloat(VirtualFrame frame, RubyBasicObject value) {
     }
 
     @Specialization(guards = "isNumeric(frame, value)")
-    protected double castNumeric(VirtualFrame frame, RubyBasicObject value) {
+    protected double castNumeric(VirtualFrame frame, DynamicObject value) {
         final Object result = callToFloat(frame, value);
 
         if (result instanceof Double) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/ProcCastNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/ProcCastNode.java
@@ -17,7 +17,7 @@
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Casts an object to a Ruby Proc object.
@@ -33,17 +33,17 @@ public ProcCastNode(RubyContext context, SourceSection sourceSection) {
     }
 
     @Specialization(guards = "isNil(nil)")
-    public RubyBasicObject doNil(Object nil) {
+    public DynamicObject doNil(Object nil) {
         return nil();
     }
 
     @Specialization(guards = "isRubyProc(proc)")
-    public RubyBasicObject doRubyProc(RubyBasicObject proc) {
+    public DynamicObject doRubyProc(DynamicObject proc) {
         return proc;
     }
 
     @Specialization
-    public Object doObject(VirtualFrame frame, RubyBasicObject object) {
+    public Object doObject(VirtualFrame frame, DynamicObject object) {
         return toProc.call(frame, object, "to_proc", null);
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/ProcOrNullNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/ProcOrNullNode.java
@@ -15,7 +15,7 @@
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(value = "child", type = RubyNode.class)
 public abstract class ProcOrNullNode extends RubyNode {
@@ -24,20 +24,20 @@ public ProcOrNullNode(RubyContext context, SourceSection sourceSection) {
         super(context, sourceSection);
     }
 
-    public abstract RubyBasicObject executeProcOrNull(Object proc);
+    public abstract DynamicObject executeProcOrNull(Object proc);
 
     @Specialization
-    public RubyBasicObject doNotProvided(NotProvided proc) {
+    public DynamicObject doNotProvided(NotProvided proc) {
         return null;
     }
 
     @Specialization(guards = "isNil(nil)")
-    public RubyBasicObject doNil(Object nil) {
+    public DynamicObject doNil(Object nil) {
         return null;
     }
 
     @Specialization(guards = "isRubyProc(proc)")
-    public RubyBasicObject doProc(RubyBasicObject proc) {
+    public DynamicObject doProc(DynamicObject proc) {
         return proc;
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/SingleValueCastNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/SingleValueCastNode.java
@@ -17,7 +17,7 @@
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.core.array.ArrayNodes;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(value = "child", type = RubyNode.class)
 public abstract class SingleValueCastNode extends RubyNode {
@@ -29,7 +29,7 @@ public SingleValueCastNode(RubyContext context, SourceSection sourceSection) {
     public abstract Object executeSingleValue(VirtualFrame frame, Object[] args);
 
     @Specialization(guards = "noArguments(args)")
-    protected RubyBasicObject castNil(Object[] args) {
+    protected DynamicObject castNil(Object[] args) {
         return nil();
     }
 
@@ -40,7 +40,7 @@ protected Object castSingle(Object[] args) {
 
     @TruffleBoundary
     @Specialization(guards = { "!noArguments(args)", "!singleArgument(args)" })
-    protected RubyBasicObject castMany(Object[] args) {
+    protected DynamicObject castMany(Object[] args) {
         return ArrayNodes.fromObjects(getContext().getCoreLibrary().getArrayClass(), args);
     }
 

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
@@ -25,7 +25,7 @@
 import org.jruby.truffle.nodes.dispatch.MissingBehavior;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Splat as used to cast a value to an array if it isn't already, as in {@code *value}.
@@ -61,7 +61,7 @@ public SplatCastNode(RubyContext context, SourceSection sourceSection, NilBehavi
     protected abstract RubyNode getChild();
 
     @Specialization(guards = "isNil(nil)")
-    public RubyBasicObject splat(Object nil) {
+    public DynamicObject splat(Object nil) {
         switch (nilBehavior) {
             case EMPTY_ARRAY:
                 return createEmptyArray();
@@ -76,14 +76,14 @@ public RubyBasicObject splat(Object nil) {
     }
 
     @Specialization(guards = "isRubyArray(array)")
-    public RubyBasicObject splat(VirtualFrame frame, RubyBasicObject array) {
+    public DynamicObject splat(VirtualFrame frame, DynamicObject array) {
         // TODO(cs): is it necessary to dup here in all cases?
         // It is needed at least for [*ary] (parsed as just a SplatNode) and b = *ary.
         return dup.executeDup(frame, array);
     }
 
     @Specialization(guards = {"!isNil(object)", "!isRubyArray(object)"})
-    public RubyBasicObject splat(VirtualFrame frame, Object object) {
+    public DynamicObject splat(VirtualFrame frame, Object object) {
         final String method;
 
         if (useToAry) {
@@ -98,7 +98,7 @@ public RubyBasicObject splat(VirtualFrame frame, Object object) {
             final Object array = toA.call(frame, object, method, null);
 
             if (RubyGuards.isRubyArray(array)) {
-                return (RubyBasicObject) array;
+                return (DynamicObject) array;
             } else if (array == nil() || array == DispatchNode.MISSING) {
                 CompilerDirectives.transferToInterpreter();
                 return ArrayNodes.fromObject(getContext().getCoreLibrary().getArrayClass(), object);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/StringToSymbolNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/StringToSymbolNode.java
@@ -14,7 +14,7 @@
 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.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Creates a symbol from a string.
@@ -27,7 +27,7 @@ public StringToSymbolNode(RubyContext context, SourceSection sourceSection) {
     }
 
     @Specialization(guards = "isRubyString(string)")
-    public RubyBasicObject doString(RubyBasicObject string) {
+    public DynamicObject doString(DynamicObject string) {
         return getSymbol(string.toString());
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/TaintResultNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/TaintResultNode.java
@@ -23,7 +23,7 @@
 import org.jruby.truffle.nodes.objects.TaintNodeGen;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 public class TaintResultNode extends RubyNode {
 
@@ -50,7 +50,7 @@ public TaintResultNode(RubyContext context, SourceSection sourceSection) {
         this.isTaintedNode = IsTaintedNodeGen.create(getContext(), getSourceSection(), null);
     }
 
-    public Object maybeTaint(RubyBasicObject source, RubyBasicObject result) {
+    public Object maybeTaint(DynamicObject source, DynamicObject result) {
         if (taintProfile.profile(isTaintedNode.isTainted(source))) {
             if (taintNode == null) {
                 CompilerDirectives.transferToInterpreter();
@@ -65,10 +65,10 @@ public Object maybeTaint(RubyBasicObject source, RubyBasicObject result) {
 
     @Override
     public Object execute(VirtualFrame frame) {
-        final RubyBasicObject result;
+        final DynamicObject result;
 
         try {
-            result = method.executeRubyBasicObject(frame);
+            result = method.executeDynamicObject(frame);
         } catch (DoNotTaint e) {
             return e.getResult();
         } catch (UnexpectedResultException e) {
@@ -77,7 +77,7 @@ public Object execute(VirtualFrame frame) {
 
         if (result != nil()) {
             if (taintFromSelf) {
-                maybeTaint((RubyBasicObject) RubyArguments.getSelf(frame.getArguments()), result);
+                maybeTaint((DynamicObject) RubyArguments.getSelf(frame.getArguments()), result);
             }
 
             // It's possible the taintFromParameter value was misconfigured by the user, but the far more likely
@@ -86,8 +86,8 @@ public Object execute(VirtualFrame frame) {
             if (taintFromParameter < RubyArguments.getUserArgumentsCount(frame.getArguments())) {
                 final Object argument = RubyArguments.getUserArgument(frame.getArguments(), taintFromParameter);
 
-                if (argument instanceof RubyBasicObject) {
-                    final RubyBasicObject taintSource = (RubyBasicObject) argument;
+                if (argument instanceof DynamicObject) {
+                    final DynamicObject taintSource = (DynamicObject) argument;
                     maybeTaint(taintSource, result);
                 }
             }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/cast/ToSNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/cast/ToSNode.java
@@ -22,7 +22,7 @@
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(type = RubyNode.class)
 public abstract class ToSNode extends RubyNode {
@@ -35,7 +35,7 @@ public ToSNode(RubyContext context, SourceSection sourceSection) {
         callToSNode = DispatchHeadNodeFactory.createMethodCall(context, true);
     }
 
-    protected RubyBasicObject kernelToS(VirtualFrame frame, Object object) {
+    protected DynamicObject kernelToS(VirtualFrame frame, Object object) {
         if (kernelToSNode == null) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
             kernelToSNode = insert(KernelNodesFactory.ToSNodeFactory.create(getContext(), getSourceSection(), new RubyNode[] {null}));
@@ -44,27 +44,27 @@ protected RubyBasicObject kernelToS(VirtualFrame frame, Object object) {
     }
 
     @Specialization(guards = "isRubyString(string)")
-    public RubyBasicObject toS(RubyBasicObject string) {
+    public DynamicObject toS(DynamicObject string) {
         return string;
     }
 
     @Specialization(guards = "!isRubyString(object)", rewriteOn = UnexpectedResultException.class)
-    public RubyBasicObject toS(VirtualFrame frame, Object object) throws UnexpectedResultException {
+    public DynamicObject toS(VirtualFrame frame, Object object) throws UnexpectedResultException {
         final Object value = callToSNode.call(frame, object, "to_s", null);
 
         if (RubyGuards.isRubyString(value)) {
-            return (RubyBasicObject) value;
+            return (DynamicObject) value;
         }
 
         throw new UnexpectedResultException(value);
     }
 
     @Specialization(guards = "!isRubyString(object)")
-    public RubyBasicObject toSFallback(VirtualFrame frame, Object object) {
+    public DynamicObject toSFallback(VirtualFrame frame, Object object) {
         final Object value = callToSNode.call(frame, object, "to_s", null);
 
         if (RubyGuards.isRubyString(value)) {
-            return (RubyBasicObject) value;
+            return (DynamicObject) value;
         } else {
             return kernelToS(frame, object);
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/coerce/NameToJavaStringNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/coerce/NameToJavaStringNode.java
@@ -17,12 +17,13 @@
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
 import org.jruby.truffle.nodes.core.SymbolNodes;
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Take a Symbol or some object accepting #to_str
@@ -41,12 +42,12 @@ public NameToJavaStringNode(RubyContext context, SourceSection sourceSection) {
     public abstract String executeToJavaString(VirtualFrame frame, Object name);
 
     @Specialization(guards = "isRubySymbol(symbol)")
-    public String coerceRubySymbol(RubyBasicObject symbol) {
+    public String coerceRubySymbol(DynamicObject symbol) {
         return SymbolNodes.getString(symbol);
     }
 
     @Specialization(guards = "isRubyString(string)")
-    public String coerceRubyString(RubyBasicObject string) {
+    public String coerceRubyString(DynamicObject string) {
         return string.toString();
     }
 
@@ -57,7 +58,7 @@ public String coerceObject(VirtualFrame frame, Object object) {
         try {
             coerced = toStr.call(frame, object, "to_str", null);
         } catch (RaiseException e) {
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == getContext().getCoreLibrary().getNoMethodErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == getContext().getCoreLibrary().getNoMethodErrorClass()) {
                 CompilerDirectives.transferToInterpreter();
                 throw new RaiseException(getContext().getCoreLibrary().typeErrorNoImplicitConversion(object, "String", this));
             } else {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/coerce/NameToSymbolOrStringNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/coerce/NameToSymbolOrStringNode.java
@@ -17,11 +17,12 @@
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Take a Symbol or some object accepting #to_str
@@ -37,26 +38,26 @@ public NameToSymbolOrStringNode(RubyContext context, SourceSection sourceSection
         toStr = DispatchHeadNodeFactory.createMethodCall(context);
     }
 
-    public abstract RubyBasicObject executeToSymbolOrString(VirtualFrame frame, Object name);
+    public abstract DynamicObject executeToSymbolOrString(VirtualFrame frame, Object name);
 
     @Specialization(guards = "isRubySymbol(symbol)")
-    public RubyBasicObject coerceRubySymbol(RubyBasicObject symbol) {
+    public DynamicObject coerceRubySymbol(DynamicObject symbol) {
         return symbol;
     }
 
     @Specialization(guards = "isRubyString(string)")
-    public RubyBasicObject coerceRubyString(RubyBasicObject string) {
+    public DynamicObject coerceRubyString(DynamicObject string) {
         return string;
     }
 
     @Specialization(guards = { "!isRubySymbol(object)", "!isRubyString(object)" })
-    public RubyBasicObject coerceObject(VirtualFrame frame, Object object) {
+    public DynamicObject coerceObject(VirtualFrame frame, Object object) {
         final Object coerced;
 
         try {
             coerced = toStr.call(frame, object, "to_str", null);
         } catch (RaiseException e) {
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == getContext().getCoreLibrary().getNoMethodErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == getContext().getCoreLibrary().getNoMethodErrorClass()) {
                 CompilerDirectives.transferToInterpreter();
                 throw new RaiseException(getContext().getCoreLibrary().typeErrorNoImplicitConversion(object, "String", this));
             } else {
@@ -65,7 +66,7 @@ public RubyBasicObject coerceObject(VirtualFrame frame, Object object) {
         }
 
         if (RubyGuards.isRubyString(coerced)) {
-            return (RubyBasicObject) coerced;
+            return (DynamicObject) coerced;
         } else {
             CompilerDirectives.transferToInterpreter();
             throw new RaiseException(getContext().getCoreLibrary().typeErrorBadCoercion(object, "String", "to_str", coerced, this));

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToAryNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToAryNode.java
@@ -16,11 +16,12 @@
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 
 @NodeChild(value = "child", type = RubyNode.class)
@@ -33,12 +34,12 @@ public ToAryNode(RubyContext context, SourceSection sourceSection) {
     }
 
     @Specialization(guards = "isRubyArray(array)")
-    public RubyBasicObject coerceRubyArray(RubyBasicObject array) {
+    public DynamicObject coerceRubyArray(DynamicObject array) {
         return array;
     }
 
     @Specialization(guards = "!isRubyArray(object)")
-    public RubyBasicObject coerceObject(VirtualFrame frame, Object object) {
+    public DynamicObject coerceObject(VirtualFrame frame, Object object) {
         if (toAryNode == null) {
             CompilerDirectives.transferToInterpreter();
             toAryNode = insert(DispatchHeadNodeFactory.createMethodCall(getContext()));
@@ -49,7 +50,7 @@ public RubyBasicObject coerceObject(VirtualFrame frame, Object object) {
         try {
             coerced = toAryNode.call(frame, object, "to_ary", null);
         } catch (RaiseException e) {
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == getContext().getCoreLibrary().getNoMethodErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == getContext().getCoreLibrary().getNoMethodErrorClass()) {
                 CompilerDirectives.transferToInterpreter();
 
                 throw new RaiseException(
@@ -59,7 +60,7 @@ public RubyBasicObject coerceObject(VirtualFrame frame, Object object) {
             }
         }
         if (RubyGuards.isRubyArray(coerced)) {
-            return (RubyBasicObject) coerced;
+            return (DynamicObject) coerced;
         } else {
             CompilerDirectives.transferToInterpreter();
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToFNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToFNode.java
@@ -16,11 +16,12 @@
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(value = "child", type = RubyNode.class)
 public abstract class ToFNode extends RubyNode {
@@ -65,7 +66,7 @@ public double coerceBoolean(VirtualFrame frame, boolean value) {
     }
 
     @Specialization
-    public double coerceRubyBasicObject(VirtualFrame frame, RubyBasicObject object) {
+    public double coerceDynamicObject(VirtualFrame frame, DynamicObject object) {
         return coerceObject(frame, object);
     }
 
@@ -80,7 +81,7 @@ private double coerceObject(VirtualFrame frame, Object object) {
         try {
             coerced = toFNode.call(frame, object, "to_f", null);
         } catch (RaiseException e) {
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == getContext().getCoreLibrary().getNoMethodErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == getContext().getCoreLibrary().getNoMethodErrorClass()) {
                 CompilerDirectives.transferToInterpreter();
                 throw new RaiseException(getContext().getCoreLibrary().typeErrorNoImplicitConversion(object, "Float", this));
             } else {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToIntNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToIntNode.java
@@ -18,13 +18,14 @@
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
 import org.jruby.truffle.nodes.core.FloatNodes;
 import org.jruby.truffle.nodes.core.FloatNodesFactory;
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(value = "child", type = RubyNode.class)
 public abstract class ToIntNode extends RubyNode {
@@ -65,7 +66,7 @@ public long coerceLong(long value) {
     }
 
     @Specialization(guards = "isRubyBignum(value)")
-    public RubyBasicObject coerceRubyBignum(RubyBasicObject value) {
+    public DynamicObject coerceRubyBignum(DynamicObject value) {
         CompilerDirectives.transferToInterpreter();
         throw new RaiseException(getContext().getCoreLibrary().rangeError("bignum too big to convert into `long'", this));
     }
@@ -85,7 +86,7 @@ public Object coerceBoolean(VirtualFrame frame, boolean value) {
     }
 
     @Specialization(guards = "!isRubyBignum(object)")
-    public Object coerceBasicObject(VirtualFrame frame, RubyBasicObject object) {
+    public Object coerceBasicObject(VirtualFrame frame, DynamicObject object) {
         return coerceObject(frame, object);
     }
 
@@ -100,7 +101,7 @@ private Object coerceObject(VirtualFrame frame, Object object) {
         try {
             coerced = toIntNode.call(frame, object, "to_int", null);
         } catch (RaiseException e) {
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == getContext().getCoreLibrary().getNoMethodErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == getContext().getCoreLibrary().getNoMethodErrorClass()) {
                 CompilerDirectives.transferToInterpreter();
                 throw new RaiseException(getContext().getCoreLibrary().typeErrorNoImplicitConversion(object, "Integer", this));
             } else {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToPathNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToPathNode.java
@@ -7,7 +7,6 @@
  * GNU General Public License version 2
  * GNU Lesser General Public License version 2.1
  */
-
 package org.jruby.truffle.nodes.coerce;
 
 import com.oracle.truffle.api.dsl.NodeChild;
@@ -16,8 +15,7 @@
 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.RubyBasicObject;
-import org.jruby.truffle.runtime.core.RubyString;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(value = "child", type = RubyNode.class)
 public abstract class ToPathNode extends RubyNode {
@@ -26,16 +24,14 @@ public ToPathNode(RubyContext context, SourceSection sourceSection) {
         super(context, sourceSection);
     }
 
-    public abstract RubyString executeRubyString(VirtualFrame frame, Object object);
-
     @Specialization(guards = "isRubyString(path)")
-    public RubyBasicObject coerceRubyString(RubyBasicObject path) {
+    public DynamicObject coerceRubyString(DynamicObject path) {
         return path;
     }
 
     @Specialization(guards = "!isRubyString(object)")
-    public RubyBasicObject coerceObject(VirtualFrame frame, Object object) {
-        return (RubyBasicObject) ruby(frame, "Rubinius::Type.coerce_to_path(object)", "object", object);
+    public DynamicObject coerceObject(VirtualFrame frame, Object object) {
+        return (DynamicObject) ruby(frame, "Rubinius::Type.coerce_to_path(object)", "object", object);
     }
 
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToStrNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/coerce/ToStrNode.java
@@ -17,11 +17,12 @@
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(value = "child", type = RubyNode.class)
 public abstract class ToStrNode extends RubyNode {
@@ -33,21 +34,21 @@ public ToStrNode(RubyContext context, SourceSection sourceSection) {
         toStrNode = DispatchHeadNodeFactory.createMethodCall(context);
     }
 
-    public abstract RubyBasicObject executeToStr(VirtualFrame frame, Object object);
+    public abstract DynamicObject executeToStr(VirtualFrame frame, Object object);
 
     @Specialization(guards = "isRubyString(string)")
-    public RubyBasicObject coerceRubyString(RubyBasicObject string) {
+    public DynamicObject coerceRubyString(DynamicObject string) {
         return string;
     }
 
     @Specialization(guards = "!isRubyString(object)")
-    public RubyBasicObject coerceObject(VirtualFrame frame, Object object) {
+    public DynamicObject coerceObject(VirtualFrame frame, Object object) {
         final Object coerced;
 
         try {
             coerced = toStrNode.call(frame, object, "to_str", null);
         } catch (RaiseException e) {
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == getContext().getCoreLibrary().getNoMethodErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == getContext().getCoreLibrary().getNoMethodErrorClass()) {
                 CompilerDirectives.transferToInterpreter();
                 throw new RaiseException(getContext().getCoreLibrary().typeErrorNoImplicitConversion(object, "String", this));
             } else {
@@ -56,7 +57,7 @@ public RubyBasicObject coerceObject(VirtualFrame frame, Object object) {
         }
 
         if (RubyGuards.isRubyString(coerced)) {
-            return (RubyBasicObject) coerced;
+            return (DynamicObject) coerced;
         } else {
             CompilerDirectives.transferToInterpreter();
             throw new RaiseException(getContext().getCoreLibrary().typeErrorBadCoercion(object, "String", "to_str", coerced, this));

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/GetConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/GetConstantNode.java
@@ -18,7 +18,7 @@
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 import org.jruby.util.IdUtil;
 
 import com.oracle.truffle.api.CompilerDirectives;
@@ -42,34 +42,34 @@ public GetConstantNode(RubyContext context, SourceSection sourceSection, Restart
     public abstract Object executeGetConstant(VirtualFrame frame, Object module, String name, RubyConstant constant);
 
     @Specialization(guards = { "constant != null", "!constant.isAutoload()" })
-    protected Object getConstant(RubyBasicObject module, String name, RubyConstant constant) {
+    protected Object getConstant(DynamicObject module, String name, RubyConstant constant) {
         return constant.getValue();
     }
 
     @Specialization(guards = { "constant != null", "constant.isAutoload()" })
-    protected Object autoloadConstant(VirtualFrame frame, RubyBasicObject module, String name, RubyConstant constant,
+    protected Object autoloadConstant(VirtualFrame frame, DynamicObject module, String name, RubyConstant constant,
             @Cached("createRequireNode()") RequireNode requireNode,
             @Cached("deepCopyReadConstantNode()") RestartableReadConstantNode readConstantNode) {
 
-        final RubyBasicObject path = (RubyBasicObject) constant.getValue();
+        final DynamicObject path = (DynamicObject) constant.getValue();
 
         // The autoload constant must only be removed if everything succeeds.
         // We remove it first to allow lookup to ignore it and add it back if there was a failure.
-        ModuleNodes.getModel(constant.getDeclaringModule()).removeConstant(this, name);
+        ModuleNodes.getFields(constant.getDeclaringModule()).removeConstant(this, name);
         try {
             requireNode.require(path);
             return readConstantNode.readConstant(frame, module, name);
         } catch (RaiseException e) {
-            ModuleNodes.getModel(constant.getDeclaringModule()).setAutoloadConstant(this, name, path);
+            ModuleNodes.getFields(constant.getDeclaringModule()).setAutoloadConstant(this, name, path);
             throw e;
         }
     }
 
     @Specialization(guards = "constant == null")
-    protected Object missingConstant(VirtualFrame frame, RubyBasicObject module, String name, Object constant,
+    protected Object missingConstant(VirtualFrame frame, DynamicObject module, String name, Object constant,
             @Cached("isValidConstantName(name)") boolean isValidConstantName,
             @Cached("createConstMissingNode()") CallDispatchHeadNode constMissingNode,
-            @Cached("getSymbol(name)") RubyBasicObject symbolName) {
+            @Cached("getSymbol(name)") DynamicObject symbolName) {
         if (!isValidConstantName) {
             CompilerDirectives.transferToInterpreter();
             throw new RaiseException(getContext().getCoreLibrary().nameError(String.format("wrong constant name %s", name), name, this));

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/LookupConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/LookupConstantNode.java
@@ -17,7 +17,7 @@
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -54,8 +54,8 @@ public LookupConstantNode(RubyContext context, SourceSection sourceSection, bool
             "module == cachedModule",
             "guardName(name, cachedName, sameNameProfile)"
     }, assumptions = "getUnmodifiedAssumption(cachedModule)", limit = "getCacheLimit()")
-    protected RubyConstant lookupConstant(VirtualFrame frame, RubyBasicObject module, String name,
-                                          @Cached("module") RubyBasicObject cachedModule,
+    protected RubyConstant lookupConstant(VirtualFrame frame, DynamicObject module, String name,
+                                          @Cached("module") DynamicObject cachedModule,
                                           @Cached("name") String cachedName,
                                           @Cached("doLookup(cachedModule, cachedName)") RubyConstant constant,
                                           @Cached("isVisible(cachedModule, constant)") boolean isVisible,
@@ -67,13 +67,13 @@ protected RubyConstant lookupConstant(VirtualFrame frame, RubyBasicObject module
         return constant;
     }
 
-    public Assumption getUnmodifiedAssumption(RubyBasicObject module) {
-        return ModuleNodes.getModel(module).getUnmodifiedAssumption();
+    public Assumption getUnmodifiedAssumption(DynamicObject module) {
+        return ModuleNodes.getFields(module).getUnmodifiedAssumption();
     }
 
     @TruffleBoundary
     @Specialization(guards = "isRubyModule(module)")
-    protected RubyConstant lookupConstantUncached(RubyBasicObject module, String name) {
+    protected RubyConstant lookupConstantUncached(DynamicObject module, String name) {
         RubyConstant constant = doLookup(module, name);
         boolean isVisible = isVisible(module, constant);
 
@@ -99,11 +99,11 @@ protected boolean guardName(String name, String cachedName, ConditionProfile sam
         }
     }
 
-    protected RubyConstant doLookup(RubyBasicObject module, String name) {
+    protected RubyConstant doLookup(DynamicObject module, String name) {
         return ModuleOperations.lookupConstant(getContext(), module, name);
     }
 
-    protected boolean isVisible(RubyBasicObject module, RubyConstant constant) {
+    protected boolean isVisible(DynamicObject module, RubyConstant constant) {
         return constant == null || constant.isVisibleTo(getContext(), LexicalScope.NONE, module);
     }
 

diff --git a/...e/src/main/java/org/jruby/truffle/nodes/constants/LookupConstantWithLexicalScopeNode.java b/...e/src/main/java/org/jruby/truffle/nodes/constants/LookupConstantWithLexicalScopeNode.java
@@ -16,7 +16,7 @@
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CompilerDirectives;
@@ -36,7 +36,7 @@ public LookupConstantWithLexicalScopeNode(RubyContext context, SourceSection sou
         this.name = name;
     }
 
-    public RubyBasicObject getModule() {
+    public DynamicObject getModule() {
         return lexicalScope.getLiveModule();
     }
 
@@ -53,8 +53,8 @@ protected RubyConstant lookupConstant(VirtualFrame frame,
         return constant;
     }
 
-    public Assumption getUnmodifiedAssumption(RubyBasicObject module) {
-        return ModuleNodes.getModel(module).getUnmodifiedAssumption();
+    public Assumption getUnmodifiedAssumption(DynamicObject module) {
+        return ModuleNodes.getFields(module).getUnmodifiedAssumption();
     }
 
     protected RubyConstant doLookup() {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/ReadConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/ReadConstantNode.java
@@ -10,6 +10,10 @@
 package org.jruby.truffle.nodes.constants;
 
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
+import org.jruby.truffle.nodes.literal.LiteralNode;
+import org.jruby.truffle.runtime.ConstantReplacer;
+import org.jruby.truffle.runtime.LexicalScope;
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 

diff --git a/...fle/src/main/java/org/jruby/truffle/nodes/constants/ReadConstantWithLexicalScopeNode.java b/...fle/src/main/java/org/jruby/truffle/nodes/constants/ReadConstantWithLexicalScopeNode.java
@@ -10,11 +10,12 @@
 package org.jruby.truffle.nodes.constants;
 
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
 import org.jruby.truffle.runtime.LexicalScope;
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
@@ -38,7 +39,7 @@ public ReadConstantWithLexicalScopeNode(RubyContext context, SourceSection sourc
     @Override
     public Object execute(VirtualFrame frame) {
         final RubyConstant constant = lookupConstantNode.executeLookupConstant(frame);
-        final RubyBasicObject module = lexicalScope.getLiveModule();
+        final DynamicObject module = lexicalScope.getLiveModule();
 
         return getConstantNode.executeGetConstant(frame, module, name, constant);
     }
@@ -54,7 +55,7 @@ public Object isDefined(VirtualFrame frame) {
         try {
             constant = lookupConstantNode.executeLookupConstant(frame);
         } catch (RaiseException e) {
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == getContext().getCoreLibrary().getNameErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == getContext().getCoreLibrary().getNameErrorClass()) {
                 // private constant
                 return nil();
             }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/ReadLiteralConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/ReadLiteralConstantNode.java
@@ -10,11 +10,12 @@
 package org.jruby.truffle.nodes.constants;
 
 import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.nodes.core.BasicObjectNodes;
 import org.jruby.truffle.nodes.literal.LiteralNode;
 import org.jruby.truffle.runtime.RubyConstant;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.source.SourceSection;
@@ -48,7 +49,7 @@ public Object isDefined(VirtualFrame frame) {
              *
              * We should maybe try to see if receiver.isDefined() but we also need its value if it is,
              * and we do not want to execute receiver twice. */
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == context.getCoreLibrary().getNameErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == context.getCoreLibrary().getNameErrorClass()) {
                 return nil();
             }
             throw e;
@@ -58,10 +59,10 @@ public Object isDefined(VirtualFrame frame) {
         try {
             constant = readConstantNode.lookupConstantNode.executeLookupConstant(frame, module, name);
         } catch (RaiseException e) {
-            if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == context.getCoreLibrary().getTypeErrorClass()) {
+            if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == context.getCoreLibrary().getTypeErrorClass()) {
                 // module is not a class/module
                 return nil();
-            } else if (((RubyBasicObject) e.getRubyException()).getLogicalClass() == context.getCoreLibrary().getNameErrorClass()) {
+            } else if (BasicObjectNodes.getLogicalClass(((DynamicObject) e.getRubyException())) == context.getCoreLibrary().getNameErrorClass()) {
                 // private constant
                 return nil();
             }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/constants/WriteConstantNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/constants/WriteConstantNode.java
@@ -17,7 +17,7 @@
 import org.jruby.truffle.nodes.core.ModuleNodes;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 /**
  * Represents writing a constant into some module.
@@ -49,9 +49,9 @@ public Object execute(VirtualFrame frame) {
             throw new RaiseException(getContext().getCoreLibrary().typeErrorIsNotA(receiverObject.toString(), "class/module", this));
         }
 
-        final RubyBasicObject module = (RubyBasicObject) receiverObject;
+        final DynamicObject module = (DynamicObject) receiverObject;
 
-        ModuleNodes.getModel(module).setConstant(this, name, rhsValue);
+        ModuleNodes.getFields(module).setConstant(this, name, rhsValue);
 
         return rhsValue;
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/control/WhenSplatNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/control/WhenSplatNode.java
@@ -19,7 +19,7 @@
 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.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 public class WhenSplatNode extends RubyNode {
 
@@ -40,10 +40,10 @@ public boolean executeBoolean(VirtualFrame frame) {
 
         final Object caseExpression = readCaseExpression.execute(frame);
 
-        final RubyBasicObject array;
+        final DynamicObject array;
 
         try {
-            array = splat.executeRubyBasicObject(frame);
+            array = splat.executeDynamicObject(frame);
         } catch (UnexpectedResultException e) {
             throw new UnsupportedOperationException();
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/conversion/ToJavaStringNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/conversion/ToJavaStringNode.java
@@ -17,7 +17,7 @@
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.core.SymbolNodes;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(value="child", type=RubyNode.class)
 public abstract class ToJavaStringNode extends RubyNode {
@@ -32,13 +32,13 @@ public ToJavaStringNode(RubyContext context, SourceSection sourceSection) {
 
     @TruffleBoundary
     @Specialization(guards = "isRubySymbol(symbol)")
-    protected String toJavaStringSymbol(RubyBasicObject symbol) {
+    protected String toJavaStringSymbol(DynamicObject symbol) {
         return SymbolNodes.getString(symbol);
     }
 
     @TruffleBoundary
     @Specialization(guards = "isRubyString(string)")
-    protected String toJavaStringString(RubyBasicObject string) {
+    protected String toJavaStringString(DynamicObject string) {
         return string.toString();
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/conversion/ToSymbolNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/conversion/ToSymbolNode.java
@@ -16,7 +16,7 @@
 import org.jruby.truffle.nodes.RubyNode;
 import org.jruby.truffle.nodes.core.StringNodes;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 
 @NodeChild(value="child", type=RubyNode.class)
 public abstract class ToSymbolNode extends RubyNode {
@@ -25,22 +25,22 @@ public ToSymbolNode(RubyContext context, SourceSection sourceSection) {
         super(context, sourceSection);
     }
 
-    public abstract RubyBasicObject executeRubySymbol(VirtualFrame frame, Object object);
+    public abstract DynamicObject executeRubySymbol(VirtualFrame frame, Object object);
 
     // TODO(CS): cache the conversion to a symbol? Or should the user do that themselves?
 
     @Specialization(guards = "isRubySymbol(symbol)")
-    protected RubyBasicObject toSymbolSymbol(RubyBasicObject symbol) {
+    protected DynamicObject toSymbolSymbol(DynamicObject symbol) {
         return symbol;
     }
 
     @Specialization(guards = "isRubyString(string)")
-    protected RubyBasicObject toSymbolString(RubyBasicObject string) {
+    protected DynamicObject toSymbolString(DynamicObject string) {
         return getSymbol(StringNodes.getByteList(string));
     }
 
     @Specialization
-    protected RubyBasicObject toSymbol(String string) {
+    protected DynamicObject toSymbol(String string) {
         return getSymbol(string);
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/BasicObjectNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/BasicObjectNodes.java
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
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
@@ -17,43 +17,64 @@
 import com.oracle.truffle.api.frame.FrameDescriptor;
 import com.oracle.truffle.api.frame.FrameSlot;
 import com.oracle.truffle.api.frame.MaterializedFrame;
+import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.core.array.ArrayNodes;
 import org.jruby.truffle.nodes.locals.ReadFrameSlotNode;
 import org.jruby.truffle.nodes.locals.ReadFrameSlotNodeGen;
 import org.jruby.truffle.nodes.locals.WriteFrameSlotNode;
 import org.jruby.truffle.nodes.locals.WriteFrameSlotNodeGen;
+import org.jruby.truffle.om.dsl.api.Layout;
+import org.jruby.truffle.om.dsl.api.Nullable;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.ThreadLocalObject;
 import org.jruby.truffle.runtime.control.RaiseException;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
-import org.jruby.truffle.runtime.core.RubyBinding;
 import org.jruby.truffle.runtime.methods.InternalMethod;
 
 @CoreClass(name = "Binding")
 public abstract class BindingNodes {
 
-    public static RubyBasicObject createRubyBinding(RubyBasicObject bindingClass) {
+    @Layout
+    public interface BindingLayout extends BasicObjectNodes.BasicObjectLayout {
+
+        DynamicObjectFactory createBindingShape(DynamicObject logicalClass, DynamicObject metaClass);
+
+        DynamicObject createBinding(DynamicObjectFactory factory, @Nullable Object self, @Nullable MaterializedFrame frame);
+
+        boolean isBinding(DynamicObject object);
+
+        Object getSelf(DynamicObject object);
+        void setSelf(DynamicObject object, Object self);
+
+        MaterializedFrame getFrame(DynamicObject object);
+        void setFrame(DynamicObject object, MaterializedFrame frame);
+
+    }
+
+    public static final BindingLayout BINDING_LAYOUT = BindingLayoutImpl.INSTANCE;
+
+    public static DynamicObject createRubyBinding(DynamicObject bindingClass) {
         return createRubyBinding(bindingClass, null, null);
     }
 
-    public static RubyBasicObject createRubyBinding(RubyBasicObject bindingClass, Object self, MaterializedFrame frame) {
-        return new RubyBinding(bindingClass, self, frame);
+    public static DynamicObject createRubyBinding(DynamicObject bindingClass, Object self, MaterializedFrame frame) {
+        return BINDING_LAYOUT.createBinding(ClassNodes.CLASS_LAYOUT.getInstanceFactory(bindingClass), self, frame);
     }
 
-    public static void setSelfAndFrame(RubyBasicObject binding, Object self, MaterializedFrame frame) {
-        ((RubyBinding) binding).self = self;
-        ((RubyBinding) binding).frame = frame;
+    public static void setSelfAndFrame(DynamicObject binding, Object self, MaterializedFrame frame) {
+        BINDING_LAYOUT.setSelf(binding, self);
+        BINDING_LAYOUT.setFrame(binding, frame);
     }
 
-    public static Object getSelf(RubyBasicObject binding) {
-        return ((RubyBinding) binding).self;
+    public static Object getSelf(DynamicObject binding) {
+        return BINDING_LAYOUT.getSelf(binding);
     }
 
-    public static MaterializedFrame getFrame(RubyBasicObject binding) {
-        return ((RubyBinding) binding).frame;
+    public static MaterializedFrame getFrame(DynamicObject binding) {
+        return BINDING_LAYOUT.getFrame(binding);
     }
 
     @CoreMethod(names = "initialize_copy", required = 1)
@@ -64,15 +85,15 @@ public InitializeCopyNode(RubyContext context, SourceSection sourceSection) {
         }
 
         @Specialization(guards = "isRubyBinding(from)")
-        public Object initializeCopy(RubyBasicObject self, RubyBasicObject from) {
+        public Object initializeCopy(DynamicObject self, DynamicObject from) {
             if (self == from) {
                 return self;
             }
 
             final Object[] arguments = getFrame(from).getArguments();
             final InternalMethod method = RubyArguments.getMethod(arguments);
             final Object boundSelf = RubyArguments.getSelf(arguments);
-            final RubyBasicObject boundBlock = RubyArguments.getBlock(arguments);
+            final DynamicObject boundBlock = RubyArguments.getBlock(arguments);
             final Object[] userArguments = RubyArguments.extractUserArguments(arguments);
 
             final Object[] copiedArguments = RubyArguments.pack(method, getFrame(from), boundSelf, boundBlock, userArguments);
@@ -88,7 +109,7 @@ public Object initializeCopy(RubyBasicObject self, RubyBasicObject from) {
     @CoreMethod(names = "local_variable_get", required = 1)
     public abstract static class LocalVariableGetNode extends CoreMethodArrayArgumentsNode {
 
-        private final RubyBasicObject dollarUnderscore;
+        private final DynamicObject dollarUnderscore;
 
         public LocalVariableGetNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
@@ -102,8 +123,8 @@ public LocalVariableGetNode(RubyContext context, SourceSection sourceSection) {
                 "getFrameDescriptor(binding) == cachedFrameDescriptor"
 
         })
-        public Object localVariableGetCached(RubyBasicObject binding, RubyBasicObject symbol,
-                                             @Cached("symbol") RubyBasicObject cachedSymbol,
+        public Object localVariableGetCached(DynamicObject binding, DynamicObject symbol,
+                                             @Cached("symbol") DynamicObject cachedSymbol,
                                              @Cached("getFrameDescriptor(binding)") FrameDescriptor cachedFrameDescriptor,
                                              @Cached("findFrameSlot(binding, symbol)") FrameSlot cachedFrameSlot,
                                              @Cached("createReadNode(cachedFrameSlot)") ReadFrameSlotNode readLocalVariableNode) {
@@ -117,7 +138,7 @@ public Object localVariableGetCached(RubyBasicObject binding, RubyBasicObject sy
 
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(symbol)", "!isLastLine(symbol)"})
-        public Object localVariableGetUncached(RubyBasicObject binding, RubyBasicObject symbol) {
+        public Object localVariableGetUncached(DynamicObject binding, DynamicObject symbol) {
             final MaterializedFrame frame = getFrame(binding);
             final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(SymbolNodes.getString(symbol));
 
@@ -130,7 +151,7 @@ public Object localVariableGetUncached(RubyBasicObject binding, RubyBasicObject
 
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(symbol)", "isLastLine(symbol)"})
-        public Object localVariableGetLastLine(RubyBasicObject binding, RubyBasicObject symbol) {
+        public Object localVariableGetLastLine(DynamicObject binding, DynamicObject symbol) {
             final MaterializedFrame frame = getFrame(binding);
             final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(SymbolNodes.getString(symbol));
 
@@ -146,12 +167,12 @@ public Object localVariableGetLastLine(RubyBasicObject binding, RubyBasicObject
             }
         }
 
-        protected FrameDescriptor getFrameDescriptor(RubyBasicObject binding) {
+        protected FrameDescriptor getFrameDescriptor(DynamicObject binding) {
             assert RubyGuards.isRubyBinding(binding);
             return getFrame(binding).getFrameDescriptor();
         }
 
-        protected FrameSlot findFrameSlot(RubyBasicObject binding, RubyBasicObject symbol) {
+        protected FrameSlot findFrameSlot(DynamicObject binding, DynamicObject symbol) {
             assert RubyGuards.isRubyBinding(binding);
             assert RubyGuards.isRubySymbol(symbol);
 
@@ -180,7 +201,7 @@ protected ReadFrameSlotNode createReadNode(FrameSlot frameSlot) {
             }
         }
 
-        protected boolean isLastLine(RubyBasicObject symbol) {
+        protected boolean isLastLine(DynamicObject symbol) {
             return symbol == dollarUnderscore;
         }
 
@@ -189,7 +210,7 @@ protected boolean isLastLine(RubyBasicObject symbol) {
     @CoreMethod(names = "local_variable_set", required = 2)
     public abstract static class LocalVariableSetNode extends CoreMethodArrayArgumentsNode {
 
-        private final RubyBasicObject dollarUnderscore;
+        private final DynamicObject dollarUnderscore;
 
         public LocalVariableSetNode(RubyContext context, SourceSection sourceSection) {
             super(context, sourceSection);
@@ -202,16 +223,16 @@ public LocalVariableSetNode(RubyContext context, SourceSection sourceSection) {
                 "getFrameDescriptor(binding) == cachedFrameDescriptor",
                 "symbol == cachedSymbol"
         })
-        public Object localVariableSetCached(RubyBasicObject binding, RubyBasicObject symbol, Object value,
-                                             @Cached("symbol") RubyBasicObject cachedSymbol,
+        public Object localVariableSetCached(DynamicObject binding, DynamicObject symbol, Object value,
+                                             @Cached("symbol") DynamicObject cachedSymbol,
                                              @Cached("getFrameDescriptor(binding)") FrameDescriptor cachedFrameDescriptor,
                                              @Cached("createWriteNode(findFrameSlot(binding, symbol))") WriteFrameSlotNode writeLocalVariableNode) {
             return writeLocalVariableNode.executeWrite(getFrame(binding), value);
         }
 
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(symbol)", "!isLastLine(symbol)"})
-        public Object localVariableSetUncached(RubyBasicObject binding, RubyBasicObject symbol, Object value) {
+        public Object localVariableSetUncached(DynamicObject binding, DynamicObject symbol, Object value) {
             final MaterializedFrame frame = getFrame(binding);
             final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(SymbolNodes.getString(symbol));
             frame.setObject(frameSlot, value);
@@ -220,19 +241,19 @@ public Object localVariableSetUncached(RubyBasicObject binding, RubyBasicObject
 
         @TruffleBoundary
         @Specialization(guards = {"isRubySymbol(symbol)", "isLastLine(symbol)"})
-        public Object localVariableSetLastLine(RubyBasicObject binding, RubyBasicObject symbol, Object value) {
+        public Object localVariableSetLastLine(DynamicObject binding, DynamicObject symbol, Object value) {
             final MaterializedFrame frame = getFrame(binding);
             final FrameSlot frameSlot = frame.getFrameDescriptor().findFrameSlot(SymbolNodes.getString(symbol));
             frame.setObject(frameSlot, ThreadLocalObject.wrap(getContext(), value));
             return value;
         }
 
-        protected FrameDescriptor getFrameDescriptor(RubyBasicObject binding) {
+        protected FrameDescriptor getFrameDescriptor(DynamicObject binding) {
             assert RubyGuards.isRubyBinding(binding);
             return getFrame(binding).getFrameDescriptor();
         }
 
-        protected FrameSlot findFrameSlot(RubyBasicObject binding, RubyBasicObject symbol) {
+        protected FrameSlot findFrameSlot(DynamicObject binding, DynamicObject symbol) {
             assert RubyGuards.isRubyBinding(binding);
             assert RubyGuards.isRubySymbol(symbol);
 
@@ -257,7 +278,7 @@ protected WriteFrameSlotNode createWriteNode(FrameSlot frameSlot) {
             return WriteFrameSlotNodeGen.create(frameSlot);
         }
 
-        protected boolean isLastLine(RubyBasicObject symbol) {
+        protected boolean isLastLine(DynamicObject symbol) {
             return symbol == dollarUnderscore;
         }
     }
@@ -271,8 +292,8 @@ public LocalVariablesNode(RubyContext context, SourceSection sourceSection) {
 
         @TruffleBoundary
         @Specialization
-        public RubyBasicObject localVariables(RubyBasicObject binding) {
-            final RubyBasicObject array = createEmptyArray();
+        public DynamicObject localVariables(DynamicObject binding) {
+            final DynamicObject array = createEmptyArray();
 
             MaterializedFrame frame = getFrame(binding);
 
@@ -290,4 +311,18 @@ public RubyBasicObject localVariables(RubyBasicObject binding) {
         }
     }
 
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode {
+
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
+            return BindingNodes.createRubyBinding(rubyClass);
+        }
+
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ClassNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ClassNodes.java
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/CoreMethodNodeManager.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/CoreMethodNodeManager.java
@@ -30,7 +30,7 @@
 import org.jruby.truffle.runtime.*;
 import org.jruby.truffle.runtime.array.ArrayUtils;
 import org.jruby.truffle.runtime.core.CoreSourceSection;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
+import com.oracle.truffle.api.object.DynamicObject;
 import org.jruby.truffle.runtime.methods.Arity;
 import org.jruby.truffle.runtime.methods.InternalMethod;
 import org.jruby.truffle.runtime.methods.SharedMethodInfo;
@@ -42,10 +42,10 @@
 
 public class CoreMethodNodeManager {
 
-    private final RubyBasicObject objectClass;
+    private final DynamicObject objectClass;
     private final SingletonClassNode singletonClassNode;
 
-    public CoreMethodNodeManager(RubyBasicObject objectClass, SingletonClassNode singletonClassNode) {
+    public CoreMethodNodeManager(DynamicObject objectClass, SingletonClassNode singletonClassNode) {
         assert RubyGuards.isRubyClass(objectClass);
         this.objectClass = objectClass;
         this.singletonClassNode = singletonClassNode;
@@ -64,14 +64,14 @@ public void addCoreMethodNodes(List<? extends NodeFactory<? extends RubyNode>> n
         }
     }
 
-    private RubyBasicObject getSingletonClass(Object object) {
+    private DynamicObject getSingletonClass(Object object) {
         return singletonClassNode.executeSingletonClass(null, object);
     }
 
     private void addCoreMethod(MethodDetails methodDetails) {
-        final RubyContext context = objectClass.getContext();
+        final RubyContext context = BasicObjectNodes.getContext(objectClass);
 
-        RubyBasicObject module;
+        DynamicObject module;
         String fullName = methodDetails.getClassAnnotation().name();
 
         if (fullName.equals("main")) {
@@ -86,7 +86,7 @@ private void addCoreMethod(MethodDetails methodDetails) {
                     throw new RuntimeException(String.format("Module %s not found when adding core library", moduleName));
                 }
 
-                module = (RubyBasicObject) constant.getValue();
+                module = (DynamicObject) constant.getValue();
             }
         }
 
@@ -109,7 +109,7 @@ private void addCoreMethod(MethodDetails methodDetails) {
             if (method.constructor()) {
                 System.err.println("WARNING: Either constructor or isModuleFunction for " + methodDetails.getIndicativeName());
             }
-            if (!ModuleNodes.getModel(module).isOnlyAModule()) {
+            if (!(RubyGuards.isRubyModule(ModuleNodes.getFields(module).rubyModuleObject) && !RubyGuards.isRubyClass(ModuleNodes.getFields(module).rubyModuleObject))) {
                 System.err.println("WARNING: Using isModuleFunction on a Class for " + methodDetails.getIndicativeName());
             }
         }
@@ -129,7 +129,7 @@ private void addCoreMethod(MethodDetails methodDetails) {
         }
     }
 
-    private static void addMethod(RubyBasicObject module, RubyRootNode rootNode, List<String> names, final Visibility originalVisibility) {
+    private static void addMethod(DynamicObject module, RubyRootNode rootNode, List<String> names, final Visibility originalVisibility) {
         assert RubyGuards.isRubyModule(module);
 
         for (String name : names) {
@@ -143,7 +143,7 @@ private static void addMethod(RubyBasicObject module, RubyRootNode rootNode, Lis
             final InternalMethod method = new InternalMethod(rootNodeCopy.getSharedMethodInfo(), name, module, visibility, false,
                     Truffle.getRuntime().createCallTarget(rootNodeCopy), null);
 
-            ModuleNodes.getModel(module).addMethod(null, method.withVisibility(visibility).withName(name));
+            ModuleNodes.getFields(module).addMethod(null, method.withVisibility(visibility).withName(name));
         }
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingConverterNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/EncodingConverterNodes.java
@@ -12,7 +12,8 @@
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
-import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jcodings.Encoding;
 import org.jcodings.EncodingDB;
@@ -26,30 +27,41 @@
 import org.jruby.runtime.builtin.IRubyObject;
 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.om.dsl.api.Layout;
+import org.jruby.truffle.om.dsl.api.Nullable;
 import org.jruby.truffle.runtime.RubyContext;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
-import org.jruby.truffle.runtime.core.RubyEncodingConverter;
 import org.jruby.util.ByteList;
 import org.jruby.util.io.EncodingUtils;
 
 @CoreClass(name = "Encoding::Converter")
 public abstract class EncodingConverterNodes {
 
-    public static EConv getEConv(RubyBasicObject encodingConverter) {
-        return getEconv(((RubyEncodingConverter) encodingConverter));
+    @Layout
+    public interface EncodingConverterLayout extends BasicObjectNodes.BasicObjectLayout {
+
+        DynamicObjectFactory createEncodingConverterShape(DynamicObject logicalClass, DynamicObject metaClass);
+
+        DynamicObject createEncodingConverter(DynamicObjectFactory factory, @Nullable EConv econv);
+
+        boolean isEncodingConverter(DynamicObject object);
+
+        EConv getEconv(DynamicObject object);
+        void setEconv(DynamicObject object, EConv econv);
+
     }
 
-    public static void setEConv(RubyBasicObject encodingConverter, EConv econv) {
-        ((RubyEncodingConverter) encodingConverter).econv = econv;
+    public static final EncodingConverterLayout ENCODING_CONVERTER_LAYOUT = EncodingConverterLayoutImpl.INSTANCE;
+
+    public static EConv getEConv(DynamicObject encodingConverter) {
+        return ENCODING_CONVERTER_LAYOUT.getEconv(encodingConverter);
     }
 
-    public static RubyBasicObject createEncodingConverter(RubyBasicObject rubyClass, EConv econv) {
-        return new RubyEncodingConverter(rubyClass, econv);
+    public static void setEConv(DynamicObject encodingConverter, EConv econv) {
+        ENCODING_CONVERTER_LAYOUT.setEconv(encodingConverter, econv);
     }
 
-    public static EConv getEconv(RubyEncodingConverter encodingConverter) {
-        return encodingConverter.econv;
+    public static DynamicObject createEncodingConverter(DynamicObject rubyClass, EConv econv) {
+        return ENCODING_CONVERTER_LAYOUT.createEncodingConverter(ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass), econv);
     }
 
     @RubiniusOnly
@@ -62,7 +74,7 @@ public InitializeNode(RubyContext context, SourceSection sourceSection) {
 
         @TruffleBoundary
         @Specialization
-        public RubyBasicObject initialize(RubyBasicObject self, Object source, Object destination, Object unusedOptions) {
+        public DynamicObject initialize(DynamicObject self, Object source, Object destination, Object unusedOptions) {
             // Adapted from RubyConverter - see attribution there
 
             Ruby runtime = getContext().getRuntime();
@@ -80,7 +92,7 @@ public RubyBasicObject initialize(RubyBasicObject self, Object source, Object de
             // by Rubinius.  Rubinius will do the heavy lifting of parsing the options hash and setting the `@options`
             // ivar to the resulting int for EConv flags.  Since we don't pass the proper data structures to EncodingUtils,
             // we must override the flags after its had a pass in order to correct the bad flags value.
-            ecflags[0] = rubiniusToJRubyFlags((int) self.getInstanceVariable("@options"));
+            ecflags[0] = rubiniusToJRubyFlags((int) BasicObjectNodes.getInstanceVariable(self, "@options"));
 
             EConv econv = EncodingUtils.econvOpenOpts(runtime.getCurrentContext(), encNames[0], encNames[1], ecflags[0], ecopts[0]);
 
@@ -172,12 +184,18 @@ public Object transcodingMap(VirtualFrame frame) {
         }
     }
 
-    public static class EncodingConverterAllocator implements Allocator {
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode {
 
-        @Override
-        public RubyBasicObject allocate(RubyContext context, RubyBasicObject rubyClass, Node currentNode) {
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
             return createEncodingConverter(rubyClass, null);
         }
 
     }
+
 }
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
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ExceptionNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ExceptionNodes.java
@@ -11,26 +11,45 @@
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.dsl.Specialization;
-import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.object.DynamicObjectFactory;
 import com.oracle.truffle.api.source.SourceSection;
 import org.jruby.truffle.nodes.RubyGuards;
 import org.jruby.truffle.nodes.core.array.ArrayNodes;
-import org.jruby.truffle.nodes.objects.Allocator;
 import org.jruby.truffle.nodes.objectstorage.ReadHeadObjectFieldNode;
+import org.jruby.truffle.om.dsl.api.Layout;
+import org.jruby.truffle.om.dsl.api.Nullable;
 import org.jruby.truffle.runtime.NotProvided;
 import org.jruby.truffle.runtime.RubyCallStack;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.backtrace.Activation;
 import org.jruby.truffle.runtime.backtrace.Backtrace;
 import org.jruby.truffle.runtime.backtrace.MRIBacktraceFormatter;
-import org.jruby.truffle.runtime.core.RubyBasicObject;
-import org.jruby.truffle.runtime.core.RubyException;
 
 import java.util.List;
 
 @CoreClass(name = "Exception")
 public abstract class ExceptionNodes {
 
+    @Layout
+    public interface ExceptionLayout extends BasicObjectNodes.BasicObjectLayout {
+
+        DynamicObjectFactory createExceptionShape(DynamicObject logicalClass, DynamicObject metaClass);
+
+        DynamicObject createException(DynamicObjectFactory factory, @Nullable Object message, @Nullable Backtrace backtrace);
+
+        boolean isException(DynamicObject object);
+
+        Object getMessage(DynamicObject object);
+        void setMessage(DynamicObject object, Object message);
+
+        Backtrace getBacktrace(DynamicObject object);
+        void setBacktrace(DynamicObject object, Backtrace backtrace);
+
+    }
+
+    public static final ExceptionLayout EXCEPTION_LAYOUT = ExceptionLayoutImpl.INSTANCE;
+
     public static class BacktraceFormatter extends MRIBacktraceFormatter {
         @Override
         protected String formatFromLine(List<Activation> activations, int n) {
@@ -41,48 +60,44 @@ protected String formatFromLine(List<Activation> activations, int n) {
     public static final BacktraceFormatter BACKTRACE_FORMATTER = new BacktraceFormatter();
 
     // TODO (eregon 16 Apr. 2015): MRI does a dynamic calls to "message"
-    public static Object getMessage(RubyBasicObject exception) {
-        assert RubyGuards.isRubyException(exception);
-        return ((RubyException) exception).message;
+    public static Object getMessage(DynamicObject exception) {
+        return EXCEPTION_LAYOUT.getMessage(exception);
     }
 
-    public static Backtrace getBacktrace(RubyBasicObject exception) {
-        assert RubyGuards.isRubyException(exception);
-        return ((RubyException) exception).backtrace;
+    public static Backtrace getBacktrace(DynamicObject exception) {
+        return EXCEPTION_LAYOUT.getBacktrace(exception);
     }
 
-    public static void setBacktrace(RubyBasicObject exception, Backtrace backtrace) {
-        assert RubyGuards.isRubyException(exception);
-        ((RubyException) exception).backtrace = backtrace;
+    public static void setBacktrace(DynamicObject exception, Backtrace backtrace) {
+        EXCEPTION_LAYOUT.setBacktrace(exception, backtrace);
     }
 
     @TruffleBoundary
-    public static RubyBasicObject asRubyStringArray(RubyBasicObject exception) {
+    public static DynamicObject asRubyStringArray(DynamicObject exception) {
         assert RubyGuards.isRubyException(exception);
 
         assert getBacktrace(exception) != null;
-        final String[] lines = BACKTRACE_FORMATTER.format(exception.getContext(), exception, getBacktrace(exception));
+        final String[] lines = BACKTRACE_FORMATTER.format(BasicObjectNodes.getContext(exception), exception, getBacktrace(exception));
 
         final Object[] array = new Object[lines.length];
 
         for (int n = 0;n < lines.length; n++) {
-            array[n] = StringNodes.createString(exception.getContext().getCoreLibrary().getStringClass(), lines[n]);
+            array[n] = StringNodes.createString(BasicObjectNodes.getContext(exception).getCoreLibrary().getStringClass(), lines[n]);
         }
 
-        return ArrayNodes.fromObjects(exception.getContext().getCoreLibrary().getArrayClass(), array);
+        return ArrayNodes.fromObjects(BasicObjectNodes.getContext(exception).getCoreLibrary().getArrayClass(), array);
     }
 
-    public static void setMessage(RubyBasicObject exception, Object message) {
-        assert RubyGuards.isRubyException(exception);
-        ((RubyException) exception).message = message;
+    public static void setMessage(DynamicObject exception, Object message) {
+        EXCEPTION_LAYOUT.setMessage(exception, message);
     }
 
-    public static RubyBasicObject createRubyException(RubyBasicObject rubyClass) {
-        return new RubyException(rubyClass);
+    public static DynamicObject createRubyException(DynamicObject rubyClass) {
+        return EXCEPTION_LAYOUT.createException(ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass), null, null);
     }
 
-    public static RubyBasicObject createRubyException(RubyBasicObject rubyClass, Object message, Backtrace backtrace) {
-        return new RubyException(rubyClass, message, backtrace);
+    public static DynamicObject createRubyException(DynamicObject rubyClass, Object message, Backtrace backtrace) {
+        return EXCEPTION_LAYOUT.createException(ClassNodes.CLASS_LAYOUT.getInstanceFactory(rubyClass), message, backtrace);
     }
 
     @CoreMethod(names = "initialize", optional = 1)
@@ -93,13 +108,13 @@ public InitializeNode(RubyContext context, SourceSection sourceSection) {
         }
 
         @Specialization
-        public RubyBasicObject initialize(RubyBasicObject exception, NotProvided message) {
+        public DynamicObject initialize(DynamicObject exception, NotProvided message) {
             setMessage(exception, nil());
             return exception;
         }
 
         @Specialization(guards = "wasProvided(message)")
-        public RubyBasicObject initialize(RubyBasicObject exception, Object message) {
+        public DynamicObject initialize(DynamicObject exception, Object message) {
             setMessage(exception, message);
             return exception;
         }
@@ -117,7 +132,7 @@ public BacktraceNode(RubyContext context, SourceSection sourceSection) {
         }
 
         @Specialization
-        public Object backtrace(RubyBasicObject exception) {
+        public Object backtrace(DynamicObject exception) {
             if (readCustomBacktrace.isSet(exception)) {
                 return readCustomBacktrace.execute(exception);
             } else if (getBacktrace(exception) != null) {
@@ -138,12 +153,12 @@ public CaptureBacktraceNode(RubyContext context, SourceSection sourceSection) {
         }
 
         @Specialization
-        public RubyBasicObject captureBacktrace(RubyBasicObject exception, NotProvided offset) {
+        public DynamicObject captureBacktrace(DynamicObject exception, NotProvided offset) {
             return captureBacktrace(exception, 1);
         }
 
         @Specialization
-        public RubyBasicObject captureBacktrace(RubyBasicObject exception, int offset) {
+        public DynamicObject captureBacktrace(DynamicObject exception, int offset) {
             Backtrace backtrace = RubyCallStack.getBacktrace(this, offset);
             setBacktrace(exception, backtrace);
             return nil();
@@ -159,16 +174,21 @@ public MessageNode(RubyContext context, SourceSection sourceSection) {
         }
 
         @Specialization
-        public Object message(RubyBasicObject exception) {
+        public Object message(DynamicObject exception) {
             return getMessage(exception);
         }
 
     }
 
-    public static class ExceptionAllocator implements Allocator {
+    @CoreMethod(names = "allocate", constructor = true)
+    public abstract static class AllocateNode extends CoreMethodArrayArgumentsNode {
 
-        @Override
-        public RubyBasicObject allocate(RubyContext context, RubyBasicObject rubyClass, Node currentNode) {
+        public AllocateNode(RubyContext context, SourceSection sourceSection) {
+            super(context, sourceSection);
+        }
+
+        @Specialization
+        public DynamicObject allocate(DynamicObject rubyClass) {
             return createRubyException(rubyClass);
         }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		fails:Module#prepend keeps the module in the chain when dupping the class