diff --git a/bootstraptest/test_method.rb b/bootstraptest/test_method.rb index f57bf62..550a1aa 100644 --- a/bootstraptest/test_method.rb +++ b/bootstraptest/test_method.rb @@ -287,16 +287,17 @@ assert_equal '1', %q( class C; def m() 1 end end assert_equal '1', %q( class C def m def mm() 1 end + mm end end - C.new.m - C.new.mm ) + C.new.m ) assert_equal '1', %q( class C def m def mm() 1 end + mm end end - instance_eval "C.new.m; C.new.mm" ) + instance_eval "C.new.m" ) # method_missing assert_equal ':m', %q( class C diff --git a/class.c b/class.c index 9ad8ec8..2547238 100644 --- a/class.c +++ b/class.c @@ -594,8 +594,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); @@ -658,7 +658,7 @@ rb_include_module(VALUE klass, 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: @@ -1360,7 +1360,7 @@ rb_define_attr(VALUE klass, const char *name, int read, int write) int rb_obj_basic_to_s_p(VALUE obj) { - const rb_method_entry_t *me = rb_method_entry(CLASS_OF(obj), rb_intern("to_s")); + const rb_method_entry_t *me = rb_method_entry(CLASS_OF(obj), rb_intern("to_s"), 0); if (me && me->def && me->def->type == VM_METHOD_TYPE_CFUNC && me->def->body.cfunc.func == rb_any_to_s) return 1; diff --git a/compile.c b/compile.c index 2fd804c..d56de76 100644 --- a/compile.c +++ b/compile.c @@ -4571,7 +4571,9 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped) ADD_INSN1(ret, nd_line(node), putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_CBASE)); ADD_INSN1(ret, nd_line(node), putobject, ID2SYM(node->nd_mid)); ADD_INSN1(ret, nd_line(node), putiseq, iseqval); - ADD_SEND (ret, nd_line(node), ID2SYM(id_core_define_method), INT2FIX(3)); + ADD_INSN1(ret, nd_line(node), putobject, + node->flags & NODE_FL_NESTED_DEF ? Qtrue : Qfalse); + ADD_SEND (ret, nd_line(node), ID2SYM(id_core_define_method), INT2FIX(4)); if (poped) { ADD_INSN(ret, nd_line(node), pop); diff --git a/eval.c b/eval.c index 2596921..ba6a87d 100644 --- a/eval.c +++ b/eval.c @@ -20,9 +20,11 @@ #define numberof(array) (int)(sizeof(array) / sizeof((array)[0])) VALUE proc_invoke(VALUE, VALUE, VALUE, VALUE); -VALUE rb_binding_new(void); +VALUE rb_binding_new(int); NORETURN(void rb_raise_jump(VALUE)); +NODE *rb_vm_get_cref(const rb_iseq_t *, const VALUE *, const VALUE *); + ID rb_frame_callee(void); VALUE rb_eLocalJumpError; VALUE rb_eSysStackError; @@ -968,6 +970,70 @@ top_include(int argc, VALUE *argv, VALUE self) return rb_mod_include(argc, argv, rb_cObject); } +void +rb_overlay_module(NODE *cref, VALUE klass, VALUE module) +{ + VALUE iclass, c, superclass = klass; + + 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; + } + } + c = iclass = rb_include_class_new(module, superclass); + module = RCLASS_SUPER(module); + while (module) { + 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); +} + +/* + * call-seq: + * overlay_module(klass, mod [, binding]) + * + * Append features of mod to klass only in the scope where + * overlay_module is called. + */ + +static VALUE +f_overlay_module(int argc, VALUE *argv, VALUE self) +{ + VALUE klass, module, binding; + NODE *cref; + + rb_scan_args(argc, argv, "21", &klass, &module, &binding); + if (NIL_P(binding)) { + cref = rb_vm_cref(); + } + else { + rb_binding_t *bind; + rb_env_t *env; + + if (!rb_obj_is_kind_of(binding, rb_cBinding)) { + rb_raise(rb_eTypeError, + "wrong argument type %s (expected Binding)", + rb_obj_classname(binding)); + } + GetBindingPtr(binding, bind); + GetEnvPtr(bind->env, env); + cref = rb_vm_get_cref(env->block.iseq, env->block.lfp, env->block.dfp); + } + rb_overlay_module(cref, klass, module); + return Qnil; +} + VALUE rb_f_trace_var(); VALUE rb_f_untrace_var(); @@ -1135,6 +1201,8 @@ Init_eval(void) rb_define_singleton_method(rb_vm_top_self(), "include", top_include, -1); + rb_define_global_function("overlay_module", f_overlay_module, -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 9bde487..077331a 100644 --- a/gc.c +++ b/gc.c @@ -1696,6 +1696,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.u0.value, 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 0ae4d47..00c844a 100644 --- a/include/ruby/intern.h +++ b/include/ruby/intern.h @@ -169,6 +169,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); @@ -321,7 +322,7 @@ VALUE rb_proc_call(VALUE, VALUE); VALUE rb_proc_call_with_block(VALUE, int argc, VALUE *argv, VALUE); int rb_proc_arity(VALUE); VALUE rb_proc_lambda_p(VALUE); -VALUE rb_binding_new(void); +VALUE rb_binding_new(int); VALUE rb_obj_method(VALUE, VALUE); VALUE rb_method_call(int, VALUE*, VALUE); int rb_mod_method_arity(VALUE, ID); diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index 028f4e9..30272ef 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -621,6 +621,7 @@ struct RClass { #define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m) #define RMODULE_M_TBL(m) RCLASS_M_TBL(m) #define RMODULE_SUPER(m) RCLASS_SUPER(m) +#define RMODULE_HAS_NESTED_METHODS FL_USER2 struct RFloat { struct RBasic basic; diff --git a/insns.def b/insns.def index fcd97ae..8663ef3 100644 --- a/insns.def +++ b/insns.def @@ -183,7 +183,7 @@ getclassvariable () (VALUE val) { - NODE * const cref = vm_get_cref(GET_ISEQ(), GET_LFP(), GET_DFP()); + NODE * const cref = rb_vm_get_cref(GET_ISEQ(), GET_LFP(), GET_DFP()); val = rb_cvar_get(vm_get_cvar_base(cref), id); } @@ -198,7 +198,7 @@ setclassvariable (VALUE val) () { - NODE * const cref = vm_get_cref(GET_ISEQ(), GET_LFP(), GET_DFP()); + NODE * const cref = rb_vm_get_cref(GET_ISEQ(), GET_LFP(), GET_DFP()); rb_cvar_set(vm_get_cvar_base(cref), id, val); } @@ -788,7 +788,7 @@ defined break; case DEFINED_METHOD:{ VALUE klass = CLASS_OF(v); - const rb_method_entry_t *me = rb_method_entry(klass, SYM2ID(obj)); + const rb_method_entry_t *me = rb_method_entry(klass, SYM2ID(obj), 0); if (me) { if (!(me->flag & NOEX_PRIVATE)) { @@ -960,7 +960,7 @@ defineclass /* enter scope */ vm_push_frame(th, class_iseq, - VM_FRAME_MAGIC_CLASS, klass, (VALUE) GET_BLOCK_PTR(), + VM_FRAME_MAGIC_CLASS, klass, 0, (VALUE) GET_BLOCK_PTR(), class_iseq->iseq_encoded, GET_SP(), 0, class_iseq->local_size); RESTORE_REGS(); @@ -992,7 +992,7 @@ send (VALUE val) // inc += - (int)(op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0)); { const rb_method_entry_t *me; - VALUE recv, klass; + VALUE recv, klass, defined_class; rb_block_t *blockptr = 0; int num = caller_setup_args(th, GET_CFP(), op_flag, (int)op_argc, (rb_iseq_t *)blockiseq, &blockptr); @@ -1002,8 +1002,8 @@ send /* get receiver */ recv = (flag & VM_CALL_FCALL_BIT) ? GET_SELF() : TOPN(num); klass = CLASS_OF(recv); - me = vm_method_search(id, klass, ic); - CALL_METHOD(num, blockptr, flag, id, me, recv); + me = vm_method_search(id, klass, ic, &defined_class); + CALL_METHOD(num, blockptr, flag, id, me, recv, defined_class); } /** @@ -1026,18 +1026,24 @@ invokesuper ID id; VALUE flag = VM_CALL_SUPER_BIT | VM_CALL_FCALL_BIT; const rb_method_entry_t *me; + rb_iseq_t *ip; recv = GET_SELF(); vm_search_superclass(GET_CFP(), GET_ISEQ(), recv, TOPN(num), &id, &klass); - /* temporary measure for [Bug #2402] [Bug #2502] [Bug #3136] */ - if (!rb_obj_is_kind_of(recv, klass)) { - rb_raise(rb_eNotImpError, "super from singleton method that is defined to multiple classes is not supported; this will be fixed in 1.9.3 or later"); + ip = GET_ISEQ(); + 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(klass, id); - - CALL_METHOD(num, blockptr, flag, id, me, recv); + CALL_METHOD(num, blockptr, flag, id, me, recv, klass); } /** @@ -1661,7 +1667,7 @@ opt_neq (VALUE val) { extern VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2); - const rb_method_entry_t *me = vm_method_search(idNeq, CLASS_OF(recv), ic); + const rb_method_entry_t *me = vm_method_search(idNeq, CLASS_OF(recv), ic, 0); val = Qundef; if (check_cfunc(me, rb_obj_not_equal)) { @@ -2062,7 +2068,7 @@ opt_not (VALUE val) { extern VALUE rb_obj_not(VALUE obj); - const rb_method_entry_t *me = vm_method_search(idNot, CLASS_OF(recv), ic); + const rb_method_entry_t *me = vm_method_search(idNot, CLASS_OF(recv), ic, 0); if (check_cfunc(me, rb_obj_not)) { val = RTEST(recv) ? Qfalse : Qtrue; diff --git a/iseq.c b/iseq.c index d7c8fb3..3f5cb1e 100644 --- a/iseq.c +++ b/iseq.c @@ -179,20 +179,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->nd_file = 0; + 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); - cref->nd_file = 0; + 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->nd_file = 0; + iseq->cref_stack = NEW_CREF(0); /* place holder */ + iseq->cref_stack->nd_omod = Qnil; } else if (RTEST(parent)) { rb_iseq_t *piseq; @@ -1365,7 +1365,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/lib/classbox.rb b/lib/classbox.rb new file mode 100644 index 0000000..91e9ab9 --- /dev/null +++ b/lib/classbox.rb @@ -0,0 +1,47 @@ +class Classbox < Module + def import_to(binding) + @__overlayed_modules__.each do |klass, modules| + modules.each do |mod| + overlay_module(klass, mod, binding) + end + end + end + + private + + def initialize + super + @__overlayed_modules__ = {} + end + + @@__optimized_methods__ = [ + :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=, :>, :>=, :!, :!=, + :length, :size, :succ + ] + + def refine(klass, &block) + mod = Module.new + modules = @__overlayed_modules__[klass] ||= [] + modules.push(mod) + overlay_module(klass, mod, binding(1)) + mod.singleton_class.send(:define_method, :method_added) do |mid| + if @@__optimized_methods__.include?(mid) + klass.send(:alias_method, :__original_optimized_method__, mid) + klass.send(:define_method, mid) {} + klass.send(:alias_method, mid, :__original_optimized_method__) + klass.send(:remove_method, :__original_optimized_method__) + end + end + mod.module_eval(&block) + end +end + +def classbox(name, &block) + classbox = Classbox.new + Object.const_set(name, classbox) + classbox.module_eval(&block) +end + +def import_classbox(classbox) + classbox.import_to(binding(1)) +end diff --git a/method.h b/method.h index e03f0d2..73ff8df 100644 --- a/method.h +++ b/method.h @@ -89,9 +89,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); +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); +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 82f7ba0..405a469 100644 --- a/node.h +++ b/node.h @@ -188,6 +188,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, @@ -234,7 +236,10 @@ enum node_type { typedef struct RNode { unsigned long flags; - char *nd_file; + union { + char *file; + VALUE value; + } u0; union { struct RNode *node; ID id; @@ -260,9 +265,11 @@ typedef struct RNode { #define RNODE(obj) (R_CAST(RNode)(obj)) -/* 0..4:T_TYPES, 5:FL_MARK, 6:reserved, 7:NODE_FL_NEWLINE */ +/* 0..4:T_TYPES, 5:FL_MARK, 6:NODE_FL_NESTED_DEF, 7:NODE_FL_NEWLINE */ #define NODE_FL_NEWLINE (((VALUE)1)<<7) +#define NODE_FL_NESTED_DEF (((VALUE)1)<<6) #define NODE_FL_CREF_PUSHED_BY_EVAL NODE_FL_NEWLINE +#define NODE_FL_CREF_OMOD_SHARED NODE_FL_NESTED_DEF #define NODE_TYPESHIFT 8 #define NODE_TYPEMASK (((VALUE)0x7f)<flags=((RNODE(n)->flags&~(-1<1); + if (in_def > 1 || in_single > 0) + $$->flags |= NODE_FL_NESTED_DEF; /*% $$ = dispatch3(def, $2, $4, $5); %*/ diff --git a/proc.c b/proc.c index 0489dd9..de2ed3d 100644 --- a/proc.c +++ b/proc.c @@ -15,6 +15,7 @@ struct METHOD { VALUE recv; VALUE rclass; + VALUE defined_class; ID id; rb_method_entry_t me; }; @@ -310,13 +311,21 @@ binding_clone(VALUE self) } VALUE -rb_binding_new(void) +rb_binding_new(int level) { rb_thread_t *th = GET_THREAD(); rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(th, th->cfp); VALUE bindval = binding_alloc(rb_cBinding); rb_binding_t *bind; + int i; + if (level < 0) { + rb_raise(rb_eArgError, "level should not be negative: %d", level); + } + for (i = 0; i < level && cfp; i++) { + cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); + cfp = rb_vm_get_ruby_level_next_cfp(th, cfp); + } if (cfp == 0) { rb_raise(rb_eRuntimeError, "Can't create Binding Object on top of Fiber."); } @@ -345,9 +354,16 @@ rb_binding_new(void) */ static VALUE -rb_f_binding(VALUE self) +rb_f_binding(int argc, VALUE *argv, VALUE self) { - return rb_binding_new(); + VALUE vlevel; + int level = 0; + + rb_scan_args(argc, argv, "01", &vlevel); + if (!NIL_P(vlevel)) { + level = NUM2INT(vlevel); + } + return rb_binding_new(level); } /* @@ -861,6 +877,7 @@ static void bm_mark(void *ptr) { struct METHOD *data = ptr; + rb_gc_mark(data->defined_class); rb_gc_mark(data->rclass); rb_gc_mark(data->recv); rb_mark_method_entry(&data->me); @@ -903,7 +920,7 @@ static VALUE mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope) { VALUE method; - VALUE rclass = klass; + VALUE rclass = klass, defined_class; ID rid = id; struct METHOD *data; rb_method_entry_t *me, meb; @@ -911,7 +928,7 @@ mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope) rb_method_flag_t flag = NOEX_UNDEF; again: - me = rb_method_entry(klass, id); + 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); @@ -953,12 +970,12 @@ mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope) } } if (def && def->type == VM_METHOD_TYPE_ZSUPER) { - klass = RCLASS_SUPER(me->klass); + klass = RCLASS_SUPER(defined_class); id = def->original_id; goto again; } - klass = me->klass; + klass = defined_class; while (rclass != klass && (FL_TEST(rclass, FL_SINGLETON) || TYPE(rclass) == T_ICLASS)) { @@ -974,6 +991,7 @@ mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope) data->recv = obj; data->rclass = rclass; + data->defined_class = defined_class; data->id = rid; data->me = *me; if (def) def->alias_count++; @@ -1085,6 +1103,7 @@ method_unbind(VALUE obj) data->me = orig->me; if (orig->me.def) orig->me.def->alias_count++; data->rclass = orig->rclass; + data->defined_class = orig->defined_class; OBJ_INFECT(method, obj); return method; @@ -1421,10 +1440,10 @@ rb_method_call(int argc, VALUE *argv, VALUE method) if ((state = EXEC_TAG()) == 0) { rb_thread_t *th = GET_THREAD(); VALUE rb_vm_call(rb_thread_t *th, VALUE recv, VALUE id, int argc, const VALUE *argv, - const rb_method_entry_t *me); + const rb_method_entry_t *me, VALUE defined_class); PASS_PASSED_BLOCK_TH(th); - result = rb_vm_call(th, data->recv, data->id, argc, argv, &data->me); + result = rb_vm_call(th, data->recv, data->id, argc, argv, &data->me, data->defined_class); } POP_TAG(); if (safe >= 0) @@ -1648,7 +1667,7 @@ method_arity(VALUE method) int rb_mod_method_arity(VALUE mod, ID id) { - rb_method_entry_t *me = rb_method_entry(mod, id); + rb_method_entry_t *me = rb_method_entry(mod, id, 0); return rb_method_entry_arity(me); } @@ -2234,6 +2253,6 @@ Init_Binding(void) rb_define_method(rb_cBinding, "clone", binding_clone, 0); rb_define_method(rb_cBinding, "dup", binding_dup, 0); rb_define_method(rb_cBinding, "eval", bind_eval, -1); - rb_define_global_function("binding", rb_f_binding, 0); + rb_define_global_function("binding", rb_f_binding, -1); } diff --git a/test/rdoc/test_rdoc_text.rb b/test/rdoc/test_rdoc_text.rb index 7e0f2cf..3b4b78e 100644 --- a/test/rdoc/test_rdoc_text.rb +++ b/test/rdoc/test_rdoc_text.rb @@ -62,8 +62,8 @@ The comments associated with assert_equal expected, flush_left(text) end + def formatter() RDoc::Markup::ToHtml.new end def test_markup - def formatter() RDoc::Markup::ToHtml.new end assert_equal "

\nhi\n