summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--ChangeLog4
-rw-r--r--class.c16
-rw-r--r--eval.c12
-rw-r--r--gc.c4
-rw-r--r--internal.h3
-rw-r--r--method.h17
-rw-r--r--object.c5
-rw-r--r--proc.c4
-rw-r--r--test/ruby/test_refinement.rb28
-rw-r--r--vm_eval.c49
-rw-r--r--vm_insnhelper.c94
-rw-r--r--vm_method.c306
12 files changed, 170 insertions, 372 deletions
diff --git a/ChangeLog b/ChangeLog
index b3775c42280..1710a330356 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+Fri Nov 30 11:07:45 2012 Shugo Maeda <shugo@ruby-lang.org>
+
+ * revert r37993 to avoid SEGV in tests.
+
Fri Nov 30 10:38:54 2012 Eric Hodel <drbrain@segment7.net>
* lib/rdoc/ri/driver.rb: Relaxed matching for pages to be more
diff --git a/class.c b/class.c
index 0aa7561aa63..e083bf633df 100644
--- a/class.c
+++ b/class.c
@@ -678,13 +678,6 @@ rb_include_module(VALUE klass, VALUE module)
}
static int
-add_refined_method_entry_i(st_data_t key, st_data_t value, st_data_t data)
-{
- rb_add_refined_method_entry((VALUE) data, (ID) key);
- return ST_CONTINUE;
-}
-
-static int
include_modules_at(VALUE klass, VALUE c, VALUE module)
{
VALUE p;
@@ -714,13 +707,6 @@ include_modules_at(VALUE klass, VALUE c, VALUE module)
}
}
c = RCLASS_SUPER(c) = rb_include_class_new(module, RCLASS_SUPER(c));
- if (FL_TEST(klass, RMODULE_IS_REFINEMENT)) {
- VALUE refined_class =
- rb_refinement_module_get_refined_class(klass);
-
- st_foreach(RMODULE_M_TBL(module), add_refined_method_entry_i,
- (st_data_t) refined_class);
- }
if (RMODULE_M_TBL(module) && RMODULE_M_TBL(module)->num_entries)
changed = 1;
skip:
@@ -752,7 +738,7 @@ rb_prepend_module(VALUE klass, VALUE module)
RCLASS_SUPER(klass) = origin;
RCLASS_ORIGIN(klass) = origin;
RCLASS_M_TBL(origin) = RCLASS_M_TBL(klass);
- RCLASS_M_TBL(klass) = st_init_numtable();
+ RCLASS_M_TBL(klass) = 0;
}
changed = include_modules_at(klass, klass, module);
if (changed < 0)
diff --git a/eval.c b/eval.c
index d4df41c18ee..cbf49f30111 100644
--- a/eval.c
+++ b/eval.c
@@ -1187,14 +1187,6 @@ rb_mod_using(VALUE self, VALUE module)
return self;
}
-VALUE rb_refinement_module_get_refined_class(VALUE module)
-{
- ID id_refined_class;
-
- CONST_ID(id_refined_class, "__refined_class__");
- return rb_attr_get(module, id_refined_class);
-}
-
static VALUE
refinement_module_include(int argc, VALUE *argv, VALUE module)
{
@@ -1203,9 +1195,11 @@ refinement_module_include(int argc, VALUE *argv, VALUE module)
rb_control_frame_t *end_cfp = RUBY_VM_END_CONTROL_FRAME(th);
VALUE result = rb_mod_include(argc, argv, module);
NODE *cref;
+ ID id_refined_class;
VALUE klass, c;
- klass = rb_refinement_module_get_refined_class(module);
+ CONST_ID(id_refined_class, "__refined_class__");
+ klass = rb_attr_get(module, id_refined_class);
while (RUBY_VM_VALID_CONTROL_FRAME_P(cfp, end_cfp)) {
if (RUBY_VM_NORMAL_ISEQ_P(cfp->iseq) &&
(cref = rb_vm_get_cref(cfp->iseq, cfp->ep)) &&
diff --git a/gc.c b/gc.c
index f1307309796..e5c6f43f597 100644
--- a/gc.c
+++ b/gc.c
@@ -2410,7 +2410,6 @@ mark_method_entry(rb_objspace_t *objspace, const rb_method_entry_t *me)
const rb_method_definition_t *def = me->def;
gc_mark(objspace, me->klass);
- again:
if (!def) return;
switch (def->type) {
case VM_METHOD_TYPE_ISEQ:
@@ -2423,9 +2422,6 @@ mark_method_entry(rb_objspace_t *objspace, const rb_method_entry_t *me)
case VM_METHOD_TYPE_IVAR:
gc_mark(objspace, def->body.attr.location);
break;
- case VM_METHOD_TYPE_REFINED:
- def = def->body.orig_def;
- goto again;
default:
break; /* ignore */
}
diff --git a/internal.h b/internal.h
index 6a2cb07cee8..86181f913a2 100644
--- a/internal.h
+++ b/internal.h
@@ -99,9 +99,6 @@ NORETURN(void rb_async_bug_errno(const char *,int));
const char *rb_builtin_type_name(int t);
const char *rb_builtin_class_name(VALUE x);
-/* eval.c */
-VALUE rb_refinement_module_get_refined_class(VALUE module);
-
/* eval_error.c */
void ruby_error_print(void);
VALUE rb_get_backtrace(VALUE info);
diff --git a/method.h b/method.h
index 57a409f8a9f..a87fc5c1ba5 100644
--- a/method.h
+++ b/method.h
@@ -42,8 +42,7 @@ typedef enum {
VM_METHOD_TYPE_NOTIMPLEMENTED,
VM_METHOD_TYPE_OPTIMIZED, /* Kernel#send, Proc#call, etc */
VM_METHOD_TYPE_MISSING, /* wrapper for method_missing(id) */
- VM_METHOD_TYPE_CFUNC_FRAMELESS,
- VM_METHOD_TYPE_REFINED,
+ VM_METHOD_TYPE_CFUNC_FRAMELESS
} rb_method_type_t;
struct rb_call_info_struct;
@@ -73,7 +72,6 @@ typedef struct rb_method_definition_struct {
OPTIMIZED_METHOD_TYPE_SEND,
OPTIMIZED_METHOD_TYPE_CALL
} optimize_type;
- struct rb_method_definition_struct *orig_def;
} body;
int alias_count;
} rb_method_definition_t;
@@ -96,16 +94,9 @@ struct unlinked_method_entry_list_entry {
void rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_method_flag_t noex);
rb_method_entry_t *rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_flag_t noex);
rb_method_entry_t *rb_method_entry(VALUE klass, ID id, VALUE *define_class_ptr);
-void rb_add_refined_method_entry(VALUE refined_class, ID mid);
-rb_method_entry_t *rb_resolve_refined_method(VALUE refinements,
- rb_method_entry_t *me,
- rb_method_entry_t *me_buf,
- VALUE *defined_class_ptr);
-rb_method_entry_t *rb_method_entry_with_refinements(VALUE klass, ID id,
- rb_method_entry_t *me_buf,
- VALUE *defined_class_ptr);
-
-rb_method_entry_t *rb_method_entry_get_without_cache(VALUE klass, ID id, VALUE *define_class_ptr);
+
+rb_method_entry_t *rb_method_entry_get_with_refinements(VALUE refinements, VALUE klass, ID id, VALUE *define_class_ptr);
+rb_method_entry_t *rb_method_entry_get_without_cache(VALUE klass, VALUE refinements, ID id, VALUE *define_class_ptr);
rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_flag_t noex);
int rb_method_entry_arity(const rb_method_entry_t *me);
diff --git a/object.c b/object.c
index 62db906b04a..f515d48ac68 100644
--- a/object.c
+++ b/object.c
@@ -1337,7 +1337,7 @@ rb_obj_cmp(VALUE obj1, VALUE obj2)
static VALUE
rb_mod_to_s(VALUE klass)
{
- ID id_defined_at;
+ ID id_refined_class, id_defined_at;
VALUE refined_class, defined_at;
if (FL_TEST(klass, FL_SINGLETON)) {
@@ -1357,7 +1357,8 @@ rb_mod_to_s(VALUE klass)
return s;
}
- refined_class = rb_refinement_module_get_refined_class(klass);
+ CONST_ID(id_refined_class, "__refined_class__");
+ refined_class = rb_attr_get(klass, id_refined_class);
if (!NIL_P(refined_class)) {
VALUE s = rb_usascii_str_new2("#<refinement:");
diff --git a/proc.c b/proc.c
index d7469857374..0aa34abd129 100644
--- a/proc.c
+++ b/proc.c
@@ -917,7 +917,7 @@ mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope)
rb_method_flag_t flag = NOEX_UNDEF;
again:
- me = rb_method_entry_with_refinements(klass, id, &meb, &defined_class);
+ me = rb_method_entry(klass, id, &defined_class);
if (UNDEFINED_METHOD_ENTRY_P(me)) {
ID rmiss = rb_intern("respond_to_missing?");
VALUE sym = ID2SYM(id);
@@ -1682,8 +1682,6 @@ rb_method_entry_arity(const rb_method_entry_t *me)
default:
break;
}
- case VM_METHOD_TYPE_REFINED:
- return -1;
}
}
rb_bug("rb_method_entry_arity: invalid method entry type (%d)", def->type);
diff --git a/test/ruby/test_refinement.rb b/test/ruby/test_refinement.rb
index 3b8a0cd6582..3ca00ed9124 100644
--- a/test/ruby/test_refinement.rb
+++ b/test/ruby/test_refinement.rb
@@ -726,6 +726,7 @@ class TestRefinement < Test::Unit::TestCase
end
def test_inline_method_cache
+ skip "can't implement efficiently with the current implementation of refinements"
c = InlineMethodCache::C.new
f = Proc.new { c.foo }
assert_equal("original", f.call)
@@ -821,31 +822,4 @@ class TestRefinement < Test::Unit::TestCase
end
end
end
-
- module RedifineRefinedMethod
- class C
- def foo
- "original"
- end
- end
-
- module M
- refine C do
- def foo
- "refined"
- end
- end
- end
-
- class C
- def foo
- "redefined"
- end
- end
- end
-
- def test_redefine_refined_method
- c = RedifineRefinedMethod::C.new
- assert_equal("refined", RedifineRefinedMethod::M.module_eval { c.foo })
- end
end
diff --git a/vm_eval.c b/vm_eval.c
index 5959e933a55..53c2918d341 100644
--- a/vm_eval.c
+++ b/vm_eval.c
@@ -179,17 +179,7 @@ vm_call0_body(rb_thread_t* th, rb_call_info_t *ci, const VALUE *argv)
case VM_METHOD_TYPE_BMETHOD:
return vm_call_bmethod_body(th, ci, argv);
case VM_METHOD_TYPE_ZSUPER:
- case VM_METHOD_TYPE_REFINED:
{
- if (ci->me->def->type == VM_METHOD_TYPE_REFINED &&
- ci->me->def->body.orig_def) {
- rb_method_entry_t orig_me;
- orig_me = *ci->me;
- orig_me.def = ci->me->def->body.orig_def;
- ci->me = &orig_me;
- goto again;
- }
-
ci->defined_class = RCLASS_SUPER(ci->defined_class);
if (!ci->defined_class || !(ci->me = rb_method_entry(ci->defined_class, ci->mid, &ci->defined_class))) {
@@ -284,7 +274,8 @@ stack_check(void)
}
static inline rb_method_entry_t *
- rb_search_method_entry(VALUE recv, ID mid, VALUE *defined_class_ptr);
+ rb_search_method_entry(VALUE refinements, VALUE recv, ID mid,
+ VALUE *defined_class_ptr);
static inline int rb_method_call_status(rb_thread_t *th, const rb_method_entry_t *me, call_type scope, VALUE self);
#define NOEX_OK NOEX_NOSUPER
@@ -304,11 +295,11 @@ static inline int rb_method_call_status(rb_thread_t *th, const rb_method_entry_t
*/
static inline VALUE
rb_call0(VALUE recv, ID mid, int argc, const VALUE *argv,
- call_type scope, VALUE self)
+ call_type scope, VALUE self, VALUE refinements)
{
VALUE defined_class;
rb_method_entry_t *me =
- rb_search_method_entry(recv, mid, &defined_class);
+ rb_search_method_entry(refinements, recv, mid, &defined_class);
rb_thread_t *th = GET_THREAD();
int call_status = rb_method_call_status(th, me, scope, self);
@@ -372,7 +363,7 @@ check_funcall(VALUE recv, ID mid, int argc, VALUE *argv)
}
}
- me = rb_search_method_entry(recv, mid, &defined_class);
+ me = rb_search_method_entry(Qnil, recv, mid, &defined_class);
call_status = rb_method_call_status(th, me, CALL_FCALL, Qundef);
if (call_status != NOEX_OK) {
if (rb_method_basic_definition_p(klass, idMethodMissing)) {
@@ -437,7 +428,8 @@ rb_type_str(enum ruby_value_type type)
}
static inline rb_method_entry_t *
-rb_search_method_entry(VALUE recv, ID mid, VALUE *defined_class_ptr)
+rb_search_method_entry(VALUE refinements, VALUE recv, ID mid,
+ VALUE *defined_class_ptr)
{
VALUE klass = CLASS_OF(recv);
@@ -476,7 +468,8 @@ rb_search_method_entry(VALUE recv, ID mid, VALUE *defined_class_ptr)
rb_id2name(mid), type, (void *)recv, flags, klass);
}
}
- return rb_method_entry(klass, mid, defined_class_ptr);
+ return rb_method_entry_get_with_refinements(refinements, klass, mid,
+ defined_class_ptr);
}
static inline int
@@ -540,7 +533,7 @@ rb_method_call_status(rb_thread_t *th, const rb_method_entry_t *me, call_type sc
static inline VALUE
rb_call(VALUE recv, ID mid, int argc, const VALUE *argv, call_type scope)
{
- return rb_call0(recv, mid, argc, argv, scope, Qundef);
+ return rb_call0(recv, mid, argc, argv, scope, Qundef, Qnil);
}
NORETURN(static void raise_method_missing(rb_thread_t *th, int argc, const VALUE *argv,
@@ -793,24 +786,10 @@ rb_funcall_passing_block_with_refinements(VALUE recv, ID mid, int argc,
const VALUE *argv,
VALUE refinements)
{
- VALUE defined_class;
- rb_method_entry_t meb, *me =
- rb_search_method_entry(recv, mid, &defined_class);
- rb_thread_t *th;
- int call_status;
-
- if (me && me->def->type == VM_METHOD_TYPE_REFINED) {
- me = rb_resolve_refined_method(refinements, me, &meb,
- &defined_class);
- }
PASS_PASSED_BLOCK_TH(GET_THREAD());
- th = GET_THREAD();
- call_status = rb_method_call_status(th, me, CALL_PUBLIC, Qundef);
- if (call_status != NOEX_OK) {
- return method_missing(recv, mid, argc, argv, call_status);
- }
- stack_check();
- return vm_call0(th, recv, mid, argc, argv, me, defined_class);
+
+ return rb_call0(recv, mid, argc, argv, CALL_PUBLIC, Qundef,
+ refinements);
}
static VALUE
@@ -837,7 +816,7 @@ send_internal(int argc, const VALUE *argv, VALUE recv, call_type scope)
id = rb_to_id(vid);
}
PASS_PASSED_BLOCK_TH(th);
- return rb_call0(recv, id, argc, argv, scope, self);
+ return rb_call0(recv, id, argc, argv, scope, self, Qnil);
}
/*
diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index d242097771c..c40f66bbe9b 100644
--- a/vm_insnhelper.c
+++ b/vm_insnhelper.c
@@ -1694,47 +1694,6 @@ vm_call_method_missing(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_inf
return vm_call_method(th, reg_cfp, &ci_entry);
}
-static VALUE
-copy_refinement_iclass(VALUE iclass, VALUE superclass)
-{
- VALUE result, c;
-
- Check_Type(iclass, T_ICLASS);
- c = result = rb_include_class_new(RBASIC(iclass)->klass, superclass);
- RCLASS_REFINED_CLASS(c) = RCLASS_REFINED_CLASS(iclass);
- iclass = RCLASS_SUPER(iclass);
- while (iclass && BUILTIN_TYPE(iclass) == T_ICLASS) {
- c = RCLASS_SUPER(c) = rb_include_class_new(RBASIC(iclass)->klass,
- RCLASS_SUPER(c));
- RCLASS_REFINED_CLASS(c) = RCLASS_REFINED_CLASS(iclass);
- iclass = RCLASS_SUPER(iclass);
- }
- return result;
-}
-
-static VALUE
-find_refinement(VALUE refinements, VALUE klass)
-{
- VALUE refinement;
-
- if (NIL_P(refinements)) {
- return Qnil;
- }
- refinement = rb_hash_lookup(refinements, klass);
- if (NIL_P(refinement) &&
- BUILTIN_TYPE(klass) == T_ICLASS) {
- refinement = rb_hash_lookup(refinements,
- RBASIC(klass)->klass);
- if (!NIL_P(refinement)) {
- refinement = copy_refinement_iclass(refinement, klass);
- }
- }
- return refinement;
-}
-
-static int rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2);
-static VALUE vm_call_super_method(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci);
-
static inline VALUE
vm_call_method(rb_thread_t *th, rb_control_frame_t *cfp, rb_call_info_t *ci)
{
@@ -1776,10 +1735,7 @@ vm_call_method(rb_thread_t *th, rb_control_frame_t *cfp, rb_call_info_t *ci)
return vm_call_bmethod(th, cfp, ci);
}
case VM_METHOD_TYPE_ZSUPER:{
- VALUE klass;
-
- zsuper_method_dispatch:
- klass = RCLASS_SUPER(ci->me->klass);
+ VALUE klass = RCLASS_SUPER(ci->me->klass);
ci_temp = *ci;
ci = &ci_temp;
@@ -1822,44 +1778,6 @@ vm_call_method(rb_thread_t *th, rb_control_frame_t *cfp, rb_call_info_t *ci)
break;
case VM_METHOD_TYPE_UNDEF:
break;
- case VM_METHOD_TYPE_REFINED:{
- NODE *cref = rb_vm_get_cref(cfp->iseq, cfp->ep);
- VALUE refinements = cref ? cref->nd_refinements : Qnil;
- VALUE refinement, defined_class;
- rb_method_entry_t orig_me, *me;
- ci_temp = *ci;
- ci = &ci_temp;
-
- refinement = find_refinement(refinements,
- ci->defined_class);
- if (NIL_P(refinement)) {
- goto no_refinement_dispatch;
- }
- me = rb_method_entry(refinement, ci->mid, &defined_class);
- if (me) {
- if (ci->call == vm_call_super_method &&
- cfp->me &&
- rb_method_definition_eq(me->def, cfp->me->def)) {
- goto no_refinement_dispatch;
- }
- ci->me = me;
- ci->defined_class = defined_class;
- if (me->def->type != VM_METHOD_TYPE_REFINED) {
- goto normal_method_dispatch;
- }
- }
-
- no_refinement_dispatch:
- if (ci->me->def->body.orig_def) {
- orig_me = *ci->me;
- orig_me.def = ci->me->def->body.orig_def;
- ci->me = &orig_me;
- goto normal_method_dispatch;
- }
- else {
- goto zsuper_method_dispatch;
- }
- }
}
rb_bug("vm_call_method: unsupported method type (%d)", ci->me->def->type);
}
@@ -1923,12 +1841,6 @@ vm_call_general(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci
return vm_call_method(th, reg_cfp, ci);
}
-static VALUE
-vm_call_super_method(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci)
-{
- return vm_call_method(th, reg_cfp, ci);
-}
-
/* super */
static inline VALUE
@@ -2017,7 +1929,7 @@ vm_search_super_method(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_inf
/* TODO: use inline cache */
ci->me = rb_method_entry(ci->klass, ci->mid, &ci->defined_class);
- ci->call = vm_call_super_method;
+ ci->call = vm_call_general;
while (iseq && !iseq->klass) {
iseq = iseq->parent_iseq;
@@ -2025,7 +1937,7 @@ vm_search_super_method(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_inf
if (ci->me && ci->me->def->type == VM_METHOD_TYPE_ISEQ && ci->me->def->body.iseq == iseq) {
ci->klass = RCLASS_SUPER(ci->defined_class);
- ci->me = rb_method_entry(ci->klass, ci->mid, &ci->defined_class);
+ ci->me = rb_method_entry_get_with_refinements(Qnil, ci->klass, ci->mid, &ci->defined_class);
}
}
diff --git a/vm_method.c b/vm_method.c
index 37e67f3da90..6580bb60284 100644
--- a/vm_method.c
+++ b/vm_method.c
@@ -4,7 +4,7 @@
#define CACHE_SIZE 0x800
#define CACHE_MASK 0x7ff
-#define EXPR1(c,m) ((((c)>>3)^(m))&CACHE_MASK)
+#define EXPR1(c,o,m) ((((c)>>3)^((o)>>3)^(m))&CACHE_MASK)
#define NOEX_NOREDEF 0
#ifndef NOEX_NOREDEF
@@ -21,6 +21,7 @@ struct cache_entry { /* method hash table. */
VALUE filled_version; /* filled state version */
ID mid; /* method's id */
VALUE klass; /* receiver's class */
+ VALUE refinements; /* refinements */
rb_method_entry_t *me;
VALUE defined_class;
};
@@ -154,12 +155,6 @@ rb_free_method_entry(rb_method_entry_t *me)
if (def) {
if (def->alias_count == 0) {
- if (def->type == VM_METHOD_TYPE_REFINED) {
- def->body.orig_def->alias_count--;
- if (def->body.orig_def->alias_count == 0) {
- xfree(def->body.orig_def);
- }
- }
xfree(def);
}
else if (def->alias_count > 0) {
@@ -172,50 +167,7 @@ rb_free_method_entry(rb_method_entry_t *me)
static int rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2);
-static inline rb_method_entry_t *
-lookup_method_table(VALUE klass, ID id)
-{
- st_data_t body;
- st_table *m_tbl = RCLASS_M_TBL(klass);
- if (st_lookup(m_tbl, id, &body)) {
- return (rb_method_entry_t *) body;
- }
- else {
- return 0;
- }
-}
-
-static void
-make_method_entry_refined(rb_method_entry_t *me)
-{
- rb_method_definition_t *new_def;
-
- if (me->def && me->def->type == VM_METHOD_TYPE_REFINED)
- return;
-
- new_def = ALLOC(rb_method_definition_t);
- new_def->type = VM_METHOD_TYPE_REFINED;
- new_def->original_id = me->called_id;
- new_def->alias_count = 0;
- new_def->body.orig_def = me->def;
- rb_vm_check_redefinition_opt_method(me, me->klass);
- if (me->def) me->def->alias_count++;
- me->def = new_def;
-}
-
-void
-rb_add_refined_method_entry(VALUE refined_class, ID mid)
-{
- rb_method_entry_t *me = lookup_method_table(refined_class, mid);
-
- if (me) {
- make_method_entry_refined(me);
- }
- else {
- rb_add_method(refined_class, mid, VM_METHOD_TYPE_REFINED, 0,
- NOEX_PUBLIC);
- }
-}
+void rb_redefine_opt_method(VALUE, ID);
static rb_method_entry_t *
rb_method_entry_make(VALUE klass, ID mid, rb_method_type_t type,
@@ -227,7 +179,6 @@ rb_method_entry_make(VALUE klass, ID mid, rb_method_type_t type,
#endif
st_table *mtbl;
st_data_t data;
- int make_refined = 0;
if (NIL_P(klass)) {
klass = rb_cObject;
@@ -248,19 +199,14 @@ rb_method_entry_make(VALUE klass, ID mid, rb_method_type_t type,
rklass = klass;
#endif
if (FL_TEST(klass, RMODULE_IS_REFINEMENT)) {
- VALUE refined_class =
- rb_refinement_module_get_refined_class(klass);
+ ID id_refined_class;
+ VALUE refined_class;
- rb_add_refined_method_entry(refined_class, mid);
- }
- if (type == VM_METHOD_TYPE_REFINED) {
- rb_method_entry_t *old_me =
- lookup_method_table(RCLASS_ORIGIN(klass), mid);
- if (old_me) rb_vm_check_redefinition_opt_method(old_me, klass);
- }
- else {
- klass = RCLASS_ORIGIN(klass);
+ CONST_ID(id_refined_class, "__refined_class__");
+ refined_class = rb_ivar_get(klass, id_refined_class);
+ rb_redefine_opt_method(refined_class, mid);
}
+ klass = RCLASS_ORIGIN(klass);
mtbl = RCLASS_M_TBL(klass);
/* check re-definition */
@@ -276,8 +222,6 @@ rb_method_entry_make(VALUE klass, ID mid, rb_method_type_t type,
}
#endif
rb_vm_check_redefinition_opt_method(old_me, klass);
- if (old_def->type == VM_METHOD_TYPE_REFINED)
- make_refined = 1;
if (RTEST(ruby_verbose) &&
type != VM_METHOD_TYPE_UNDEF &&
@@ -330,10 +274,6 @@ rb_method_entry_make(VALUE klass, ID mid, rb_method_type_t type,
}
}
- if (make_refined) {
- make_method_entry_refined(me);
- }
-
st_insert(mtbl, mid, (st_data_t) me);
return me;
@@ -401,12 +341,7 @@ rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *opts, rb_method_
int line;
rb_method_entry_t *me = rb_method_entry_make(klass, mid, type, 0, noex);
rb_method_definition_t *def = ALLOC(rb_method_definition_t);
- if (me->def && me->def->type == VM_METHOD_TYPE_REFINED) {
- me->def->body.orig_def = def;
- }
- else {
- me->def = def;
- }
+ me->def = def;
def->type = type;
def->original_id = mid;
def->alias_count = 0;
@@ -444,13 +379,10 @@ rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *opts, rb_method_
case VM_METHOD_TYPE_ZSUPER:
case VM_METHOD_TYPE_UNDEF:
break;
- case VM_METHOD_TYPE_REFINED:
- def->body.orig_def = (rb_method_definition_t *) opts;
- break;
default:
rb_bug("rb_add_method: unsupported method type (%d)\n", type);
}
- if (type != VM_METHOD_TYPE_UNDEF && type != VM_METHOD_TYPE_REFINED) {
+ if (type != VM_METHOD_TYPE_UNDEF) {
method_added(klass, mid);
}
return me;
@@ -493,18 +425,86 @@ rb_get_alloc_func(VALUE klass)
return 0;
}
+static VALUE
+copy_refinement_iclass(VALUE iclass, VALUE superclass)
+{
+ VALUE result, c;
+
+ Check_Type(iclass, T_ICLASS);
+ c = result = rb_include_class_new(RBASIC(iclass)->klass, superclass);
+ RCLASS_REFINED_CLASS(c) = RCLASS_REFINED_CLASS(iclass);
+ iclass = RCLASS_SUPER(iclass);
+ while (iclass && BUILTIN_TYPE(iclass) == T_ICLASS) {
+ c = RCLASS_SUPER(c) = rb_include_class_new(RBASIC(iclass)->klass,
+ RCLASS_SUPER(c));
+ RCLASS_REFINED_CLASS(c) = RCLASS_REFINED_CLASS(iclass);
+ iclass = RCLASS_SUPER(iclass);
+ }
+ return result;
+}
+
+static inline int
+lookup_method_table(VALUE klass, ID id, st_data_t *body)
+{
+ st_table *m_tbl = RCLASS_M_TBL(klass);
+ if (!m_tbl) {
+ m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(RBASIC(klass)->klass));
+ }
+ return st_lookup(m_tbl, id, body);
+}
+
static inline rb_method_entry_t*
-search_method(VALUE klass, ID id, VALUE *defined_class_ptr)
+search_method_with_refinements(VALUE klass, ID id, VALUE refinements,
+ VALUE *defined_class_ptr)
{
- rb_method_entry_t *me;
+ st_data_t body;
+ VALUE iclass, skipped_class = Qnil;
+
+ for (body = 0; klass; klass = RCLASS_SUPER(klass)) {
+ if (klass != skipped_class) {
+ iclass = rb_hash_lookup(refinements, klass);
+ if (NIL_P(iclass) && BUILTIN_TYPE(klass) == T_ICLASS) {
+ iclass = rb_hash_lookup(refinements, RBASIC(klass)->klass);
+ if (!NIL_P(iclass))
+ iclass = copy_refinement_iclass(iclass, klass);
+ }
+ if (!NIL_P(iclass)) {
+ skipped_class = klass;
+ klass = iclass;
+ }
+ }
+ if (lookup_method_table(klass, id, &body)) break;
+ }
- for (me = 0; klass; klass = RCLASS_SUPER(klass)) {
- if ((me = lookup_method_table(klass, id)) != 0) break;
+ if (defined_class_ptr)
+ *defined_class_ptr = klass;
+ return (rb_method_entry_t *)body;
+}
+
+static inline rb_method_entry_t*
+search_method_without_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)
+{
+ st_data_t body;
+
+ for (body = 0; klass; klass = RCLASS_SUPER(klass)) {
+ if (lookup_method_table(klass, id, &body)) break;
}
if (defined_class_ptr)
*defined_class_ptr = klass;
- return me;
+ return (rb_method_entry_t *)body;
+}
+
+static rb_method_entry_t*
+search_method(VALUE klass, ID id, VALUE refinements, VALUE *defined_class_ptr)
+{
+ if (NIL_P(refinements)) {
+ return search_method_without_refinements(klass, id, defined_class_ptr);
+ }
+ else {
+ return search_method_with_refinements(klass, id, refinements,
+ defined_class_ptr);
+ }
}
/*
@@ -514,17 +514,19 @@ search_method(VALUE klass, ID id, VALUE *defined_class_ptr)
* rb_method_entry() simply.
*/
rb_method_entry_t *
-rb_method_entry_get_without_cache(VALUE klass, ID id,
+rb_method_entry_get_without_cache(VALUE klass, VALUE refinements, ID id,
VALUE *defined_class_ptr)
{
VALUE defined_class;
- rb_method_entry_t *me = search_method(klass, id, &defined_class);
+ rb_method_entry_t *me = search_method(klass, id, refinements,
+ &defined_class);
if (ruby_running) {
struct cache_entry *ent;
- ent = cache + EXPR1(klass, id);
+ ent = cache + EXPR1(klass, refinements, id);
ent->filled_version = GET_VM_STATE_VERSION();
ent->klass = klass;
+ ent->refinements = refinements;
ent->defined_class = defined_class;
if (UNDEFINED_METHOD_ENTRY_P(me)) {
@@ -544,89 +546,37 @@ rb_method_entry_get_without_cache(VALUE klass, ID id,
}
rb_method_entry_t *
-rb_method_entry(VALUE klass, ID id, VALUE *defined_class_ptr)
+rb_method_entry_get_with_refinements(VALUE refinements, VALUE klass, ID id,
+ VALUE *defined_class_ptr)
{
#if OPT_GLOBAL_METHOD_CACHE
struct cache_entry *ent;
- ent = cache + EXPR1(klass, id);
+ ent = cache + EXPR1(klass, refinements, id);
if (ent->filled_version == GET_VM_STATE_VERSION() &&
- ent->mid == id && ent->klass == klass) {
+ ent->mid == id && ent->klass == klass &&
+ ent->refinements == refinements) {
if (defined_class_ptr)
*defined_class_ptr = ent->defined_class;
return ent->me;
}
#endif
- return rb_method_entry_get_without_cache(klass, id, defined_class_ptr);
-}
-
-static rb_method_entry_t *
-get_original_method_entry(VALUE refinements,
- rb_method_entry_t *me, rb_method_entry_t *me_buf,
- VALUE *defined_class_ptr)
-{
- if (me->def->body.orig_def) {
- *me_buf = *me;
- me_buf->def = me->def->body.orig_def;
- return me_buf;
- }
- else {
- rb_method_entry_t *tmp_me;
- tmp_me = rb_method_entry(RCLASS_SUPER(me->klass), me->called_id,
- defined_class_ptr);
- return rb_resolve_refined_method(refinements, tmp_me, me_buf,
- defined_class_ptr);
- }
-}
-
-rb_method_entry_t *
-rb_resolve_refined_method(VALUE refinements, rb_method_entry_t *me,
- rb_method_entry_t *me_buf,
- VALUE *defined_class_ptr)
-{
- if (me && me->def->type == VM_METHOD_TYPE_REFINED) {
- VALUE refinement;
- rb_method_entry_t *tmp_me;
-
- refinement = find_refinement(refinements, me->klass);
- if (NIL_P(refinement)) {
- return get_original_method_entry(refinements, me, me_buf,
+ return rb_method_entry_get_without_cache(klass, refinements, id,
defined_class_ptr);
- }
- tmp_me = rb_method_entry(refinement, me->called_id,
- defined_class_ptr);
- if (tmp_me && tmp_me->def->type != VM_METHOD_TYPE_REFINED) {
- return tmp_me;
- }
- else {
- return get_original_method_entry(refinements, me, me_buf,
- defined_class_ptr);
- }
- }
- else {
- return me;
- }
}
rb_method_entry_t *
-rb_method_entry_with_refinements(VALUE klass, ID id,
- rb_method_entry_t *me_buf,
- VALUE *defined_class_ptr)
+rb_method_entry(VALUE klass, ID id, VALUE *defined_class_ptr)
{
- VALUE defined_class;
- rb_method_entry_t *me = rb_method_entry(klass, id, &defined_class);
-
- if (me && me->def->type == VM_METHOD_TYPE_REFINED) {
- NODE *cref = rb_vm_cref();
- VALUE refinements = cref ? cref->nd_refinements : Qnil;
+ NODE *cref = rb_vm_cref();
+ VALUE refinements = Qnil;
- me = rb_resolve_refined_method(refinements, me, me_buf,
- &defined_class);
+ if (cref && !NIL_P(cref->nd_refinements)) {
+ refinements = cref->nd_refinements;
}
- if (defined_class_ptr)
- *defined_class_ptr = defined_class;
- return me;
+ return rb_method_entry_get_with_refinements(refinements, klass, id,
+ defined_class_ptr);
}
static void
@@ -725,9 +675,9 @@ rb_export_method(VALUE klass, ID name, rb_method_flag_t noex)
rb_secure(4);
}
- me = search_method(klass, name, &defined_class);
+ me = search_method(klass, name, Qnil, &defined_class);
if (!me && RB_TYPE_P(klass, T_MODULE)) {
- me = search_method(rb_cObject, name, &defined_class);
+ me = search_method(rb_cObject, name, Qnil, &defined_class);
}
if (UNDEFINED_METHOD_ENTRY_P(me)) {
@@ -749,9 +699,7 @@ rb_export_method(VALUE klass, ID name, rb_method_flag_t noex)
int
rb_method_boundp(VALUE klass, ID id, int ex)
{
- rb_method_entry_t meb;
- rb_method_entry_t *me =
- rb_method_entry_with_refinements(klass, id, &meb, 0);
+ rb_method_entry_t *me = rb_method_entry(klass, id, 0);
if (me != 0) {
if ((ex & ~NOEX_RESPONDS) &&
@@ -817,6 +765,9 @@ void
rb_undef(VALUE klass, ID id)
{
rb_method_entry_t *me;
+ NODE *cref = rb_vm_cref();
+ VALUE refinements = Qnil;
+ void rb_using_refinement(NODE *cref, VALUE klass, VALUE module);
if (NIL_P(klass)) {
rb_raise(rb_eTypeError, "no class to undef method");
@@ -832,7 +783,10 @@ rb_undef(VALUE klass, ID id)
rb_warn("undefining `%s' may cause serious problems", rb_id2name(id));
}
- me = search_method(klass, id, 0);
+ if (cref && !NIL_P(cref->nd_refinements)) {
+ refinements = cref->nd_refinements;
+ }
+ me = search_method(klass, id, refinements, 0);
if (UNDEFINED_METHOD_ENTRY_P(me)) {
const char *s0 = " class";
@@ -853,6 +807,11 @@ rb_undef(VALUE klass, ID id)
rb_id2name(id), s0, rb_class2name(c));
}
+ if (!RTEST(rb_class_inherited_p(klass, me->klass))) {
+ VALUE mod = rb_module_new();
+ rb_using_refinement(cref, klass, mod);
+ klass = mod;
+ }
rb_add_method(klass, id, VM_METHOD_TYPE_UNDEF, 0, NOEX_PUBLIC);
CALL_METHOD_HOOK(klass, undefined, id);
@@ -1074,10 +1033,6 @@ rb_method_entry_eq(const rb_method_entry_t *m1, const rb_method_entry_t *m2)
static int
rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2)
{
- if (d1 && d1->type == VM_METHOD_TYPE_REFINED)
- d1 = d1->body.orig_def;
- if (d2 && d2->type == VM_METHOD_TYPE_REFINED)
- d2 = d2->body.orig_def;
if (d1 == d2) return 1;
if (!d1 || !d2) return 0;
if (d1->type != d2->type) {
@@ -1112,7 +1067,6 @@ rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_defini
static st_index_t
rb_hash_method_definition(st_index_t hash, const rb_method_definition_t *def)
{
- again:
hash = rb_hash_uint(hash, def->type);
switch (def->type) {
case VM_METHOD_TYPE_ISEQ:
@@ -1133,9 +1087,6 @@ rb_hash_method_definition(st_index_t hash, const rb_method_definition_t *def)
return hash;
case VM_METHOD_TYPE_OPTIMIZED:
return rb_hash_uint(hash, def->body.optimize_type);
- case VM_METHOD_TYPE_REFINED:
- def = def->body.orig_def;
- goto again;
default:
rb_bug("rb_hash_method_definition: unsupported method type (%d)\n", def->type);
}
@@ -1165,11 +1116,11 @@ rb_alias(VALUE klass, ID name, ID def)
}
again:
- orig_me = search_method(klass, def, 0);
+ orig_me = search_method(klass, def, Qnil, 0);
if (UNDEFINED_METHOD_ENTRY_P(orig_me)) {
if ((!RB_TYPE_P(klass, T_MODULE)) ||
- (orig_me = search_method(rb_cObject, def, 0),
+ (orig_me = search_method(rb_cObject, def, Qnil, 0),
UNDEFINED_METHOD_ENTRY_P(orig_me))) {
rb_print_undef(klass, def, 0);
}
@@ -1445,9 +1396,9 @@ rb_mod_modfunc(int argc, VALUE *argv, VALUE module)
id = rb_to_id(argv[i]);
for (;;) {
- me = search_method(m, id, 0);
+ me = search_method(m, id, Qnil, 0);
if (me == 0) {
- me = search_method(rb_cObject, id, 0);
+ me = search_method(rb_cObject, id, Qnil, 0);
}
if (UNDEFINED_METHOD_ENTRY_P(me)) {
rb_print_undef(module, id, 0);
@@ -1561,6 +1512,21 @@ obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
}
void
+rb_redefine_opt_method(VALUE klass, ID mid)
+{
+ st_data_t data;
+ rb_method_entry_t *me = 0;
+ VALUE origin = RCLASS_ORIGIN(klass);
+
+ if (!st_lookup(RCLASS_M_TBL(origin), mid, &data) ||
+ !(me = (rb_method_entry_t *)data) ||
+ (!me->def || me->def->type == VM_METHOD_TYPE_UNDEF)) {
+ return;
+ }
+ rb_vm_check_redefinition_opt_method(me, origin);
+}
+
+void
Init_eval_method(void)
{
#undef rb_intern