summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--ChangeLog8
-rw-r--r--class.c6
-rw-r--r--eval.c197
-rw-r--r--gc.c6
-rw-r--r--include/ruby/intern.h1
-rw-r--r--include/ruby/ruby.h1
-rw-r--r--insns.def16
-rw-r--r--iseq.c13
-rw-r--r--method.h3
-rw-r--r--node.h8
-rw-r--r--object.c1
-rw-r--r--test/ruby/test_fiber.rb5
-rw-r--r--test/ruby/test_refinement.rb304
-rw-r--r--test/ruby/test_thread.rb5
-rw-r--r--vm.c4
-rw-r--r--vm_eval.c4
-rw-r--r--vm_insnhelper.c80
-rw-r--r--vm_insnhelper.h9
-rw-r--r--vm_method.c83
19 files changed, 699 insertions, 55 deletions
diff --git a/ChangeLog b/ChangeLog
index 8efc225..8f5deaa 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+Thu Aug 2 20:32:29 2012 Shugo Maeda <shugo@ruby-lang.org>
+
+ * eval.c (rb_mod_using): new method Module#using. [experimental]
+
+ * eval.c (rb_mod_refine): new method Module#refine. [experimental]
+
+ * eval.c (f_using): new method Kernel#using. [experimental]
+
Thu Aug 2 20:08:02 2012 Shugo Maeda <shugo@ruby-lang.org>
* class.c, insns.def, method.h, proc.c, vm.c, vm_core.h, vm_eval.c,
diff --git a/class.c b/class.c
index 025f02f..8cfb0b1 100644
--- a/class.c
+++ b/class.c
@@ -620,8 +620,8 @@ rb_define_module_id_under(VALUE outer, ID id)
return module;
}
-static VALUE
-include_class_new(VALUE module, VALUE super)
+VALUE
+rb_include_class_new(VALUE module, VALUE super)
{
VALUE klass = class_alloc(T_ICLASS, rb_cClass);
@@ -703,7 +703,7 @@ include_modules_at(VALUE klass, VALUE c, VALUE module)
break;
}
}
- c = RCLASS_SUPER(c) = include_class_new(module, RCLASS_SUPER(c));
+ c = RCLASS_SUPER(c) = rb_include_class_new(module, RCLASS_SUPER(c));
if (RMODULE_M_TBL(module) && RMODULE_M_TBL(module)->num_entries)
changed = 1;
skip:
diff --git a/eval.c b/eval.c
index 14e0c5c..58735fd 100644
--- a/eval.c
+++ b/eval.c
@@ -23,6 +23,8 @@
NORETURN(void rb_raise_jump(VALUE));
+NODE *rb_vm_get_cref(const rb_iseq_t *, const VALUE *);
+
VALUE rb_eLocalJumpError;
VALUE rb_eSysStackError;
@@ -1025,6 +1027,180 @@ rb_mod_prepend(int argc, VALUE *argv, VALUE module)
}
void
+rb_overlay_module(NODE *cref, VALUE klass, VALUE module)
+{
+ VALUE iclass, c, superclass = klass;
+
+ Check_Type(klass, T_CLASS);
+ Check_Type(module, T_MODULE);
+ if (NIL_P(cref->nd_omod)) {
+ cref->nd_omod = rb_hash_new();
+ rb_funcall(cref->nd_omod, rb_intern("compare_by_identity"), 0);
+ }
+ else {
+ if (cref->flags & NODE_FL_CREF_OMOD_SHARED) {
+ cref->nd_omod = rb_hash_dup(cref->nd_omod);
+ cref->flags &= ~NODE_FL_CREF_OMOD_SHARED;
+ }
+ if (!NIL_P(c = rb_hash_lookup(cref->nd_omod, klass))) {
+ superclass = c;
+ while (c && TYPE(c) == T_ICLASS) {
+ if (RBASIC(c)->klass == module) {
+ /* already overlayed module */
+ return;
+ }
+ c = RCLASS_SUPER(c);
+ }
+ }
+ }
+ FL_SET(module, RMODULE_IS_OVERLAYED);
+ c = iclass = rb_include_class_new(module, superclass);
+ module = RCLASS_SUPER(module);
+ while (module) {
+ FL_SET(module, RMODULE_IS_OVERLAYED);
+ c = RCLASS_SUPER(c) = rb_include_class_new(module, RCLASS_SUPER(c));
+ module = RCLASS_SUPER(module);
+ }
+ rb_hash_aset(cref->nd_omod, klass, iclass);
+ rb_clear_cache_by_class(klass);
+}
+
+static int
+using_module_i(VALUE klass, VALUE module, VALUE arg)
+{
+ NODE *cref = (NODE *) arg;
+
+ rb_overlay_module(cref, klass, module);
+ return ST_CONTINUE;
+}
+
+void
+rb_using_module(NODE *cref, VALUE module)
+{
+ ID id_overlayed_modules;
+ VALUE overlayed_modules;
+
+ Check_Type(module, T_MODULE);
+ CONST_ID(id_overlayed_modules, "__overlayed_modules__");
+ overlayed_modules = rb_attr_get(module, id_overlayed_modules);
+ if (NIL_P(overlayed_modules)) return;
+ rb_hash_foreach(overlayed_modules, using_module_i, (VALUE) cref);
+}
+
+/*
+ * call-seq:
+ * using(module) -> self
+ *
+ * Import class refinements from <i>module</i> into the receiver.
+ */
+
+static VALUE
+rb_mod_using(VALUE self, VALUE module)
+{
+ NODE *cref = rb_vm_cref();
+ ID id_using_modules;
+ VALUE using_modules;
+
+ CONST_ID(id_using_modules, "__using_modules__");
+ using_modules = rb_attr_get(self, id_using_modules);
+ if (NIL_P(using_modules)) {
+ using_modules = rb_hash_new();
+ rb_funcall(using_modules, rb_intern("compare_by_identity"), 0);
+ rb_ivar_set(self, id_using_modules, using_modules);
+ }
+ rb_hash_aset(using_modules, module, Qtrue);
+ rb_using_module(cref, module);
+ rb_funcall(module, rb_intern("used"), 1, self);
+ return self;
+}
+
+void rb_redefine_opt_method(VALUE, ID);
+
+static VALUE
+refinement_module_method_added(VALUE mod, VALUE mid)
+{
+ ID id = SYM2ID(mid);
+ ID id_refined_class;
+ VALUE klass;
+
+ CONST_ID(id_refined_class, "__refined_class__");
+ klass = rb_ivar_get(mod, id_refined_class);
+ rb_redefine_opt_method(klass, id);
+ return Qnil;
+}
+
+static VALUE
+refinement_module_include(int argc, VALUE *argv, VALUE module)
+{
+ rb_thread_t *th = GET_THREAD();
+ rb_control_frame_t *cfp = th->cfp;
+ 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;
+
+ 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)) &&
+ !NIL_P(cref->nd_omod) &&
+ !NIL_P(c = rb_hash_lookup(cref->nd_omod, klass))) {
+ while (argc--) {
+ VALUE mod = argv[argc];
+ if (rb_class_inherited_p(module, mod)) {
+ RCLASS_SUPER(c) =
+ rb_include_class_new(mod, RCLASS_SUPER(c));
+ }
+ }
+ break;
+ }
+ cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
+ }
+ return result;
+}
+
+/*
+ * call-seq:
+ * refine(klass) { block } -> self
+ *
+ * Refine <i>klass</i> in the receiver.
+ */
+
+static VALUE
+rb_mod_refine(VALUE module, VALUE klass)
+{
+ NODE *cref = rb_vm_cref();
+ VALUE mod;
+ ID id_overlayed_modules, id_refined_class;
+ VALUE overlayed_modules;
+
+ Check_Type(klass, T_CLASS);
+ CONST_ID(id_overlayed_modules, "__overlayed_modules__");
+ overlayed_modules = rb_attr_get(module, id_overlayed_modules);
+ if (NIL_P(overlayed_modules)) {
+ overlayed_modules = rb_hash_new();
+ rb_funcall(overlayed_modules, rb_intern("compare_by_identity"), 0);
+ rb_ivar_set(module, id_overlayed_modules, overlayed_modules);
+ }
+ mod = rb_hash_aref(overlayed_modules, klass);
+ if (NIL_P(mod)) {
+ mod = rb_module_new();
+ CONST_ID(id_refined_class, "__refined_class__");
+ rb_ivar_set(mod, id_refined_class, klass);
+ rb_define_singleton_method(mod, "method_added",
+ refinement_module_method_added, 1);
+ rb_define_singleton_method(mod, "include",
+ refinement_module_include, -1);
+ rb_overlay_module(cref, klass, mod);
+ rb_hash_aset(overlayed_modules, klass, mod);
+ }
+ rb_mod_module_eval(0, NULL, mod);
+ return mod;
+}
+
+void
rb_obj_call_init(VALUE obj, int argc, VALUE *argv)
{
PASS_PASSED_BLOCK();
@@ -1134,6 +1310,23 @@ top_include(int argc, VALUE *argv, VALUE self)
return rb_mod_include(argc, argv, rb_cObject);
}
+/*
+ * call-seq:
+ * using(module) -> self
+ *
+ * Import class refinements from <i>module</i> into the scope where
+ * <code>using</code> is called.
+ */
+
+static VALUE
+f_using(VALUE self, VALUE module)
+{
+ NODE *cref = rb_vm_cref();
+
+ rb_using_module(cref, module);
+ return self;
+}
+
static VALUE *
errinfo_place(rb_thread_t *th)
{
@@ -1298,6 +1491,8 @@ Init_eval(void)
rb_define_private_method(rb_cModule, "include", rb_mod_include, -1);
rb_define_private_method(rb_cModule, "prepend_features", rb_mod_prepend_features, 1);
rb_define_private_method(rb_cModule, "prepend", rb_mod_prepend, -1);
+ rb_define_private_method(rb_cModule, "using", rb_mod_using, 1);
+ rb_define_private_method(rb_cModule, "refine", rb_mod_refine, 1);
rb_undef_method(rb_cClass, "module_function");
@@ -1309,6 +1504,8 @@ Init_eval(void)
rb_define_singleton_method(rb_vm_top_self(), "include", top_include, -1);
+ rb_define_global_function("using", f_using, 1);
+
rb_define_method(rb_mKernel, "extend", rb_obj_extend, -1);
rb_define_global_function("trace_var", rb_f_trace_var, -1); /* in variable.c */
diff --git a/gc.c b/gc.c
index 13e572f..c6e1edc 100644
--- a/gc.c
+++ b/gc.c
@@ -1994,6 +1994,12 @@ gc_mark_children(rb_objspace_t *objspace, VALUE ptr, int lev)
ptr = (VALUE)obj->as.node.u2.node;
goto again;
+ case NODE_CREF:
+ gc_mark(objspace, obj->as.node.nd_omod, lev);
+ gc_mark(objspace, (VALUE)obj->as.node.u1.node, lev);
+ ptr = (VALUE)obj->as.node.u3.node;
+ goto again;
+
default: /* unlisted NODE */
if (is_pointer_to_heap(objspace, obj->as.node.u1.node)) {
gc_mark(objspace, (VALUE)obj->as.node.u1.node, lev);
diff --git a/include/ruby/intern.h b/include/ruby/intern.h
index bc3d0fc..71f5442 100644
--- a/include/ruby/intern.h
+++ b/include/ruby/intern.h
@@ -173,6 +173,7 @@ VALUE rb_define_class_id_under(VALUE, ID, VALUE);
VALUE rb_module_new(void);
VALUE rb_define_module_id(ID);
VALUE rb_define_module_id_under(VALUE, ID);
+VALUE rb_include_class_new(VALUE, VALUE);
VALUE rb_mod_included_modules(VALUE);
VALUE rb_mod_include_p(VALUE, VALUE);
VALUE rb_mod_ancestors(VALUE);
diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h
index e9474d1..c551791 100644
--- a/include/ruby/ruby.h
+++ b/include/ruby/ruby.h
@@ -655,6 +655,7 @@ struct RClass {
#define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
#define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
#define RMODULE_SUPER(m) RCLASS_SUPER(m)
+#define RMODULE_IS_OVERLAYED FL_USER2
struct RFloat {
struct RBasic basic;
diff --git a/insns.def b/insns.def
index a36a56e..24e358d 100644
--- a/insns.def
+++ b/insns.def
@@ -183,8 +183,8 @@ getclassvariable
()
(VALUE val)
{
- NODE *cref = vm_get_cref(GET_ISEQ(), GET_EP());
- val = rb_cvar_get(vm_get_cvar_base(cref), id);
+ NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP());
+ val = rb_cvar_get(vm_get_cvar_base(cref, GET_CFP()), id);
}
/**
@@ -198,8 +198,8 @@ setclassvariable
(VALUE val)
()
{
- NODE *cref = vm_get_cref(GET_ISEQ(), GET_EP());
- rb_cvar_set(vm_get_cvar_base(cref), id, val);
+ NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP());
+ rb_cvar_set(vm_get_cvar_base(cref, GET_CFP()), id, val);
}
/**
@@ -777,8 +777,8 @@ defined
break;
case DEFINED_CVAR:
{
- NODE *cref = vm_get_cref(GET_ISEQ(), GET_EP());
- klass = vm_get_cvar_base(cref);
+ NODE *cref = rb_vm_get_cref(GET_ISEQ(), GET_EP());
+ klass = vm_get_cvar_base(cref, GET_CFP());
if (rb_cvar_defined(klass, SYM2ID(obj))) {
expr_type = "class variable";
}
@@ -970,6 +970,7 @@ defineclass
klass, 0, VM_ENVVAL_BLOCK_PTR(GET_BLOCK_PTR()),
class_iseq->iseq_encoded, GET_SP(),
class_iseq->local_size, 0);
+ rb_vm_using_modules(class_iseq->cref_stack, klass);
RESTORE_REGS();
INC_VM_STATE_VERSION();
@@ -1044,12 +1045,11 @@ invokesuper
while (ip && !ip->klass) {
ip = ip->parent_iseq;
}
- again:
me = rb_method_entry(klass, id, &klass);
if (me && me->def->type == VM_METHOD_TYPE_ISEQ &&
me->def->body.iseq == ip) {
klass = RCLASS_SUPER(klass);
- goto again;
+ me = rb_method_entry_get_with_omod(Qnil, klass, id, &klass);
}
CALL_METHOD(num, blockptr, flag, id, me, recv, klass);
diff --git a/iseq.c b/iseq.c
index 175adc4..8b08752 100644
--- a/iseq.c
+++ b/iseq.c
@@ -199,17 +199,20 @@ set_relation(rb_iseq_t *iseq, const VALUE parent)
/* set class nest stack */
if (type == ISEQ_TYPE_TOP) {
/* toplevel is private */
- iseq->cref_stack = NEW_BLOCK(rb_cObject);
+ iseq->cref_stack = NEW_CREF(rb_cObject);
+ iseq->cref_stack->nd_omod = Qnil;
iseq->cref_stack->nd_visi = NOEX_PRIVATE;
if (th->top_wrapper) {
- NODE *cref = NEW_BLOCK(th->top_wrapper);
+ NODE *cref = NEW_CREF(th->top_wrapper);
+ cref->nd_omod = Qnil;
cref->nd_visi = NOEX_PRIVATE;
cref->nd_next = iseq->cref_stack;
iseq->cref_stack = cref;
}
}
else if (type == ISEQ_TYPE_METHOD || type == ISEQ_TYPE_CLASS) {
- iseq->cref_stack = NEW_BLOCK(0); /* place holder */
+ iseq->cref_stack = NEW_CREF(0); /* place holder */
+ iseq->cref_stack->nd_omod = Qnil;
}
else if (RTEST(parent)) {
rb_iseq_t *piseq;
@@ -1653,7 +1656,9 @@ rb_iseq_clone(VALUE iseqval, VALUE newcbase)
iseq1->local_iseq = iseq1;
}
if (newcbase) {
- iseq1->cref_stack = NEW_BLOCK(newcbase);
+ iseq1->cref_stack = NEW_CREF(newcbase);
+ iseq1->cref_stack->nd_omod = iseq0->cref_stack->nd_omod;
+ iseq1->cref_stack->nd_visi = iseq0->cref_stack->nd_visi;
if (iseq0->cref_stack->nd_next) {
iseq1->cref_stack->nd_next = iseq0->cref_stack->nd_next;
}
diff --git a/method.h b/method.h
index 26333b4..9e7a615 100644
--- a/method.h
+++ b/method.h
@@ -91,7 +91,8 @@ void rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc,
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);
-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_omod(VALUE omod, VALUE klass, ID id, VALUE *define_class_ptr);
+rb_method_entry_t *rb_method_entry_get_without_cache(VALUE klass, VALUE omod, 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/node.h b/node.h
index 16343c7..42a24c2 100644
--- a/node.h
+++ b/node.h
@@ -190,6 +190,8 @@ enum node_type {
#define NODE_COLON2 NODE_COLON2
NODE_COLON3,
#define NODE_COLON3 NODE_COLON3
+ NODE_CREF,
+#define NODE_CREF NODE_CREF
NODE_DOT2,
#define NODE_DOT2 NODE_DOT2
NODE_DOT3,
@@ -263,9 +265,10 @@ typedef struct RNode {
#define RNODE(obj) (R_CAST(RNode)(obj))
-/* 0..4:T_TYPES, 5:reserved, 6:reserved, 7:NODE_FL_NEWLINE */
+/* 0..4:T_TYPES, 5:reserved, 6:NODE_FL_CREF_OMOD_SHARED, 7:NODE_FL_NEWLINE */
#define NODE_FL_NEWLINE (((VALUE)1)<<7)
#define NODE_FL_CREF_PUSHED_BY_EVAL NODE_FL_NEWLINE
+#define NODE_FL_CREF_OMOD_SHARED (((VALUE)1)<<6)
#define NODE_TYPESHIFT 8
#define NODE_TYPEMASK (((VALUE)0x7f)<<NODE_TYPESHIFT)
@@ -280,6 +283,8 @@ typedef struct RNode {
#define nd_set_line(n,l) \
RNODE(n)->flags=((RNODE(n)->flags&~(-1<<NODE_LSHIFT))|(((l)&NODE_LMASK)<<NODE_LSHIFT))
+#define nd_omod nd_reserved
+
#define nd_head u1.node
#define nd_alen u2.argc
#define nd_next u3.node
@@ -437,6 +442,7 @@ typedef struct RNode {
#define NEW_MODULE(n,b) NEW_NODE(NODE_MODULE,n,NEW_SCOPE(0,b),0)
#define NEW_COLON2(c,i) NEW_NODE(NODE_COLON2,c,i,0)
#define NEW_COLON3(i) NEW_NODE(NODE_COLON3,0,i,0)
+#define NEW_CREF(a) NEW_NODE(NODE_CREF,a,0,0)
#define NEW_DOT2(b,e) NEW_NODE(NODE_DOT2,b,e,0)
#define NEW_DOT3(b,e) NEW_NODE(NODE_DOT3,b,e,0)
#define NEW_SELF() NEW_NODE(NODE_SELF,0,0,0)
diff --git a/object.c b/object.c
index 7cc1e79..1e005e5 100644
--- a/object.c
+++ b/object.c
@@ -2863,6 +2863,7 @@ Init_Object(void)
rb_define_private_method(rb_cModule, "included", rb_obj_dummy, 1);
rb_define_private_method(rb_cModule, "extended", rb_obj_dummy, 1);
rb_define_private_method(rb_cModule, "prepended", rb_obj_dummy, 1);
+ rb_define_private_method(rb_cModule, "used", rb_obj_dummy, 1);
rb_define_private_method(rb_cModule, "method_added", rb_obj_dummy, 1);
rb_define_private_method(rb_cModule, "method_removed", rb_obj_dummy, 1);
rb_define_private_method(rb_cModule, "method_undefined", rb_obj_dummy, 1);
diff --git a/test/ruby/test_fiber.rb b/test/ruby/test_fiber.rb
index 9bac234..44bdbfc 100644
--- a/test/ruby/test_fiber.rb
+++ b/test/ruby/test_fiber.rb
@@ -216,10 +216,7 @@ class TestFiber < Test::Unit::TestCase
def test_no_valid_cfp
bug5083 = '[ruby-dev:44208]'
- error = assert_raise(RuntimeError) do
- Fiber.new(&Module.method(:nesting)).resume
- end
- assert_equal("Can't call on top of Fiber or Thread", error.message, bug5083)
+ assert_equal([], Fiber.new(&Module.method(:nesting)).resume)
error = assert_raise(RuntimeError) do
Fiber.new(&Module.method(:undef_method)).resume(:to_s)
end
diff --git a/test/ruby/test_refinement.rb b/test/ruby/test_refinement.rb
new file mode 100644
index 0000000..6578989
--- /dev/null
+++ b/test/ruby/test_refinement.rb
@@ -0,0 +1,304 @@
+require 'test/unit'
+
+class TestRefinement < Test::Unit::TestCase
+ class Foo
+ def x
+ return "Foo#x"
+ end
+
+ def y
+ return "Foo#y"
+ end
+
+ def call_x
+ return x
+ end
+ end
+
+ module FooExt
+ refine Foo do
+ def x
+ return "FooExt#x"
+ end
+
+ def y
+ return "FooExt#y " + super
+ end
+
+ def z
+ return "FooExt#z"
+ end
+ end
+ end
+
+ module FooExt2
+ refine Foo do
+ def x
+ return "FooExt2#x"
+ end
+
+ def y
+ return "FooExt2#y " + super
+ end
+
+ def z
+ return "FooExt2#z"
+ end
+ end
+ end
+
+ class FooSub < Foo
+ def x
+ return "FooSub#x"
+ end
+
+ def y
+ return "FooSub#y " + super
+ end
+ end
+
+ class FooExtClient
+ using FooExt
+
+ def self.invoke_x_on(foo)
+ return foo.x
+ end
+
+ def self.invoke_y_on(foo)
+ return foo.y
+ end
+
+ def self.invoke_z_on(foo)
+ return foo.z
+ end
+
+ def self.invoke_call_x_on(foo)
+ return foo.call_x
+ end
+ end
+
+ class FooExtClient2
+ using FooExt
+ using FooExt2
+
+ def self.invoke_y_on(foo)
+ return foo.y
+ end
+ end
+
+ def test_override
+ foo = Foo.new
+ assert_equal("Foo#x", foo.x)
+ assert_equal("FooExt#x", FooExtClient.invoke_x_on(foo))
+ assert_equal("Foo#x", foo.x)
+ end
+
+ def test_super
+ foo = Foo.new
+ assert_equal("Foo#y", foo.y)
+ assert_equal("FooExt#y Foo#y", FooExtClient.invoke_y_on(foo))
+ assert_equal("Foo#y", foo.y)
+ end
+
+ def test_super_chain
+ foo = Foo.new
+ assert_equal("Foo#y", foo.y)
+ assert_equal("FooExt2#y FooExt#y Foo#y", FooExtClient2.invoke_y_on(foo))
+ assert_equal("Foo#y", foo.y)
+ end
+
+ def test_new_method
+ foo = Foo.new
+ assert_raise(NoMethodError) { foo.z }
+ assert_equal("FooExt#z", FooExtClient.invoke_z_on(foo))
+ assert_raise(NoMethodError) { foo.z }
+ end
+
+ def test_no_local_rebinding
+ foo = Foo.new
+ assert_equal("Foo#x", foo.call_x)
+ assert_equal("Foo#x", FooExtClient.invoke_call_x_on(foo))
+ assert_equal("Foo#x", foo.call_x)
+ end
+
+ def test_subclass_is_prior
+ sub = FooSub.new
+ assert_equal("FooSub#x", sub.x)
+ assert_equal("FooSub#x", FooExtClient.invoke_x_on(sub))
+ assert_equal("FooSub#x", sub.x)
+ end
+
+ def test_super_in_subclass
+ sub = FooSub.new
+ assert_equal("FooSub#y Foo#y", sub.y)
+ # not "FooSub#y FooExt#y Foo#y"
+ assert_equal("FooSub#y Foo#y", FooExtClient.invoke_y_on(sub))
+ assert_equal("FooSub#y Foo#y", sub.y)
+ end
+
+ def test_new_method_on_subclass
+ sub = FooSub.new
+ assert_raise(NoMethodError) { sub.z }
+ assert_equal("FooExt#z", FooExtClient.invoke_z_on(sub))
+ assert_raise(NoMethodError) { sub.z }
+ end
+
+ def test_module_eval
+ foo = Foo.new
+ assert_equal("Foo#x", foo.x)
+ assert_equal("FooExt#x", FooExt.module_eval { foo.x })
+ assert_equal("Foo#x", foo.x)
+ end
+
+ def test_instance_eval
+ foo = Foo.new
+ ext_client = FooExtClient.new
+ assert_equal("Foo#x", foo.x)
+ assert_equal("FooExt#x", ext_client.instance_eval { foo.x })
+ assert_equal("Foo#x", foo.x)
+ end
+
+ def test_override_builtin_method
+ m = Module.new {
+ refine Fixnum do
+ def /(other) quo(other) end
+ end
+ }
+ assert_equal(0, 1 / 2)
+ assert_equal(Rational(1, 2), m.module_eval { 1 / 2 })
+ assert_equal(0, 1 / 2)
+ end
+
+ def test_return_value_of_refine
+ mod = nil
+ result = nil
+ m = Module.new {
+ result = refine(Object) {
+ mod = self
+ }
+ }
+ assert_equal mod, result
+ end
+
+ def test_refine_same_class_twice
+ result1 = nil
+ result2 = nil
+ result3 = nil
+ m = Module.new {
+ result1 = refine(Fixnum) {
+ def foo; return "foo" end
+ }
+ result2 = refine(Fixnum) {
+ def bar; return "bar" end
+ }
+ result3 = refine(String) {
+ def baz; return "baz" end
+ }
+ }
+ assert_equal("foo", m.module_eval { 1.foo })
+ assert_equal("bar", m.module_eval { 1.bar })
+ assert_equal(result1, result2)
+ assert_not_equal(result1, result3)
+ end
+
+ def test_respond_to?
+ m = Module.new {
+ refine Fixnum do
+ def foo; "foo"; end
+ end
+ }
+ assert_equal(false, 1.respond_to?(:foo))
+ assert_equal(true, m.module_eval { 1.respond_to?(:foo) })
+ assert_equal(false, 1.respond_to?(:foo))
+ end
+
+ def test_builtin_method_no_local_rebinding
+ m = Module.new {
+ refine String do
+ def <=>(other) return 0 end
+ end
+ }
+ assert_equal(false, m.module_eval { "1" >= "2" })
+
+ m2 = Module.new {
+ refine Array do
+ def each
+ super do |i|
+ yield 2 * i
+ end
+ end
+ end
+ }
+ a = [1, 2, 3]
+ assert_equal(1, m2.module_eval { a.min })
+ end
+
+ def test_module_inclusion
+ m1 = Module.new {
+ def foo
+ "m1#foo"
+ end
+
+ def bar
+ "m1#bar"
+ end
+ }
+ m2 = Module.new {
+ def bar
+ "m2#bar"
+ end
+
+ def baz
+ "m2#baz"
+ end
+ }
+ m3 = Module.new {
+ def baz
+ "m3#baz"
+ end
+ }
+ include_proc = Proc.new {
+ include m3, m2
+ }
+ m = Module.new {
+ refine String do
+ include m1
+ module_eval(&include_proc)
+
+ def call_foo
+ foo
+ end
+
+ def call_bar
+ bar
+ end
+
+ def call_baz
+ baz
+ end
+ end
+
+ def self.call_foo(s)
+ s.foo
+ end
+
+ def self.call_bar(s)
+ s.bar
+ end
+
+ def self.call_baz(s)
+ s.baz
+ end
+ }
+ assert_equal("m1#foo", m.module_eval { "abc".foo })
+ assert_equal("m2#bar", m.module_eval { "abc".bar })
+ assert_equal("m3#baz", m.module_eval { "abc".baz })
+ assert_equal("m1#foo", m.module_eval { "abc".call_foo })
+ assert_equal("m2#bar", m.module_eval { "abc".call_bar })
+ assert_equal("m3#baz", m.module_eval { "abc".call_baz })
+ assert_equal("m1#foo", m.call_foo("abc"))
+ assert_equal("m2#bar", m.call_bar("abc"))
+ assert_equal("m3#baz", m.call_baz("abc"))
+ end
+end
+
diff --git a/test/ruby/test_thread.rb b/test/ruby/test_thread.rb
index 523cad4..c8081b4 100644
--- a/test/ruby/test_thread.rb
+++ b/test/ruby/test_thread.rb
@@ -606,10 +606,7 @@ class TestThread < Test::Unit::TestCase
def test_no_valid_cfp
skip 'with win32ole, cannot run this testcase because win32ole redefines Thread#intialize' if defined?(WIN32OLE)
bug5083 = '[ruby-dev:44208]'
- error = assert_raise(RuntimeError) do
- Thread.new(&Module.method(:nesting)).join
- end
- assert_equal("Can't call on top of Fiber or Thread", error.message, bug5083)
+ assert_equal([], Thread.new(&Module.method(:nesting)).value)
error = assert_raise(RuntimeError) do
Thread.new(:to_s, &Module.method(:undef_method)).join
end
diff --git a/vm.c b/vm.c
index f249585..dd216bd 100644
--- a/vm.c
+++ b/vm.c
@@ -787,9 +787,9 @@ rb_vm_cref(void)
rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp);
if (cfp == 0) {
- rb_raise(rb_eRuntimeError, "Can't call on top of Fiber or Thread");
+ return NULL;
}
- return vm_get_cref(cfp->iseq, cfp->ep);
+ return rb_vm_get_cref(cfp->iseq, cfp->ep);
}
#if 0
diff --git a/vm_eval.c b/vm_eval.c
index 58af869..a4f7843 100644
--- a/vm_eval.c
+++ b/vm_eval.c
@@ -391,7 +391,7 @@ 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_omod(Qnil, klass, mid, defined_class_ptr);
}
static inline int
@@ -1310,6 +1310,7 @@ yield_under(VALUE under, VALUE self, VALUE values)
}
cref = vm_cref_push(th, under, NOEX_PUBLIC, blockptr);
cref->flags |= NODE_FL_CREF_PUSHED_BY_EVAL;
+ rb_vm_using_modules(cref, under);
if (values == Qundef) {
return vm_yield_with_cref(th, 1, &self, cref);
@@ -1331,6 +1332,7 @@ eval_under(VALUE under, VALUE self, VALUE src, const char *file, int line)
else {
SafeStringValue(src);
}
+ rb_vm_using_modules(cref, under);
return eval_string_with_cref(self, src, Qnil, cref, file, line);
}
diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index 8e24a73..b06fb55 100644
--- a/vm_insnhelper.c
+++ b/vm_insnhelper.c
@@ -1128,13 +1128,13 @@ vm_get_cref0(const rb_iseq_t *iseq, const VALUE *ep)
}
}
-static NODE *
-vm_get_cref(const rb_iseq_t *iseq, const VALUE *ep)
+NODE *
+rb_vm_get_cref(const rb_iseq_t *iseq, const VALUE *ep)
{
NODE *cref = vm_get_cref0(iseq, ep);
if (cref == 0) {
- rb_bug("vm_get_cref: unreachable");
+ rb_bug("rb_vm_get_cref: unreachable");
}
return cref;
}
@@ -1143,7 +1143,8 @@ static NODE *
vm_cref_push(rb_thread_t *th, VALUE klass, int noex, rb_block_t *blockptr)
{
rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(th, th->cfp);
- NODE *cref = NEW_BLOCK(klass);
+ NODE *cref = NEW_CREF(klass);
+ cref->nd_omod = Qnil;
cref->nd_visi = noex;
if (blockptr) {
@@ -1152,6 +1153,11 @@ vm_cref_push(rb_thread_t *th, VALUE klass, int noex, rb_block_t *blockptr)
else if (cfp) {
cref->nd_next = vm_get_cref0(cfp->iseq, cfp->ep);
}
+ /* TODO: why cref->nd_next is 1? */
+ if (cref->nd_next && cref->nd_next != (void *) 1 &&
+ !NIL_P(cref->nd_next->nd_omod)) {
+ COPY_CREF_OMOD(cref, cref->nd_next);
+ }
return cref;
}
@@ -1159,7 +1165,7 @@ vm_cref_push(rb_thread_t *th, VALUE klass, int noex, rb_block_t *blockptr)
static inline VALUE
vm_get_cbase(const rb_iseq_t *iseq, const VALUE *ep)
{
- NODE *cref = vm_get_cref(iseq, ep);
+ NODE *cref = rb_vm_get_cref(iseq, ep);
VALUE klass = Qundef;
while (cref) {
@@ -1175,7 +1181,7 @@ vm_get_cbase(const rb_iseq_t *iseq, const VALUE *ep)
static inline VALUE
vm_get_const_base(const rb_iseq_t *iseq, const VALUE *ep)
{
- NODE *cref = vm_get_cref(iseq, ep);
+ NODE *cref = rb_vm_get_cref(iseq, ep);
VALUE klass = Qundef;
while (cref) {
@@ -1201,6 +1207,20 @@ vm_check_if_namespace(VALUE klass)
}
static inline VALUE
+vm_get_iclass(rb_control_frame_t *cfp, VALUE klass)
+{
+ if (TYPE(klass) == T_MODULE &&
+ FL_TEST(klass, RMODULE_IS_OVERLAYED) &&
+ TYPE(cfp->klass) == T_ICLASS &&
+ RBASIC(cfp->klass)->klass == klass) {
+ return cfp->klass;
+ }
+ else {
+ return klass;
+ }
+}
+
+static inline VALUE
vm_get_ev_const(rb_thread_t *th, const rb_iseq_t *iseq,
VALUE orig_klass, ID id, int is_defined)
{
@@ -1208,7 +1228,7 @@ vm_get_ev_const(rb_thread_t *th, const rb_iseq_t *iseq,
if (orig_klass == Qnil) {
/* in current lexical scope */
- const NODE *root_cref = vm_get_cref(iseq, th->cfp->ep);
+ const NODE *root_cref = rb_vm_get_cref(iseq, th->cfp->ep);
const NODE *cref;
VALUE klass = orig_klass;
@@ -1254,7 +1274,7 @@ vm_get_ev_const(rb_thread_t *th, const rb_iseq_t *iseq,
/* search self */
if (root_cref && !NIL_P(root_cref->nd_clss)) {
- klass = root_cref->nd_clss;
+ klass = vm_get_iclass(th->cfp, root_cref->nd_clss);
}
else {
klass = CLASS_OF(th->cfp->self);
@@ -1279,7 +1299,7 @@ vm_get_ev_const(rb_thread_t *th, const rb_iseq_t *iseq,
}
static inline VALUE
-vm_get_cvar_base(NODE *cref)
+vm_get_cvar_base(NODE *cref, rb_control_frame_t *cfp)
{
VALUE klass;
@@ -1296,7 +1316,7 @@ vm_get_cvar_base(NODE *cref)
rb_warn("class variable access from toplevel");
}
- klass = cref->nd_clss;
+ klass = vm_get_iclass(cfp, cref->nd_clss);
if (NIL_P(klass)) {
rb_raise(rb_eTypeError, "no class variables available");
@@ -1805,3 +1825,43 @@ opt_eq_func(VALUE recv, VALUE obj, IC ic)
return Qundef;
}
+void rb_using_module(NODE *cref, VALUE module);
+
+static int
+vm_using_module_i(VALUE module, VALUE value, VALUE arg)
+{
+ NODE *cref = (NODE *) arg;
+
+ rb_using_module(cref, module);
+ return ST_CONTINUE;
+}
+
+static void
+rb_vm_using_modules(NODE *cref, VALUE klass)
+{
+ ID id_using_modules;
+ VALUE using_modules;
+
+ CONST_ID(id_using_modules, "__using_modules__");
+ using_modules = rb_attr_get(klass, id_using_modules);
+ switch (TYPE(klass)) {
+ case T_CLASS:
+ if (NIL_P(using_modules)) {
+ VALUE super = rb_class_real(RCLASS_SUPER(klass));
+ using_modules = rb_attr_get(super, id_using_modules);
+ if (!NIL_P(using_modules)) {
+ using_modules = rb_hash_dup(using_modules);
+ rb_ivar_set(klass, id_using_modules, using_modules);
+ }
+ }
+ break;
+ case T_MODULE:
+ rb_using_module(cref, klass);
+ break;
+ }
+ if (!NIL_P(using_modules)) {
+ rb_hash_foreach(using_modules, vm_using_module_i,
+ (VALUE) cref);
+ }
+}
+
diff --git a/vm_insnhelper.h b/vm_insnhelper.h
index fdaa818..d78a84c 100644
--- a/vm_insnhelper.h
+++ b/vm_insnhelper.h
@@ -160,8 +160,17 @@ enum vm_regan_acttype {
/* deal with control flow 2: method/iterator */
/**********************************************************/
+#define COPY_CREF_OMOD(c1, c2) do { \
+ (c1)->nd_omod = (c2)->nd_omod; \
+ if (!NIL_P((c2)->nd_omod)) { \
+ (c1)->flags |= NODE_FL_CREF_OMOD_SHARED; \
+ (c2)->flags |= NODE_FL_CREF_OMOD_SHARED; \
+ } \
+} while (0)
+
#define COPY_CREF(c1, c2) do { \
NODE *__tmp_c2 = (c2); \
+ COPY_CREF_OMOD(c1, __tmp_c2); \
(c1)->nd_clss = __tmp_c2->nd_clss; \
(c1)->nd_visi = __tmp_c2->nd_visi;\
(c1)->nd_next = __tmp_c2->nd_next; \
diff --git a/vm_method.c b/vm_method.c
index 9acded6..13174dd 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 omod; /* overlay modules */
rb_method_entry_t *me;
VALUE defined_class;
};
@@ -385,12 +386,20 @@ rb_get_alloc_func(VALUE klass)
}
static rb_method_entry_t*
-search_method(VALUE klass, ID id, VALUE *defined_class_ptr)
+search_method(VALUE klass, ID id, VALUE omod, VALUE *defined_class_ptr)
{
st_data_t body;
+ VALUE iclass, skipped_class = Qnil;
for (body = 0; klass; klass = RCLASS_SUPER(klass)) {
- st_table *m_tbl = RCLASS_M_TBL(klass);
+ st_table *m_tbl;
+
+ if (!NIL_P(omod) && klass != skipped_class &&
+ !NIL_P(iclass = rb_hash_lookup(omod, klass))) {
+ skipped_class = klass;
+ klass = iclass;
+ }
+ m_tbl = RCLASS_M_TBL(klass);
if (!m_tbl) {
m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(RBASIC(klass)->klass));
}
@@ -409,17 +418,18 @@ 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 omod, 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, omod, &defined_class);
if (ruby_running) {
struct cache_entry *ent;
- ent = cache + EXPR1(klass, id);
+ ent = cache + EXPR1(klass, omod, id);
ent->filled_version = GET_VM_STATE_VERSION();
ent->klass = klass;
+ ent->omod = omod;
ent->defined_class = defined_class;
if (UNDEFINED_METHOD_ENTRY_P(me)) {
@@ -439,19 +449,33 @@ 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_omod(VALUE omod, VALUE klass, ID id,
+ VALUE *defined_class_ptr)
{
struct cache_entry *ent;
- ent = cache + EXPR1(klass, id);
+ ent = cache + EXPR1(klass, omod, id);
if (ent->filled_version == GET_VM_STATE_VERSION() &&
- ent->mid == id && ent->klass == klass) {
+ ent->mid == id && ent->klass == klass && ent->omod == omod) {
if (defined_class_ptr)
*defined_class_ptr = ent->defined_class;
return ent->me;
}
- return rb_method_entry_get_without_cache(klass, id, defined_class_ptr);
+ return rb_method_entry_get_without_cache(klass, omod, id,
+ defined_class_ptr);
+}
+
+rb_method_entry_t *
+rb_method_entry(VALUE klass, ID id, VALUE *defined_class_ptr)
+{
+ NODE *cref = rb_vm_cref();
+ VALUE omod = Qnil;
+
+ if (cref && !NIL_P(cref->nd_omod)) {
+ omod = cref->nd_omod;
+ }
+ return rb_method_entry_get_with_omod(omod, klass, id, defined_class_ptr);
}
static void
@@ -550,9 +574,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)) {
@@ -640,6 +664,9 @@ void
rb_undef(VALUE klass, ID id)
{
rb_method_entry_t *me;
+ NODE *cref = rb_vm_cref();
+ VALUE omod = Qnil;
+ void rb_overlay_module(NODE *cref, VALUE klass, VALUE module);
if (NIL_P(klass)) {
rb_raise(rb_eTypeError, "no class to undef method");
@@ -655,7 +682,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_omod)) {
+ omod = cref->nd_omod;
+ }
+ me = search_method(klass, id, omod, 0);
if (UNDEFINED_METHOD_ENTRY_P(me)) {
const char *s0 = " class";
@@ -676,6 +706,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_overlay_module(cref, klass, mod);
+ klass = mod;
+ }
rb_add_method(klass, id, VM_METHOD_TYPE_UNDEF, 0, NOEX_PUBLIC);
CALL_METHOD_HOOK(klass, undefined, id);
@@ -980,11 +1015,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);
}
@@ -1260,9 +1295,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);
@@ -1376,6 +1411,20 @@ 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;
+
+ if (!st_lookup(RCLASS_M_TBL(klass), 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, klass);
+}
+
+void
Init_eval_method(void)
{
#undef rb_intern