Add Class#attached_object method

CHANGELOG.md

@@ -32,6 +32,7 @@ Compatibility:
 * Make `Coverage.start` and `Coverage.result` accept parameters (#3149, @mtortonesi, @andrykonchin).
 * Implement `rb_check_funcall()` (@eregon).
 * Implement `MatchData#{byteoffset,deconstruct,deconstruct_keys}` from Ruby 3.2 (#3039, @rwstauner).
+* Implement `Class#attached_object` method (#3039, @andrykonchin).
 
 Performance:
 

spec/ruby/core/class/attached_object_spec.rb

@@ -19,13 +19,13 @@
     it "raises TypeError if the class is not a singleton class" do
       a = Class.new
 
-      -> { a.attached_object }.should raise_error(TypeError)
+      -> { a.attached_object }.should raise_error(TypeError, /is not a singleton class/)
     end
 
     it "raises TypeError for special singleton classes" do
-      -> { nil.singleton_class.attached_object }.should raise_error(TypeError)
-      -> { true.singleton_class.attached_object }.should raise_error(TypeError)
-      -> { false.singleton_class.attached_object }.should raise_error(TypeError)
+      -> { nil.singleton_class.attached_object }.should raise_error(TypeError, /`NilClass' is not a singleton class/)
+      -> { true.singleton_class.attached_object }.should raise_error(TypeError, /`TrueClass' is not a singleton class/)
+      -> { false.singleton_class.attached_object }.should raise_error(TypeError, /`FalseClass' is not a singleton class/)
     end
   end
 end

src/main/java/org/truffleruby/core/exception/CoreExceptions.java

@@ -548,6 +548,12 @@ public RubyException typeErrorCantCreateInstanceOfSingletonClass(Node currentNod
         return typeError("can't create instance of singleton class", currentNode, null);
     }
 
+    @TruffleBoundary
+    public RubyException typeErrorNotASingletonClass(Node currentNode, RubyClass rubyClass) {
+        String className = rubyClass.fields.getName();
+        return typeError(StringUtils.format("`%s' is not a singleton class", className), currentNode, null);
+    }
+
     @TruffleBoundary
     public RubyException superclassMismatch(String name, Node currentNode) {
         return typeError("superclass mismatch for class " + name, currentNode);

src/main/java/org/truffleruby/core/klass/ClassNodes.java

@@ -276,6 +276,22 @@ RubyClass newSingletonInstance(RubyClass rubyClass) {
         }
     }
 
+    @CoreMethod(names = "attached_object")
+    public abstract static class AttachedObjectNode extends CoreMethodArrayArgumentsNode {
+
+        @Specialization(guards = "rubyClass.isSingleton")
+        Object attachedObject(RubyClass rubyClass) {
+            return rubyClass.attached;
+        }
+
+        @Specialization(guards = "!rubyClass.isSingleton")
+        Object attachedObjectOfNonSingletonClass(RubyClass rubyClass) {
+            throw new RaiseException(
+                    getContext(),
+                    getContext().getCoreExceptions().typeErrorNotASingletonClass(this, rubyClass));
+        }
+    }
+
     // Worth always splitting to have monomorphic #__allocate__ and #initialize,
     // Worth always inlining as the field accesses and initializations are optimized when the allocation is visible,
     // and a non-inlined call to #__allocate__ would allocate the arguments Object[] which is about the same number of

src/main/java/org/truffleruby/core/klass/RubyClass.java

@@ -37,6 +37,7 @@ public final class RubyClass extends RubyModule implements ObjectGraphNode {
     public final boolean isSingleton;
     /** If this is an object's metaclass, then nonSingletonClass is the logical class of the object. */
     public final RubyClass nonSingletonClass;
+    /** Ruby object which this class is a metaclass/singleton class of */
     public final RubyDynamicObject attached;
     /* a RubyClass or nil for BasicObject */
     public final Object superclass;
@@ -57,6 +58,7 @@ public RubyClass(
             Object superclass) {
         super(classClass, language.classShape, language, sourceSection, lexicalParent, givenBaseName);
         assert !isSingleton || givenBaseName == null;
+        assert isSingleton == (attached != null);
         this.isSingleton = isSingleton;
         this.attached = attached;
         this.nonSingletonClass = computeNonSingletonClass(isSingleton, superclass);
@@ -83,7 +85,6 @@ public RubyClass(
         fields.afterConstructed();
     }
 
-
     /** Special constructor to build the 'Class' RubyClass itself. */
     RubyClass(RubyLanguage language, Shape classShape) {
         super(language, classShape, "constructor only for the class Class");

test/mri/excludes/TestClass.rb

@@ -15,4 +15,3 @@
 exclude :test_subclass_gc, "NoMethodError: undefined method `subclasses' for #<Class:0x25fd48>"
 exclude :test_subclass_gc_stress, "NoMethodError: undefined method `subclasses' for #<Class:0x11c93f8>"
 exclude :test_subclasses, "NoMethodError: undefined method `subclasses' for #<Class:0x11c9b48>"
-exclude :test_attached_object, "NoMethodError: undefined method `attached_object' for #<Class:#<#<Class:0x197b18>:0x197b28>>"