Rename RCLASS_EXT() macro to RCLASS_EXT_PRIME() to prevent using it wrongly

tagomoris · tagomoris · commit 90e5ce6132f8 · 2025-05-11T23:32:50.000+09:00
The macro RCLASS_EXT() accesses the prime classext directly, but it can be
valid only in a limited situation when namespace is enabled.
So, to prevent using RCLASS_EXT() in the wrong way, rename the macro and
let the developer check it is ok to access the prime classext or not.
diff --git a/class.c b/class.c
@@ -256,7 +256,7 @@ duplicate_classext_subclasses(rb_classext_t *orig, rb_classext_t *copy)
 static void
 class_duplicate_iclass_classext(VALUE iclass, rb_classext_t *mod_ext, const rb_namespace_t *ns)
 {
-    rb_classext_t *src = RCLASS_EXT(iclass);
+    rb_classext_t *src = RCLASS_EXT_PRIME(iclass);
     rb_classext_t *ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(iclass, ns);
     int first_set = 0;
 
@@ -416,7 +416,7 @@ rb_class_classext_foreach(VALUE klass, rb_class_classext_foreach_callback_func *
         foreach_arg.callback_arg = arg;
         rb_st_foreach(tbl, class_classext_foreach_i, (st_data_t)&foreach_arg);
     }
-    func(RCLASS_EXT(klass), true, (VALUE)NULL, arg);
+    func(RCLASS_EXT_PRIME(klass), true, (VALUE)NULL, arg);
 }
 
 VALUE
@@ -545,7 +545,7 @@ debug_dump_super_chain(rb_classext_t *ext, const rb_namespace_t *ns)
             if (ns) {
                 s = RCLASSEXT_SUPER(RCLASS_EXT_READABLE_IN_NS(s, ns));
             } else {
-                s = RCLASSEXT_SUPER(RCLASS_EXT(s));
+                s = RCLASSEXT_SUPER(RCLASS_EXT_PRIME(s));
             }
         } else {
             chaining = false;
@@ -835,9 +835,9 @@ rb_class_debug_dump_all_classext(VALUE klass)
     rb_str_cat_cstr(r, buf);
     rb_str_cat_cstr(r, "========================\n");
     rb_str_cat_cstr(r, "Namespace: ");
-    rb_str_concat(r, debug_dump_inspect_or_return_type(rb_get_namespace_object((rb_namespace_t *)RCLASSEXT_NS(RCLASS_EXT(klass)))));
+    rb_str_concat(r, debug_dump_inspect_or_return_type(rb_get_namespace_object((rb_namespace_t *)RCLASSEXT_NS(RCLASS_EXT_PRIME(klass)))));
     rb_str_cat_cstr(r, "\n");
-    rb_str_concat(r, debug_dump_classext(RCLASS_EXT(klass), klass, (rb_namespace_t *)NULL));
+    rb_str_concat(r, debug_dump_classext(RCLASS_EXT_PRIME(klass), klass, (rb_namespace_t *)NULL));
     rb_str_cat_cstr(r, "----\n");
     if (RCLASS(klass)->ns_classext_tbl) {
         rb_st_foreach(RCLASS(klass)->ns_classext_tbl, debug_dump_classext_i, (st_data_t)r);
@@ -1143,7 +1143,7 @@ class_alloc(VALUE flags, VALUE klass)
     if (RGENGC_WB_PROTECTED_CLASS) flags |= FL_WB_PROTECTED;
     NEWOBJ_OF(obj, struct RClass, klass, flags, alloc_size, 0);
 
-    memset(RCLASS_EXT(obj), 0, sizeof(rb_classext_t));
+    memset(RCLASS_EXT_PRIME(obj), 0, sizeof(rb_classext_t));
 
     /* ZALLOC
       RCLASS_CONST_TBL(obj) = 0;
diff --git a/gc.c b/gc.c
@@ -3749,7 +3749,7 @@ update_classext(rb_classext_t *ext, bool is_prime, VALUE namespace, void *arg)
     } else {
         // Classext is not copied in this case
         for (attr_index_t i = 0; i < RCLASS_FIELDS_COUNT(klass); i++) {
-            UPDATE_IF_MOVED(objspace, RCLASSEXT_FIELDS(RCLASS_EXT(klass))[i]);
+            UPDATE_IF_MOVED(objspace, RCLASSEXT_FIELDS(RCLASS_EXT_PRIME(klass))[i]);
         }
     }
 
diff --git a/internal/class.h b/internal/class.h
@@ -157,7 +157,7 @@ static inline bool RCLASS_PRIME_CLASSEXT_READABLE_P(VALUE obj);
 static inline bool RCLASS_PRIME_CLASSEXT_WRITABLE_P(VALUE obj);
 static inline void RCLASS_SET_PRIME_CLASSEXT_WRITABLE(VALUE obj, bool writable);
 
-#define RCLASS_EXT(c) (&((struct RClass_and_rb_classext_t*)(c))->classext)
+#define RCLASS_EXT_PRIME(c) (&((struct RClass_and_rb_classext_t*)(c))->classext)
 #define RCLASS_EXT_PRIME_P(ext, c) (&((struct RClass_and_rb_classext_t*)(c))->classext == ext)
 
 static inline rb_classext_t * RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns);
@@ -200,17 +200,17 @@ static inline void RCLASSEXT_SET_ORIGIN(rb_classext_t *ext, VALUE klass, VALUE o
 static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE includer);
 
 /* Prime classext entry accessor for very specific reason */
-#define RCLASS_PRIME_NS(c) (RCLASS_EXT(c)->ns)
+#define RCLASS_PRIME_NS(c) (RCLASS_EXT_PRIME(c)->ns)
 // To invalidate CC by inserting&invalidating method entry into tables containing the target cme
 // See clear_method_cache_by_id_in_class()
-#define RCLASS_PRIME_FIELDS(c) (RCLASS_EXT(c)->fields)
-#define RCLASS_PRIME_M_TBL(c) (RCLASS_EXT(c)->m_tbl)
-#define RCLASS_PRIME_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
-#define RCLASS_PRIME_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)
-#define RCLASS_PRIME_CC_TBL(c) (RCLASS_EXT(c)->cc_tbl)
-#define RCLASS_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT(c)->m_tbl != tbl)
-#define RCLASS_CALLABLE_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT(c)->callable_m_tbl != tbl)
-#define RCLASS_CC_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT(c)->cc_tbl != tbl)
+#define RCLASS_PRIME_FIELDS(c) (RCLASS_EXT_PRIME(c)->fields)
+#define RCLASS_PRIME_M_TBL(c) (RCLASS_EXT_PRIME(c)->m_tbl)
+#define RCLASS_PRIME_CONST_TBL(c) (RCLASS_EXT_PRIME(c)->const_tbl)
+#define RCLASS_PRIME_CALLABLE_M_TBL(c) (RCLASS_EXT_PRIME(c)->callable_m_tbl)
+#define RCLASS_PRIME_CC_TBL(c) (RCLASS_EXT_PRIME(c)->cc_tbl)
+#define RCLASS_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->m_tbl != tbl)
+#define RCLASS_CALLABLE_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->callable_m_tbl != tbl)
+#define RCLASS_CC_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->cc_tbl != tbl)
 
 // Read accessor, regarding namespaces
 #define RCLASS_SUPER(c) (RCLASS_EXT_READABLE(c)->super)
@@ -235,9 +235,9 @@ static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE
 #define RCLASS_CLASSPATH(c) (RCLASS_EXT_READABLE(c)->classpath)
 
 // namespaces don't make changes on these refined_class/attached_object/includer
-#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
-#define RCLASS_ATTACHED_OBJECT(c) (RCLASS_EXT(c)->as.singleton_class.attached_object)
-#define RCLASS_INCLUDER(c) (RCLASS_EXT(c)->includer)
+#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT_PRIME(c)->refined_class)
+#define RCLASS_ATTACHED_OBJECT(c) (RCLASS_EXT_PRIME(c)->as.singleton_class.attached_object)
+#define RCLASS_INCLUDER(c) (RCLASS_EXT_PRIME(c)->includer)
 
 // Writable classext entries (instead of RCLASS_SET_*) because member data will be operated directly
 #define RCLASS_WRITABLE_M_TBL(c) (RCLASS_EXT_WRITABLE(c)->m_tbl)
@@ -369,7 +369,7 @@ RCLASS_EXT_READABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)
     if (ext)
         return ext;
     // Classext for the ns not found. Refer the prime one instead.
-    return RCLASS_EXT(obj);
+    return RCLASS_EXT_PRIME(obj);
 }
 
 static inline rb_classext_t *
@@ -378,7 +378,7 @@ RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)
     if (!ns
         || NAMESPACE_BUILTIN_P(ns)
         || RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
-        return RCLASS_EXT(obj);
+        return RCLASS_EXT_PRIME(obj);
     }
     return RCLASS_EXT_READABLE_LOOKUP(obj, ns);
 }
@@ -388,12 +388,12 @@ RCLASS_EXT_READABLE(VALUE obj)
 {
     const rb_namespace_t *ns;
     if (RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
-        return RCLASS_EXT(obj);
+        return RCLASS_EXT_PRIME(obj);
     }
     // delay namespace loading to optimize for unmodified classes
     ns = rb_current_namespace();
     if (!ns || NAMESPACE_BUILTIN_P(ns)) {
-        return RCLASS_EXT(obj);
+        return RCLASS_EXT_PRIME(obj);
     }
     return RCLASS_EXT_READABLE_LOOKUP(obj, ns);
 }
@@ -417,7 +417,7 @@ RCLASS_EXT_WRITABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)
         // re-check the classext is not created to avoid the multi-thread race
         ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);
         if (!ext) {
-            ext = rb_class_duplicate_classext(RCLASS_EXT(obj), obj, ns);
+            ext = rb_class_duplicate_classext(RCLASS_EXT_PRIME(obj), obj, ns);
             first_set = RCLASS_SET_NAMESPACE_CLASSEXT(obj, ns, ext);
             if (first_set) {
                 RCLASS_SET_PRIME_CLASSEXT_WRITABLE(obj, false);
@@ -434,7 +434,7 @@ RCLASS_EXT_WRITABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)
     if (!ns
         || NAMESPACE_BUILTIN_P(ns)
         || RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj)) {
-        return RCLASS_EXT(obj);
+        return RCLASS_EXT_PRIME(obj);
     }
     return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);
 }
@@ -444,14 +444,14 @@ RCLASS_EXT_WRITABLE(VALUE obj)
 {
     const rb_namespace_t *ns;
     if (RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj)) {
-        return RCLASS_EXT(obj);
+        return RCLASS_EXT_PRIME(obj);
     }
     // delay namespace loading to optimize for unmodified classes
     ns = rb_current_namespace();
     if (!ns || NAMESPACE_BUILTIN_P(ns)) {
         // If no namespace is specified, Ruby VM is in bootstrap
         // and the clean class definition is under construction.
-        return RCLASS_EXT(obj);
+        return RCLASS_EXT_PRIME(obj);
     }
     return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);
 }
@@ -521,7 +521,7 @@ RCLASS_SINGLETON_P(VALUE klass)
 static inline void
 RCLASS_SET_SUPER(VALUE klass, VALUE super)
 {
-    RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT(klass)), super);
+    RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT_PRIME(klass)), super);
 }
 
 static inline void
@@ -551,7 +551,7 @@ RCLASS_SET_FIELDS_HASH(VALUE obj, const st_table *tbl)
 {
     RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
     RUBY_ASSERT(rb_shape_obj_too_complex_p(obj));
-    RCLASSEXT_FIELDS(RCLASS_EXT(obj)) = (VALUE *)tbl;
+    RCLASSEXT_FIELDS(RCLASS_EXT_PRIME(obj)) = (VALUE *)tbl;
 }
 
 static inline void
@@ -591,7 +591,7 @@ static inline void
 RCLASS_SET_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check_promoted)
 {
     RUBY_ASSERT(!check_promoted || !RB_OBJ_PROMOTED(klass));
-    RCLASSEXT_M_TBL(RCLASS_EXT(klass)) = table;
+    RCLASSEXT_M_TBL(RCLASS_EXT_PRIME(klass)) = table;
 }
 
 #define RCLASS_WRITE_M_TBL_EVEN_WHEN_PROMOTED(klass, table) RCLASS_WRITE_M_TBL_WORKAROUND(klass, table, false)
@@ -609,7 +609,7 @@ RCLASS_WRITE_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check
 static inline void
 RCLASS_SET_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared)
 {
-    rb_classext_t *ext = RCLASS_EXT(klass);
+    rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
     RCLASSEXT_CONST_TBL(ext) = table;
     if (shared)
         RCLASSEXT_SHARED_CONST_TBL(ext) = true;
@@ -639,7 +639,7 @@ RCLASS_WRITE_CC_TBL(VALUE klass, struct rb_id_table *table)
 static inline void
 RCLASS_SET_CVC_TBL(VALUE klass, struct rb_id_table *table)
 {
-    RCLASSEXT_CVC_TBL(RCLASS_EXT(klass)) = table;
+    RCLASSEXT_CVC_TBL(RCLASS_EXT_PRIME(klass)) = table;
 }
 
 static inline void
@@ -651,7 +651,7 @@ RCLASS_WRITE_CVC_TBL(VALUE klass, struct rb_id_table *table)
 static inline void
 RCLASS_SET_REFINED_CLASS(VALUE klass, VALUE refined)
 {
-    RB_OBJ_WRITE(klass, &RCLASSEXT_REFINED_CLASS(RCLASS_EXT(klass)), refined);
+    RB_OBJ_WRITE(klass, &RCLASSEXT_REFINED_CLASS(RCLASS_EXT_PRIME(klass)), refined);
 }
 
 static inline rb_alloc_func_t
@@ -660,20 +660,20 @@ RCLASS_ALLOCATOR(VALUE klass)
     if (RCLASS_SINGLETON_P(klass)) {
         return 0;
     }
-    return RCLASS_EXT(klass)->as.class.allocator;
+    return RCLASS_EXT_PRIME(klass)->as.class.allocator;
 }
 
 static inline void
 RCLASS_SET_ALLOCATOR(VALUE klass, rb_alloc_func_t allocator)
 {
     assert(!RCLASS_SINGLETON_P(klass));
-    RCLASS_EXT(klass)->as.class.allocator = allocator; // Allocator is set only on the initial definition
+    RCLASS_EXT_PRIME(klass)->as.class.allocator = allocator; // Allocator is set only on the initial definition
 }
 
 static inline void
 RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
 {
-    rb_classext_t *ext = RCLASS_EXT(klass);
+    rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
     RB_OBJ_WRITE(klass, &RCLASSEXT_ORIGIN(ext), origin);
     if (klass != origin) RCLASSEXT_ICLASS_IS_ORIGIN(RCLASS_EXT_WRITABLE(origin)) = true;
 }
@@ -689,7 +689,7 @@ RCLASS_WRITE_ORIGIN(VALUE klass, VALUE origin)
 static inline void
 RICLASS_SET_ORIGIN_SHARED_MTBL(VALUE iclass)
 {
-    RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(RCLASS_EXT(iclass)) = true;
+    RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(RCLASS_EXT_PRIME(iclass)) = true;
 }
 
 static inline void
@@ -724,7 +724,7 @@ RCLASS_WRITE_SUPERCLASSES(VALUE klass, size_t depth, VALUE *superclasses, bool o
 static inline void
 RCLASS_SET_SUBCLASSES(VALUE klass, struct rb_subclass_anchor *anchor)
 {
-    rb_classext_t *ext = RCLASS_EXT(klass);
+    rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
     RCLASSEXT_SUBCLASSES(ext) = anchor;
 }
 
@@ -773,14 +773,14 @@ RCLASS_SET_ATTACHED_OBJECT(VALUE klass, VALUE attached_object)
 {
     assert(RCLASS_SINGLETON_P(klass));
 
-    RB_OBJ_WRITE(klass, &RCLASS_EXT(klass)->as.singleton_class.attached_object, attached_object);
+    RB_OBJ_WRITE(klass, &RCLASS_EXT_PRIME(klass)->as.singleton_class.attached_object, attached_object);
     return attached_object;
 }
 
 static inline void
 RCLASS_SET_MAX_IV_COUNT(VALUE klass, attr_index_t count)
 {
-    RCLASSEXT_MAX_IV_COUNT(RCLASS_EXT(klass)) = count;
+    RCLASSEXT_MAX_IV_COUNT(RCLASS_EXT_PRIME(klass)) = count;
 }
 
 static inline void
@@ -792,7 +792,7 @@ RCLASS_WRITE_MAX_IV_COUNT(VALUE klass, attr_index_t count)
 static inline void
 RCLASS_SET_CLONED(VALUE klass, bool cloned)
 {
-    RCLASSEXT_CLONED(RCLASS_EXT(klass)) = cloned;
+    RCLASSEXT_CLONED(RCLASS_EXT_PRIME(klass)) = cloned;
 }
 
 #endif /* INTERNAL_CLASS_H */

Original file line number	Diff line number	Diff line change
`@@ -3749,7 +3749,7 @@ update_classext(rb_classext_t ext, bool is_prime, VALUE namespace, void arg)`
`3749`	`3749`	`} else {`
`3750`	`3750`	`// Classext is not copied in this case`
`3751`	`3751`	`for (attr_index_t i = 0; i < RCLASS_FIELDS_COUNT(klass); i++) {`
`3752`		`- UPDATE_IF_MOVED(objspace, RCLASSEXT_FIELDS(RCLASS_EXT(klass))[i]);`
	`3752`	`+ UPDATE_IF_MOVED(objspace, RCLASSEXT_FIELDS(RCLASS_EXT_PRIME(klass))[i]);`
`3753`	`3753`	`}`
`3754`	`3754`	`}`
`3755`	`3755`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ static inline bool RCLASS_PRIME_CLASSEXT_READABLE_P(VALUE obj);`
`157`	`157`	`static inline bool RCLASS_PRIME_CLASSEXT_WRITABLE_P(VALUE obj);`
`158`	`158`	`static inline void RCLASS_SET_PRIME_CLASSEXT_WRITABLE(VALUE obj, bool writable);`
`159`	`159`
`160`		`-#define RCLASS_EXT(c) (&((struct RClass_and_rb_classext_t*)(c))->classext)`
	`160`	`+#define RCLASS_EXT_PRIME(c) (&((struct RClass_and_rb_classext_t*)(c))->classext)`
`161`	`161`	`#define RCLASS_EXT_PRIME_P(ext, c) (&((struct RClass_and_rb_classext_t*)(c))->classext == ext)`
`162`	`162`
`163`	`163`	`static inline rb_classext_t * RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns);`
`@@ -200,17 +200,17 @@ static inline void RCLASSEXT_SET_ORIGIN(rb_classext_t *ext, VALUE klass, VALUE o`
`200`	`200`	`static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE includer);`
`201`	`201`
`202`	`202`	`/* Prime classext entry accessor for very specific reason */`
`203`		`-#define RCLASS_PRIME_NS(c) (RCLASS_EXT(c)->ns)`
	`203`	`+#define RCLASS_PRIME_NS(c) (RCLASS_EXT_PRIME(c)->ns)`
`204`	`204`	`// To invalidate CC by inserting&invalidating method entry into tables containing the target cme`
`205`	`205`	`// See clear_method_cache_by_id_in_class()`
`206`		`-#define RCLASS_PRIME_FIELDS(c) (RCLASS_EXT(c)->fields)`
`207`		`-#define RCLASS_PRIME_M_TBL(c) (RCLASS_EXT(c)->m_tbl)`
`208`		`-#define RCLASS_PRIME_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)`
`209`		`-#define RCLASS_PRIME_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)`
`210`		`-#define RCLASS_PRIME_CC_TBL(c) (RCLASS_EXT(c)->cc_tbl)`
`211`		`-#define RCLASS_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT(c)->m_tbl != tbl)`
`212`		`-#define RCLASS_CALLABLE_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT(c)->callable_m_tbl != tbl)`
`213`		`-#define RCLASS_CC_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT(c)->cc_tbl != tbl)`
	`206`	`+#define RCLASS_PRIME_FIELDS(c) (RCLASS_EXT_PRIME(c)->fields)`
	`207`	`+#define RCLASS_PRIME_M_TBL(c) (RCLASS_EXT_PRIME(c)->m_tbl)`
	`208`	`+#define RCLASS_PRIME_CONST_TBL(c) (RCLASS_EXT_PRIME(c)->const_tbl)`
	`209`	`+#define RCLASS_PRIME_CALLABLE_M_TBL(c) (RCLASS_EXT_PRIME(c)->callable_m_tbl)`
	`210`	`+#define RCLASS_PRIME_CC_TBL(c) (RCLASS_EXT_PRIME(c)->cc_tbl)`
	`211`	`+#define RCLASS_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->m_tbl != tbl)`
	`212`	`+#define RCLASS_CALLABLE_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->callable_m_tbl != tbl)`
	`213`	`+#define RCLASS_CC_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->cc_tbl != tbl)`
`214`	`214`
`215`	`215`	`// Read accessor, regarding namespaces`
`216`	`216`	`#define RCLASS_SUPER(c) (RCLASS_EXT_READABLE(c)->super)`
`@@ -235,9 +235,9 @@ static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE`
`235`	`235`	`#define RCLASS_CLASSPATH(c) (RCLASS_EXT_READABLE(c)->classpath)`
`236`	`236`
`237`	`237`	`// namespaces don't make changes on these refined_class/attached_object/includer`
`238`		`-#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)`
`239`		`-#define RCLASS_ATTACHED_OBJECT(c) (RCLASS_EXT(c)->as.singleton_class.attached_object)`
`240`		`-#define RCLASS_INCLUDER(c) (RCLASS_EXT(c)->includer)`
	`238`	`+#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT_PRIME(c)->refined_class)`
	`239`	`+#define RCLASS_ATTACHED_OBJECT(c) (RCLASS_EXT_PRIME(c)->as.singleton_class.attached_object)`
	`240`	`+#define RCLASS_INCLUDER(c) (RCLASS_EXT_PRIME(c)->includer)`
`241`	`241`
`242`	`242`	`// Writable classext entries (instead of RCLASS_SET_*) because member data will be operated directly`
`243`	`243`	`#define RCLASS_WRITABLE_M_TBL(c) (RCLASS_EXT_WRITABLE(c)->m_tbl)`
`@@ -369,7 +369,7 @@ RCLASS_EXT_READABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)`
`369`	`369`	`if (ext)`
`370`	`370`	`return ext;`
`371`	`371`	`// Classext for the ns not found. Refer the prime one instead.`
`372`		`- return RCLASS_EXT(obj);`
	`372`	`+ return RCLASS_EXT_PRIME(obj);`
`373`	`373`	`}`
`374`	`374`
`375`	`375`	`static inline rb_classext_t *`
`@@ -378,7 +378,7 @@ RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)`
`378`	`378`	`if (!ns`
`379`	`379`	`\|\| NAMESPACE_BUILTIN_P(ns)`
`380`	`380`	`\|\| RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {`
`381`		`- return RCLASS_EXT(obj);`
	`381`	`+ return RCLASS_EXT_PRIME(obj);`
`382`	`382`	`}`
`383`	`383`	`return RCLASS_EXT_READABLE_LOOKUP(obj, ns);`
`384`	`384`	`}`
`@@ -388,12 +388,12 @@ RCLASS_EXT_READABLE(VALUE obj)`
`388`	`388`	`{`
`389`	`389`	`const rb_namespace_t *ns;`
`390`	`390`	`if (RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {`
`391`		`- return RCLASS_EXT(obj);`
	`391`	`+ return RCLASS_EXT_PRIME(obj);`
`392`	`392`	`}`
`393`	`393`	`// delay namespace loading to optimize for unmodified classes`
`394`	`394`	`ns = rb_current_namespace();`
`395`	`395`	`if (!ns \|\| NAMESPACE_BUILTIN_P(ns)) {`
`396`		`- return RCLASS_EXT(obj);`
	`396`	`+ return RCLASS_EXT_PRIME(obj);`
`397`	`397`	`}`
`398`	`398`	`return RCLASS_EXT_READABLE_LOOKUP(obj, ns);`
`399`	`399`	`}`
`@@ -417,7 +417,7 @@ RCLASS_EXT_WRITABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)`
`417`	`417`	`// re-check the classext is not created to avoid the multi-thread race`
`418`	`418`	`ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);`
`419`	`419`	`if (!ext) {`
`420`		`- ext = rb_class_duplicate_classext(RCLASS_EXT(obj), obj, ns);`
	`420`	`+ ext = rb_class_duplicate_classext(RCLASS_EXT_PRIME(obj), obj, ns);`
`421`	`421`	`first_set = RCLASS_SET_NAMESPACE_CLASSEXT(obj, ns, ext);`
`422`	`422`	`if (first_set) {`
`423`	`423`	`RCLASS_SET_PRIME_CLASSEXT_WRITABLE(obj, false);`
`@@ -434,7 +434,7 @@ RCLASS_EXT_WRITABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)`
`434`	`434`	`if (!ns`
`435`	`435`	`\|\| NAMESPACE_BUILTIN_P(ns)`
`436`	`436`	`\|\| RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj)) {`
`437`		`- return RCLASS_EXT(obj);`
	`437`	`+ return RCLASS_EXT_PRIME(obj);`
`438`	`438`	`}`
`439`	`439`	`return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);`
`440`	`440`	`}`
`@@ -444,14 +444,14 @@ RCLASS_EXT_WRITABLE(VALUE obj)`
`444`	`444`	`{`
`445`	`445`	`const rb_namespace_t *ns;`
`446`	`446`	`if (RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj)) {`
`447`		`- return RCLASS_EXT(obj);`
	`447`	`+ return RCLASS_EXT_PRIME(obj);`
`448`	`448`	`}`
`449`	`449`	`// delay namespace loading to optimize for unmodified classes`
`450`	`450`	`ns = rb_current_namespace();`
`451`	`451`	`if (!ns \|\| NAMESPACE_BUILTIN_P(ns)) {`
`452`	`452`	`// If no namespace is specified, Ruby VM is in bootstrap`
`453`	`453`	`// and the clean class definition is under construction.`
`454`		`- return RCLASS_EXT(obj);`
	`454`	`+ return RCLASS_EXT_PRIME(obj);`
`455`	`455`	`}`
`456`	`456`	`return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);`
`457`	`457`	`}`
`@@ -521,7 +521,7 @@ RCLASS_SINGLETON_P(VALUE klass)`
`521`	`521`	`static inline void`
`522`	`522`	`RCLASS_SET_SUPER(VALUE klass, VALUE super)`
`523`	`523`	`{`
`524`		`- RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT(klass)), super);`
	`524`	`+ RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT_PRIME(klass)), super);`
`525`	`525`	`}`
`526`	`526`
`527`	`527`	`static inline void`
`@@ -551,7 +551,7 @@ RCLASS_SET_FIELDS_HASH(VALUE obj, const st_table *tbl)`
`551`	`551`	`{`
`552`	`552`	`RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) \|\| RB_TYPE_P(obj, RUBY_T_MODULE));`
`553`	`553`	`RUBY_ASSERT(rb_shape_obj_too_complex_p(obj));`
`554`		`- RCLASSEXT_FIELDS(RCLASS_EXT(obj)) = (VALUE *)tbl;`
	`554`	`+ RCLASSEXT_FIELDS(RCLASS_EXT_PRIME(obj)) = (VALUE *)tbl;`
`555`	`555`	`}`
`556`	`556`
`557`	`557`	`static inline void`
`@@ -591,7 +591,7 @@ static inline void`
`591`	`591`	`RCLASS_SET_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check_promoted)`
`592`	`592`	`{`
`593`	`593`	`RUBY_ASSERT(!check_promoted \|\| !RB_OBJ_PROMOTED(klass));`
`594`		`- RCLASSEXT_M_TBL(RCLASS_EXT(klass)) = table;`
	`594`	`+ RCLASSEXT_M_TBL(RCLASS_EXT_PRIME(klass)) = table;`
`595`	`595`	`}`
`596`	`596`
`597`	`597`	`#define RCLASS_WRITE_M_TBL_EVEN_WHEN_PROMOTED(klass, table) RCLASS_WRITE_M_TBL_WORKAROUND(klass, table, false)`
`@@ -609,7 +609,7 @@ RCLASS_WRITE_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check`
`609`	`609`	`static inline void`
`610`	`610`	`RCLASS_SET_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared)`
`611`	`611`	`{`
`612`		`- rb_classext_t *ext = RCLASS_EXT(klass);`
	`612`	`+ rb_classext_t *ext = RCLASS_EXT_PRIME(klass);`
`613`	`613`	`RCLASSEXT_CONST_TBL(ext) = table;`
`614`	`614`	`if (shared)`
`615`	`615`	`RCLASSEXT_SHARED_CONST_TBL(ext) = true;`
`@@ -639,7 +639,7 @@ RCLASS_WRITE_CC_TBL(VALUE klass, struct rb_id_table *table)`
`639`	`639`	`static inline void`
`640`	`640`	`RCLASS_SET_CVC_TBL(VALUE klass, struct rb_id_table *table)`
`641`	`641`	`{`
`642`		`- RCLASSEXT_CVC_TBL(RCLASS_EXT(klass)) = table;`
	`642`	`+ RCLASSEXT_CVC_TBL(RCLASS_EXT_PRIME(klass)) = table;`
`643`	`643`	`}`
`644`	`644`
`645`	`645`	`static inline void`
`@@ -651,7 +651,7 @@ RCLASS_WRITE_CVC_TBL(VALUE klass, struct rb_id_table *table)`
`651`	`651`	`static inline void`
`652`	`652`	`RCLASS_SET_REFINED_CLASS(VALUE klass, VALUE refined)`
`653`	`653`	`{`
`654`		`- RB_OBJ_WRITE(klass, &RCLASSEXT_REFINED_CLASS(RCLASS_EXT(klass)), refined);`
	`654`	`+ RB_OBJ_WRITE(klass, &RCLASSEXT_REFINED_CLASS(RCLASS_EXT_PRIME(klass)), refined);`
`655`	`655`	`}`
`656`	`656`
`657`	`657`	`static inline rb_alloc_func_t`
`@@ -660,20 +660,20 @@ RCLASS_ALLOCATOR(VALUE klass)`
`660`	`660`	`if (RCLASS_SINGLETON_P(klass)) {`
`661`	`661`	`return 0;`
`662`	`662`	`}`
`663`		`- return RCLASS_EXT(klass)->as.class.allocator;`
	`663`	`+ return RCLASS_EXT_PRIME(klass)->as.class.allocator;`
`664`	`664`	`}`
`665`	`665`
`666`	`666`	`static inline void`
`667`	`667`	`RCLASS_SET_ALLOCATOR(VALUE klass, rb_alloc_func_t allocator)`
`668`	`668`	`{`
`669`	`669`	`assert(!RCLASS_SINGLETON_P(klass));`
`670`		`- RCLASS_EXT(klass)->as.class.allocator = allocator; // Allocator is set only on the initial definition`
	`670`	`+ RCLASS_EXT_PRIME(klass)->as.class.allocator = allocator; // Allocator is set only on the initial definition`
`671`	`671`	`}`
`672`	`672`
`673`	`673`	`static inline void`
`674`	`674`	`RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)`
`675`	`675`	`{`
`676`		`- rb_classext_t *ext = RCLASS_EXT(klass);`
	`676`	`+ rb_classext_t *ext = RCLASS_EXT_PRIME(klass);`
`677`	`677`	`RB_OBJ_WRITE(klass, &RCLASSEXT_ORIGIN(ext), origin);`
`678`	`678`	`if (klass != origin) RCLASSEXT_ICLASS_IS_ORIGIN(RCLASS_EXT_WRITABLE(origin)) = true;`
`679`	`679`	`}`
`@@ -689,7 +689,7 @@ RCLASS_WRITE_ORIGIN(VALUE klass, VALUE origin)`
`689`	`689`	`static inline void`
`690`	`690`	`RICLASS_SET_ORIGIN_SHARED_MTBL(VALUE iclass)`
`691`	`691`	`{`
`692`		`- RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(RCLASS_EXT(iclass)) = true;`
	`692`	`+ RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(RCLASS_EXT_PRIME(iclass)) = true;`
`693`	`693`	`}`
`694`	`694`
`695`	`695`	`static inline void`
`@@ -724,7 +724,7 @@ RCLASS_WRITE_SUPERCLASSES(VALUE klass, size_t depth, VALUE *superclasses, bool o`
`724`	`724`	`static inline void`
`725`	`725`	`RCLASS_SET_SUBCLASSES(VALUE klass, struct rb_subclass_anchor *anchor)`
`726`	`726`	`{`
`727`		`- rb_classext_t *ext = RCLASS_EXT(klass);`
	`727`	`+ rb_classext_t *ext = RCLASS_EXT_PRIME(klass);`
`728`	`728`	`RCLASSEXT_SUBCLASSES(ext) = anchor;`
`729`	`729`	`}`
`730`	`730`
`@@ -773,14 +773,14 @@ RCLASS_SET_ATTACHED_OBJECT(VALUE klass, VALUE attached_object)`
`773`	`773`	`{`
`774`	`774`	`assert(RCLASS_SINGLETON_P(klass));`
`775`	`775`
`776`		`- RB_OBJ_WRITE(klass, &RCLASS_EXT(klass)->as.singleton_class.attached_object, attached_object);`
	`776`	`+ RB_OBJ_WRITE(klass, &RCLASS_EXT_PRIME(klass)->as.singleton_class.attached_object, attached_object);`
`777`	`777`	`return attached_object;`
`778`	`778`	`}`
`779`	`779`
`780`	`780`	`static inline void`
`781`	`781`	`RCLASS_SET_MAX_IV_COUNT(VALUE klass, attr_index_t count)`
`782`	`782`	`{`
`783`		`- RCLASSEXT_MAX_IV_COUNT(RCLASS_EXT(klass)) = count;`
	`783`	`+ RCLASSEXT_MAX_IV_COUNT(RCLASS_EXT_PRIME(klass)) = count;`
`784`	`784`	`}`
`785`	`785`
`786`	`786`	`static inline void`
`@@ -792,7 +792,7 @@ RCLASS_WRITE_MAX_IV_COUNT(VALUE klass, attr_index_t count)`
`792`	`792`	`static inline void`
`793`	`793`	`RCLASS_SET_CLONED(VALUE klass, bool cloned)`
`794`	`794`	`{`
`795`		`- RCLASSEXT_CLONED(RCLASS_EXT(klass)) = cloned;`
	`795`	`+ RCLASSEXT_CLONED(RCLASS_EXT_PRIME(klass)) = cloned;`
`796`	`796`	`}`
`797`	`797`
`798`	`798`	`#endif /* INTERNAL_CLASS_H */`