final uses of getSingletonClass replaced

enebo · enebo · commit 1e0e0b600091 · 2024-12-16T14:55:58.000-06:00
diff --git a/core/src/main/java/org/jruby/MetaClass.java b/core/src/main/java/org/jruby/MetaClass.java
@@ -100,11 +100,13 @@ public RubyClass makeMetaClass(RubyClass superClass) {
 
     private RubyClass getSuperSingletonMetaClass() {
         if (attached instanceof RubyClass att) {
-            RubyClass superClass = att.getSuperClass();
+            RubyClass superClass = att.superClass();
             if (superClass != null) superClass = superClass.getRealClass();
             // #<Class:BasicObject>'s singleton class == Class.singleton_class
-            if (superClass == null) return runtime.getClassClass().getSingletonClass();
-            return superClass.getMetaClass().getSingletonClass();
+            // Context should be safe here as we never make a metaclass from a metaclass before first TC is made.
+            var context = getRuntime().getCurrentContext();
+            if (superClass == null) return runtime.getClassClass().singletonClass(context);
+            return superClass.getMetaClass().singletonClass(context);
         }
 
         return getSuperClass().getRealClass().getMetaClass(); // NOTE: is this correct?
diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -29,6 +29,7 @@
 package org.jruby;
 
 import org.jcodings.Encoding;
+import org.jruby.api.JRubyAPI;
 import org.jruby.ast.util.ArgsUtil;
 import org.jruby.ir.interpreter.Interpreter;
 import org.jruby.java.proxies.JavaProxy;
@@ -461,23 +462,21 @@ public static RubyClass getMetaClass(IRubyObject arg) {
         return ((RubyBasicObject) arg).metaClass;
     }
 
-    /** rb_singleton_class
-     *
-     * Note: this method is specialized for RubyFixnum, RubySymbol,
-     * RubyNil and RubyBoolean
-     *
-     * Will either return the existing singleton class for this
-     * object, or create a new one and return that.
-     */
     @Override
     public RubyClass getSingletonClass() {
-        RubyClass klass = metaClass.toSingletonClass(this);
-
-        if (isFrozen()) klass.setFrozen(true);
-
-        return klass;
+        return singletonClass(getCurrentContext());
     }
 
+    /**
+     * Will either return the existing singleton class for this object, or create a new one and return that.
+     * For a few types a singleton class is not possible so it will throw an error.
+     *
+     * @param context the current thread context
+     * @return the singleton of this type
+     */
+
+    // MRI: rb_singleton_class
+    @JRubyAPI
     public RubyClass singletonClass(ThreadContext context) {
         RubyClass klass = metaClass.toSingletonClass(this);
 
diff --git a/core/src/main/java/org/jruby/RubyBignum.java b/core/src/main/java/org/jruby/RubyBignum.java
@@ -156,11 +156,6 @@ public BigInteger getBigIntegerValue() {
         return value;
     }
 
-    @Override
-    public RubyClass getSingletonClass() {
-        return singletonClass(getRuntime().getCurrentContext());
-    }
-
     @Override
     public RubyClass singletonClass(ThreadContext context) {
         throw typeError(context, "can't define singleton");
diff --git a/core/src/main/java/org/jruby/RubyBoolean.java b/core/src/main/java/org/jruby/RubyBoolean.java
@@ -88,11 +88,6 @@ public boolean isImmediate() {
         return true;
     }
 
-    @Override
-    public RubyClass getSingletonClass() {
-        return metaClass;
-    }
-
     public RubyClass singletonClass(ThreadContext context) {
         return metaClass;
     }
diff --git a/core/src/main/java/org/jruby/RubyFixnum.java b/core/src/main/java/org/jruby/RubyFixnum.java
@@ -180,10 +180,6 @@ public boolean isImmediate() {
     	return true;
     }
 
-    public RubyClass getSingletonClass() {
-        return singletonClass(getRuntime().getCurrentContext());
-    }
-
     public RubyClass singletonClass(ThreadContext context) {
         throw typeError(context, "can't define singleton");
     }
diff --git a/core/src/main/java/org/jruby/RubyFloat.java b/core/src/main/java/org/jruby/RubyFloat.java
@@ -147,11 +147,6 @@ private RubyFloat(RubyClass klass, double value) {
         this.flags |= FROZEN_F;
     }
 
-    @Override
-    public RubyClass getSingletonClass() {
-        return singletonClass(getRuntime().getCurrentContext());
-    }
-
     public RubyClass singletonClass(ThreadContext context) {
         throw typeError(context, "can't define singleton");
     }
diff --git a/core/src/main/java/org/jruby/RubyNil.java b/core/src/main/java/org/jruby/RubyNil.java
@@ -93,11 +93,6 @@ public boolean isImmediate() {
         return true;
     }
 
-    @Override
-    public RubyClass getSingletonClass() {
-        return metaClass;
-    }
-
     public RubyClass singletonClass(ThreadContext context) {
         return metaClass;
     }
diff --git a/core/src/main/java/org/jruby/RubyString.java b/core/src/main/java/org/jruby/RubyString.java
@@ -4973,11 +4973,6 @@ private static IRubyObject getPatternQuoted(ThreadContext context, IRubyObject p
         return pat; // String
     }
 
-    @Override
-    public RubyClass getSingletonClass() {
-        return singletonClass(getRuntime().getCurrentContext());
-    }
-
     public RubyClass singletonClass(ThreadContext context) {
         if (isChilled()) {
             mutateChilledString();
diff --git a/core/src/main/java/org/jruby/RubySymbol.java b/core/src/main/java/org/jruby/RubySymbol.java
@@ -305,11 +305,6 @@ public boolean isImmediate() {
     	return true;
     }
 
-    @Override
-    public RubyClass getSingletonClass() {
-        return singletonClass(getRuntime().getCurrentContext());
-    }
-
     public RubyClass singletonClass(ThreadContext context) {
         throw typeError(context, "can't define singleton");
     }
diff --git a/core/src/main/java/org/jruby/ext/ffi/jffi/Function.java b/core/src/main/java/org/jruby/ext/ffi/jffi/Function.java
@@ -50,8 +50,9 @@ public static RubyClass createFunctionClass(ThreadContext context, RubyModule FF
         
         this.enums = enums;
         this.saveError = saveError;
+        var singleton = singletonClass(getRuntime().getCurrentContext());
         // Wire up Function#call(*args) to use the super-fast native invokers
-        getSingletonClass().addMethod("call", createDynamicMethod(getSingletonClass()));
+        singleton.addMethod("call", createDynamicMethod(singleton));
     }
 
     Function(Ruby runtime, RubyClass klass, MemoryIO address,
@@ -64,8 +65,9 @@ public static RubyClass createFunctionClass(ThreadContext context, RubyModule FF
                 functionInfo.jffiReturnType, functionInfo.jffiParameterTypes, functionInfo.convention);
         this.enums = enums;
         this.saveError = true;
+        var singleton = singletonClass(getRuntime().getCurrentContext());
         // Wire up Function#call(*args) to use the super-fast native invokers
-        getSingletonClass().addMethod("call", createDynamicMethod(getSingletonClass()));
+        singleton.addMethod("call", createDynamicMethod(singleton));
     }
     
     @JRubyMethod(name = { "new" }, meta = true, required = 2, optional = 2, checkArity = false)
diff --git a/core/src/main/java/org/jruby/ext/ffi/jffi/JFFIInvoker.java b/core/src/main/java/org/jruby/ext/ffi/jffi/JFFIInvoker.java
@@ -57,8 +57,9 @@ public static RubyClass createInvokerClass(ThreadContext context, RubyModule FFI
         this.returnType = returnType;
         this.convention = convention;
         this.enums = enums;
+        var singleton = singletonClass(getRuntime().getCurrentContext());
         // Wire up Function#call(*args) to use the super-fast native invokers
-        getSingletonClass().addMethod("call", createDynamicMethod(getSingletonClass()));
+        singleton.addMethod("call", createDynamicMethod(singleton));
     }
     
     @JRubyMethod(name = { "new" }, meta = true, required = 4)
diff --git a/core/src/main/java/org/jruby/javasupport/Java.java b/core/src/main/java/org/jruby/javasupport/Java.java
@@ -506,7 +506,7 @@ private static void generateInterfaceProxy(ThreadContext context, final Class ja
         for (int i = extended.length; --i >= 0; ) {
             proxy.include(context, getInterfaceModule(context, extended[i]));
         }
-        Initializer.setupProxyModule(context.runtime, javaClass, proxy);
+        Initializer.setupProxyModule(context, javaClass, proxy);
         addToJavaPackageModule(proxy);
     }
 
@@ -572,7 +572,7 @@ private static RubyClass createProxyClass(ThreadContext context, final RubyClass
 
         if ( invokeInherited ) proxyClass.inherit(superClass);
 
-        Initializer.setupProxyClass(context.runtime, javaClass, proxyClass);
+        Initializer.setupProxyClass(context, javaClass, proxyClass);
 
         return proxyClass;
     }
diff --git a/core/src/main/java/org/jruby/javasupport/binding/ClassInitializer.java b/core/src/main/java/org/jruby/javasupport/binding/ClassInitializer.java
@@ -16,11 +16,12 @@ final class ClassInitializer extends Initializer {
 
     @Override
     public RubyClass initialize(final RubyModule proxy) {
+        var context = proxy.getRuntime().getCurrentContext();
         final RubyClass proxyClass = (RubyClass) proxy;
 
         // flag the class as a Java class proxy.
         proxy.setJavaProxy(true);
-        proxy.getSingletonClass().setJavaProxy(true);
+        proxy.singletonClass(context).setJavaProxy(true);
 
         // set parent to either package module or outer class
         final RubyModule parent;
diff --git a/core/src/main/java/org/jruby/javasupport/binding/Initializer.java b/core/src/main/java/org/jruby/javasupport/binding/Initializer.java
@@ -5,6 +5,7 @@
 import org.jruby.RubyModule;
 import org.jruby.java.proxies.JavaProxy;
 import org.jruby.javasupport.JavaSupport;
+import org.jruby.runtime.ThreadContext;
 import org.jruby.util.log.Logger;
 import org.jruby.util.log.LoggerFactory;
 
@@ -32,44 +33,54 @@ public Initializer(Ruby runtime, Class javaClass) {
         this.javaClass = javaClass;
     }
 
+    @Deprecated(since = "10.0")
     public static RubyModule setupProxyClass(Ruby runtime, final Class<?> javaClass, RubyClass proxy) {
+        return setupProxyClass(runtime.getCurrentContext(), javaClass, proxy);
+    }
+
+    public static RubyModule setupProxyClass(ThreadContext context, final Class<?> javaClass, RubyClass proxy) {
         setJavaClassFor(javaClass, proxy);
 
         proxy.reifiedClass((Class) javaClass);
 
         if ( javaClass.isArray() ) {
-            flagAsJavaProxy(proxy); return proxy;
+            flagAsJavaProxy(context, proxy); return proxy;
         }
 
         if ( javaClass.isPrimitive() ) {
-            final RubyClass proxySingleton = proxy.getSingletonClass();
+            final RubyClass proxySingleton = proxy.singletonClass(context);
             proxySingleton.undefineMethod("new"); // remove ConcreteJavaProxy class method 'new'
             if ( javaClass == Void.TYPE ) {
                 // special treatment ... while Java::int[4] is OK Java::void[2] is NOT!
                 proxySingleton.undefineMethod("[]"); // from JavaProxy
                 proxySingleton.undefineMethod("new_array"); // from JavaProxy
             }
-            flagAsJavaProxy(proxy); return proxy;
+            flagAsJavaProxy(context, proxy); return proxy;
         }
 
-        proxy = new ClassInitializer(runtime, javaClass).initialize(proxy);
-        flagAsJavaProxy(proxy); return proxy;
+        proxy = new ClassInitializer(context.runtime, javaClass).initialize(proxy);
+        flagAsJavaProxy(context, proxy); return proxy;
     }
 
+    @Deprecated(since = "10.0")
     public static RubyModule setupProxyModule(Ruby runtime, final Class<?> javaClass, RubyModule proxy) {
+        return setupProxyModule(runtime.getCurrentContext(), javaClass, proxy);
+    }
+
+    public static RubyModule setupProxyModule(ThreadContext context, final Class<?> javaClass, RubyModule proxy) {
         setJavaClassFor(javaClass, proxy);
 
         assert javaClass.isInterface();
 
-        proxy = new InterfaceInitializer(runtime, javaClass).initialize(proxy);
-        flagAsJavaProxy(proxy);
+        proxy = new InterfaceInitializer(context.runtime, javaClass).initialize(proxy);
+        flagAsJavaProxy(context, proxy);
         return proxy;
     }
 
-    private static void flagAsJavaProxy(final RubyModule proxy) {
+    private static void flagAsJavaProxy(ThreadContext context, final RubyModule proxy) {
         // flag the class as a Java class proxy.
         proxy.setJavaProxy(true);
-        proxy.getSingletonClass().setJavaProxy(true);
+        proxy.singletonClass(context).setJavaProxy(true);
     }
 
     private static void setJavaClassFor(final Class<?> javaClass, final RubyModule proxy) {
diff --git a/core/src/main/java/org/jruby/javasupport/binding/InstanceFieldGetterInstaller.java b/core/src/main/java/org/jruby/javasupport/binding/InstanceFieldGetterInstaller.java
@@ -2,6 +2,7 @@
 
 import org.jruby.RubyModule;
 import org.jruby.java.invokers.InstanceFieldGetter;
+import org.jruby.runtime.ThreadContext;
 
 import java.lang.reflect.Field;
 
@@ -14,7 +15,7 @@ public InstanceFieldGetterInstaller(String name, Field field) {
         super(name, INSTANCE_FIELD, field);
     }
 
-    @Override void install(final RubyModule proxy) {
+    @Override void install(ThreadContext context, final RubyModule proxy) {
         if (isAccessible()) {
             proxy.addMethod(name, new InstanceFieldGetter(name, proxy, field));
         }
diff --git a/core/src/main/java/org/jruby/javasupport/binding/InstanceFieldSetterInstaller.java b/core/src/main/java/org/jruby/javasupport/binding/InstanceFieldSetterInstaller.java
@@ -2,6 +2,7 @@
 
 import org.jruby.RubyModule;
 import org.jruby.java.invokers.InstanceFieldSetter;
+import org.jruby.runtime.ThreadContext;
 
 import java.lang.reflect.Field;
 
@@ -14,7 +15,7 @@ public InstanceFieldSetterInstaller(String name, Field field) {
         super(name, INSTANCE_FIELD, field);
     }
 
-    @Override void install(final RubyModule proxy) {
+    @Override void install(ThreadContext context, final RubyModule proxy) {
         if (isAccessible()) {
             proxy.addMethod(name, new InstanceFieldSetter(name, proxy, field));
         }
diff --git a/core/src/main/java/org/jruby/javasupport/binding/InstanceMethodInvokerInstaller.java b/core/src/main/java/org/jruby/javasupport/binding/InstanceMethodInvokerInstaller.java
@@ -2,6 +2,7 @@
 
 import org.jruby.RubyModule;
 import org.jruby.java.invokers.InstanceMethodInvoker;
+import org.jruby.runtime.ThreadContext;
 
 import java.lang.reflect.Method;
 
@@ -12,7 +13,7 @@ public class InstanceMethodInvokerInstaller extends MethodInstaller {
 
     public InstanceMethodInvokerInstaller(String name) { super(name, INSTANCE_METHOD); }
 
-    @Override void install(final RubyModule proxy) {
+    @Override void install(ThreadContext context, final RubyModule proxy) {
         if ( hasLocalMethod() ) {
             defineMethods(proxy, new InstanceMethodInvoker(proxy, () -> methods.toArray(new Method[methods.size()]), name));
         }
diff --git a/core/src/main/java/org/jruby/javasupport/binding/MethodGatherer.java b/core/src/main/java/org/jruby/javasupport/binding/MethodGatherer.java
@@ -30,7 +30,9 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import static org.jruby.api.Create.newString;
 import static org.jruby.api.Error.typeError;
+import static org.jruby.api.Warn.warning;
 import static org.jruby.runtime.Visibility.PUBLIC;
 
 public class MethodGatherer {
@@ -359,8 +361,7 @@ protected Boolean computeValue(Class<?> type) {
     protected void installInnerClasses(final Class<?> javaClass, final RubyModule proxy) {
         // setup constants for public inner classes
         Class<?>[] classes = ClassUtils.getDeclaredClasses(javaClass);
-
-        final Ruby runtime = proxy.getRuntime();
+        var context = proxy.getRuntime().getCurrentContext();
 
         for ( int i = classes.length; --i >= 0; ) {
             final Class<?> clazz = classes[i];
@@ -378,21 +379,22 @@ protected void installInnerClasses(final Class<?> javaClass, final RubyModule pr
                  Typically this is used for singleton patterns where the field is an instance of the inner class, and
                  in languages like Kotlin the class itself is not what users intend to access. See GH-6196.
                  */
-                runtime.getWarnings().warning("inner class \"" + javaClass.getName() + "::" + simpleName + "\" conflicts with field of same name");
+                warning(context, "inner class \"" + javaClass.getName() + "::" + simpleName + "\" conflicts with field of same name");
                 continue;
             }
 
-            final RubyModule innerProxy = Java.getProxyClass(runtime, clazz);
+            final RubyModule innerProxy = Java.getProxyClass(context.runtime, clazz);
 
             if ( IdUtil.isConstant(simpleName) ) {
                 if (proxy.getConstantAt(simpleName) == null) {
-                    proxy.const_set(runtime.newString(simpleName), innerProxy);
+                    proxy.const_set(newString(context, simpleName), innerProxy);
                 }
             }
             else { // lower-case name
                 if ( ! proxy.respondsTo(simpleName) ) {
+                    var singleton = proxy.singletonClass(context);
                     // define a class method
-                    proxy.getSingletonClass().addMethod(simpleName, new JavaMethod.JavaMethodZero(proxy.getSingletonClass(), PUBLIC, simpleName) {
+                    singleton.addMethod(simpleName, new JavaMethod.JavaMethodZero(singleton, PUBLIC, simpleName) {
                         @Override
                         public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name) {
                             return innerProxy;
@@ -476,7 +478,8 @@ protected void installConstants(final RubyModule proxy) {
     }
 
     protected void installClassMethods(final RubyModule proxy) {
-        getStaticInstallers().forEach(($, value) -> value.install(proxy));
+        var context = proxy.getRuntime().getCurrentContext();
+        getStaticInstallers().forEach(($, value) -> value.install(context, proxy));
     }
 
     void installConstructors(Class<?> javaClass, final RubyModule proxy) {
@@ -690,7 +693,8 @@ protected static void addField(
     }
 
     void installInstanceMethods(final RubyModule proxy) {
-        getInstanceInstallers().forEach(($, value) -> value.install(proxy));
+        var context = proxy.getRuntime().getCurrentContext();
+        getInstanceInstallers().forEach(($, value) -> value.install(context, proxy));
     }
 
     private static class PartitionedMethods {
diff --git a/core/src/main/java/org/jruby/javasupport/binding/NamedInstaller.java b/core/src/main/java/org/jruby/javasupport/binding/NamedInstaller.java
diff --git a/core/src/main/java/org/jruby/javasupport/binding/SingletonMethodInvokerInstaller.java b/core/src/main/java/org/jruby/javasupport/binding/SingletonMethodInvokerInstaller.java
diff --git a/core/src/main/java/org/jruby/javasupport/binding/StaticFieldGetterInstaller.java b/core/src/main/java/org/jruby/javasupport/binding/StaticFieldGetterInstaller.java
diff --git a/core/src/main/java/org/jruby/javasupport/binding/StaticFieldSetterInstaller.java b/core/src/main/java/org/jruby/javasupport/binding/StaticFieldSetterInstaller.java
diff --git a/core/src/main/java/org/jruby/javasupport/binding/StaticMethodInvokerInstaller.java b/core/src/main/java/org/jruby/javasupport/binding/StaticMethodInvokerInstaller.java

Original file line number	Diff line number	Diff line change
`@@ -88,11 +88,6 @@ public boolean isImmediate() {`
`88`	`88`	`return true;`
`89`	`89`	`}`
`90`	`90`
`91`		`- @Override`
`92`		`- public RubyClass getSingletonClass() {`
`93`		`- return metaClass;`
`94`		`- }`
`95`		`-`
`96`	`91`	`public RubyClass singletonClass(ThreadContext context) {`
`97`	`92`	`return metaClass;`
`98`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -180,10 +180,6 @@ public boolean isImmediate() {`
`180`	`180`	`return true;`
`181`	`181`	`}`
`182`	`182`
`183`		`- public RubyClass getSingletonClass() {`
`184`		`- return singletonClass(getRuntime().getCurrentContext());`
`185`		`- }`
`186`		`-`
`187`	`183`	`public RubyClass singletonClass(ThreadContext context) {`
`188`	`184`	`throw typeError(context, "can't define singleton");`
`189`	`185`	`}`
Original file line number	Diff line number	Diff line change
`@@ -147,11 +147,6 @@ private RubyFloat(RubyClass klass, double value) {`
`147`	`147`	`this.flags \|= FROZEN_F;`
`148`	`148`	`}`
`149`	`149`
`150`		`- @Override`
`151`		`- public RubyClass getSingletonClass() {`
`152`		`- return singletonClass(getRuntime().getCurrentContext());`
`153`		`- }`
`154`		`-`
`155`	`150`	`public RubyClass singletonClass(ThreadContext context) {`
`156`	`151`	`throw typeError(context, "can't define singleton");`
`157`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -93,11 +93,6 @@ public boolean isImmediate() {`
`93`	`93`	`return true;`
`94`	`94`	`}`
`95`	`95`
`96`		`- @Override`
`97`		`- public RubyClass getSingletonClass() {`
`98`		`- return metaClass;`
`99`		`- }`
`100`		`-`
`101`	`96`	`public RubyClass singletonClass(ThreadContext context) {`
`102`	`97`	`return metaClass;`
`103`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -305,11 +305,6 @@ public boolean isImmediate() {`
`305`	`305`	`return true;`
`306`	`306`	`}`
`307`	`307`
`308`		`- @Override`
`309`		`- public RubyClass getSingletonClass() {`
`310`		`- return singletonClass(getRuntime().getCurrentContext());`
`311`		`- }`
`312`		`-`
`313`	`308`	`public RubyClass singletonClass(ThreadContext context) {`
`314`	`309`	`throw typeError(context, "can't define singleton");`
`315`	`310`	`}`