class.c: merge conditional methods into ROM tables

Move conditional mrb_define_method_id() calls into ROM entry
arrays using #ifdef guards. With linear search, sizeof in
MRB_MT_ROM_TAB() adjusts automatically after preprocessing.

Cross-class ROM tables (methods a gem defines on a class it does
not own) are reverted to mrb_define_method_id(). Multiple gems
should not add ROM table layers to the same class; each layer
costs a 16-byte mrb_mt_tbl struct in RAM and deepens the lookup
chain. Use mrb_define_method_id() for cross-class methods.

Co-authored-by: Claude <noreply@anthropic.com>

doc/guides/rom-method-table.md

@@ -210,10 +210,23 @@ static const mrb_mt_entry str_rom_entries[] = {
 ## Conditional Methods
 
 Methods that depend on build configuration (e.g., `MRB_NO_FLOAT`) can
-be handled in two ways:
+use `#ifdef` directly inside the ROM entries array. The `sizeof` in
+`MRB_MT_ROM_TAB()` automatically adjusts to the number of entries
+that survive preprocessing:
 
-**Option A: Separate ROM table under `#ifdef`** (preferred for large
-blocks):
+```c
+static const mrb_mt_entry integer_rom_entries[] = {
+  MRB_MT_ENTRY(int_to_s, MRB_SYM(to_s), 0),
+  MRB_MT_ENTRY(int_add,  MRB_OPSYM(add), 0),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(int_to_f, MRB_SYM(to_f), MRB_MT_NOARG),
+#endif
+};
+static mrb_mt_tbl integer_rom_mt = MRB_MT_ROM_TAB(integer_rom_entries);
+```
+
+For conditional methods on a **different class**, use a separate ROM
+table wrapped in the `#ifdef`:
 
 ```c
 #ifndef MRB_NO_FLOAT
@@ -229,22 +242,6 @@ void mrb_init_numeric(mrb_state *mrb) {
 }
 ```
 
-**Option B: Keep as `mrb_define_method_id()`** (preferred for a few
-conditional methods):
-
-```c
-void mrb_init_numeric(mrb_state *mrb) {
-  mrb_mt_init_rom(integer, &integer_rom_mt);
-#ifndef MRB_NO_FLOAT
-  mrb_define_method_id(mrb, integer, MRB_SYM(to_f), int_to_f, MRB_ARGS_NONE());
-#endif
-}
-```
-
-Both approaches work correctly. The ROM layer and the
-`mrb_define_method_id()` calls coexist: method lookup walks the
-mutable layer first, then the ROM chain.
-
 ## Extension Gems
 
 Extension gems use exactly the same pattern. Since gems are
@@ -295,6 +292,11 @@ Some methods must remain as `mrb_define_method_id()` calls:
 - **Methods on dynamically created classes**: Classes created at
   init time (not stored in `mrb->xxx_class`) that require
   `mrb_define_class()` to obtain the class pointer.
+- **Cross-class methods** (methods on a class the gem does not own):
+  Each ROM table adds a 16-byte `mrb_mt_tbl` layer to the target
+  class's chain. For 1-2 methods, this overhead exceeds the savings.
+  Use `mrb_define_method_id()` instead — cross-class methods share
+  the target class's existing mutable layer.
 
 These methods are added after `mrb_mt_init_rom()` and go into the
 mutable layer that sits in front of the ROM chain.

mrbgems/mruby-complex/src/complex.c

@@ -575,16 +575,6 @@ static const mrb_mt_entry complex_rom_entries[] = {
 };
 static mrb_mt_tbl complex_rom_mt = MRB_MT_ROM_TAB(complex_rom_entries);
 
-static const mrb_mt_entry nil_to_c_rom_entries[] = {
-  MRB_MT_ENTRY(nil_to_c, MRB_SYM(to_c), MRB_MT_NOARG),
-};
-static mrb_mt_tbl nil_to_c_rom_mt = MRB_MT_ROM_TAB(nil_to_c_rom_entries);
-
-static const mrb_mt_entry kernel_complex_rom_entries[] = {
-  MRB_MT_ENTRY(complex_s_rect, MRB_SYM(Complex), MRB_MT_PRIVATE),
-};
-static mrb_mt_tbl kernel_complex_rom_mt = MRB_MT_ROM_TAB(kernel_complex_rom_entries);
-
 void mrb_mruby_complex_gem_init(mrb_state *mrb)
 {
   struct RClass *comp;
@@ -598,8 +588,8 @@ void mrb_mruby_complex_gem_init(mrb_state *mrb)
   mrb_define_class_method_id(mrb, comp, MRB_SYM(rect), complex_s_rect, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 
   mrb_mt_init_rom(comp, &complex_rom_mt);
-  mrb_mt_init_rom(mrb->nil_class, &nil_to_c_rom_mt);
-  mrb_mt_init_rom(mrb->kernel_module, &kernel_complex_rom_mt);
+  mrb_define_method_id(mrb, mrb->nil_class, MRB_SYM(to_c), nil_to_c, MRB_ARGS_NONE());
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(Complex), complex_s_rect, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 }
 
 void

mrbgems/mruby-kernel-ext/src/kernel.c

@@ -296,6 +296,10 @@ static const mrb_mt_entry kernel_ext_rom_entries[] = {
   MRB_MT_ENTRY(mrb_f_integer, MRB_SYM(Integer),    MRB_MT_PRIVATE),
   MRB_MT_ENTRY(mrb_f_string,  MRB_SYM(String),     MRB_MT_PRIVATE),
   MRB_MT_ENTRY(mrb_f_array,   MRB_SYM(Array),      MRB_MT_PRIVATE),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(mrb_f_float,   MRB_SYM(Float),      MRB_MT_PRIVATE),
+#endif
+  MRB_MT_ENTRY(mrb_f_hash,    MRB_SYM(Hash),       MRB_MT_PRIVATE),
 };
 static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
 
@@ -304,11 +308,6 @@ mrb_mruby_kernel_ext_gem_init(mrb_state *mrb)
 {
   struct RClass *krn = mrb->kernel_module;
 
-#ifndef MRB_NO_FLOAT
-  mrb_define_private_method_id(mrb, krn, MRB_SYM(Float), mrb_f_float, MRB_ARGS_REQ(1));
-#endif
-  /* Hash stays as runtime (depends on mrb_ensure_hash_type availability) */
-  mrb_define_private_method_id(mrb, krn, MRB_SYM(Hash), mrb_f_hash, MRB_ARGS_REQ(1));
   mrb_mt_init_rom(krn, &kernel_ext_rom_mt);
 }
 

mrbgems/mruby-method/src/method.c

@@ -866,17 +866,6 @@ static const mrb_mt_entry method_mtd_rom_entries[] = {
 };
 static mrb_mt_tbl method_mtd_rom_mt = MRB_MT_ROM_TAB(method_mtd_rom_entries);
 
-static const mrb_mt_entry method_krn_rom_entries[] = {
-  MRB_MT_ENTRY(mrb_kernel_method,           MRB_SYM(method),           0),
-  MRB_MT_ENTRY(mrb_kernel_singleton_method, MRB_SYM(singleton_method), 0),
-};
-static mrb_mt_tbl method_krn_rom_mt = MRB_MT_ROM_TAB(method_krn_rom_entries);
-
-static const mrb_mt_entry method_mod_rom_entries[] = {
-  MRB_MT_ENTRY(mrb_module_instance_method, MRB_SYM(instance_method), 0),
-};
-static mrb_mt_tbl method_mod_rom_mt = MRB_MT_ROM_TAB(method_mod_rom_entries);
-
 void
 mrb_mruby_method_gem_init(mrb_state* mrb)
 {
@@ -892,8 +881,9 @@ mrb_mruby_method_gem_init(mrb_state* mrb)
   MRB_UNDEF_ALLOCATOR(method);
   mrb_undef_class_method_id(mrb, method, MRB_SYM(new));
   mrb_mt_init_rom(method, &method_mtd_rom_mt);
-  mrb_mt_init_rom(mrb->kernel_module, &method_krn_rom_mt);
-  mrb_mt_init_rom(mrb->module_class, &method_mod_rom_mt);
+  mrb_define_method_id(mrb, mrb->kernel_module, MRB_SYM(method), mrb_kernel_method, MRB_ARGS_REQ(1));
+  mrb_define_method_id(mrb, mrb->kernel_module, MRB_SYM(singleton_method), mrb_kernel_singleton_method, MRB_ARGS_REQ(1));
+  mrb_define_method_id(mrb, mrb->module_class, MRB_SYM(instance_method), mrb_module_instance_method, MRB_ARGS_REQ(1));
 }
 
 void

mrbgems/mruby-numeric-ext/src/numeric_ext.c

@@ -493,6 +493,7 @@ static const mrb_mt_entry integer_ext_rom_entries[] = {
 };
 static mrb_mt_tbl integer_ext_rom_mt = MRB_MT_ROM_TAB(integer_ext_rom_entries);
 
+
 void
 mrb_mruby_numeric_ext_gem_init(mrb_state* mrb)
 {

mrbgems/mruby-object-ext/src/object.c

@@ -101,14 +101,12 @@ static const mrb_mt_entry nil_ext_rom_entries[] = {
   MRB_MT_ENTRY(nil_to_a, MRB_SYM(to_a), MRB_MT_NOARG),
   MRB_MT_ENTRY(nil_to_h, MRB_SYM(to_h), MRB_MT_NOARG),
   MRB_MT_ENTRY(nil_to_i, MRB_SYM(to_i), MRB_MT_NOARG),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(nil_to_f, MRB_SYM(to_f), MRB_MT_NOARG),
+#endif
 };
 static mrb_mt_tbl nil_ext_rom_mt = MRB_MT_ROM_TAB(nil_ext_rom_entries);
 
-static const mrb_mt_entry kernel_ext_rom_entries[] = {
-  MRB_MT_ENTRY(mrb_obj_itself, MRB_SYM(itself), MRB_MT_NOARG),
-};
-static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
-
 static const mrb_mt_entry bob_ext_rom_entries[] = {
   MRB_MT_ENTRY(obj_instance_exec, MRB_SYM(instance_exec), 0),
 };
@@ -120,11 +118,8 @@ mrb_mruby_object_ext_gem_init(mrb_state* mrb)
   struct RClass * n = mrb->nil_class;
 
   mrb_mt_init_rom(n, &nil_ext_rom_mt);
-#ifndef MRB_NO_FLOAT
-  mrb_define_method_id(mrb, n, MRB_SYM(to_f), nil_to_f,       MRB_ARGS_NONE());
-#endif
 
-  mrb_mt_init_rom(mrb->kernel_module, &kernel_ext_rom_mt);
+  mrb_define_method_id(mrb, mrb->kernel_module, MRB_SYM(itself), mrb_obj_itself, MRB_ARGS_NONE());
 
   mrb_mt_init_rom(mrb_class_get_id(mrb, MRB_SYM(BasicObject)), &bob_ext_rom_mt);
 }

mrbgems/mruby-proc-ext/src/proc.c

@@ -253,18 +253,13 @@ static const mrb_mt_entry proc_ext_rom_entries[] = {
 };
 static mrb_mt_tbl proc_ext_rom_mt = MRB_MT_ROM_TAB(proc_ext_rom_entries);
 
-static const mrb_mt_entry kernel_ext_rom_entries[] = {
-  MRB_MT_ENTRY(kernel_proc, MRB_SYM(proc), MRB_MT_PRIVATE),
-};
-static mrb_mt_tbl kernel_ext_rom_mt = MRB_MT_ROM_TAB(kernel_ext_rom_entries);
-
 void
 mrb_mruby_proc_ext_gem_init(mrb_state* mrb)
 {
   struct RClass *p = mrb->proc_class;
 
   mrb_mt_init_rom(p, &proc_ext_rom_mt);
-  mrb_mt_init_rom(mrb->kernel_module, &kernel_ext_rom_mt);
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(proc), kernel_proc, MRB_ARGS_BLOCK());
 }
 
 void

mrbgems/mruby-random/src/random.c

@@ -568,12 +568,6 @@ random_f_bytes(mrb_state *mrb, mrb_value self)
 }
 
 
-static const mrb_mt_entry kernel_rand_rom_entries[] = {
-  MRB_MT_ENTRY(random_f_rand,  MRB_SYM(rand),  MRB_MT_PRIVATE),
-  MRB_MT_ENTRY(random_f_srand, MRB_SYM(srand), MRB_MT_PRIVATE),
-};
-static mrb_mt_tbl kernel_rand_rom_mt = MRB_MT_ROM_TAB(kernel_rand_rom_entries);
-
 static const mrb_mt_entry random_rom_entries[] = {
   MRB_MT_ENTRY(random_m_init,  MRB_SYM(initialize), 0),
   MRB_MT_ENTRY(random_m_rand,  MRB_SYM(rand),       0),
@@ -582,13 +576,6 @@ static const mrb_mt_entry random_rom_entries[] = {
 };
 static mrb_mt_tbl random_rom_mt = MRB_MT_ROM_TAB(random_rom_entries);
 
-static const mrb_mt_entry array_rand_rom_entries[] = {
-  MRB_MT_ENTRY(mrb_ary_shuffle,      MRB_SYM(shuffle),    0),
-  MRB_MT_ENTRY(mrb_ary_shuffle_bang, MRB_SYM_B(shuffle),  0),
-  MRB_MT_ENTRY(mrb_ary_sample,      MRB_SYM(sample),     0),
-};
-static mrb_mt_tbl array_rand_rom_mt = MRB_MT_ROM_TAB(array_rand_rom_entries);
-
 void mrb_mruby_random_gem_init(mrb_state *mrb)
 {
   struct RClass *array = mrb->array_class;
@@ -602,9 +589,12 @@ void mrb_mruby_random_gem_init(mrb_state *mrb)
   mrb_define_class_method_id(mrb, random, MRB_SYM(srand), random_f_srand, MRB_ARGS_OPT(1));
   mrb_define_class_method_id(mrb, random, MRB_SYM(bytes), random_f_bytes, MRB_ARGS_REQ(1));
 
-  mrb_mt_init_rom(mrb->kernel_module, &kernel_rand_rom_mt);
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(rand), random_f_rand, MRB_ARGS_OPT(1));
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(srand), random_f_srand, MRB_ARGS_OPT(1));
   mrb_mt_init_rom(random, &random_rom_mt);
-  mrb_mt_init_rom(array, &array_rand_rom_mt);
+  mrb_define_method_id(mrb, array, MRB_SYM(shuffle), mrb_ary_shuffle, MRB_ARGS_OPT(1));
+  mrb_define_method_id(mrb, array, MRB_SYM_B(shuffle), mrb_ary_shuffle_bang, MRB_ARGS_OPT(1));
+  mrb_define_method_id(mrb, array, MRB_SYM(sample), mrb_ary_sample, MRB_ARGS_OPT(2));
 
   mrb_value d = mrb_obj_new(mrb, random, 0, NULL);
   rand_state *t = random_ptr(d);

mrbgems/mruby-rational/src/rational.c

@@ -1243,38 +1243,25 @@ static const mrb_mt_entry rational_rom_entries[] = {
   MRB_MT_ENTRY(rational_div,         MRB_SYM(quo),         0),
   MRB_MT_ENTRY(rational_pow,         MRB_OPSYM(pow),       0),
   MRB_MT_ENTRY(rational_hash,        MRB_SYM(hash),        MRB_MT_NOARG),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(mrb_rational_to_f,   MRB_SYM(to_f),        MRB_MT_NOARG),
+#endif
 };
 static mrb_mt_tbl rational_rom_mt = MRB_MT_ROM_TAB(rational_rom_entries);
 
-static const mrb_mt_entry integer_to_r_rom_entries[] = {
-  MRB_MT_ENTRY(int_to_r, MRB_SYM(to_r), MRB_MT_NOARG),
-};
-static mrb_mt_tbl integer_to_r_rom_mt = MRB_MT_ROM_TAB(integer_to_r_rom_entries);
-
-static const mrb_mt_entry nil_to_r_rom_entries[] = {
-  MRB_MT_ENTRY(nil_to_r, MRB_SYM(to_r), MRB_MT_NOARG),
-};
-static mrb_mt_tbl nil_to_r_rom_mt = MRB_MT_ROM_TAB(nil_to_r_rom_entries);
-
-static const mrb_mt_entry kernel_rational_rom_entries[] = {
-  MRB_MT_ENTRY(rational_m, MRB_SYM(Rational), MRB_MT_PRIVATE),
-};
-static mrb_mt_tbl kernel_rational_rom_mt = MRB_MT_ROM_TAB(kernel_rational_rom_entries);
-
 void mrb_mruby_rational_gem_init(mrb_state *mrb)
 {
   struct RClass *rat = mrb_define_class_id(mrb, MRB_SYM(Rational), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
   MRB_SET_INSTANCE_TT(rat, MRB_TT_RATIONAL);
   MRB_UNDEF_ALLOCATOR(rat);
   mrb_undef_class_method_id(mrb, rat, MRB_SYM(new));
+  mrb_mt_init_rom(rat, &rational_rom_mt);
+  mrb_define_method_id(mrb, mrb->integer_class, MRB_SYM(to_r), int_to_r, MRB_ARGS_NONE());
+  mrb_define_method_id(mrb, mrb->nil_class, MRB_SYM(to_r), nil_to_r, MRB_ARGS_NONE());
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(Rational), rational_m, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
 #ifndef MRB_NO_FLOAT
-  mrb_define_method_id(mrb, rat, MRB_SYM(to_f), mrb_rational_to_f, MRB_ARGS_NONE());
   mrb_define_method_id(mrb, mrb->float_class, MRB_SYM(to_r), float_to_r, MRB_ARGS_NONE());
 #endif
-  mrb_mt_init_rom(rat, &rational_rom_mt);
-  mrb_mt_init_rom(mrb->integer_class, &integer_to_r_rom_mt);
-  mrb_mt_init_rom(mrb->nil_class, &nil_to_r_rom_mt);
-  mrb_mt_init_rom(mrb->kernel_module, &kernel_rational_rom_mt);
 }
 
 void

mrbgems/mruby-socket/src/socket.c

@@ -1289,6 +1289,14 @@ static const mrb_mt_entry basicsocket_rom_entries[] = {
   MRB_MT_ENTRY(mrb_basicsocket_setsockopt,    MRB_SYM(setsockopt),    0),
   MRB_MT_ENTRY(mrb_basicsocket_shutdown,      MRB_SYM(shutdown),      0),
   MRB_MT_ENTRY(mrb_basicsocket_set_is_socket, MRB_SYM_E(_is_socket),  0),
+#ifdef _WIN32
+  MRB_MT_ENTRY(mrb_win32_basicsocket_close,    MRB_SYM(close),    MRB_MT_NOARG),
+  MRB_MT_ENTRY(mrb_win32_basicsocket_sysread,  MRB_SYM(sysread),  0),
+  MRB_MT_ENTRY(mrb_win32_basicsocket_sysseek,  MRB_SYM(sysseek),  0),
+  MRB_MT_ENTRY(mrb_win32_basicsocket_syswrite, MRB_SYM(syswrite), 0),
+  MRB_MT_ENTRY(mrb_win32_basicsocket_sysread,  MRB_SYM(read),     0),
+  MRB_MT_ENTRY(mrb_win32_basicsocket_syswrite, MRB_SYM(write),    0),
+#endif
 };
 static mrb_mt_tbl basicsocket_rom_mt = MRB_MT_ROM_TAB(basicsocket_rom_entries);
 
@@ -1342,16 +1350,6 @@ mrb_mruby_socket_gem_init(mrb_state* mrb)
   mrb_define_class_method_id(mrb, sock, MRB_SYM(sockaddr_un), mrb_socket_sockaddr_un, MRB_ARGS_REQ(1));
   mrb_define_class_method_id(mrb, sock, MRB_SYM(socketpair), mrb_socket_socketpair, MRB_ARGS_REQ(3));
 
-  /* Windows IO Methods Overridden on BasicSocket */
-#ifdef _WIN32
-  mrb_define_method_id(mrb, bsock, MRB_SYM(close), mrb_win32_basicsocket_close, MRB_ARGS_NONE());
-  mrb_define_method_id(mrb, bsock, MRB_SYM(sysread), mrb_win32_basicsocket_sysread, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
-  mrb_define_method_id(mrb, bsock, MRB_SYM(sysseek), mrb_win32_basicsocket_sysseek, MRB_ARGS_REQ(1));
-  mrb_define_method_id(mrb, bsock, MRB_SYM(syswrite), mrb_win32_basicsocket_syswrite, MRB_ARGS_REQ(1));
-  mrb_define_method_id(mrb, bsock, MRB_SYM(read), mrb_win32_basicsocket_sysread, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
-  mrb_define_method_id(mrb, bsock, MRB_SYM(write), mrb_win32_basicsocket_syswrite, MRB_ARGS_REQ(1));
-#endif
-
   struct RClass *option = mrb_define_class_under_id(mrb, sock, MRB_SYM(Option), mrb->object_class);
   mrb_define_class_method_id(mrb, option, MRB_SYM(bool), socket_option_s_bool, MRB_ARGS_REQ(4));
   mrb_define_class_method_id(mrb, option, MRB_SYM(int), socket_option_s_int, MRB_ARGS_REQ(4));

mrbgems/mruby-string-ext/src/string.c

@@ -2276,18 +2276,13 @@ static const mrb_mt_entry string_ext_rom_entries[] = {
 };
 static mrb_mt_tbl string_ext_rom_mt = MRB_MT_ROM_TAB(string_ext_rom_entries);
 
-static const mrb_mt_entry integer_chr_rom_entries[] = {
-  MRB_MT_ENTRY(int_chr, MRB_SYM(chr), 0),
-};
-static mrb_mt_tbl integer_chr_rom_mt = MRB_MT_ROM_TAB(integer_chr_rom_entries);
-
 void
 mrb_mruby_string_ext_gem_init(mrb_state* mrb)
 {
   struct RClass *s = mrb->string_class;
 
   mrb_mt_init_rom(s, &string_ext_rom_mt);
-  mrb_mt_init_rom(mrb->integer_class, &integer_chr_rom_mt);
+  mrb_define_method_id(mrb, mrb->integer_class, MRB_SYM(chr), int_chr, MRB_ARGS_NONE()|MRB_ARGS_OPT(1));
 }
 
 void

mrbgems/mruby-time/src/time.c

@@ -1711,6 +1711,9 @@ static const mrb_mt_entry time_rom_entries[] = {
   MRB_MT_ENTRY(time_utc_offset, MRB_SYM(gmt_offset),     MRB_MT_NOARG),
   MRB_MT_ENTRY(time_utc_offset, MRB_SYM(gmtoff),         MRB_MT_NOARG),
   MRB_MT_ENTRY(time_utc_offset, MRB_SYM(utc_offset),     MRB_MT_NOARG),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(time_to_f,      MRB_SYM(to_f),            MRB_MT_NOARG),
+#endif
 };
 static mrb_mt_tbl time_rom_mt = MRB_MT_ROM_TAB(time_rom_entries);
 
@@ -1729,9 +1732,6 @@ mrb_mruby_time_gem_init(mrb_state* mrb)
   mrb_define_class_method_id(mrb, tc, MRB_SYM(utc), time_gm, MRB_ARGS_ARG(1,6));      /* 15.2.19.6.6 */
 
   mrb_mt_init_rom(tc, &time_rom_mt);
-#ifndef MRB_NO_FLOAT
-  mrb_define_method_id(mrb, tc, MRB_SYM(to_f), time_to_f, MRB_ARGS_NONE());       /* 15.2.19.7.24 */
-#endif
 }
 
 void

src/kernel.c

@@ -694,6 +694,10 @@ static const mrb_mt_entry kernel_rom_entries[] = {
   MRB_MT_ENTRY(mrb_ensure_int_type,              MRB_SYM(__to_int),                     MRB_MT_NOARG),
   MRB_MT_ENTRY(mrb_false,                        MRB_SYM_Q(respond_to_missing),         MRB_MT_PRIVATE),
   MRB_MT_ENTRY(mrb_obj_method_recursive_p,       MRB_SYM_Q(__method_recursive),         0),
+#ifndef HAVE_MRUBY_IO_GEM
+  MRB_MT_ENTRY(mrb_p_m,     MRB_SYM(p),     MRB_MT_PRIVATE),
+  MRB_MT_ENTRY(mrb_print_m, MRB_SYM(print), MRB_MT_PRIVATE),
+#endif
 };
 static mrb_mt_tbl kernel_rom_mt = MRB_MT_ROM_TAB(kernel_rom_entries);
 
@@ -711,11 +715,5 @@ mrb_init_kernel(mrb_state *mrb)
 
   mrb_mt_init_rom(krn, &kernel_rom_mt);
 
-  /* conditional methods not in ROM table */
-#ifndef HAVE_MRUBY_IO_GEM
-  mrb_define_private_method_id(mrb, krn, MRB_SYM(p),                  mrb_p_m,                         MRB_ARGS_ANY());     /* 15.3.1.3.34 */
-  mrb_define_private_method_id(mrb, krn, MRB_SYM(print),              mrb_print_m,                     MRB_ARGS_ANY());     /* 15.3.1.3.35 */
-#endif
-
   mrb_include_module(mrb, mrb->object_class, mrb->kernel_module);
 }

src/numeric.c

@@ -2303,6 +2303,9 @@ static const mrb_mt_entry numeric_rom_entries[] = {
   MRB_MT_ENTRY(num_finite_p,   MRB_SYM_Q(finite),   MRB_MT_NOARG),
   MRB_MT_ENTRY(num_infinite_p, MRB_SYM_Q(infinite), MRB_MT_NOARG),
   MRB_MT_ENTRY(num_eql,        MRB_SYM_Q(eql),      0),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(num_fdiv, MRB_SYM(fdiv), 0),
+#endif
 };
 static mrb_mt_tbl numeric_rom_mt = MRB_MT_ROM_TAB(numeric_rom_entries);
 
@@ -2338,6 +2341,10 @@ static const mrb_mt_entry integer_rom_entries[] = {
   MRB_MT_ENTRY(int_to_s,             MRB_SYM(inspect),                0),
   MRB_MT_ENTRY(int_divmod,           MRB_SYM(divmod),                 0),
   MRB_MT_ENTRY(coerce_step_counter,  MRB_SYM(__coerce_step_counter),  0),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(int_fdiv, MRB_SYM(fdiv), 0),
+  MRB_MT_ENTRY(int_to_f, MRB_SYM(to_f), MRB_MT_NOARG),
+#endif
 };
 static mrb_mt_tbl integer_rom_mt = MRB_MT_ROM_TAB(integer_rom_entries);
 
@@ -2387,9 +2394,6 @@ mrb_init_numeric(mrb_state *mrb)
   /* Numeric Class */
   numeric = mrb_define_class_id(mrb, MRB_SYM(Numeric), mrb->object_class);                  /* 15.2.7 */
   mrb_mt_init_rom(numeric, &numeric_rom_mt);
-#ifndef MRB_NO_FLOAT
-  mrb_define_method_id(mrb, numeric, MRB_SYM(fdiv),      num_fdiv,        MRB_ARGS_REQ(1));
-#endif
 
   /* Integer Class */
   mrb->integer_class = integer = mrb_define_class_id(mrb, MRB_SYM(Integer),  numeric);     /* 15.2.8 */
@@ -2397,10 +2401,6 @@ mrb_init_numeric(mrb_state *mrb)
   MRB_UNDEF_ALLOCATOR(integer);
   mrb_undef_class_method_id(mrb, integer, MRB_SYM(new));
   mrb_mt_init_rom(integer, &integer_rom_mt);
-#ifndef MRB_NO_FLOAT
-  mrb_define_method_id(mrb, integer, MRB_SYM(fdiv),     int_fdiv,        MRB_ARGS_REQ(1));
-  mrb_define_method_id(mrb, integer, MRB_SYM(to_f),     int_to_f,        MRB_ARGS_NONE()); /* 15.2.8.3.23 */
-#endif
 
   /* Fixnum Class for compatibility */
   mrb_define_const_id(mrb, mrb->object_class, MRB_SYM(Fixnum), mrb_obj_value(integer));

src/string.c

@@ -3555,6 +3555,9 @@ static const mrb_mt_entry string_rom_entries[] = {
   MRB_MT_ENTRY(mrb_str_byteslice,      MRB_SYM(byteslice),       0),
   MRB_MT_ENTRY(mrb_str_bytesplice,     MRB_SYM(bytesplice),      0),
   MRB_MT_ENTRY(sub_replace,            MRB_SYM(__sub_replace),   0),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(mrb_str_to_f, MRB_SYM(to_f), MRB_MT_NOARG),
+#endif
 };
 static mrb_mt_tbl string_rom_mt = MRB_MT_ROM_TAB(string_rom_entries);
 
@@ -3571,9 +3574,5 @@ mrb_init_string(mrb_state *mrb)
 
   mrb_mt_init_rom(s, &string_rom_mt);
 
-  /* conditional methods not in ROM table */
-#ifndef MRB_NO_FLOAT
-  mrb_define_method_id(mrb, s, MRB_SYM(to_f),            mrb_str_to_f,            MRB_ARGS_NONE()); /* 15.2.10.5.38 */
-#endif
   mrb_define_method_id(mrb, mrb->kernel_module, MRB_SYM(__ENCODING__), mrb_encoding, MRB_ARGS_NONE());
 }