[GR-19220] Fix singleton class lookup bug when singleton class is replaced on the instance (#3088)

PullRequest: truffleruby/3860

Author: eregon

CHANGELOG.md

@@ -6,6 +6,7 @@ New features:
 Bug fixes:
 
 * Fix `Dir.glob` returning blank string entry with leading `**/` in glob and `base:` argument (@rwstauner).
+* Fix class lookup after an object's class has been replaced by `IO#reopen` (@itarato, @eregon).
 
 Compatibility:
 

spec/ruby/core/kernel/singleton_class_spec.rb

@@ -1,3 +1,4 @@
+# truffleruby_primitives: true
 require_relative '../../spec_helper'
 
 describe "Kernel#singleton_class" do
@@ -42,4 +43,32 @@
     obj.freeze
     obj.singleton_class.frozen?.should be_true
   end
+
+  context "for an IO object with a replaced singleton class" do
+    it "looks up singleton methods from the fresh singleton class after an object instance got a new one" do
+      proxy = -> (io) { io.foo }
+      if RUBY_ENGINE == 'truffleruby'
+        # We need an inline cache with only this object seen, the best way to do that is to use a Primitive
+        sclass = -> (io) { Primitive.singleton_class(io) }
+      else
+        sclass = -> (io) { io.singleton_class }
+      end
+
+      io = File.new(__FILE__)
+      io.define_singleton_method(:foo) { "old" }
+      sclass1 = sclass.call(io)
+      proxy.call(io).should == "old"
+
+      # IO#reopen is the only method which can replace an object's singleton class
+      io2 = File.new(__FILE__)
+      io.reopen(io2)
+      io.define_singleton_method(:foo) { "new" }
+      sclass2 = sclass.call(io)
+      sclass2.should_not.equal?(sclass1)
+      proxy.call(io).should == "new"
+    ensure
+      io2.close
+      io.close
+    end
+  end
 end

src/main/java/org/truffleruby/core/VMPrimitiveNodes.java

@@ -68,11 +68,11 @@
 import org.truffleruby.core.proc.ProcOperations;
 import org.truffleruby.core.proc.RubyProc;
 import org.truffleruby.core.string.RubyString;
+import org.truffleruby.core.support.RubyIO;
 import org.truffleruby.core.symbol.RubySymbol;
 import org.truffleruby.core.thread.RubyThread;
 import org.truffleruby.extra.ffi.Pointer;
 import org.truffleruby.interop.TranslateInteropExceptionNode;
-import org.truffleruby.language.RubyDynamicObject;
 import org.truffleruby.language.RubyGuards;
 import org.truffleruby.language.SafepointAction;
 import org.truffleruby.language.arguments.ArgumentsDescriptor;
@@ -423,9 +423,10 @@ protected Object getSection(Object section, RubyProc block,
     @Primitive(name = "vm_set_class")
     public abstract static class VMSetClassNode extends PrimitiveArrayArgumentsNode {
 
+        /** Only support it on IO for IO#reopen since this is the only case which needs it */
         @TruffleBoundary
         @Specialization
-        protected RubyDynamicObject setClass(RubyDynamicObject object, RubyClass newClass) {
+        protected RubyIO setClass(RubyIO object, RubyClass newClass) {
             SharedObjects.propagate(getLanguage(), object, newClass);
             synchronized (object) {
                 object.setMetaClass(newClass);

src/main/java/org/truffleruby/core/support/TypeNodes.java

@@ -49,6 +49,7 @@
 import org.truffleruby.language.objects.IsFrozenNode;
 import org.truffleruby.language.objects.LogicalClassNode;
 import org.truffleruby.language.objects.MetaClassNode;
+import org.truffleruby.language.objects.SingletonClassNode;
 import org.truffleruby.language.objects.WriteObjectFieldNode;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
@@ -103,6 +104,15 @@ protected RubyClass metaClass(Object object,
         }
     }
 
+    @Primitive(name = "singleton_class")
+    public abstract static class SingletonClassPrimitiveNode extends PrimitiveArrayArgumentsNode {
+        @Specialization
+        protected RubyClass singletonClass(Object object,
+                @Cached SingletonClassNode singletonClassNode) {
+            return singletonClassNode.executeSingletonClass(object);
+        }
+    }
+
     @Primitive(name = "equal?")
     public abstract static class EqualPrimitiveNode extends PrimitiveArrayArgumentsNode {
         @Specialization

src/main/java/org/truffleruby/language/RubyGuards.java

@@ -33,6 +33,7 @@
 import org.truffleruby.core.regexp.RubyRegexp;
 import org.truffleruby.core.string.ImmutableRubyString;
 import org.truffleruby.core.string.RubyString;
+import org.truffleruby.core.support.RubyIO;
 import org.truffleruby.core.symbol.RubySymbol;
 import org.truffleruby.interop.ToJavaStringNode;
 import org.truffleruby.language.arguments.ArgumentsDescriptor;
@@ -137,6 +138,11 @@ public static boolean isRubyModule(Object value) {
         return value instanceof RubyModule;
     }
 
+    @Idempotent
+    public static boolean isRubyIO(Object value) {
+        return value instanceof RubyIO;
+    }
+
     public static boolean isRubyRegexp(Object value) {
         return value instanceof RubyRegexp;
     }

src/main/java/org/truffleruby/language/objects/MetaClassNode.java

@@ -42,7 +42,11 @@ public final RubyClass executeCached(Object value) {
     public abstract RubyClass execute(Node node, Object value);
 
     @Specialization(
-            guards = { "isSingleContext()", "object == cachedObject", "metaClass.isSingleton" },
+            guards = {
+                    "isSingleContext()",
+                    "object == cachedObject",
+                    "metaClass.isSingleton",
+                    "!isRubyIO(cachedObject)" },
             limit = "1")
     protected static RubyClass singleton(Node node, RubyDynamicObject object,
             @Cached("object") RubyDynamicObject cachedObject,

src/main/java/org/truffleruby/language/objects/SingletonClassNode.java

@@ -60,7 +60,11 @@ protected RubyClass singletonClassClassUncached(RubyClass rubyClass) {
 
     @Specialization(
             // no need to guard on the context, the RubyDynamicObject is context-specific
-            guards = { "isSingleContext()", "object == cachedObject", "!isRubyClass(cachedObject)" },
+            guards = {
+                    "isSingleContext()",
+                    "object == cachedObject",
+                    "!isRubyClass(cachedObject)",
+                    "!isRubyIO(cachedObject)" },
             limit = "1")
     protected RubyClass singletonClassInstanceCached(RubyDynamicObject object,
             @Cached("object") RubyDynamicObject cachedObject,