Last boostrapping classes/modules decoupled from non-boot

At this point all classes and modules not happening before
first threadcontext can now depend on TC being available. This
will lead to a lot more lower classes using TC rather than the
classes runtime field.

Author: enebo

core/src/main/java/org/jruby/MetaClass.java

@@ -50,16 +50,33 @@ public MetaClass(Ruby runtime, RubyClass superClass, IRubyObject attached) {
      */
     MetaClass(Ruby runtime, RubyClass superClass, RubyBasicObject attached) {
         super(runtime, superClass, false);
-        this.attached = attached;
-        // use same ClassIndex as metaclass, since we're technically still of that type
-        classIndex(superClass.getClassIndex());
-        superClass.addSubclass(this);
+        metaClassInit(superClass, attached);
 
         if (LOG_SINGLETONS || LOG_SINGLETONS_VERBOSE) {
             logSingleton(runtime, superClass, attached);
         }
     }
 
+    /**
+     * This is an internal API only used by Ruby constructor before ThreadContext exists.  This is for bootstrapping
+     * only.
+     * @param runtime
+     * @param superClass
+     * @param Class
+     * @param attached
+     */
+    MetaClass(Ruby runtime, RubyClass superClass, RubyClass Class, RubyBasicObject attached) {
+        super(runtime, superClass, Class);
+        metaClassInit(superClass, attached);
+    }
+
+    private void metaClassInit(RubyClass superClass, RubyBasicObject attached) {
+        this.attached = attached;
+        // use same ClassIndex as metaclass, since we're technically still of that type
+        classIndex(superClass.getClassIndex());
+        superClass.addSubclass(this);
+    }
+
     private static void logSingleton(Ruby runtime, RubyClass superClass, RubyBasicObject attached) {
         if (runtime.isBooting()) return; // don't log singleton created during boot
 

core/src/main/java/org/jruby/Ruby.java

@@ -217,6 +217,7 @@
 import static org.jruby.api.Access.errnoModule;
 import static org.jruby.api.Access.loadService;
 import static org.jruby.api.Convert.asFixnum;
+import static org.jruby.api.Convert.asSymbol;
 import static org.jruby.api.Create.newEmptyString;
 import static org.jruby.api.Create.newFrozenString;
 import static org.jruby.api.Error.*;
@@ -335,36 +336,35 @@ private Ruby(RubyInstanceConfig config) {
         classClass.setMetaClass(classClass);
         refinementClass.setMetaClass(classClass);
 
-        RubyClass metaClass;
-        metaClass = basicObjectClass.makeMetaClass(classClass); // runtime needed for 3 things:
-        metaClass = objectClass.makeMetaClass(metaClass);       // 1. ObjectSpace
-        metaClass = moduleClass.makeMetaClass(metaClass);       // 2. Access 'Class' for makeMetaClass
-        classClass.makeMetaClass(metaClass);                    // 3. booting check to ignore logging singletons
-        refinementClass.makeMetaClass(metaClass);
+        var metaClass = basicObjectClass.makeMetaClassBootstrap(classClass, classClass);
+        metaClass = objectClass.makeMetaClassBootstrap(metaClass, classClass);
+        metaClass = moduleClass.makeMetaClassBootstrap(metaClass, classClass);
+        classClass.makeMetaClassBootstrap(metaClass, classClass);
+        refinementClass.makeMetaClassBootstrap(metaClass, classClass);
 
-        RubyObject.createObjectClass(objectClass);
-        RubyModule.createModuleClass(moduleClass);
-        RubyClass.createClassClass(this, classClass);
+        RubyObject.finishObjectClass(objectClass);
+        RubyModule.finishModuleClass(moduleClass);
+        RubyClass.finishClassClass(this, classClass);
 
         // set constants now that they're initialized
-        basicObjectClass.setConstant("BasicObject", basicObjectClass);  // FIXME: We know these sets will work so make something primal
-        objectClass.setConstant("BasicObject", basicObjectClass);       // just for these (to remove all checks which would require
-        objectClass.setConstant("Object", objectClass);                 // runtime.
-        objectClass.setConstant("Class", classClass);
-        objectClass.setConstant("Module", moduleClass);
-        objectClass.setConstant("Refinement", refinementClass);
+        basicObjectClass.defineConstantBootstrap("BasicObject", basicObjectClass);
+        objectClass.defineConstantBootstrap("BasicObject", basicObjectClass);
+        objectClass.defineConstantBootstrap("Object", objectClass);
+        objectClass.defineConstantBootstrap("Class", classClass);
+        objectClass.defineConstantBootstrap("Module", moduleClass);
+        objectClass.defineConstantBootstrap("Refinement", refinementClass);
 
         // specializer for RubyObject subclasses
         objectSpecializer = new RubyObjectSpecializer(this);
 
-        kernelModule = defineModuleUnder("Kernel", objectClass);   // Initialize Kernel and include into Object
+        kernelModule = defineModuleBootstrap("Kernel");   // Initialize Kernel and include into Object
         topSelf = new RubyObject(this, objectClass);  // Object is ready, create top self
 
         // nil, true, and false all are set in TC so they need to be created above (both class and instances).
-        // their methods are added afterwards since no dispatch happens until after first TC is defined.
-        nilClass = defineClass("NilClass", objectClass, NOT_ALLOCATABLE_ALLOCATOR);
-        falseClass = defineClass("FalseClass", objectClass, NOT_ALLOCATABLE_ALLOCATOR);
-        trueClass = defineClass("TrueClass", objectClass, NOT_ALLOCATABLE_ALLOCATOR);
+        // their methods are added afterward since no dispatch happens until after first TC is defined.
+        nilClass = defineClassBootstrap("NilClass");
+        falseClass = defineClassBootstrap("FalseClass");
+        trueClass = defineClassBootstrap("TrueClass");
 
         nilObject = new RubyNil(this, nilClass);
         nilPrefilledArray = new IRubyObject[NIL_PREFILLED_ARRAY_SIZE];
@@ -1389,24 +1389,6 @@ public RubyClass fastGetClass(String internedName) {
         return getClass(internedName);
     }
 
-    /**
-     * Define a new class under the Object namespace. Roughly equivalent to
-     * rb_define_class in MRI.  This is an internal API.  Please use
-     * {@link org.jruby.api.Define#defineClass(ThreadContext, String, RubyClass, ObjectAllocator)} instead.
-     * For bootstrappin we still need a non-ThreadContext define for nil and boolean class definition
-     * as they are required before we can initialize our topmost ThreadContext.
-     *
-     * @param name The name for the new class
-     * @param superClass The super class for the new class
-     * @param allocator An ObjectAllocator instance that can construct
-     * instances of the new class.
-     * @return The new class
-     */
-    @Extension
-    public RubyClass defineClass(String name, RubyClass superClass, ObjectAllocator allocator) {
-        return defineClassUnder(name, superClass, allocator, objectClass, null);
-    }
-
     /**
      * A variation of defineClass that allows passing in an array of supplementary
      * call sites for improving dynamic invocation performance.
@@ -1419,7 +1401,12 @@ public RubyClass defineClass(String name, RubyClass superClass, ObjectAllocator
      */
     @Deprecated(since = "10.0")
     public RubyClass defineClass(String name, RubyClass superClass, ObjectAllocator allocator, CallSite[] callSites) {
-        return defineClassUnder(name, superClass, allocator, objectClass, callSites);
+        return defineClassUnder(getCurrentContext(), name, superClass, allocator, objectClass, callSites);
+    }
+
+    @Deprecated(since = "10.0")
+    public RubyClass defineClass(String name, RubyClass superClass, ObjectAllocator allocator) {
+        return defineClassUnder(getCurrentContext(), name, superClass, allocator, objectClass, null);
     }
 
     /**
@@ -1440,15 +1427,20 @@ public RubyClass defineClass(String name, RubyClass superClass, ObjectAllocator
     @Extension
     @Deprecated(since = "10.0")
     public RubyClass defineClassUnder(String name, RubyClass superClass, ObjectAllocator allocator, RubyModule parent) {
-        return defineClassUnder(name, superClass, allocator, parent, null);
+        return defineClassUnder(runtimeError.getCurrentContext(), name, superClass, allocator, parent, null);
+    }
+
+    @Deprecated(since = "10.0")
+    public RubyClass defineClassUnder(String id, RubyClass superClass, ObjectAllocator allocator, RubyModule parent, CallSite[] callSites) {
+        return defineClassUnder(getCurrentContext(), id, superClass, allocator, parent, callSites);
     }
 
     /**
      * A variation of defineClassUnder that allows passing in an array of
      * supplementary call sites to improve dynamic invocation.  This is an internal API.  Please
-     * use {@link org.jruby.api.Define#defineClassUnder(ThreadContext, String, RubyClass, ObjectAllocator, RubyModule)}
-     * or {@link org.jruby.RubyModule#defineClassUnder(ThreadContext, String, RubyClass, ObjectAllocator)} instead.
+     * use {@link org.jruby.RubyModule#defineClassUnder(ThreadContext, String, RubyClass, ObjectAllocator)} instead.
      *
+     * @param context the current thread context
      * @param id The name for the new class as an ISO-8859_1 String (id-value)
      * @param superClass The super class for the new class
      * @param allocator An ObjectAllocator instance that can construct
@@ -1457,32 +1449,38 @@ public RubyClass defineClassUnder(String name, RubyClass superClass, ObjectAlloc
      * @param callSites The array of call sites to add
      * @return The new class
      */
-    public RubyClass defineClassUnder(String id, RubyClass superClass, ObjectAllocator allocator, RubyModule parent, CallSite[] callSites) {
-        IRubyObject classObj = parent.getConstantAt(id);
-
-        if (classObj != null) {
-            if (!(classObj instanceof RubyClass)) throw typeError(getCurrentContext(), str(this, ids(this, id), " is not a class"));
-            RubyClass klazz = (RubyClass)classObj;
-            if (klazz.getSuperClass().getRealClass() != superClass) {
-                throw newNameError(str(this, ids(this, id), " is already defined"), newSymbol(id));
-            }
-            // If we define a class in Ruby, but later want to allow it to be defined in Java,
-            // the allocator needs to be updated
-            if (klazz.getAllocator() != allocator) klazz.allocator(allocator);
-            return klazz;
-        }
+    public RubyClass defineClassUnder(ThreadContext context, String id, RubyClass superClass, ObjectAllocator allocator,
+                                      RubyModule parent, CallSite[] callSites) {
+        IRubyObject object = parent.getConstantAt(id);
+        if (object != null) return foundExistingClass(context, id, superClass, allocator, object);
 
         boolean parentIsObject = parent == objectClass;
 
-        if (superClass == null) {
-            IRubyObject className = parentIsObject ? ids(this, id) :
-                    parent.toRubyString(getCurrentContext()).append(newString("::")).append(ids(this, id));
-            warn(getCurrentContext(), str(this, "no super class for '", className, "', Object assumed"));
+        if (superClass == null) superClass = determineSuperClass(context, id, parent, parentIsObject);
+
+        return RubyClass.newClass(this, superClass, id, allocator, parent, !parentIsObject, callSites);
+    }
+
+    private RubyClass determineSuperClass(ThreadContext context, String id, RubyModule parent, boolean parentIsObject) {
+        RubyClass superClass;
+        IRubyObject className = parentIsObject ? ids(this, id) :
+                parent.toRubyString(context).append(newString("::")).append(ids(this, id));
+        warn(context, str(this, "no super class for '", className, "', Object assumed"));
+
+        superClass = objectClass;
+        return superClass;
+    }
 
-            superClass = objectClass;
+    private RubyClass foundExistingClass(ThreadContext context, String id, RubyClass superClass, ObjectAllocator allocator, IRubyObject obj) {
+        if (!(obj instanceof RubyClass klazz)) throw typeError(context, str(this, ids(this, id), " is not a class"));
+
+        if (klazz.getSuperClass().getRealClass() != superClass) {
+            throw newNameError(str(this, ids(this, id), " is already defined"), asSymbol(context, id));
         }
+        // If we define a class in Ruby, but later want to allow it to be defined in Java, the allocator needs to be updated
+        if (klazz.getAllocator() != allocator) klazz.allocator(allocator);
 
-        return RubyClass.newClass(this, superClass, id, allocator, parent, !parentIsObject, callSites);
+        return klazz;
     }
 
     /**
@@ -1495,7 +1493,32 @@ public RubyClass defineClassUnder(String id, RubyClass superClass, ObjectAllocat
     @Deprecated(since = "10.0")
     @Extension
     public RubyModule defineModule(String name) {
-        return defineModuleUnder(name, objectClass);
+        return defineModuleUnder(getCurrentContext(), name, objectClass);
+    }
+
+    /**
+     * This is only for defining nil,true,false.  The reason we have this is so all other define methods
+     * can count on ThreadContext being available.  These are defined before that point.
+     * @param name The name for the new class
+     * @return The new class
+     */
+    public RubyClass defineClassBootstrap(String name) {
+        return RubyClass.newClass(this, objectClass, name, NOT_ALLOCATABLE_ALLOCATOR, objectClass, false, null);
+    }
+
+    /**
+     * This is only for defining kernel.  The reason we have this is so all other define methods
+     * can count on ThreadContext being available.  These are defined before that point.
+     * @param name The name for the new class
+     * @return The new module
+     */
+    public RubyModule defineModuleBootstrap(String name) {
+        return RubyModule.newModule(this, name, objectClass, false);
+    }
+
+    @Deprecated(since = "10.0")
+    public RubyModule defineModuleUnder(String name, RubyModule parent) {
+        return defineModuleUnder(getCurrentContext(), name, parent);
     }
 
     /**
@@ -1509,22 +1532,24 @@ public RubyModule defineModule(String name) {
      * module
      * @return The new module
      */
-    @Extension
-    public RubyModule defineModuleUnder(String name, RubyModule parent) {
+    public RubyModule defineModuleUnder(ThreadContext context, String name, RubyModule parent) {
         IRubyObject moduleObj = parent.getConstantAt(name);
 
         boolean parentIsObject = parent == objectClass;
 
-        if (moduleObj != null) {
-            if (moduleObj.isModule()) return (RubyModule) moduleObj;
+        return moduleObj != null ?
+                foundExistingModule(context, parent, moduleObj, parentIsObject) :
+                RubyModule.newModule(this, name, parent, !parentIsObject);
+    }
 
-            RubyString typeName = parentIsObject ?
-                    types(this, moduleObj.getMetaClass()) : types(this, parent, moduleObj.getMetaClass());
+    private RubyModule foundExistingModule(ThreadContext context, RubyModule parent, IRubyObject moduleObj,
+                                           boolean parentIsObject) {
+        if (moduleObj.isModule()) return (RubyModule) moduleObj;
 
-            throw typeError(getCurrentContext(), str(this, typeName, " is not a module"));
-        }
+        RubyString typeName = parentIsObject ?
+                types(this, moduleObj.getMetaClass()) : types(this, parent, moduleObj.getMetaClass());
 
-        return RubyModule.newModule(this, name, parent, !parentIsObject);
+        throw typeError(context, str(this, typeName, " is not a module"));
     }
 
     /**

core/src/main/java/org/jruby/RubyBasicObject.java

@@ -500,6 +500,23 @@ public RubyClass makeMetaClass(RubyClass superClass) {
         return klass;
     }
 
+    /**
+     * This will create a new metaclass.  This is only used during bootstrapping before
+     * the initial ThreadContext is defined.  Normal needs of making a metaclass should use
+     * {@link RubyBasicObject#makeMetaClass(RubyClass)}
+     * @param superClass
+     * @param Class
+     * @return
+     */
+    public RubyClass makeMetaClassBootstrap(RubyClass superClass, RubyClass Class) {
+        MetaClass klass = new MetaClass(getRuntime(), superClass, Class, this); // rb_class_boot
+        setMetaClass(klass);
+
+        klass.setMetaClass(superClass.getRealClass().metaClass);
+
+        return klass;
+    }
+
     /**
      * Makes it possible to change the metaclass of an object. In
      * practice, this is a simple version of Smalltalks Become, except

core/src/main/java/org/jruby/RubyClass.java

@@ -120,7 +120,7 @@ public class RubyClass extends RubyModule {
     private static final Logger LOG = LoggerFactory.getLogger(RubyClass.class);
     private static final double SUBCLASSES_CLEAN_FACTOR = 0.25;
 
-    public static void createClassClass(Ruby runtime, RubyClass Class) {
+    public static void finishClassClass(Ruby runtime, RubyClass Class) {
         Class.reifiedClass(RubyClass.class).
                 kindOf(new RubyModule.JavaClassKindOf(RubyClass.class)).
                 classIndex(ClassIndex.CLASS);
@@ -431,6 +431,25 @@ protected RubyClass(Ruby runtime, RubyClass superClass, boolean objectSpace) {
         superClass(superClass); // this is the only case it might be null here (in MetaClass construction)
     }
 
+    /**
+     *  This is an internal API only used by Ruby constructor before ThreadContext exists.
+     * @param runtime
+     * @param superClass
+     * @param Class
+     */
+    protected RubyClass(Ruby runtime, RubyClass superClass, RubyClass Class) {
+        super(runtime, Class, false);
+
+        this.runtime = runtime;
+        if ((this.realClass = superClass.realClass) != null) {
+            this.variableTableManager = realClass.variableTableManager;
+        } else {
+            this.variableTableManager = new VariableTableManager(this);
+        }
+
+        superClass(superClass);
+    }
+
     /** used by CLASS_ALLOCATOR (any Class' class will be a Class!)
      *  also used to bootstrap Object class
      */

core/src/main/java/org/jruby/RubyConverter.java

@@ -61,7 +61,6 @@
 import static org.jruby.api.Convert.*;
 import static org.jruby.api.Create.newArray;
 import static org.jruby.api.Create.newString;
-import static org.jruby.api.Define.defineClassUnder;
 import static org.jruby.api.Error.*;
 import static org.jruby.runtime.Visibility.PRIVATE;
 
@@ -121,7 +120,7 @@ public class RubyConverter extends RubyObject {
     }
 
     public static RubyClass createConverterClass(ThreadContext context, RubyClass Object, RubyClass Encoding) {
-        return defineClassUnder(context, "Converter", Object, RubyConverter::new, Encoding).
+        return Encoding.defineClassUnder(context, "Converter", Object, RubyConverter::new).
                 reifiedClass(RubyConverter.class).
                 kindOf(new RubyModule.JavaClassKindOf(RubyConverter.class)).
                 classIndex(ClassIndex.CONVERTER).