jruby · Nov 29, 2014 · Nov 30, 2014 · Nov 30, 2014 · Nov 30, 2014 · Nov 30, 2014
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -130,10 +130,10 @@
 import org.jruby.truffle.translator.TranslatorDriver;
 import org.jruby.util.ByteList;
 import org.jruby.util.DefinedMessage;
-import org.jruby.util.DynamicJRubyClassLoader;
+import org.jruby.util.JRubyClassLoader;
 import org.jruby.util.IOInputStream;
 import org.jruby.util.IOOutputStream;
-import org.jruby.util.JRubyClassLoader;
+import org.jruby.util.ClassDefininngJRubyClassLoader;
 import org.jruby.util.KCode;
 import org.jruby.util.SafePropertyAccessor;
 import org.jruby.util.cli.Options;
@@ -727,7 +727,7 @@ public IRubyObject runNormally(Node scriptNode) {
             // IR JIT does not handle all scripts yet, so let those that fail run in interpreter instead
             // FIXME: restore error once JIT should handle everything
             try {
-                scriptAndCode = tryCompile(scriptNode, new JRubyClassLoader(getJRubyClassLoader()));
+                scriptAndCode = tryCompile(scriptNode, new ClassDefininngJRubyClassLoader(getJRubyClassLoader()));
                 if (scriptAndCode != null && Options.JIT_LOGGING.load()) {
                     LOG.info("done compiling target script: " + scriptNode.getPosition().getFile());
                 }
@@ -767,7 +767,7 @@ public IRubyObject runNormally(Node scriptNode) {
      * @return an instance of the successfully-compiled Script, or null.
      */
     public Script tryCompile(Node node) {
-        return tryCompile(node, new JRubyClassLoader(getJRubyClassLoader())).script();
+        return tryCompile(node, new ClassDefininngJRubyClassLoader(getJRubyClassLoader())).script();
     }
 
     private void failForcedCompile(Node scriptNode) throws RaiseException {
@@ -783,7 +783,7 @@ private void handeCompileError(Node node, Throwable t) {
         }
     }
 
-    private ScriptAndCode tryCompile(Node node, JRubyClassLoader classLoader) {
+    private ScriptAndCode tryCompile(Node node, ClassDefininngJRubyClassLoader classLoader) {
         try {
             return Compiler.getInstance().execute(this, node, classLoader);
         } catch (NotCompilableException e) {
@@ -2569,10 +2569,10 @@ public static ClassLoader getClassLoader() {
      *
      * @return
      */
-    public synchronized DynamicJRubyClassLoader getJRubyClassLoader() {
+    public synchronized JRubyClassLoader getJRubyClassLoader() {
         // FIXME: Get rid of laziness and handle restricted access elsewhere
         if (!Ruby.isSecurityRestricted() && jrubyClassLoader == null) {
-            jrubyClassLoader = new DynamicJRubyClassLoader(config.getLoader());
+            jrubyClassLoader = new JRubyClassLoader(config.getLoader());
 
             // if jit code cache is used, we need to add the cache directory to the classpath
             // so the previously generated class files can be reused.
@@ -2913,7 +2913,7 @@ public void compileAndLoadFile(String filename, InputStream in, boolean wrap) {
             // script was not found in cache above, so proceed to compile
             Node scriptNode = parseFile(readStream, filename, null);
             if (script == null) {
-                scriptAndCode = tryCompile(scriptNode, new JRubyClassLoader(jrubyClassLoader));
+                scriptAndCode = tryCompile(scriptNode, new ClassDefininngJRubyClassLoader(jrubyClassLoader));
                 if (scriptAndCode != null) script = scriptAndCode.script();
             }
 
@@ -4831,7 +4831,7 @@ public FilenoUtil getFilenoUtil() {
 
     // Java support
     private JavaSupport javaSupport;
-    private DynamicJRubyClassLoader jrubyClassLoader;
+    private JRubyClassLoader jrubyClassLoader;
 
     // Management/monitoring
     private BeanManager beanManager;

diff --git a/core/src/main/java/org/jruby/anno/InvokerGenerator.java b/core/src/main/java/org/jruby/anno/InvokerGenerator.java
@@ -38,7 +38,7 @@
 
 import org.jruby.RubyModule.MethodClumper;
 import org.jruby.internal.runtime.methods.DumpingInvocationMethodFactory;
-import org.jruby.util.JRubyClassLoader;
+import org.jruby.util.ClassDefininngJRubyClassLoader;
 import org.jruby.util.log.Logger;
 import org.jruby.util.log.LoggerFactory;
 
@@ -68,7 +68,7 @@ public static void main(String[] args) throws Exception {
             br.close();
         }
 
-        DumpingInvocationMethodFactory dumper = new DumpingInvocationMethodFactory(args[1], new JRubyClassLoader(ClassLoader.getSystemClassLoader()));
+        DumpingInvocationMethodFactory dumper = new DumpingInvocationMethodFactory(args[1], new ClassDefininngJRubyClassLoader(ClassLoader.getSystemClassLoader()));
 
         for (String name : classNames) {
             MethodClumper clumper = new MethodClumper();

diff --git a/core/src/main/java/org/jruby/compiler/util/HandleFactory.java b/core/src/main/java/org/jruby/compiler/util/HandleFactory.java
@@ -35,7 +35,7 @@
 import java.lang.reflect.Modifier;
 import org.jruby.compiler.JITCompiler;
 import org.jruby.compiler.impl.SkinnyMethodAdapter;
-import org.jruby.util.JRubyClassLoader;
+import org.jruby.util.ClassDefininngJRubyClassLoader;
 import org.objectweb.asm.ClassVisitor;
 import org.objectweb.asm.ClassWriter;
 import static org.jruby.util.CodegenUtils.*;
@@ -53,7 +53,7 @@ public static class Handle {
         public Object invoke(Object receiver, Object... args) { throw fail(); }
     }
 
-    public static Handle createHandle(JRubyClassLoader classLoader, Method method) {
+    public static Handle createHandle(ClassDefininngJRubyClassLoader classLoader, Method method) {
         String name = createHandleName(method);
 
         Class handleClass;
@@ -72,9 +72,9 @@ public static Handle createHandle(JRubyClassLoader classLoader, Method method) {
         }
     }
 
-    public static Class createHandleClass(JRubyClassLoader classLoader, Method method, String name) {
+    public static Class createHandleClass(ClassDefininngJRubyClassLoader classLoader, Method method, String name) {
         byte[] bytes = createHandleBytes(method, name);
-        return (classLoader != null ? classLoader : new JRubyClassLoader(JRubyClassLoader.class.getClassLoader())).defineClass(name, bytes);
+        return (classLoader != null ? classLoader : new ClassDefininngJRubyClassLoader(ClassDefininngJRubyClassLoader.class.getClassLoader())).defineClass(name, bytes);
     }
 
     public static byte[] createHandleBytes(Method method, String name) {

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/InvocationMethodFactory.java b/core/src/main/java/org/jruby/internal/runtime/methods/InvocationMethodFactory.java
@@ -60,7 +60,7 @@
 import org.jruby.util.CodegenUtils;
 import static org.jruby.util.CodegenUtils.*;
 import static java.lang.System.*;
-import org.jruby.util.JRubyClassLoader;
+import org.jruby.util.ClassDefininngJRubyClassLoader;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.util.CheckClassAdapter;
@@ -174,7 +174,7 @@ public class InvocationMethodFactory extends MethodFactory implements Opcodes {
     public static final int BLOCK_INDEX = 6;
 
     /** The classloader to use for code loading */
-    protected final JRubyClassLoader classLoader;
+    protected final ClassDefininngJRubyClassLoader classLoader;
 
     /** An object to sync against when loading classes, to avoid dups */
     protected final Object syncObject;
@@ -204,10 +204,10 @@ public InvocationMethodFactory(ClassLoader classLoader) {
         // use the given classloader as our sync, regardless of whether we wrap it
         this.syncObject = classLoader;
 
-        if (classLoader instanceof JRubyClassLoader) {
-            this.classLoader = (JRubyClassLoader)classLoader;
+        if (classLoader instanceof ClassDefininngJRubyClassLoader) {
+            this.classLoader = (ClassDefininngJRubyClassLoader)classLoader;
         } else {
-            this.classLoader = new JRubyClassLoader(classLoader);
+            this.classLoader = new ClassDefininngJRubyClassLoader(classLoader);
         }
     }
 

diff --git a/core/src/main/java/org/jruby/ir/Compiler.java b/core/src/main/java/org/jruby/ir/Compiler.java
@@ -21,14 +21,14 @@
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.Visibility;
 import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.util.JRubyClassLoader;
+import org.jruby.util.ClassDefininngJRubyClassLoader;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-public class Compiler extends IRTranslator<ScriptAndCode, JRubyClassLoader> {
+public class Compiler extends IRTranslator<ScriptAndCode, ClassDefininngJRubyClassLoader> {
 
     // Compiler is singleton
     private Compiler() {}
@@ -43,7 +43,7 @@ public static Compiler getInstance() {
     }
 
     @Override
-    protected ScriptAndCode execute(final Ruby runtime, final IRScriptBody scope, JRubyClassLoader classLoader) {
+    protected ScriptAndCode execute(final Ruby runtime, final IRScriptBody scope, ClassDefininngJRubyClassLoader classLoader) {
         JVMVisitor visitor;
         byte[] bytecode;
         Class compiled;

diff --git a/core/src/main/java/org/jruby/java/codegen/RealClassGenerator.java b/core/src/main/java/org/jruby/java/codegen/RealClassGenerator.java
@@ -28,7 +28,7 @@
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.callsite.CacheEntry;
 import org.jruby.util.ClassDefiningClassLoader;
-import org.jruby.util.JRubyClassLoader;
+import org.jruby.util.ClassDefininngJRubyClassLoader;
 import static org.jruby.util.CodegenUtils.*;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Type;
@@ -456,11 +456,11 @@ public static Class defineRealImplClass(Ruby ruby, String name, Class superClass
         // create the class
         byte[] bytes = cw.toByteArray();
         Class newClass;
-        JRubyClassLoader loader;
-        if (superClass.getClassLoader() instanceof JRubyClassLoader) {
-            loader = new JRubyClassLoader(superClass.getClassLoader());
+        ClassDefininngJRubyClassLoader loader;
+        if (superClass.getClassLoader() instanceof ClassDefininngJRubyClassLoader) {
+            loader = new ClassDefininngJRubyClassLoader(superClass.getClassLoader());
         } else {
-            loader = new JRubyClassLoader(ruby.getJRubyClassLoader());
+            loader = new ClassDefininngJRubyClassLoader(ruby.getJRubyClassLoader());
         }
         try {
             newClass = loader.loadClass(name);

diff --git a/core/src/main/java/org/jruby/runtime/MethodFactory.java b/core/src/main/java/org/jruby/runtime/MethodFactory.java
@@ -45,7 +45,7 @@
 import org.jruby.lexer.yacc.ISourcePosition;
 import org.jruby.parser.StaticScope;
 import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.util.JRubyClassLoader;
+import org.jruby.util.ClassDefininngJRubyClassLoader;
 import org.jruby.util.OneShotClassLoader;
 import org.jruby.util.cli.Options;
 import org.jruby.util.log.Logger;
@@ -81,7 +81,7 @@ public abstract class MethodFactory {
                 baos.write(buf, 0, bytesRead);
             }
 
-            JRubyClassLoader oscl = new JRubyClassLoader(Ruby.getClassLoader());
+            ClassDefininngJRubyClassLoader oscl = new ClassDefininngJRubyClassLoader(Ruby.getClassLoader());
             Class<?> unloaderClass = oscl.defineClass("org.jruby.util.JDBCDriverUnloader", baos.toByteArray());
             unloaderClass.newInstance();
             can = true;

diff --git a/core/src/main/java/org/jruby/runtime/load/CompiledScriptLoader.java b/core/src/main/java/org/jruby/runtime/load/CompiledScriptLoader.java
@@ -12,7 +12,7 @@
 import org.jruby.Ruby;
 import org.jruby.ast.executable.Script;
 import org.jruby.util.OneShotClassLoader;
-import org.jruby.util.JRubyClassLoader;
+import org.jruby.util.ClassDefininngJRubyClassLoader;
 import org.objectweb.asm.ClassReader;
 
 /**
@@ -31,7 +31,7 @@ public static Script loadScriptFromFile(Ruby runtime, InputStream inStream, Stri
                 baos.write(buf, 0, read);
             }
             buf = baos.toByteArray();
-            JRubyClassLoader jcl = runtime.getJRubyClassLoader();
+            ClassDefininngJRubyClassLoader jcl = runtime.getJRubyClassLoader();
             OneShotClassLoader oscl = new OneShotClassLoader(jcl);
 
             ClassReader cr = new ClassReader(buf);

diff --git a/core/src/main/java/org/jruby/truffle/nodes/RubyNode.java b/core/src/main/java/org/jruby/truffle/nodes/RubyNode.java
@@ -67,8 +67,8 @@ public RubyArray executeArray(VirtualFrame frame) throws UnexpectedResultExcepti
         return RubyTypesGen.RUBYTYPES.expectRubyArray(execute(frame));
     }
 
-    public BigInteger executeBignum(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.RUBYTYPES.expectBigInteger(execute(frame));
+    public RubyBignum executeBignum(VirtualFrame frame) throws UnexpectedResultException {
+        return RubyTypesGen.RUBYTYPES.expectRubyBignum(execute(frame));
     }
 
     public boolean executeBoolean(VirtualFrame frame) throws UnexpectedResultException {
@@ -143,10 +143,6 @@ public RubyNilClass executeRubyNilClass(VirtualFrame frame) throws UnexpectedRes
         return RubyTypesGen.RUBYTYPES.expectRubyNilClass(execute(frame));
     }
 
-    public RubyObject executeRubyObject(VirtualFrame frame) throws UnexpectedResultException {
-        return RubyTypesGen.RUBYTYPES.expectRubyObject(execute(frame));
-    }
-
     public RubyProc executeRubyProc(VirtualFrame frame) throws UnexpectedResultException {
         return RubyTypesGen.RUBYTYPES.expectRubyProc(execute(frame));
     }
@@ -239,7 +235,7 @@ public static boolean isFixnum(Object o) {
     }
 
     public static boolean isBignum(Object o) {
-        return o instanceof BigInteger;
+        return o instanceof RubyBignum;
     }
 
     public static boolean isFloat(Object o) {
@@ -251,7 +247,7 @@ public static boolean isFirstFixnum(Object o) {
     }
 
     public static boolean isFirstBignum(Object o) {
-        return o instanceof BigInteger;
+        return o instanceof RubyBignum;
     }
 
     public static boolean isFirstFloat(Object o) {
@@ -263,11 +259,23 @@ public static boolean isSecondFixnum(Object a, Object b) {
     }
 
     public static boolean isSecondBignum(Object a, Object b) {
-        return b instanceof BigInteger;
+        return b instanceof RubyBignum;
     }
 
     public static boolean isSecondFloat(Object a, Object b) {
         return b instanceof Double;
     }
 
+    public RubyBignum bignum(int value) {
+        return bignum((long) value);
+    }
+
+    public RubyBignum bignum(long value) {
+        return bignum(BigInteger.valueOf(value));
+    }
+
+    public RubyBignum bignum(BigInteger value) {
+        return new RubyBignum(getContext().getCoreLibrary().getBignumClass(), value);
+    }
+
 }
diff --git a/core/src/main/java/org/jruby/truffle/nodes/RubyTypes.java b/core/src/main/java/org/jruby/truffle/nodes/RubyTypes.java
@@ -22,8 +22,6 @@
 import org.jruby.truffle.runtime.rubinius.RubiniusChannel;
 import org.jruby.truffle.runtime.LexicalScope;
 
-import java.math.BigInteger;
-
 /**
  * The list of types and type conversions that the AST interpreter knows about and can specialise
  * using. Used by the DSL.
@@ -37,7 +35,7 @@
                 long.class, //
                 double.class, //
                 String.class, // for SymbolCastNode
-                BigInteger.class, //
+                RubyBignum.class, //
                 RubyRange.IntegerFixnumRange.class, //
                 RubyRange.LongFixnumRange.class, //
                 RubyRange.ObjectRange.class, //
@@ -62,7 +60,6 @@
                 RubiniusChannel.class, //
                 RubiniusByteArray.class, //
                 RubyEncodingConverter.class, //
-                RubyObject.class, //
                 RubyBasicObject.class, //
                 Object[].class})
 

diff --git a/core/src/main/java/org/jruby/truffle/nodes/cast/ArrayCastNode.java b/core/src/main/java/org/jruby/truffle/nodes/cast/ArrayCastNode.java
@@ -20,10 +20,9 @@
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.RubyArray;
 import org.jruby.truffle.runtime.core.RubyBasicObject;
+import org.jruby.truffle.runtime.core.RubyBignum;
 import org.jruby.truffle.runtime.core.RubyNilClass;
 
-import java.math.BigInteger;
-
 @NodeChild("child")
 public abstract class ArrayCastNode extends RubyNode {
 
@@ -62,7 +61,7 @@ public RubyNilClass cast(double value) {
     }
 
     @Specialization
-    public RubyNilClass cast(BigInteger value) {
+    public RubyNilClass cast(RubyBignum value) {
         return getContext().getCoreLibrary().getNilObject();
     }
 

diff --git a/core/src/main/java/org/jruby/truffle/nodes/cast/BooleanCastNode.java b/core/src/main/java/org/jruby/truffle/nodes/cast/BooleanCastNode.java
@@ -18,8 +18,6 @@
 import org.jruby.truffle.runtime.*;
 import org.jruby.truffle.runtime.core.*;
 
-import java.math.BigInteger;
-
 /**
  * Casts a value into a boolean.
  */
@@ -55,7 +53,7 @@ public boolean doLongFixnum(long value) {
     }
 
     @Specialization
-    public boolean doBignum(BigInteger value) {
+    public boolean doBignum(RubyBignum value) {
         return true;
     }
 

diff --git a/core/src/main/java/org/jruby/truffle/nodes/control/PassthroughNode.java b/core/src/main/java/org/jruby/truffle/nodes/control/PassthroughNode.java
@@ -18,8 +18,6 @@
 import org.jruby.truffle.runtime.UndefinedPlaceholder;
 import org.jruby.truffle.runtime.core.*;
 
-import java.math.BigInteger;
-
 public abstract class PassthroughNode extends RubyNode {
 
     @Child protected RubyNode child;
@@ -40,7 +38,7 @@ public RubyArray executeArray(VirtualFrame frame) throws UnexpectedResultExcepti
     }
 
     @Override
-    public BigInteger executeBignum(VirtualFrame frame) throws UnexpectedResultException {
+    public RubyBignum executeBignum(VirtualFrame frame) throws UnexpectedResultException {
         return child.executeBignum(frame);
     }
 
@@ -134,11 +132,6 @@ public RubyNilClass executeRubyNilClass(VirtualFrame frame) throws UnexpectedRes
         return child.executeRubyNilClass(frame);
     }
 
-    @Override
-    public RubyObject executeRubyObject(VirtualFrame frame) throws UnexpectedResultException {
-        return child.executeRubyObject(frame);
-    }
-
     @Override
     public RubyProc executeRubyProc(VirtualFrame frame) throws UnexpectedResultException {
         return child.executeRubyProc(frame);