Remove use of RTYPEDDATA_P and rbimpl_rtypeddata_p

nobu · nobu · commit f42a105962ac · 2026-01-15T09:13:44.000+09:00
diff --git a/encoding.c b/encoding.c
@@ -126,7 +126,7 @@ static const rb_data_type_t encoding_data_type = {
 };
 
 #define is_encoding_type(obj) (RTYPEDDATA_TYPE(obj) == &encoding_data_type)
-#define is_data_encoding(obj) (rbimpl_rtypeddata_p(obj) && is_encoding_type(obj))
+#define is_data_encoding(obj) is_encoding_type(obj)
 #define is_obj_encoding(obj) (rbimpl_obj_typeddata_p(obj) && is_encoding_type(obj))
 
 int
diff --git a/error.c b/error.c
@@ -1355,8 +1355,7 @@ rb_check_type(VALUE x, int t)
         rb_bug(UNDEF_LEAKED);
     }
 
-    xt = TYPE(x);
-    if (xt != t || (xt == T_DATA && rbimpl_rtypeddata_p(x))) {
+    if (t == T_DATA) {
         /*
          * Typed data is not simple `T_DATA`, but in a sense an
          * extension of `struct RVALUE`, which are incompatible with
@@ -1365,6 +1364,10 @@ rb_check_type(VALUE x, int t)
          * So it is not enough to just check `T_DATA`, it must be
          * identified by its `type` using `Check_TypedStruct` instead.
          */
+        rb_unexpected_object_type(x, builtin_types[t]);
+    }
+    xt = TYPE(x);
+    if (xt != t) {
         unexpected_type(x, xt, t);
     }
 }
diff --git a/ext/objspace/objspace_dump.c b/ext/objspace/objspace_dump.c
@@ -573,11 +573,9 @@ dump_object(VALUE obj, struct dump_config *dc)
         break;
 
       case T_DATA:
-        if (RTYPEDDATA_P(obj)) {
-            dump_append(dc, ", \"struct\":\"");
-            dump_append(dc, RTYPEDDATA_TYPE(obj)->wrap_struct_name);
-            dump_append(dc, "\"");
-        }
+        dump_append(dc, ", \"struct\":\"");
+        dump_append(dc, RTYPEDDATA_TYPE(obj)->wrap_struct_name);
+        dump_append(dc, "\"");
         break;
 
       case T_FLOAT:
diff --git a/gc.c b/gc.c
@@ -1176,7 +1176,7 @@ rb_gc_handle_weak_references(VALUE obj)
 {
     switch (BUILTIN_TYPE(obj)) {
       case T_DATA:
-        if (RTYPEDDATA_P(obj)) {
+        {
             const rb_data_type_t *type = RTYPEDDATA_TYPE(obj);
 
             if (type->function.handle_weak_references) {
@@ -1189,9 +1189,6 @@ rb_gc_handle_weak_references(VALUE obj)
                 );
             }
         }
-        else {
-           rb_bug("rb_gc_handle_weak_references: unknown T_DATA");
-        }
         break;
 
       case T_IMEMO: {
diff --git a/include/ruby/internal/core/rtypeddata.h b/include/ruby/internal/core/rtypeddata.h
@@ -603,26 +603,7 @@ RBIMPL_ATTR_ARTIFICIAL()
 /**
  * @private
  *
- * This  is an  implementation detail  of  Check_Type().  People  don't use  it
- * directly.
- *
- * @param[in]  obj    Object in question
- * @retval     true
- * @pre        `obj` must be a Ruby object of ::RUBY_T_DATA.
- */
-static inline bool
-rbimpl_rtypeddata_p(VALUE obj)
-{
-    return true;
-}
-
-RBIMPL_ATTR_PURE()
-RBIMPL_ATTR_ARTIFICIAL()
-/**
- * @private
- *
- * Identical to rbimpl_rtypeddata_p(), except it is allowed to call on non-data
- * objects.
+ * Checks whether the passed object is ::RTypedData.
  *
  * This is an  implementation detail of inline functions defined  in this file.
  * People don't use it directly.
@@ -634,7 +615,7 @@ RBIMPL_ATTR_ARTIFICIAL()
 static inline bool
 rbimpl_obj_typeddata_p(VALUE obj)
 {
-    return RB_TYPE_P(obj, RUBY_T_DATA) && rbimpl_rtypeddata_p(obj);
+    return RB_TYPE_P(obj, RUBY_T_DATA);
 }
 
 RBIMPL_ATTR_PURE_UNLESS_DEBUG()
@@ -651,7 +632,7 @@ RTYPEDDATA_P(VALUE obj)
 {
     RBIMPL_TYPEDDATA_PRECONDITION(obj, RBIMPL_UNREACHABLE_RETURN(false));
 
-    return rbimpl_rtypeddata_p(obj);
+    return true;
 }
 
 RBIMPL_ATTR_PURE_UNLESS_DEBUG()
diff --git a/include/ruby/internal/value_type.h b/include/ruby/internal/value_type.h
@@ -410,14 +410,6 @@ RB_TYPE_P(VALUE obj, enum ruby_value_type t)
 #endif
 /** @endcond */
 
-RBIMPL_ATTR_PURE()
-RBIMPL_ATTR_ARTIFICIAL()
-/**
- * @private
- * Defined in ruby/internal/core/rtypeddata.h
- */
-static inline bool rbimpl_rtypeddata_p(VALUE obj);
-
 RBIMPL_ATTR_ARTIFICIAL()
 /**
  * Identical  to  RB_TYPE_P(),  except  it  raises  exceptions  on  predication
@@ -432,19 +424,11 @@ RBIMPL_ATTR_ARTIFICIAL()
 static inline void
 Check_Type(VALUE v, enum ruby_value_type t)
 {
+    /* Typed data is not simple `T_DATA`, see `rb_check_type` */
+    RUBY_ASSERT_ALWAYS(t != RUBY_T_DATA);
     if (RB_UNLIKELY(! RB_TYPE_P(v, t))) {
-        goto unexpected_type;
+        rb_unexpected_type(v, RBIMPL_CAST((int)t));
     }
-    else if (t == RUBY_T_DATA && rbimpl_rtypeddata_p(v)) {
-        /* Typed data is not simple `T_DATA`, see `rb_check_type` */
-        goto unexpected_type;
-    }
-    else {
-        return;
-    }
-
-  unexpected_type:
-    rb_unexpected_type(v, RBIMPL_CAST((int)t));
 }
 
 #endif /* RBIMPL_VALUE_TYPE_H */
diff --git a/include/ruby/random.h b/include/ruby/random.h
@@ -333,7 +333,6 @@ static inline const rb_random_interface_t *
 rb_rand_if(VALUE obj)
 {
     RBIMPL_ASSERT_OR_ASSUME(RB_TYPE_P(obj, T_DATA));
-    RBIMPL_ASSERT_OR_ASSUME(RTYPEDDATA_P(obj));
     RUBY_ASSERT(rb_typeddata_is_kind_of(obj, &rb_random_data_type));
     const struct rb_data_type_struct *t = RTYPEDDATA_TYPE(obj);
     const void *ret = t->data;
diff --git a/ractor.c b/ractor.c
@@ -1446,7 +1446,7 @@ allow_frozen_shareable_p(VALUE obj)
     if (!RB_TYPE_P(obj, T_DATA)) {
         return true;
     }
-    else if (RTYPEDDATA_P(obj)) {
+    else {
         const rb_data_type_t *type = RTYPEDDATA_TYPE(obj);
         if (type->flags & RUBY_TYPED_FROZEN_SHAREABLE) {
             return true;
diff --git a/shape.h b/shape.h
@@ -458,8 +458,7 @@ rb_obj_using_gen_fields_table_p(VALUE obj)
 {
     switch (BUILTIN_TYPE(obj)) {
       case T_DATA:
-        if (RTYPEDDATA_P(obj)) return false;
-        break;
+        return false;
 
       case T_STRUCT:
         if (!FL_TEST_RAW(obj, RSTRUCT_GEN_FIELDS)) return false;
diff --git a/spec/ruby/optional/capi/ext/typed_data_spec.c b/spec/ruby/optional/capi/ext/typed_data_spec.c
@@ -175,9 +175,11 @@ VALUE sws_typed_rb_check_typeddata_different_type(VALUE self, VALUE obj) {
   return rb_check_typeddata(obj, &sample_typed_wrapped_struct_other_data_type) == DATA_PTR(obj) ? Qtrue : Qfalse;
 }
 
+#ifndef RUBY_VERSION_IS_4_1
 VALUE sws_typed_RTYPEDDATA_P(VALUE self, VALUE obj) {
   return RTYPEDDATA_P(obj) ? Qtrue : Qfalse;
 }
+#endif
 
 void Init_typed_data_spec(void) {
   VALUE cls = rb_define_class("CApiAllocTypedSpecs", rb_cObject);
@@ -198,7 +200,9 @@ void Init_typed_data_spec(void) {
   rb_define_method(cls, "rb_check_typeddata_same_type", sws_typed_rb_check_typeddata_same_type, 1);
   rb_define_method(cls, "rb_check_typeddata_same_type_parent", sws_typed_rb_check_typeddata_same_type_parent, 1);
   rb_define_method(cls, "rb_check_typeddata_different_type", sws_typed_rb_check_typeddata_different_type, 1);
+#ifndef RUBY_VERSION_IS_4_1
   rb_define_method(cls, "RTYPEDDATA_P", sws_typed_RTYPEDDATA_P, 1);
+#endif
 }
 
 #ifdef __cplusplus
diff --git a/spec/ruby/optional/capi/typed_data_spec.rb b/spec/ruby/optional/capi/typed_data_spec.rb
@@ -86,13 +86,13 @@
     end
   end
 
-  describe "RTYPEDDATA_P" do
-    it "returns true for a typed data" do
-      a = @s.typed_wrap_struct(1024)
-      @s.RTYPEDDATA_P(a).should == true
-    end
+  ruby_version_is ""..."4.1" do
+    describe "RTYPEDDATA_P" do
+      it "returns true for a typed data" do
+        a = @s.typed_wrap_struct(1024)
+        @s.RTYPEDDATA_P(a).should == true
+      end
 
-    ruby_version_is ""..."4.1" do
       it "returns false for an untyped data object" do
         a = @s.untyped_wrap_struct(1024)
         @s.RTYPEDDATA_P(a).should == false
diff --git a/variable.c b/variable.c
@@ -1261,11 +1261,8 @@ rb_obj_fields(VALUE obj, ID field_name)
     if (rb_shape_obj_has_fields(obj)) {
         switch (BUILTIN_TYPE(obj)) {
           case T_DATA:
-            if (LIKELY(RTYPEDDATA_P(obj))) {
-                fields_obj = RTYPEDDATA(obj)->fields_obj;
-                break;
-            }
-            goto generic_fields;
+            fields_obj = RTYPEDDATA(obj)->fields_obj;
+            break;
           case T_STRUCT:
             if (LIKELY(!FL_TEST_RAW(obj, RSTRUCT_GEN_FIELDS))) {
                 fields_obj = RSTRUCT_FIELDS_OBJ(obj);
@@ -1298,11 +1295,8 @@ rb_free_generic_ivar(VALUE obj)
         st_data_t key = (st_data_t)obj, value;
         switch (BUILTIN_TYPE(obj)) {
           case T_DATA:
-            if (LIKELY(RTYPEDDATA_P(obj))) {
-                RB_OBJ_WRITE(obj, &RTYPEDDATA(obj)->fields_obj, 0);
-                break;
-            }
-            goto generic_fields;
+            RB_OBJ_WRITE(obj, &RTYPEDDATA(obj)->fields_obj, 0);
+            break;
           case T_STRUCT:
             if (LIKELY(!FL_TEST_RAW(obj, RSTRUCT_GEN_FIELDS))) {
                 RSTRUCT_SET_FIELDS_OBJ(obj, 0);
@@ -1348,11 +1342,8 @@ rb_obj_set_fields(VALUE obj, VALUE fields_obj, ID field_name, VALUE original_fie
     if (fields_obj != original_fields_obj) {
         switch (BUILTIN_TYPE(obj)) {
           case T_DATA:
-            if (LIKELY(RTYPEDDATA_P(obj))) {
-                RB_OBJ_WRITE(obj, &RTYPEDDATA(obj)->fields_obj, fields_obj);
-                break;
-            }
-            goto generic_fields;
+            RB_OBJ_WRITE(obj, &RTYPEDDATA(obj)->fields_obj, fields_obj);
+            break;
           case T_STRUCT:
             if (LIKELY(!FL_TEST_RAW(obj, RSTRUCT_GEN_FIELDS))) {
                 RSTRUCT_SET_FIELDS_OBJ(obj, fields_obj);

Original file line number	Diff line number	Diff line change
`@@ -1355,8 +1355,7 @@ rb_check_type(VALUE x, int t)`
`1355`	`1355`	`rb_bug(UNDEF_LEAKED);`
`1356`	`1356`	`}`
`1357`	`1357`
`1358`		`- xt = TYPE(x);`
`1359`		`- if (xt != t \|\| (xt == T_DATA && rbimpl_rtypeddata_p(x))) {`
	`1358`	`+ if (t == T_DATA) {`
`1360`	`1359`	`/*`
`1361`	`1360`	* Typed data is not simple `T_DATA`, but in a sense an
`1362`	`1361`	* extension of `struct RVALUE`, which are incompatible with
`@@ -1365,6 +1364,10 @@ rb_check_type(VALUE x, int t)`
`1365`	`1364`	* So it is not enough to just check `T_DATA`, it must be
`1366`	`1365`	* identified by its `type` using `Check_TypedStruct` instead.
`1367`	`1366`	`*/`
	`1367`	`+ rb_unexpected_object_type(x, builtin_types[t]);`
	`1368`	`+ }`
	`1369`	`+ xt = TYPE(x);`
	`1370`	`+ if (xt != t) {`
`1368`	`1371`	`unexpected_type(x, xt, t);`
`1369`	`1372`	`}`
`1370`	`1373`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1176,7 +1176,7 @@ rb_gc_handle_weak_references(VALUE obj)`
`1176`	`1176`	`{`
`1177`	`1177`	`switch (BUILTIN_TYPE(obj)) {`
`1178`	`1178`	`case T_DATA:`
`1179`		`- if (RTYPEDDATA_P(obj)) {`
	`1179`	`+ {`
`1180`	`1180`	`const rb_data_type_t *type = RTYPEDDATA_TYPE(obj);`
`1181`	`1181`
`1182`	`1182`	`if (type->function.handle_weak_references) {`
`@@ -1189,9 +1189,6 @@ rb_gc_handle_weak_references(VALUE obj)`
`1189`	`1189`	`);`
`1190`	`1190`	`}`
`1191`	`1191`	`}`
`1192`		`- else {`
`1193`		`- rb_bug("rb_gc_handle_weak_references: unknown T_DATA");`
`1194`		`- }`
`1195`	`1192`	`break;`
`1196`	`1193`
`1197`	`1194`	`case T_IMEMO: {`
Original file line number	Diff line number	Diff line change
`@@ -333,7 +333,6 @@ static inline const rb_random_interface_t *`
`333`	`333`	`rb_rand_if(VALUE obj)`
`334`	`334`	`{`
`335`	`335`	`RBIMPL_ASSERT_OR_ASSUME(RB_TYPE_P(obj, T_DATA));`
`336`		`- RBIMPL_ASSERT_OR_ASSUME(RTYPEDDATA_P(obj));`
`337`	`336`	`RUBY_ASSERT(rb_typeddata_is_kind_of(obj, &rb_random_data_type));`
`338`	`337`	`const struct rb_data_type_struct *t = RTYPEDDATA_TYPE(obj);`
`339`	`338`	`const void *ret = t->data;`
Original file line number	Diff line number	Diff line change
`@@ -1446,7 +1446,7 @@ allow_frozen_shareable_p(VALUE obj)`
`1446`	`1446`	`if (!RB_TYPE_P(obj, T_DATA)) {`
`1447`	`1447`	`return true;`
`1448`	`1448`	`}`
`1449`		`- else if (RTYPEDDATA_P(obj)) {`
	`1449`	`+ else {`
`1450`	`1450`	`const rb_data_type_t *type = RTYPEDDATA_TYPE(obj);`
`1451`	`1451`	`if (type->flags & RUBY_TYPED_FROZEN_SHAREABLE) {`
`1452`	`1452`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -458,8 +458,7 @@ rb_obj_using_gen_fields_table_p(VALUE obj)`
`458`	`458`	`{`
`459`	`459`	`switch (BUILTIN_TYPE(obj)) {`
`460`	`460`	`case T_DATA:`
`461`		`- if (RTYPEDDATA_P(obj)) return false;`
`462`		`- break;`
	`461`	`+ return false;`
`463`	`462`
`464`	`463`	`case T_STRUCT:`
`465`	`464`	`if (!FL_TEST_RAW(obj, RSTRUCT_GEN_FIELDS)) return false;`
Original file line number	Diff line number	Diff line change
`@@ -175,9 +175,11 @@ VALUE sws_typed_rb_check_typeddata_different_type(VALUE self, VALUE obj) {`
`175`	`175`	`return rb_check_typeddata(obj, &sample_typed_wrapped_struct_other_data_type) == DATA_PTR(obj) ? Qtrue : Qfalse;`
`176`	`176`	`}`
`177`	`177`
	`178`	`+#ifndef RUBY_VERSION_IS_4_1`
`178`	`179`	`VALUE sws_typed_RTYPEDDATA_P(VALUE self, VALUE obj) {`
`179`	`180`	`return RTYPEDDATA_P(obj) ? Qtrue : Qfalse;`
`180`	`181`	`}`
	`182`	`+#endif`
`181`	`183`
`182`	`184`	`void Init_typed_data_spec(void) {`
`183`	`185`	`VALUE cls = rb_define_class("CApiAllocTypedSpecs", rb_cObject);`
`@@ -198,7 +200,9 @@ void Init_typed_data_spec(void) {`
`198`	`200`	`rb_define_method(cls, "rb_check_typeddata_same_type", sws_typed_rb_check_typeddata_same_type, 1);`
`199`	`201`	`rb_define_method(cls, "rb_check_typeddata_same_type_parent", sws_typed_rb_check_typeddata_same_type_parent, 1);`
`200`	`202`	`rb_define_method(cls, "rb_check_typeddata_different_type", sws_typed_rb_check_typeddata_different_type, 1);`
	`203`	`+#ifndef RUBY_VERSION_IS_4_1`
`201`	`204`	`rb_define_method(cls, "RTYPEDDATA_P", sws_typed_RTYPEDDATA_P, 1);`
	`205`	`+#endif`
`202`	`206`	`}`
`203`	`207`
`204`	`208`	`#ifdef __cplusplus`