summaryrefslogtreecommitdiff
path: root/class.c
diff options
context:
space:
mode:
authorJeremy Evans <code@jeremyevans.net>2019-10-12 01:02:51 -0700
committerNobuyoshi Nakada <nobu@ruby-lang.org>2019-11-28 19:57:04 +0900
commita0579f3606561a74e323f6193b9504c06845236c (patch)
tree3ccff84a2cacdb455ef9259aa15d46eec376b6cb /class.c
parent5069c5f5214ce68df8b3954321ad9114c5368dc3 (diff)
Make prepending a refined module after inclusion not break refinements
After the previous commit, this was still broken. The reason it was broken is that a refined module that hasn't been prepended to yet keeps the refined methods in the module's method table. When prepending, the module's method table is moved to the origin iclass, and then the refined methods are moved from the method table to a new method table in the module itself. Unfortunately, that means that if a class has included the module, prepending breaks the refinements, because when the methods are moved from the origin iclass method table to the module method table, they are removed from the method table from the iclass created when the module was included earlier. Fix this by always creating an origin class when including a module that has any refinements, even if the refinements are not currently used. I wasn't sure the best way to do that. The approach I choose was to use an object flag. The flag is set on the module when Module#refine is called, and if the flag is present when the module is included in another module or class, an origin iclass is created for the module. Fixes [Bug #13446]
Notes
Notes: Merged: https://github.com/ruby/ruby/pull/2550
Diffstat (limited to 'class.c')
-rw-r--r--class.c27
1 files changed, 19 insertions, 8 deletions
diff --git a/class.c b/class.c
index e03ba22..f9e2322 100644
--- a/class.c
+++ b/class.c
@@ -890,6 +890,8 @@ add_refined_method_entry_i(ID key, VALUE value, void *data)
return ID_TABLE_CONTINUE;
}
+static void ensure_origin(VALUE klass);
+
static int
include_modules_at(const VALUE klass, VALUE c, VALUE module, int search_super)
{
@@ -897,6 +899,10 @@ include_modules_at(const VALUE klass, VALUE c, VALUE module, int search_super)
int method_changed = 0, constant_changed = 0;
struct rb_id_table *const klass_m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(klass));
+ if (FL_TEST(module, RCLASS_REFINED_BY_ANY)) {
+ ensure_origin(module);
+ }
+
while (module) {
int superclass_seen = FALSE;
struct rb_id_table *tbl;
@@ -978,15 +984,10 @@ move_refined_method(ID key, VALUE value, void *data)
}
}
-void
-rb_prepend_module(VALUE klass, VALUE module)
+static void
+ensure_origin(VALUE klass)
{
- VALUE origin;
- int changed = 0;
-
- ensure_includable(klass, module);
-
- origin = RCLASS_ORIGIN(klass);
+ VALUE origin = RCLASS_ORIGIN(klass);
if (origin == klass) {
origin = class_alloc(T_ICLASS, klass);
OBJ_WB_UNPROTECT(origin); /* TODO: conservative shading. Need more survey. */
@@ -997,6 +998,16 @@ rb_prepend_module(VALUE klass, VALUE module)
RCLASS_M_TBL_INIT(klass);
rb_id_table_foreach(RCLASS_M_TBL(origin), move_refined_method, (void *)klass);
}
+}
+
+void
+rb_prepend_module(VALUE klass, VALUE module)
+{
+ VALUE origin;
+ int changed = 0;
+
+ ensure_includable(klass, module);
+ ensure_origin(klass);
changed = include_modules_at(klass, klass, module, FALSE);
if (changed < 0)
rb_raise(rb_eArgError, "cyclic prepend detected");