Copy Data type's var table manager with new realClass

headius · headius · commit 04897a1f2901 · 2025-12-11T17:09:06.000-06:00
In order to allow Data types to specialize their fields completely,
we introduced a copy constructor for VariableTableManager that
duplicates the Data type's VTM into the new subclass. But because
that duplicate still used the same realClass, variable accessors
would frequently return to the original Data type's VTM rather than
use the duplicate.

This patch fixes the duplication process to also reset the
realClass to the new Data type subclass, keeping all future usages
and updates at the correct level. Without this, new instance
variables discovered on subtypes would add an accessor on the
subtype, but then proceed to allocate the variable table based on
the size of the table in the old VTM from the Data supertype.
diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
@@ -550,7 +550,7 @@ public static RubyClass newClass(ThreadContext context, RubyClass superClass, St
                 baseName(name);
         clazz.makeMetaClass(context, superClass.getMetaClass());
         if (setParent) clazz.setParent(parent);
-        clazz.copyVariableTableManager(context, superClass);
+        clazz.copyVariableTableManagerForData(context, superClass);
         parent.setConstant(context, name, clazz, file, line);
         superClass.invokeInherited(context, superClass, clazz);
         return clazz;
@@ -1073,7 +1073,7 @@ private RubyClass initializeCommon(ThreadContext context, RubyClass superClazz,
         allocator = superClazz.allocator;
         makeMetaClass(context, superClazz.getMetaClass());
         superClazz.addSubclass(this);
-        copyVariableTableManager(context, superClazz);
+        copyVariableTableManagerForData(context, superClazz);
 
         marshal = superClazz.marshal;
 
@@ -1083,11 +1083,11 @@ private RubyClass initializeCommon(ThreadContext context, RubyClass superClazz,
         return this;
     }
 
-    private void copyVariableTableManager(ThreadContext context, RubyClass superClazz) {
+    private void copyVariableTableManagerForData(ThreadContext context, RubyClass superClazz) {
         VariableTableManager variableTableManager = superClazz.getVariableTableManager();
         if (variableTableManager.getRealClass().superClass() == context.runtime.getData()) {
             // duplicate data's variable table in subclasses
-            this.variableTableManager = variableTableManager.duplicate();
+            this.variableTableManager = variableTableManager.duplicateForData(this);
         }
     }
 
diff --git a/core/src/main/java/org/jruby/runtime/ivars/VariableTableManager.java b/core/src/main/java/org/jruby/runtime/ivars/VariableTableManager.java
@@ -107,13 +107,14 @@ public VariableTableManager(RubyClass realClass) {
     }
 
     /**
-     * Copy constructor with deep cloning.
+     * Copy constructor with deep cloning for subclasses of Data types. The new realClass will be the
+     * subclass rather than the original Data type.
      *
      * @param original VariableTableManager to copy
      */
-    VariableTableManager(VariableTableManager original) {
+    VariableTableManager(VariableTableManager original, RubyClass realClass) {
         synchronized (original) {
-            this.realClass = original.realClass;
+            this.realClass = realClass;
             this.variableAccessors = copyVariableAccessors(original.variableAccessors);
             this.variableNames = original.variableNames.clone();
             this.hasObjectID = original.hasObjectID;
@@ -544,8 +545,8 @@ public Object clearVariable(RubyBasicObject object, String name) {
         }
     }
 
-    public VariableTableManager duplicate() {
-        return new VariableTableManager(this);
+    public VariableTableManager duplicateForData(RubyClass newRealClass) {
+        return new VariableTableManager(this, newRealClass);
     }
 
     /**

Original file line number	Diff line number	Diff line change
`@@ -107,13 +107,14 @@ public VariableTableManager(RubyClass realClass) {`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`/**`
`110`		`- * Copy constructor with deep cloning.`
	`110`	`+ * Copy constructor with deep cloning for subclasses of Data types. The new realClass will be the`
	`111`	`+ * subclass rather than the original Data type.`
`111`	`112`	`*`
`112`	`113`	`* @param original VariableTableManager to copy`
`113`	`114`	`*/`
`114`		`- VariableTableManager(VariableTableManager original) {`
	`115`	`+ VariableTableManager(VariableTableManager original, RubyClass realClass) {`
`115`	`116`	`synchronized (original) {`
`116`		`- this.realClass = original.realClass;`
	`117`	`+ this.realClass = realClass;`
`117`	`118`	`this.variableAccessors = copyVariableAccessors(original.variableAccessors);`
`118`	`119`	`this.variableNames = original.variableNames.clone();`
`119`	`120`	`this.hasObjectID = original.hasObjectID;`
`@@ -544,8 +545,8 @@ public Object clearVariable(RubyBasicObject object, String name) {`
`544`	`545`	`}`
`545`	`546`	`}`
`546`	`547`
`547`		`- public VariableTableManager duplicate() {`
`548`		`- return new VariableTableManager(this);`
	`548`	`+ public VariableTableManager duplicateForData(RubyClass newRealClass) {`
	`549`	`+ return new VariableTableManager(this, newRealClass);`
`549`	`550`	`}`
`550`	`551`
`551`	`552`	`/**`