jruby · Apr 30, 2015 · Apr 30, 2015 · Apr 30, 2015 · Apr 30, 2015
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyNode.java
@@ -31,12 +31,6 @@
 import org.jruby.truffle.runtime.core.*;
 import org.jruby.truffle.runtime.rubinius.RubiniusByteArray;
 
-/**
- * Base class for most nodes in Ruby.
- *
- * @see YieldDispatchNode
- */
-@TypeSystemReference(RubyTypes.class)
 public abstract class RubyNode extends Node {
 
     private final RubyContext context;
@@ -54,178 +48,209 @@ public RubyNode(RubyContext context, SourceSection sourceSection) {
         this.context = context;
     }
 
-    @Override
-    public boolean isInstrumentable() {
-        return true;
-    }
-
-    @Override
-    public ProbeNode.WrapperNode createWrapperNode() {
-        return new RubyWrapperNode(this);
-    }
+    // Fundamental execute method
 
     public abstract Object execute(VirtualFrame frame);
 
-    /**
-     * Records that this node was wrapped by the JRuby parser with a "newline" node.
-     */
-    public void setAtNewline() {
-        atNewline = true;
-    }
-
-    /**
-     * Was this ndoe wrapped by a JRuby parser "newline" node?
-     */
-    public boolean isAtNewline() {
-        return atNewline;
-    }
+    // Execute without returing the result
 
-    /**
-     * Ruby's parallel semantic path.
-     * 
-     * @see DefinedNode
-     */
-    public Object isDefined(VirtualFrame frame) {
-        return getContext().makeString("expression");
+    public void executeVoid(VirtualFrame frame) {
+        execute(frame);
     }
 
-    public String executeString(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectString(execute(frame));
-    }
+    // Utility methods to execute and expect a particular type
 
-    public RubyArray executeArray(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyArray(execute(frame));
-    }
+    public UndefinedPlaceholder executeUndefinedPlaceholder(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyBignum executeBignum(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyBignum(execute(frame));
+        if (value instanceof UndefinedPlaceholder) {
+            return (UndefinedPlaceholder) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
     public boolean executeBoolean(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectBoolean(execute(frame));
-    }
+        final Object value = execute(frame);
 
-    public int executeIntegerFixnum(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectInteger(execute(frame));
+        if (value instanceof Boolean) {
+            return (boolean) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public long executeLongFixnum(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectLong(execute(frame));
-    }
+    public int executeInteger(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyRange.IntegerFixnumRange executeIntegerFixnumRange(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectIntegerFixnumRange(execute(frame));
+        if (value instanceof Integer) {
+            return (int) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyRange.LongFixnumRange executeLongFixnumRange(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectLongFixnumRange(execute(frame));
-    }
+    public long executeLong(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public double executeFloat(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectDouble(execute(frame));
+        if (value instanceof Long) {
+            return (long) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public Object[] executeObjectArray(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectObjectArray(execute(frame));
-    }
+    public RubyBignum executeRubyBignum(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyRange.ObjectRange executeObjectRange(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectObjectRange(execute(frame));
+        if (value instanceof RubyBignum) {
+            return (RubyBignum) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyBasicObject executeRubyBasicObject(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyBasicObject(execute(frame));
-    }
+    public RubyRange.IntegerFixnumRange executeIntegerFixnumRange(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyBinding executeRubyBinding(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyBinding(execute(frame));
+        if (value instanceof RubyRange.IntegerFixnumRange) {
+            return (RubyRange.IntegerFixnumRange) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyClass executeRubyClass(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyClass(execute(frame));
-    }
+    public RubyRange.LongFixnumRange executeLongFixnumRange(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyException executeRubyException(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyException(execute(frame));
+        if (value instanceof RubyRange.LongFixnumRange) {
+            return (RubyRange.LongFixnumRange) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyFiber executeRubyFiber(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyFiber(execute(frame));
-    }
+    public double executeDouble(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyHash executeRubyHash(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyHash(execute(frame));
+        if (value instanceof Double) {
+            return (double) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyMatchData executeRubyMatchData(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyMatchData(execute(frame));
-    }
+    public RubyString executeRubyString(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyModule executeRubyModule(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyModule(execute(frame));
+        if (value instanceof RubyString) {
+            return (RubyString) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyNilClass executeRubyNilClass(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyNilClass(execute(frame));
-    }
+    public RubyArray executeRubyArray(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyProc executeRubyProc(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyProc(execute(frame));
+        if (value instanceof RubyArray) {
+            return (RubyArray) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyRange executeRubyRange(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyRange(execute(frame));
+    public RubyHash executeRubyHash(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
+
+        if (value instanceof RubyHash) {
+            return (RubyHash) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
     public RubyRegexp executeRubyRegexp(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyRegexp(execute(frame));
-    }
+        final Object value = execute(frame);
 
-    public RubySymbol executeRubySymbol(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubySymbol(execute(frame));
+        if (value instanceof RubyRegexp) {
+            return (RubyRegexp) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyThread executeRubyThread(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyThread(execute(frame));
-    }
+    public RubyModule executeRubyModule(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
 
-    public RubyTime executeRubyTime(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyTime(execute(frame));
+        if (value instanceof RubyModule) {
+            return (RubyModule) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyString executeRubyString(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyString(execute(frame));
-    }
-    public RubyEncoding executeRubyEncoding(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyEncoding(execute(frame));
+    public RubyProc executeRubyProc(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
+
+        if (value instanceof RubyProc) {
+            return (RubyProc) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public UndefinedPlaceholder executeUndefinedPlaceholder(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectUndefinedPlaceholder(execute(frame));
+    public RubyBasicObject executeRubyBasicObject(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
+
+        if (value instanceof RubyBasicObject) {
+            return (RubyBasicObject) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public TruffleObject executeTruffleObject(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectTruffleObject(execute(frame));
+    public Object[] executeObjectArray(VirtualFrame frame) throws UnexpectedResultException {
+        final Object value = execute(frame);
+
+        if (value instanceof Object[]) {
+            return (Object[]) value;
+        } else {
+            throw new UnexpectedResultException(value);
+        }
     }
 
-    public RubyEncodingConverter executeRubyEncodingConverter(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyEncodingConverter(execute(frame));
+    @Override
+    public boolean isInstrumentable() {
+        return true;
     }
 
-    public RubyMethod executeRubyMethod(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyMethod(execute(frame));
+    @Override
+    public ProbeNode.WrapperNode createWrapperNode() {
+        return new RubyWrapperNode(this);
     }
 
-    public RubyUnboundMethod executeRubyUnboundMethod(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubyUnboundMethod(execute(frame));
+    /**
+     * Records that this node was wrapped by the JRuby parser with a "newline" node.
+     */
+    public void setAtNewline() {
+        atNewline = true;
     }
 
-    public RubiniusByteArray executeRubiniusByteArray(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.expectRubiniusByteArray(execute(frame));
+    /**
+     * Was this ndoe wrapped by a JRuby parser "newline" node?
+     */
+    public boolean isAtNewline() {
+        return atNewline;
     }
 
-    public void executeVoid(VirtualFrame frame) {
-        execute(frame);
+    /**
+     * Ruby's parallel semantic path.
+     * 
+     * @see DefinedNode
+     */
+    public Object isDefined(VirtualFrame frame) {
+        return getContext().makeString("expression");
     }
 
     public RubyNode getNonProxyNode() {