More conversion to new singletonClass

enebo · enebo · commit ae03bb082634 · 2024-12-16T14:12:29.000-06:00
diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -75,6 +75,7 @@
 import static org.jruby.api.Error.typeError;
 import static org.jruby.api.Warn.warn;
 import static org.jruby.ir.runtime.IRRuntimeHelpers.dupIfKeywordRestAtCallsite;
+import static org.jruby.ir.runtime.IRRuntimeHelpers.getCurrentClassBase;
 import static org.jruby.runtime.Helpers.invokeChecked;
 import static org.jruby.runtime.ThreadContext.*;
 import static org.jruby.runtime.Visibility.*;
@@ -1882,12 +1883,15 @@ public IRubyObject specificEval(ThreadContext context, RubyModule mod, IRubyObje
         return evalUnder(context, mod, evalStr, file, line, evalType);
     }
 
+    @Deprecated(since = "10.0")
     protected RubyModule getInstanceEvalClass() {
-        if (isImmediate()) {
-            // Ruby uses Qnil here, we use "dummy" because we need a class
-            return getRuntime().getDummy();
-        }
-        return getSingletonClass();
+        return getInstanceEvalClass(getCurrentContext());
+    }
+
+    protected RubyModule getInstanceEvalClass(ThreadContext context) {
+        return isImmediate() ?
+                context.runtime.getDummy() : // MRI uses Qnil here, we use "dummy" because we need a class
+                singletonClass(context);
     }
 
     /**
@@ -2543,25 +2547,25 @@ public RubyArray to_a(ThreadContext context) {
             reads = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE},
             writes = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE})
     public IRubyObject instance_eval(ThreadContext context, Block block) {
-        return specificEval(context, getInstanceEvalClass(), block, EvalType.INSTANCE_EVAL);
+        return specificEval(context, getInstanceEvalClass(context), block, EvalType.INSTANCE_EVAL);
     }
     @JRubyMethod(name = "instance_eval",
             reads = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE},
             writes = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE})
     public IRubyObject instance_eval(ThreadContext context, IRubyObject arg0, Block block) {
-        return specificEval(context, getInstanceEvalClass(), arg0, block, EvalType.INSTANCE_EVAL);
+        return specificEval(context, getInstanceEvalClass(context), arg0, block, EvalType.INSTANCE_EVAL);
     }
     @JRubyMethod(name = "instance_eval",
             reads = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE},
             writes = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE})
     public IRubyObject instance_eval(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) {
-        return specificEval(context, getInstanceEvalClass(), arg0, arg1, block, EvalType.INSTANCE_EVAL);
+        return specificEval(context, getInstanceEvalClass(context), arg0, arg1, block, EvalType.INSTANCE_EVAL);
     }
     @JRubyMethod(name = "instance_eval",
             reads = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE},
             writes = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE})
     public IRubyObject instance_eval(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) {
-        return specificEval(context, getInstanceEvalClass(), arg0, arg1, arg2, block, EvalType.INSTANCE_EVAL);
+        return specificEval(context, getInstanceEvalClass(context), arg0, arg1, arg2, block, EvalType.INSTANCE_EVAL);
     }
 
     // This is callable and will work but the rest = true is put so we can match the expected arity error message
@@ -2601,14 +2605,9 @@ public IRubyObject instance_eval(ThreadContext context, IRubyObject[] args, Bloc
             reads = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE},
             writes = {LASTLINE, BACKREF, VISIBILITY, BLOCK, SELF, METHODNAME, LINE, CLASS, FILENAME, SCOPE})
     public IRubyObject instance_exec(ThreadContext context, IRubyObject[] args, Block block) {
-        if (!block.isGiven()) {
-            throw context.runtime.newLocalJumpErrorNoBlock();
-        }
-
-        RubyModule klazz = isImmediate() ?  // MRI uses Qnil here, we use "dummy" because we need a class
-                context.runtime.getDummy() : singletonClass(context);
+        if (!block.isGiven()) throw context.runtime.newLocalJumpErrorNoBlock();
 
-        return yieldUnder(context, klazz, args, block, EvalType.INSTANCE_EVAL);
+        return yieldUnder(context, getInstanceEvalClass(context), args, block, EvalType.INSTANCE_EVAL);
     }
 
     /** rb_obj_extend
diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
@@ -536,7 +536,7 @@ public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name
     }
 
     /**
-     * @see #getSingletonClass()
+     * @see #singletonClass(ThreadContext)
      */
     RubyClass toSingletonClass(RubyBasicObject target) {
         // replaced after makeMetaClass with MetaClass's toSingletonClass
@@ -2217,14 +2217,15 @@ protected void extraClinitLookup(SkinnyMethodAdapter m) {
             // now create proxy class
             m.getstatic(javaPath, RUBY_FIELD, ci(Ruby.class));
             m.getstatic(javaPath, RUBY_CLASS_FIELD, ci(RubyClass.class));
+            m.invokevirtual("org/jruby/Ruby", "getCurrentContext", "()Lorg/jruby/runtime/ThreadContext;");
             m.ldc(org.objectweb.asm.Type.getType("L" + javaPath + ";"));
             // if (simpleAlloc) // if simple, don't init, if complex, do init
             // m.iconst_0(); // false (as int)
             // else
             m.iconst_1(); // true (as int)
 
             m.invokestatic(p(JavaProxyClass.class), "setProxyClassReified",
-                    sig(JavaProxyClass.class, Ruby.class, RubyClass.class, Class.class, boolean.class));
+                    sig(JavaProxyClass.class, ThreadContext.class, RubyClass.class, Class.class, boolean.class));
             m.dup();
             m.putstatic(javaPath, RUBY_PROXY_CLASS_FIELD, ci(JavaProxyClass.class));
 
diff --git a/core/src/main/java/org/jruby/anno/AnnotationBinder.java b/core/src/main/java/org/jruby/anno/AnnotationBinder.java
@@ -131,6 +131,7 @@ public void processType(TypeElement cd) {
             out.println("import org.jruby.runtime.Arity;");
             out.println("import org.jruby.runtime.Visibility;");
             out.println("import org.jruby.runtime.MethodIndex;");
+            out.println("import org.jruby.runtime.ThreadContext;");
             out.println("import java.util.Arrays;");
             out.println("import java.util.List;");
             out.println("import jakarta.annotation.Generated;");
@@ -161,8 +162,11 @@ public void processType(TypeElement cd) {
 
             out.println("        JavaMethod javaMethod;");
             out.println("        DynamicMethod moduleMethod, aliasedMethod;");
-            if (hasMeta || hasModule) out.println("        RubyClass singletonClass = cls.getSingletonClass();");
-            out.println("        Ruby runtime = cls.getRuntime();");
+            out.println("        ThreadContext context = cls.getRuntime().getCurrentContext();");
+            out.println("        Ruby runtime = context.runtime;");
+            if (hasMeta || hasModule) {
+                out.println("        RubyClass singletonClass = cls.singletonClass(context);");
+            }
             out.println("        boolean core = runtime.isBootingCore();");
 
             Map<CharSequence, List<ExecutableElement>> annotatedMethods = new LinkedHashMap<>();
@@ -501,7 +505,7 @@ private void generateMethodAddCalls(ExecutableElement md, final boolean meta, fi
         } else {
             defineMethodOnClass("javaMethod", "cls", names, aliases, md);
             if (module) {
-                out.println("        moduleMethod = populateModuleMethod(cls, javaMethod);");
+                out.println("        moduleMethod = populateModuleMethod(cls, singletonClass, javaMethod);");
                 defineMethodOnClass("moduleMethod", "singletonClass", names, aliases, md);
             }
         }
diff --git a/core/src/main/java/org/jruby/anno/TypePopulator.java b/core/src/main/java/org/jruby/anno/TypePopulator.java
@@ -35,6 +35,7 @@
 import java.util.Optional;
 
 import org.jruby.Ruby;
+import org.jruby.RubyClass;
 import org.jruby.RubyModule;
 import org.jruby.internal.runtime.methods.DynamicMethod;
 import org.jruby.internal.runtime.methods.JavaMethod;
@@ -66,10 +67,16 @@ public static void populateMethod(JavaMethod javaMethod, int arity, String simpl
         javaMethod.setNotImplemented(notImplemented);
         javaMethod.setNativeCall(nativeTarget, nativeName, nativeReturn, nativeArguments, isStatic, false);
     }
-    
+
+    // Still needed for older generated populators.
+    @Deprecated(since = "10.0")
     public static DynamicMethod populateModuleMethod(RubyModule cls, DynamicMethod javaMethod) {
+        return populateModuleMethod(cls, cls.singletonClass(cls.getRuntime().getCurrentContext()), javaMethod);
+    }
+
+    public static DynamicMethod populateModuleMethod(RubyModule cls, RubyClass singletonClass, DynamicMethod javaMethod) {
         DynamicMethod moduleMethod = javaMethod.dup();
-        moduleMethod.setImplementationClass(cls.getSingletonClass());
+        moduleMethod.setImplementationClass(singletonClass);
         moduleMethod.setVisibility(Visibility.PUBLIC);
         return moduleMethod;
     }
diff --git a/core/src/main/java/org/jruby/ir/instructions/DefineMetaClassInstr.java b/core/src/main/java/org/jruby/ir/instructions/DefineMetaClassInstr.java
@@ -68,11 +68,9 @@ public static DefineMetaClassInstr decode(IRReaderDecoder d) {
 
     @Override
     public Object interpret(ThreadContext context, StaticScope currScope, DynamicScope currDynScope, IRubyObject self, Object[] temp) {
-        Ruby runtime = context.runtime;
-
         IRubyObject obj = (IRubyObject) getObject().retrieve(context, self, currScope, currDynScope, temp);
 
-        return IRRuntimeHelpers.newInterpretedMetaClass(runtime, metaClassBody, obj);
+        return IRRuntimeHelpers.newInterpretedMetaClass(context, metaClassBody, obj);
     }
 
     @Override
diff --git a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java
@@ -1709,8 +1709,8 @@ public static IRubyObject setInstanceVariable(IRubyObject self, IRubyObject valu
      * Construct a new DynamicMethod to wrap the given IRModuleBody and singletonizable object. Used by interpreter.
      */
     @Interp
-    public static DynamicMethod newInterpretedMetaClass(Ruby runtime, IRScope metaClassBody, IRubyObject obj) {
-        RubyClass singletonClass = newMetaClassFromIR(runtime, metaClassBody.getStaticScope(), obj, metaClassBody.maybeUsingRefinements());
+    public static DynamicMethod newInterpretedMetaClass(ThreadContext context, IRScope metaClassBody, IRubyObject obj) {
+        RubyClass singletonClass = newMetaClassFromIR(context, metaClassBody.getStaticScope(), obj, metaClassBody.maybeUsingRefinements());
 
         return new InterpretedIRBodyMethod(metaClassBody, singletonClass);
     }
@@ -1720,18 +1720,18 @@ public static DynamicMethod newInterpretedMetaClass(Ruby runtime, IRScope metaCl
      */
     @JIT
     public static DynamicMethod newCompiledMetaClass(ThreadContext context, MethodHandle handle, StaticScope scope, IRubyObject obj, int line, boolean refinements, boolean dynscopeEliminated) {
-        RubyClass singletonClass = newMetaClassFromIR(context.runtime, scope, obj, refinements);
+        RubyClass singletonClass = newMetaClassFromIR(context, scope, obj, refinements);
 
         return new CompiledIRNoProtocolMethod(handle, scope, scope.getFile(), line,
                 singletonClass, !dynscopeEliminated);
     }
 
-    private static RubyClass newMetaClassFromIR(Ruby runtime, StaticScope scope, IRubyObject obj, boolean refinements) {
-        RubyClass singletonClass = Helpers.getSingletonClass(runtime, obj);
+    private static RubyClass newMetaClassFromIR(ThreadContext context, StaticScope scope, IRubyObject obj, boolean refinements) {
+        RubyClass singletonClass = obj.singletonClass(context);
 
         scope.setModule(singletonClass);
 
-        if (refinements) scope.captureParentRefinements(runtime.getCurrentContext());
+        if (refinements) scope.captureParentRefinements(context);
 
         return singletonClass;
     }
diff --git a/core/src/main/java/org/jruby/java/proxies/ArrayJavaProxy.java b/core/src/main/java/org/jruby/java/proxies/ArrayJavaProxy.java
@@ -44,7 +44,7 @@ public static RubyClass createArrayJavaProxy(ThreadContext context, RubyClass Ja
         return defineClass(context, "ArrayJavaProxy", JavaProxy, NOT_ALLOCATABLE_ALLOCATOR).
                 defineMethods(context, ArrayJavaProxy.class).
                 include(context, Enumerable).
-                tap(c -> c.singletonClass(context).addMethod("new", new ArrayNewMethod(c.getSingletonClass(), Visibility.PUBLIC)));
+                tap(c -> c.singletonClass(context).addMethod("new", new ArrayNewMethod(c.singletonClass(context), Visibility.PUBLIC)));
     }
 
     public static ArrayJavaProxy newArray(final Ruby runtime, final Class<?> elementType, final int... dimensions) {
diff --git a/core/src/main/java/org/jruby/java/proxies/ConcreteJavaProxy.java b/core/src/main/java/org/jruby/java/proxies/ConcreteJavaProxy.java
@@ -426,12 +426,17 @@ public void ensureThis(Object self) {
         if (getObject() == null) setObject(self);
     }
 
+    @Deprecated(since = "10.0")
     protected static void initialize(final RubyClass concreteJavaProxy) {
+        initialize(concreteJavaProxy.getRuntime().getCurrentContext(), concreteJavaProxy);
+    }
+
+    protected static void initialize(ThreadContext context, final RubyClass concreteJavaProxy) {
         concreteJavaProxy.addMethod("initialize", new InitializeMethod(concreteJavaProxy));
         // We define a custom "new" method to ensure that __jcreate! is getting called,
         // so that if the user doesn't call super in their subclasses, the object will
         // still get set up properly. See JRUBY-4704.
-        RubyClass singleton = concreteJavaProxy.getSingletonClass();
+        RubyClass singleton = concreteJavaProxy.singletonClass(context);
         singleton.addMethod("new", new NewMethod(singleton));
     }
 
diff --git a/core/src/main/java/org/jruby/java/proxies/JavaInterfaceTemplate.java b/core/src/main/java/org/jruby/java/proxies/JavaInterfaceTemplate.java
@@ -60,6 +60,7 @@
 import static org.jruby.api.Access.objectClass;
 import static org.jruby.api.Convert.asSymbol;
 import static org.jruby.api.Convert.castAsModule;
+import static org.jruby.api.Create.newArray;
 import static org.jruby.api.Define.defineModule;
 import static org.jruby.api.Error.argumentError;
 import static org.jruby.api.Error.typeError;
@@ -129,13 +130,12 @@ public static IRubyObject append_features(ThreadContext context, IRubyObject sel
     }
 
     private static void appendFeaturesToClass(ThreadContext context, final IRubyObject self, final RubyClass clazz) {
-        final Ruby runtime = context.runtime;
-        checkAlreadyReified(clazz, runtime);
+        checkAlreadyReified(context, clazz);
 
         final IRubyObject javaClass = JavaProxy.getJavaClass((RubyModule) self);
         RubyArray javaInterfaces;
         if ( ! clazz.hasInstanceVariable("@java_interfaces") ) {
-            javaInterfaces = RubyArray.newArray(runtime, javaClass);
+            javaInterfaces = newArray(context, javaClass);
             clazz.setInstanceVariable("@java_interfaces", javaInterfaces);
 
             initInterfaceImplMethods(context, clazz);
@@ -151,19 +151,19 @@ private static void appendFeaturesToClass(ThreadContext context, final IRubyObje
         }
     }
 
-    private static void checkAlreadyReified(final RubyClass clazz, Ruby runtime) throws RaiseException {
+    private static void checkAlreadyReified(ThreadContext context, final RubyClass clazz) throws RaiseException {
         // not allowed for original (non-generated) Java classes
         // note: not allowing for any previously created class right now;
         // this restriction might be loosened later for generated classes
         if ( ( Java.NEW_STYLE_EXTENSION && clazz.reifiedClass() != null )
                 ||
                 ( clazz.hasInstanceVariable("@java_class")
                     && clazz.getInstanceVariable("@java_class").isTrue()
-                    && !clazz.getSingletonClass().isMethodBound("java_proxy_class", false) )
+                    && !clazz.singletonClass(context).isMethodBound("java_proxy_class", false) )
                 ||
                 ( clazz.hasInstanceVariable("@java_proxy_class")
                     && clazz.getInstanceVariable("@java_proxy_class").isTrue() ) ) {
-            throw runtime.newArgumentError("can not add Java interface to existing Java class");
+            throw argumentError(context, "can not add Java interface to existing Java class");
         }
     }
 
diff --git a/core/src/main/java/org/jruby/java/proxies/JavaProxy.java b/core/src/main/java/org/jruby/java/proxies/JavaProxy.java
@@ -576,10 +576,6 @@ public void setVariable(int index, Object value) {
         super.setVariable(index, value);
     }
 
-    public RubyClass getSingletonClass() {
-        return singletonClass(getRuntime().getCurrentContext());
-    }
-
     /** rb_singleton_class
      *
      * Note: this method is specialized for RubyFixnum, RubySymbol,
diff --git a/core/src/main/java/org/jruby/javasupport/Java.java b/core/src/main/java/org/jruby/javasupport/Java.java
@@ -1000,7 +1000,7 @@ static RubyModule getProxyOrPackageUnderPackage(final ThreadContext context,
         }
 
         // saves class in singletonized parent, so we don't come back here :
-        if ( cacheMethod ) bindJavaPackageOrClassMethod(parentPackage, name, result);
+        if ( cacheMethod )  bindJavaPackageOrClassMethod(context, parentPackage, name, result);
 
         return result;
     }
@@ -1148,17 +1148,17 @@ private static RubyModule getTopLevelProxyOrPackage(ThreadContext context,
     private static boolean bindJavaPackageOrClassMethod(ThreadContext context, final String name,
         final RubyModule packageOrClass) {
         final RubyModule javaPackage = context.runtime.getJavaSupport().getJavaModule();
-        return bindJavaPackageOrClassMethod(javaPackage, name, packageOrClass);
+        return bindJavaPackageOrClassMethod(context, javaPackage, name, packageOrClass);
     }
 
-    private static boolean bindJavaPackageOrClassMethod(final RubyModule parentPackage,
+    private static boolean bindJavaPackageOrClassMethod(ThreadContext context, final RubyModule parentPackage,
         final String name, final RubyModule packageOrClass) {
 
         if ( parentPackage.getMetaClass().isMethodBound(name, false) ) {
             return false;
         }
 
-        final RubyClass singleton = parentPackage.getSingletonClass();
+        final RubyClass singleton = parentPackage.singletonClass(context);
         singleton.addMethod(name.intern(), new JavaAccessor(singleton, packageOrClass, parentPackage, name));
         return true;
     }
diff --git a/core/src/main/java/org/jruby/javasupport/proxy/JavaProxyClass.java b/core/src/main/java/org/jruby/javasupport/proxy/JavaProxyClass.java
@@ -521,15 +521,15 @@ public static RubyObject get_with_class(final IRubyObject self, IRubyObject obj)
     }
     
     // Note: called from <clinit> of reified classes
-    public static JavaProxyClass setProxyClassReified(final Ruby runtime, final RubyClass clazz,
+    public static JavaProxyClass setProxyClassReified(ThreadContext context, final RubyClass clazz,
             final Class<? extends ReifiedJavaProxy> reified, final boolean allocator) {
-        JavaProxyClass proxyClass = new JavaProxyClass(runtime, reified);
+        JavaProxyClass proxyClass = new JavaProxyClass(context.runtime, reified);
         clazz.setInstanceVariable("@java_proxy_class", proxyClass);
 
-        RubyClass singleton = clazz.getSingletonClass();
+        RubyClass singleton = clazz.singletonClass(context);
 
         singleton.setInstanceVariable("@java_proxy_class", proxyClass);
-        singleton.setInstanceVariable("@java_class", Java.wrapJavaObject(runtime, reified));
+        singleton.setInstanceVariable("@java_class", Java.wrapJavaObject(context.runtime, reified));
 
         if (allocator) {
             DynamicMethod oldNewMethod = singleton.searchMethod("new");
@@ -538,7 +538,7 @@ public static JavaProxyClass setProxyClassReified(final Ruby runtime, final Ruby
                 singleton.addMethod("new", new NewMethodReified(clazz, reified));
             }
             // Install initialize
-            StaticJCreateMethod.tryInstall(runtime, clazz, proxyClass, reified, defaultNew);
+            StaticJCreateMethod.tryInstall(context.runtime, clazz, proxyClass, reified, defaultNew);
         }
         return proxyClass;
     }
diff --git a/core/src/main/java/org/jruby/runtime/Helpers.java b/core/src/main/java/org/jruby/runtime/Helpers.java

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public static RubyClass createArrayJavaProxy(ThreadContext context, RubyClass Ja`
`44`	`44`	`return defineClass(context, "ArrayJavaProxy", JavaProxy, NOT_ALLOCATABLE_ALLOCATOR).`
`45`	`45`	`defineMethods(context, ArrayJavaProxy.class).`
`46`	`46`	`include(context, Enumerable).`
`47`		`- tap(c -> c.singletonClass(context).addMethod("new", new ArrayNewMethod(c.getSingletonClass(), Visibility.PUBLIC)));`
	`47`	`+ tap(c -> c.singletonClass(context).addMethod("new", new ArrayNewMethod(c.singletonClass(context), Visibility.PUBLIC)));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`public static ArrayJavaProxy newArray(final Ruby runtime, final Class<?> elementType, final int... dimensions) {`
Original file line number	Diff line number	Diff line change
`@@ -576,10 +576,6 @@ public void setVariable(int index, Object value) {`
`576`	`576`	`super.setVariable(index, value);`
`577`	`577`	`}`
`578`	`578`
`579`		`- public RubyClass getSingletonClass() {`
`580`		`- return singletonClass(getRuntime().getCurrentContext());`
`581`		`- }`
`582`		`-`
`583`	`579`	`/** rb_singleton_class`
`584`	`580`	`*`
`585`	`581`	`* Note: this method is specialized for RubyFixnum, RubySymbol,`