diff options
Diffstat (limited to 'proc.c')
| -rw-r--r-- | proc.c | 4200 |
1 files changed, 3240 insertions, 960 deletions
@@ -11,16 +11,32 @@ #include "eval_intern.h" #include "internal.h" -#include "gc.h" +#include "internal/class.h" +#include "internal/error.h" +#include "internal/eval.h" +#include "internal/gc.h" +#include "internal/hash.h" +#include "internal/object.h" +#include "internal/proc.h" +#include "internal/symbol.h" +#include "method.h" #include "iseq.h" +#include "vm_core.h" +#include "ractor_core.h" +#include "yjit.h" + +const rb_cref_t *rb_vm_cref_in_context(VALUE self, VALUE cbase); struct METHOD { - VALUE recv; - VALUE rclass; - VALUE defined_class; - ID id; - rb_method_entry_t *me; - struct unlinked_method_entry_list_entry *ume; + const VALUE recv; + const VALUE klass; + /* needed for #super_method */ + const VALUE iclass; + /* Different than me->owner only for ZSUPER methods. + This is error-prone but unavoidable unless ZSUPER methods are removed. */ + const VALUE owner; + const rb_method_entry_t * const me; + /* for bound methods, `me' should be rb_callable_method_entry_t * */ }; VALUE rb_cUnboundMethod; @@ -28,56 +44,69 @@ VALUE rb_cMethod; VALUE rb_cBinding; VALUE rb_cProc; -static VALUE bmcall(VALUE, VALUE, int, VALUE *, VALUE); +static rb_block_call_func bmcall; static int method_arity(VALUE); static int method_min_max_arity(VALUE, int *max); -static ID attached; +static VALUE proc_binding(VALUE self); /* Proc */ -#define IS_METHOD_PROC_NODE(node) (nd_type(node) == NODE_IFUNC && (node)->nd_cfnc == bmcall) +#define IS_METHOD_PROC_IFUNC(ifunc) ((ifunc)->func == bmcall) static void -proc_free(void *ptr) +block_mark_and_move(struct rb_block *block) { - RUBY_FREE_ENTER("proc"); - if (ptr) { - ruby_xfree(ptr); + switch (block->type) { + case block_type_iseq: + case block_type_ifunc: + { + struct rb_captured_block *captured = &block->as.captured; + rb_gc_mark_and_move(&captured->self); + rb_gc_mark_and_move(&captured->code.val); + if (captured->ep) { + rb_gc_mark_and_move((VALUE *)&captured->ep[VM_ENV_DATA_INDEX_ENV]); + } + } + break; + case block_type_symbol: + rb_gc_mark_and_move(&block->as.symbol); + break; + case block_type_proc: + rb_gc_mark_and_move(&block->as.proc); + break; } - RUBY_FREE_LEAVE("proc"); } static void -proc_mark(void *ptr) +proc_mark_and_move(void *ptr) { - rb_proc_t *proc; - RUBY_MARK_ENTER("proc"); - if (ptr) { - proc = ptr; - RUBY_MARK_UNLESS_NULL(proc->envval); - RUBY_MARK_UNLESS_NULL(proc->blockprocval); - RUBY_MARK_UNLESS_NULL(proc->block.proc); - RUBY_MARK_UNLESS_NULL(proc->block.self); - if (proc->block.iseq && RUBY_VM_IFUNC_P(proc->block.iseq)) { - RUBY_MARK_UNLESS_NULL((VALUE)(proc->block.iseq)); - } - } - RUBY_MARK_LEAVE("proc"); + rb_proc_t *proc = ptr; + block_mark_and_move((struct rb_block *)&proc->block); } +typedef struct { + rb_proc_t basic; + VALUE env[VM_ENV_DATA_SIZE + 1]; /* ..., envval */ +} cfunc_proc_t; + static size_t proc_memsize(const void *ptr) { - return ptr ? sizeof(rb_proc_t) : 0; + const rb_proc_t *proc = ptr; + if (proc->block.as.captured.ep == ((const cfunc_proc_t *)ptr)->env+1) + return sizeof(cfunc_proc_t); + return sizeof(rb_proc_t); } static const rb_data_type_t proc_data_type = { "proc", { - proc_mark, - proc_free, - proc_memsize, + proc_mark_and_move, + RUBY_TYPED_DEFAULT_FREE, + proc_memsize, + proc_mark_and_move, }, + 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED }; VALUE @@ -90,48 +119,33 @@ rb_proc_alloc(VALUE klass) VALUE rb_obj_is_proc(VALUE proc) { - if (rb_typeddata_is_kind_of(proc, &proc_data_type)) { - return Qtrue; - } - else { - return Qfalse; - } + return RBOOL(rb_typeddata_is_kind_of(proc, &proc_data_type)); } /* :nodoc: */ static VALUE -proc_dup(VALUE self) +proc_clone(VALUE self) { - VALUE procval = rb_proc_alloc(rb_cProc); - rb_proc_t *src, *dst; - GetProcPtr(self, src); - GetProcPtr(procval, dst); - - dst->block = src->block; - dst->block.proc = procval; - dst->blockprocval = src->blockprocval; - dst->envval = src->envval; - dst->safe_level = src->safe_level; - dst->is_lambda = src->is_lambda; - - return procval; + VALUE procval = rb_proc_dup(self); + return rb_obj_clone_setup(self, procval, Qnil); } /* :nodoc: */ static VALUE -proc_clone(VALUE self) +proc_dup(VALUE self) { - VALUE procval = proc_dup(self); - CLONESETUP(procval, self); - return procval; + VALUE procval = rb_proc_dup(self); + return rb_obj_dup_setup(self, procval); } /* * call-seq: * prc.lambda? -> true or false * - * Returns +true+ for a Proc object for which argument handling is rigid. - * Such procs are typically generated by +lambda+. + * Returns +true+ if a Proc object is lambda. + * +false+ if non-lambda. + * + * The lambda-ness affects argument handling and the behavior of +return+ and +break+. * * A Proc object generated by +proc+ ignores extra arguments. * @@ -211,7 +225,7 @@ proc_clone(VALUE self) * C.new.e(1,2) #=> ArgumentError * C.new.method(:e).to_proc.lambda? #=> true * - * This exception insures that methods never have tricks + * This exception ensures that methods never have tricks * and makes it easy to have wrappers to define methods that behave as usual. * * class C @@ -233,7 +247,7 @@ rb_proc_lambda_p(VALUE procval) rb_proc_t *proc; GetProcPtr(procval, proc); - return proc->is_lambda ? Qtrue : Qfalse; + return RBOOL(proc->is_lambda); } /* Binding */ @@ -241,42 +255,35 @@ rb_proc_lambda_p(VALUE procval) static void binding_free(void *ptr) { - rb_binding_t *bind; RUBY_FREE_ENTER("binding"); - if (ptr) { - bind = ptr; - ruby_xfree(bind); - } + ruby_xfree(ptr); RUBY_FREE_LEAVE("binding"); } static void -binding_mark(void *ptr) +binding_mark_and_move(void *ptr) { - rb_binding_t *bind; - RUBY_MARK_ENTER("binding"); - if (ptr) { - bind = ptr; - RUBY_MARK_UNLESS_NULL(bind->env); - RUBY_MARK_UNLESS_NULL(bind->path); - RUBY_MARK_UNLESS_NULL(bind->blockprocval); - } - RUBY_MARK_LEAVE("binding"); + rb_binding_t *bind = ptr; + + block_mark_and_move((struct rb_block *)&bind->block); + rb_gc_mark_and_move((VALUE *)&bind->pathobj); } static size_t binding_memsize(const void *ptr) { - return ptr ? sizeof(rb_binding_t) : 0; + return sizeof(rb_binding_t); } -static const rb_data_type_t binding_data_type = { +const rb_data_type_t ruby_binding_data_type = { "binding", { - binding_mark, - binding_free, - binding_memsize, + binding_mark_and_move, + binding_free, + binding_memsize, + binding_mark_and_move, }, + 0, 0, RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY }; VALUE @@ -284,61 +291,89 @@ rb_binding_alloc(VALUE klass) { VALUE obj; rb_binding_t *bind; - obj = TypedData_Make_Struct(klass, rb_binding_t, &binding_data_type, bind); + obj = TypedData_Make_Struct(klass, rb_binding_t, &ruby_binding_data_type, bind); +#if YJIT_STATS + rb_yjit_collect_binding_alloc(); +#endif return obj; } -/* :nodoc: */ static VALUE -binding_dup(VALUE self) +binding_copy(VALUE self) { VALUE bindval = rb_binding_alloc(rb_cBinding); rb_binding_t *src, *dst; GetBindingPtr(self, src); GetBindingPtr(bindval, dst); - dst->env = src->env; - dst->path = src->path; - dst->blockprocval = src->blockprocval; + rb_vm_block_copy(bindval, &dst->block, &src->block); + RB_OBJ_WRITE(bindval, &dst->pathobj, src->pathobj); dst->first_lineno = src->first_lineno; return bindval; } /* :nodoc: */ static VALUE -binding_clone(VALUE self) +binding_dup(VALUE self) { - VALUE bindval = binding_dup(self); - CLONESETUP(bindval, self); - return bindval; + return rb_obj_dup_setup(self, binding_copy(self)); } -VALUE -rb_binding_new_with_cfp(rb_thread_t *th, const rb_control_frame_t *src_cfp) +/* :nodoc: */ +static VALUE +binding_clone(VALUE self) { - return rb_vm_make_binding(th, src_cfp); + return rb_obj_clone_setup(self, binding_copy(self), Qnil); } VALUE rb_binding_new(void) { - rb_thread_t *th = GET_THREAD(); - return rb_binding_new_with_cfp(th, th->cfp); + rb_execution_context_t *ec = GET_EC(); + return rb_vm_make_binding(ec, ec->cfp); } /* * call-seq: * binding -> a_binding * - * Returns a +Binding+ object, describing the variable and + * Returns a Binding object, describing the variable and * method bindings at the point of call. This object can be used when - * calling +eval+ to execute the evaluated command in this - * environment. See also the description of class +Binding+. + * calling Binding#eval to execute the evaluated command in this + * environment, or extracting its local variables. * - * def get_binding(param) - * return binding + * class User + * def initialize(name, position) + * @name = name + * @position = position + * end + * + * def get_binding + * binding + * end * end - * b = get_binding("hello") - * eval("param", b) #=> "hello" + * + * user = User.new('Joan', 'manager') + * template = '{name: @name, position: @position}' + * + * # evaluate template in context of the object + * eval(template, user.get_binding) + * #=> {:name=>"Joan", :position=>"manager"} + * + * Binding#local_variable_get can be used to access the variables + * whose names are reserved Ruby keywords: + * + * # This is valid parameter declaration, but `if` parameter can't + * # be accessed by name, because it is a reserved word. + * def validate(field, validation, if: nil) + * condition = binding.local_variable_get('if') + * return unless condition + * + * # ...Some implementation ... + * end + * + * validate(:name, :empty?, if: false) # skips validation + * validate(:name, :empty?, if: true) # performs validation + * */ static VALUE @@ -357,7 +392,7 @@ rb_f_binding(VALUE self) * reporting syntax errors. * * def get_binding(param) - * return binding + * binding * end * b = get_binding("hello") * b.eval("param") #=> "hello" @@ -373,69 +408,569 @@ bind_eval(int argc, VALUE *argv, VALUE bindval) return rb_f_eval(argc+1, args, Qnil /* self will be searched in eval */); } -static VALUE -proc_new(VALUE klass, int is_lambda) +static const VALUE * +get_local_variable_ptr(const rb_env_t **envp, ID lid, bool search_outer) { - VALUE procval = Qnil; - rb_thread_t *th = GET_THREAD(); - rb_control_frame_t *cfp = th->cfp; - rb_block_t *block; + const rb_env_t *env = *envp; + do { + if (!VM_ENV_FLAGS(env->ep, VM_FRAME_FLAG_CFRAME)) { + if (VM_ENV_FLAGS(env->ep, VM_ENV_FLAG_ISOLATED)) { + return NULL; + } + + const rb_iseq_t *iseq = env->iseq; + + VM_ASSERT(rb_obj_is_iseq((VALUE)iseq)); + + const unsigned int local_table_size = ISEQ_BODY(iseq)->local_table_size; + for (unsigned int i=0; i<local_table_size; i++) { + if (ISEQ_BODY(iseq)->local_table[i] == lid) { + if (ISEQ_BODY(iseq)->local_iseq == iseq && + ISEQ_BODY(iseq)->param.flags.has_block && + (unsigned int)ISEQ_BODY(iseq)->param.block_start == i) { + const VALUE *ep = env->ep; + if (!VM_ENV_FLAGS(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM)) { + RB_OBJ_WRITE(env, &env->env[i], rb_vm_bh_to_procval(GET_EC(), VM_ENV_BLOCK_HANDLER(ep))); + VM_ENV_FLAGS_SET(ep, VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM); + } + } + + *envp = env; + unsigned int last_lvar = env->env_size+VM_ENV_INDEX_LAST_LVAR + - 1 /* errinfo */; + return &env->env[last_lvar - (local_table_size - i)]; + } + } + } + else { + *envp = NULL; + return NULL; + } + } while (search_outer && (env = rb_vm_env_prev_env(env)) != NULL); + + *envp = NULL; + return NULL; +} - if ((block = rb_vm_control_frame_block_ptr(cfp)) != 0) { - /* block found */ +/* + * check local variable name. + * returns ID if it's an already interned symbol, or 0 with setting + * local name in String to *namep. + */ +static ID +check_local_id(VALUE bindval, volatile VALUE *pname) +{ + ID lid = rb_check_id(pname); + VALUE name = *pname; + + if (lid) { + if (!rb_is_local_id(lid)) { + rb_name_err_raise("wrong local variable name '%1$s' for %2$s", + bindval, ID2SYM(lid)); + } } else { - cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); + if (!rb_is_local_name(name)) { + rb_name_err_raise("wrong local variable name '%1$s' for %2$s", + bindval, name); + } + return 0; + } + return lid; +} + +/* + * call-seq: + * binding.local_variables -> Array + * + * Returns the names of the binding's local variables as symbols. + * + * def foo + * a = 1 + * 2.times do |n| + * binding.local_variables #=> [:a, :n] + * end + * end + * + * This method is the short version of the following code: + * + * binding.eval("local_variables") + * + */ +static VALUE +bind_local_variables(VALUE bindval) +{ + const rb_binding_t *bind; + const rb_env_t *env; + + GetBindingPtr(bindval, bind); + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + return rb_vm_env_local_variables(env); +} + +int +rb_numparam_id_p(ID id) +{ + return (tNUMPARAM_1 << ID_SCOPE_SHIFT) <= id && id < ((tNUMPARAM_1 + 9) << ID_SCOPE_SHIFT); +} + +int +rb_implicit_param_p(ID id) +{ + return id == idItImplicit || rb_numparam_id_p(id); +} + +/* + * call-seq: + * binding.local_variable_get(symbol) -> obj + * + * Returns the value of the local variable +symbol+. + * + * def foo + * a = 1 + * binding.local_variable_get(:a) #=> 1 + * binding.local_variable_get(:b) #=> NameError + * end + * + * This method is the short version of the following code: + * + * binding.eval("#{symbol}") + * + */ +static VALUE +bind_local_variable_get(VALUE bindval, VALUE sym) +{ + ID lid = check_local_id(bindval, &sym); + const rb_binding_t *bind; + const VALUE *ptr; + const rb_env_t *env; + + if (!lid) goto undefined; + if (rb_numparam_id_p(lid)) { + rb_name_err_raise("numbered parameter '%1$s' is not a local variable", + bindval, ID2SYM(lid)); + } + + GetBindingPtr(bindval, bind); + + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + if ((ptr = get_local_variable_ptr(&env, lid, TRUE)) != NULL) { + return *ptr; + } + + sym = ID2SYM(lid); + undefined: + rb_name_err_raise("local variable '%1$s' is not defined for %2$s", + bindval, sym); + UNREACHABLE_RETURN(Qundef); +} + +/* + * call-seq: + * binding.local_variable_set(symbol, obj) -> obj + * + * Set local variable named +symbol+ as +obj+. + * + * def foo + * a = 1 + * bind = binding + * bind.local_variable_set(:a, 2) # set existing local variable `a' + * bind.local_variable_set(:b, 3) # create new local variable `b' + * # `b' exists only in binding + * + * p bind.local_variable_get(:a) #=> 2 + * p bind.local_variable_get(:b) #=> 3 + * p a #=> 2 + * p b #=> NameError + * end + * + * This method behaves similarly to the following code: + * + * binding.eval("#{symbol} = #{obj}") + * + * if +obj+ can be dumped in Ruby code. + */ +static VALUE +bind_local_variable_set(VALUE bindval, VALUE sym, VALUE val) +{ + ID lid = check_local_id(bindval, &sym); + rb_binding_t *bind; + const VALUE *ptr; + const rb_env_t *env; + + if (!lid) lid = rb_intern_str(sym); + if (rb_numparam_id_p(lid)) { + rb_name_err_raise("numbered parameter '%1$s' is not a local variable", + bindval, ID2SYM(lid)); + } + + GetBindingPtr(bindval, bind); + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + if ((ptr = get_local_variable_ptr(&env, lid, TRUE)) == NULL) { + /* not found. create new env */ + ptr = rb_binding_add_dynavars(bindval, bind, 1, &lid); + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + } + +#if YJIT_STATS + rb_yjit_collect_binding_set(); +#endif + + RB_OBJ_WRITE(env, ptr, val); + + return val; +} + +/* + * call-seq: + * binding.local_variable_defined?(symbol) -> obj + * + * Returns +true+ if a local variable +symbol+ exists. + * + * def foo + * a = 1 + * binding.local_variable_defined?(:a) #=> true + * binding.local_variable_defined?(:b) #=> false + * end + * + * This method is the short version of the following code: + * + * binding.eval("defined?(#{symbol}) == 'local-variable'") + * + */ +static VALUE +bind_local_variable_defined_p(VALUE bindval, VALUE sym) +{ + ID lid = check_local_id(bindval, &sym); + const rb_binding_t *bind; + const rb_env_t *env; + + if (!lid) return Qfalse; + if (rb_numparam_id_p(lid)) { + rb_name_err_raise("numbered parameter '%1$s' is not a local variable", + bindval, ID2SYM(lid)); + } + + GetBindingPtr(bindval, bind); + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + return RBOOL(get_local_variable_ptr(&env, lid, TRUE)); +} + +/* + * call-seq: + * binding.implicit_parameters -> Array + * + * Returns the names of numbered parameters and "it" parameter + * that are defined in the binding. + * + * def foo + * [42].each do + * it + * binding.implicit_parameters #=> [:it] + * end + * + * { k: 42 }.each do + * _2 + * binding.implicit_parameters #=> [:_1, :_2] + * end + * end + * + */ +static VALUE +bind_implicit_parameters(VALUE bindval) +{ + const rb_binding_t *bind; + const rb_env_t *env; + + GetBindingPtr(bindval, bind); + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + + if (get_local_variable_ptr(&env, idItImplicit, FALSE)) { + return rb_ary_new_from_args(1, ID2SYM(idIt)); + } + + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + return rb_vm_env_numbered_parameters(env); +} + +/* + * call-seq: + * binding.implicit_parameter_get(symbol) -> obj + * + * Returns the value of the numbered parameter or "it" parameter. + * + * def foo + * [42].each do + * it + * binding.implicit_parameter_get(:it) #=> 42 + * end + * + * { k: 42 }.each do + * _2 + * binding.implicit_parameter_get(:_1) #=> :k + * binding.implicit_parameter_get(:_2) #=> 42 + * end + * end + * + */ +static VALUE +bind_implicit_parameter_get(VALUE bindval, VALUE sym) +{ + ID lid = check_local_id(bindval, &sym); + const rb_binding_t *bind; + const VALUE *ptr; + const rb_env_t *env; - if ((block = rb_vm_control_frame_block_ptr(cfp)) != 0) { - if (is_lambda) { - rb_warn("tried to create Proc object without a block"); - } - } - else { - rb_raise(rb_eArgError, - "tried to create Proc object without a block"); - } + if (lid == idIt) lid = idItImplicit; + + if (!lid || !rb_implicit_param_p(lid)) { + rb_name_err_raise("'%1$s' is not an implicit parameter", + bindval, sym); } - procval = block->proc; + GetBindingPtr(bindval, bind); - if (procval) { - if (RBASIC(procval)->klass == klass) { - return procval; - } - else { - VALUE newprocval = proc_dup(procval); - RBASIC(newprocval)->klass = klass; - return newprocval; - } + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + if ((ptr = get_local_variable_ptr(&env, lid, FALSE)) != NULL) { + return *ptr; } - procval = rb_vm_make_proc(th, block, klass); + if (lid == idItImplicit) lid = idIt; + rb_name_err_raise("implicit parameter '%1$s' is not defined for %2$s", bindval, ID2SYM(lid)); + UNREACHABLE_RETURN(Qundef); +} + +/* + * call-seq: + * binding.implicit_parameter_defined?(symbol) -> obj + * + * Returns +true+ if the numbered parameter or "it" parameter exists. + * + * def foo + * [42].each do + * it + * binding.implicit_parameter_defined?(:it) #=> true + * binding.implicit_parameter_defined?(:_1) #=> false + * end + * + * { k: 42 }.each do + * _2 + * binding.implicit_parameter_defined?(:_1) #=> true + * binding.implicit_parameter_defined?(:_2) #=> true + * binding.implicit_parameter_defined?(:_3) #=> false + * binding.implicit_parameter_defined?(:it) #=> false + * end + * end + * + */ +static VALUE +bind_implicit_parameter_defined_p(VALUE bindval, VALUE sym) +{ + ID lid = check_local_id(bindval, &sym); + const rb_binding_t *bind; + const rb_env_t *env; + + if (lid == idIt) lid = idItImplicit; - if (is_lambda) { - rb_proc_t *proc; - GetProcPtr(procval, proc); - proc->is_lambda = TRUE; + if (!lid || !rb_implicit_param_p(lid)) { + rb_name_err_raise("'%1$s' is not an implicit parameter", + bindval, sym); } + + GetBindingPtr(bindval, bind); + env = VM_ENV_ENVVAL_PTR(vm_block_ep(&bind->block)); + return RBOOL(get_local_variable_ptr(&env, lid, FALSE)); +} + +/* + * call-seq: + * binding.receiver -> object + * + * Returns the bound receiver of the binding object. + */ +static VALUE +bind_receiver(VALUE bindval) +{ + const rb_binding_t *bind; + GetBindingPtr(bindval, bind); + return vm_block_self(&bind->block); +} + +/* + * call-seq: + * binding.source_location -> [String, Integer] + * + * Returns the Ruby source filename and line number of the binding object. + */ +static VALUE +bind_location(VALUE bindval) +{ + VALUE loc[2]; + const rb_binding_t *bind; + GetBindingPtr(bindval, bind); + loc[0] = pathobj_path(bind->pathobj); + loc[1] = INT2FIX(bind->first_lineno); + + return rb_ary_new4(2, loc); +} + +static VALUE +cfunc_proc_new(VALUE klass, VALUE ifunc) +{ + rb_proc_t *proc; + cfunc_proc_t *sproc; + VALUE procval = TypedData_Make_Struct(klass, cfunc_proc_t, &proc_data_type, sproc); + VALUE *ep; + + proc = &sproc->basic; + vm_block_type_set(&proc->block, block_type_ifunc); + + *(VALUE **)&proc->block.as.captured.ep = ep = sproc->env + VM_ENV_DATA_SIZE-1; + ep[VM_ENV_DATA_INDEX_FLAGS] = VM_FRAME_MAGIC_IFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL | VM_ENV_FLAG_ESCAPED; + ep[VM_ENV_DATA_INDEX_ME_CREF] = Qfalse; + ep[VM_ENV_DATA_INDEX_SPECVAL] = VM_BLOCK_HANDLER_NONE; + ep[VM_ENV_DATA_INDEX_ENV] = Qundef; /* envval */ + + /* self? */ + RB_OBJ_WRITE(procval, &proc->block.as.captured.code.ifunc, ifunc); + proc->is_lambda = TRUE; return procval; } +VALUE +rb_func_proc_dup(VALUE src_obj) +{ + RUBY_ASSERT(rb_typeddata_is_instance_of(src_obj, &proc_data_type)); + + rb_proc_t *src_proc; + GetProcPtr(src_obj, src_proc); + RUBY_ASSERT(vm_block_type(&src_proc->block) == block_type_ifunc); + + cfunc_proc_t *proc; + VALUE proc_obj = TypedData_Make_Struct(rb_obj_class(src_obj), cfunc_proc_t, &proc_data_type, proc); + + memcpy(&proc->basic, src_proc, sizeof(rb_proc_t)); + RB_OBJ_WRITTEN(proc_obj, Qundef, proc->basic.block.as.captured.self); + RB_OBJ_WRITTEN(proc_obj, Qundef, proc->basic.block.as.captured.code.val); + + const VALUE *src_ep = src_proc->block.as.captured.ep; + VALUE *ep = *(VALUE **)&proc->basic.block.as.captured.ep = proc->env + VM_ENV_DATA_SIZE - 1; + ep[VM_ENV_DATA_INDEX_FLAGS] = src_ep[VM_ENV_DATA_INDEX_FLAGS]; + ep[VM_ENV_DATA_INDEX_ME_CREF] = src_ep[VM_ENV_DATA_INDEX_ME_CREF]; + ep[VM_ENV_DATA_INDEX_SPECVAL] = src_ep[VM_ENV_DATA_INDEX_SPECVAL]; + RB_OBJ_WRITE(proc_obj, &ep[VM_ENV_DATA_INDEX_ENV], src_ep[VM_ENV_DATA_INDEX_ENV]); + + return proc_obj; +} + +static VALUE +sym_proc_new(VALUE klass, VALUE sym) +{ + VALUE procval = rb_proc_alloc(klass); + rb_proc_t *proc; + GetProcPtr(procval, proc); + + vm_block_type_set(&proc->block, block_type_symbol); + proc->is_lambda = TRUE; + RB_OBJ_WRITE(procval, &proc->block.as.symbol, sym); + return procval; +} + +struct vm_ifunc * +rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc) +{ + if (min_argc < UNLIMITED_ARGUMENTS || +#if SIZEOF_INT * 2 > SIZEOF_VALUE + min_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) || +#endif + 0) { + rb_raise(rb_eRangeError, "minimum argument number out of range: %d", + min_argc); + } + if (max_argc < UNLIMITED_ARGUMENTS || +#if SIZEOF_INT * 2 > SIZEOF_VALUE + max_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) || +#endif + 0) { + rb_raise(rb_eRangeError, "maximum argument number out of range: %d", + max_argc); + } + rb_execution_context_t *ec = GET_EC(); + + struct vm_ifunc *ifunc = IMEMO_NEW(struct vm_ifunc, imemo_ifunc, (VALUE)rb_vm_svar_lep(ec, ec->cfp)); + + rb_gc_register_pinning_obj((VALUE)ifunc); + + ifunc->func = func; + ifunc->data = data; + ifunc->argc.min = min_argc; + ifunc->argc.max = max_argc; + + return ifunc; +} + +VALUE +rb_func_lambda_new(rb_block_call_func_t func, VALUE val, int min_argc, int max_argc) +{ + struct vm_ifunc *ifunc = rb_vm_ifunc_new(func, (void *)val, min_argc, max_argc); + return cfunc_proc_new(rb_cProc, (VALUE)ifunc); +} + +static const char proc_without_block[] = "tried to create Proc object without a block"; + +static VALUE +proc_new(VALUE klass, int8_t is_lambda) +{ + VALUE procval; + const rb_execution_context_t *ec = GET_EC(); + rb_control_frame_t *cfp = ec->cfp; + VALUE block_handler; + + if ((block_handler = rb_vm_frame_block_handler(cfp)) == VM_BLOCK_HANDLER_NONE) { + rb_raise(rb_eArgError, proc_without_block); + } + + /* block is in cf */ + switch (vm_block_handler_type(block_handler)) { + case block_handler_type_proc: + procval = VM_BH_TO_PROC(block_handler); + + if (RBASIC_CLASS(procval) == klass) { + return procval; + } + else { + VALUE newprocval = rb_proc_dup(procval); + RBASIC_SET_CLASS(newprocval, klass); + return newprocval; + } + break; + + case block_handler_type_symbol: + return (klass != rb_cProc) ? + sym_proc_new(klass, VM_BH_TO_SYMBOL(block_handler)) : + rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler)); + break; + + case block_handler_type_ifunc: + case block_handler_type_iseq: + return rb_vm_make_proc_lambda(ec, VM_BH_TO_CAPT_BLOCK(block_handler), klass, is_lambda); + } + VM_UNREACHABLE(proc_new); + return Qnil; +} + /* * call-seq: * Proc.new {|...| block } -> a_proc - * Proc.new -> a_proc * - * Creates a new <code>Proc</code> object, bound to the current - * context. <code>Proc::new</code> may be called without a block only - * within a method with an attached block, in which case that block is - * converted to the <code>Proc</code> object. + * Creates a new Proc object, bound to the current context. * - * def proc_from - * Proc.new - * end - * proc = proc_from { "hello" } + * proc = Proc.new { "hello" } * proc.call #=> "hello" + * + * Raises ArgumentError if called without a block. + * + * Proc.new #=> ArgumentError */ static VALUE @@ -443,17 +978,10 @@ rb_proc_s_new(int argc, VALUE *argv, VALUE klass) { VALUE block = proc_new(klass, FALSE); - rb_obj_call_init(block, argc, argv); + rb_obj_call_init_kw(block, argc, argv, RB_PASS_CALLED_KEYWORDS); return block; } -/* - * call-seq: - * proc { |...| block } -> a_proc - * - * Equivalent to <code>Proc.new</code>. - */ - VALUE rb_block_proc(void) { @@ -462,104 +990,133 @@ rb_block_proc(void) /* * call-seq: - * lambda { |...| block } -> a_proc + * proc { |...| block } -> a_proc * - * Equivalent to <code>Proc.new</code>, except the resulting Proc objects - * check the number of parameters passed when called. + * Equivalent to Proc.new. */ +static VALUE +f_proc(VALUE _) +{ + return proc_new(rb_cProc, FALSE); +} + VALUE rb_block_lambda(void) { return proc_new(rb_cProc, TRUE); } -VALUE -rb_f_lambda(void) +static void +f_lambda_filter_non_literal(void) { - rb_warn("rb_f_lambda() is deprecated; use rb_block_proc() instead"); + rb_control_frame_t *cfp = GET_EC()->cfp; + VALUE block_handler = rb_vm_frame_block_handler(cfp); + + if (block_handler == VM_BLOCK_HANDLER_NONE) { + // no block error raised else where + return; + } + + switch (vm_block_handler_type(block_handler)) { + case block_handler_type_iseq: + if (RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)->ep == VM_BH_TO_ISEQ_BLOCK(block_handler)->ep) { + return; + } + break; + case block_handler_type_symbol: + return; + case block_handler_type_proc: + if (rb_proc_lambda_p(VM_BH_TO_PROC(block_handler))) { + return; + } + break; + case block_handler_type_ifunc: + break; + } + + rb_raise(rb_eArgError, "the lambda method requires a literal block"); +} + +/* + * call-seq: + * lambda { |...| block } -> a_proc + * + * Equivalent to Proc.new, except the resulting Proc objects check the + * number of parameters passed when called. + */ + +static VALUE +f_lambda(VALUE _) +{ + f_lambda_filter_non_literal(); return rb_block_lambda(); } -/* Document-method: === +/* Document-method: Proc#=== * * call-seq: * proc === obj -> result_of_proc * - * Invokes the block with +obj+ as the proc's parameter like Proc#call. It - * is to allow a proc object to be a target of +when+ clause in a case - * statement. + * Invokes the block with +obj+ as the proc's parameter like Proc#call. + * This allows a proc object to be the target of a +when+ clause + * in a case statement. */ /* CHECKME: are the argument checking semantics correct? */ /* + * Document-method: Proc#[] + * Document-method: Proc#call + * Document-method: Proc#yield + * * call-seq: - * prc.call(params,...) -> obj - * prc[params,...] -> obj - * prc.(params,...) -> obj - * - * Invokes the block, setting the block's parameters to the values in - * <i>params</i> using something close to method calling semantics. - * Generates a warning if multiple values are passed to a proc that - * expects just one (previously this silently converted the parameters - * to an array). Note that prc.() invokes prc.call() with the parameters - * given. It's a syntax sugar to hide "call". - * - * For procs created using <code>lambda</code> or <code>->()</code> an error - * is generated if the wrong number of parameters are passed to a Proc with - * multiple parameters. For procs created using <code>Proc.new</code> or - * <code>Kernel.proc</code>, extra parameters are silently discarded. - * - * Returns the value of the last expression evaluated in the block. See - * also <code>Proc#yield</code>. - * - * a_proc = Proc.new {|a, *b| b.collect {|i| i*a }} - * a_proc.call(9, 1, 2, 3) #=> [9, 18, 27] - * a_proc[9, 1, 2, 3] #=> [9, 18, 27] - * a_proc = lambda {|a,b| a} - * a_proc.call(1,2,3) + * call(...) -> obj + * self[...] -> obj + * yield(...) -> obj * - * <em>produces:</em> + * Invokes the block, setting the block's parameters to the arguments + * using something close to method calling semantics. + * Returns the value of the last expression evaluated in the block. + * + * a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } } + * a_proc.call(9, 1, 2, 3) #=> [9, 18, 27] + * a_proc[9, 1, 2, 3] #=> [9, 18, 27] + * a_proc.(9, 1, 2, 3) #=> [9, 18, 27] + * a_proc.yield(9, 1, 2, 3) #=> [9, 18, 27] + * + * Note that <code>prc.()</code> invokes <code>prc.call()</code> with + * the parameters given. It's syntactic sugar to hide "call". + * + * For procs created using #lambda or <code>->()</code> an error is + * generated if the wrong number of parameters are passed to the + * proc. For procs created using Proc.new or Kernel.proc, extra + * parameters are silently discarded and missing parameters are set + * to +nil+. + * + * a_proc = proc {|a,b| [a,b] } + * a_proc.call(1) #=> [1, nil] * - * prog.rb:4:in `block in <main>': wrong number of arguments (3 for 2) (ArgumentError) - * from prog.rb:5:in `call' - * from prog.rb:5:in `<main>' + * a_proc = lambda {|a,b| [a,b] } + * a_proc.call(1) # ArgumentError: wrong number of arguments (given 1, expected 2) * + * See also Proc#lambda?. */ - +#if 0 static VALUE proc_call(int argc, VALUE *argv, VALUE procval) { - VALUE vret; - rb_proc_t *proc; - rb_block_t *blockptr = 0; - rb_iseq_t *iseq; - VALUE passed_procval; - GetProcPtr(procval, proc); - - iseq = proc->block.iseq; - if (BUILTIN_TYPE(iseq) == T_NODE || iseq->arg_block != -1) { - if (rb_block_given_p()) { - rb_proc_t *passed_proc; - RB_GC_GUARD(passed_procval) = rb_block_proc(); - GetProcPtr(passed_procval, passed_proc); - blockptr = &passed_proc->block; - } - } - - vret = rb_vm_invoke_proc(GET_THREAD(), proc, argc, argv, blockptr); - RB_GC_GUARD(procval); - return vret; + /* removed */ } +#endif #if SIZEOF_LONG > SIZEOF_INT static inline int check_argc(long argc) { if (argc > INT_MAX || argc < 0) { - rb_raise(rb_eArgError, "too many arguments (%lu)", - (unsigned long)argc); + rb_raise(rb_eArgError, "too many arguments (%lu)", + (unsigned long)argc); } return (int)argc; } @@ -568,68 +1125,90 @@ check_argc(long argc) #endif VALUE -rb_proc_call(VALUE self, VALUE args) +rb_proc_call_kw(VALUE self, VALUE args, int kw_splat) { VALUE vret; rb_proc_t *proc; + int argc = check_argc(RARRAY_LEN(args)); + const VALUE *argv = RARRAY_CONST_PTR(args); GetProcPtr(self, proc); - vret = rb_vm_invoke_proc(GET_THREAD(), proc, - check_argc(RARRAY_LEN(args)), RARRAY_PTR(args), 0); + vret = rb_vm_invoke_proc(GET_EC(), proc, argc, argv, + kw_splat, VM_BLOCK_HANDLER_NONE); RB_GC_GUARD(self); RB_GC_GUARD(args); return vret; } VALUE -rb_proc_call_with_block(VALUE self, int argc, VALUE *argv, VALUE pass_procval) +rb_proc_call(VALUE self, VALUE args) { + return rb_proc_call_kw(self, args, RB_NO_KEYWORDS); +} + +static VALUE +proc_to_block_handler(VALUE procval) +{ + return NIL_P(procval) ? VM_BLOCK_HANDLER_NONE : procval; +} + +VALUE +rb_proc_call_with_block_kw(VALUE self, int argc, const VALUE *argv, VALUE passed_procval, int kw_splat) +{ + rb_execution_context_t *ec = GET_EC(); VALUE vret; rb_proc_t *proc; - rb_block_t *block = 0; GetProcPtr(self, proc); - - if (!NIL_P(pass_procval)) { - rb_proc_t *pass_proc; - GetProcPtr(pass_procval, pass_proc); - block = &pass_proc->block; - } - - vret = rb_vm_invoke_proc(GET_THREAD(), proc, argc, argv, block); + vret = rb_vm_invoke_proc(ec, proc, argc, argv, kw_splat, proc_to_block_handler(passed_procval)); RB_GC_GUARD(self); - RB_GC_GUARD(pass_procval); return vret; } +VALUE +rb_proc_call_with_block(VALUE self, int argc, const VALUE *argv, VALUE passed_procval) +{ + return rb_proc_call_with_block_kw(self, argc, argv, passed_procval, RB_NO_KEYWORDS); +} + + /* * call-seq: - * prc.arity -> fixnum + * prc.arity -> integer * - * Returns the number of arguments that would not be ignored. If the block + * Returns the number of mandatory arguments. If the block * is declared to take no arguments, returns 0. If the block is known - * to take exactly n arguments, returns n. If the block has optional - * arguments, return -n-1, where n is the number of mandatory - * arguments. A <code>proc</code> with no argument declarations - * is the same a block declaring <code>||</code> as its arguments. - * - * proc {}.arity #=> 0 - * proc {||}.arity #=> 0 - * proc {|a|}.arity #=> 1 - * proc {|a,b|}.arity #=> 2 - * proc {|a,b,c|}.arity #=> 3 - * proc {|*a|}.arity #=> -1 - * proc {|a,*b|}.arity #=> -2 - * proc {|a,*b, c|}.arity #=> -3 - * - * proc { |x = 0| }.arity #=> 0 - * lambda { |a = 0| }.arity #=> -1 - * proc { |x=0, y| }.arity #=> 0 - * lambda { |x=0, y| }.arity #=> -2 - * proc { |x=0, y=0| }.arity #=> 0 - * lambda { |x=0, y=0| }.arity #=> -1 - * proc { |x, y=0| }.arity #=> 1 - * lambda { |x, y=0| }.arity #=> -2 - * proc { |(x, y), z=0| }.arity #=> 1 - * lambda { |(x, y), z=0| }.arity #=> -2 + * to take exactly n arguments, returns n. + * If the block has optional arguments, returns -n-1, where n is the + * number of mandatory arguments, with the exception for blocks that + * are not lambdas and have only a finite number of optional arguments; + * in this latter case, returns n. + * Keyword arguments will be considered as a single additional argument, + * that argument being mandatory if any keyword argument is mandatory. + * A #proc with no argument declarations is the same as a block + * declaring <code>||</code> as its arguments. + * + * proc {}.arity #=> 0 + * proc { || }.arity #=> 0 + * proc { |a| }.arity #=> 1 + * proc { |a, b| }.arity #=> 2 + * proc { |a, b, c| }.arity #=> 3 + * proc { |*a| }.arity #=> -1 + * proc { |a, *b| }.arity #=> -2 + * proc { |a, *b, c| }.arity #=> -3 + * proc { |x:, y:, z:0| }.arity #=> 1 + * proc { |*a, x:, y:0| }.arity #=> -2 + * + * proc { |a=0| }.arity #=> 0 + * lambda { |a=0| }.arity #=> -1 + * proc { |a=0, b| }.arity #=> 1 + * lambda { |a=0, b| }.arity #=> -2 + * proc { |a=0, b=0| }.arity #=> 0 + * lambda { |a=0, b=0| }.arity #=> -1 + * proc { |a, b=0| }.arity #=> 1 + * lambda { |a, b=0| }.arity #=> -2 + * proc { |(a, b), c=0| }.arity #=> 1 + * lambda { |(a, b), c=0| }.arity #=> -2 + * proc { |a, x:0, y:0| }.arity #=> 1 + * lambda { |a, x:0, y:0| }.arity #=> -2 */ static VALUE @@ -642,10 +1221,39 @@ proc_arity(VALUE self) static inline int rb_iseq_min_max_arity(const rb_iseq_t *iseq, int *max) { - *max = iseq->arg_rest == -1 ? - iseq->argc + iseq->arg_post_len + iseq->arg_opts - (iseq->arg_opts > 0) + *max = ISEQ_BODY(iseq)->param.flags.has_rest == FALSE ? + ISEQ_BODY(iseq)->param.lead_num + ISEQ_BODY(iseq)->param.opt_num + ISEQ_BODY(iseq)->param.post_num + + (ISEQ_BODY(iseq)->param.flags.has_kw == TRUE || ISEQ_BODY(iseq)->param.flags.has_kwrest == TRUE || ISEQ_BODY(iseq)->param.flags.forwardable == TRUE) : UNLIMITED_ARGUMENTS; - return iseq->argc + iseq->arg_post_len; + return ISEQ_BODY(iseq)->param.lead_num + ISEQ_BODY(iseq)->param.post_num + (ISEQ_BODY(iseq)->param.flags.has_kw && ISEQ_BODY(iseq)->param.keyword->required_num > 0); +} + +static int +rb_vm_block_min_max_arity(const struct rb_block *block, int *max) +{ + again: + switch (vm_block_type(block)) { + case block_type_iseq: + return rb_iseq_min_max_arity(rb_iseq_check(block->as.captured.code.iseq), max); + case block_type_proc: + block = vm_proc_block(block->as.proc); + goto again; + case block_type_ifunc: + { + const struct vm_ifunc *ifunc = block->as.captured.code.ifunc; + if (IS_METHOD_PROC_IFUNC(ifunc)) { + /* e.g. method(:foo).to_proc.arity */ + return method_min_max_arity((VALUE)ifunc->data, max); + } + *max = ifunc->argc.max; + return ifunc->argc.min; + } + case block_type_symbol: + *max = UNLIMITED_ARGUMENTS; + return 1; + } + *max = UNLIMITED_ARGUMENTS; + return 0; } /* @@ -658,89 +1266,298 @@ static int rb_proc_min_max_arity(VALUE self, int *max) { rb_proc_t *proc; - rb_iseq_t *iseq; GetProcPtr(self, proc); - iseq = proc->block.iseq; - if (iseq) { - if (BUILTIN_TYPE(iseq) != T_NODE) { - return rb_iseq_min_max_arity(iseq, max); - } - else { - NODE *node = (NODE *)iseq; - if (IS_METHOD_PROC_NODE(node)) { - /* e.g. method(:foo).to_proc.arity */ - return method_min_max_arity(node->nd_tval, max); - } - } - } - *max = UNLIMITED_ARGUMENTS; - return 0; + return rb_vm_block_min_max_arity(&proc->block, max); } int rb_proc_arity(VALUE self) { rb_proc_t *proc; - int max, min = rb_proc_min_max_arity(self, &max); + int max, min; GetProcPtr(self, proc); + min = rb_vm_block_min_max_arity(&proc->block, &max); return (proc->is_lambda ? min == max : max != UNLIMITED_ARGUMENTS) ? min : -min-1; } -#define get_proc_iseq rb_proc_get_iseq +static void +block_setup(struct rb_block *block, VALUE block_handler) +{ + switch (vm_block_handler_type(block_handler)) { + case block_handler_type_iseq: + block->type = block_type_iseq; + block->as.captured = *VM_BH_TO_ISEQ_BLOCK(block_handler); + break; + case block_handler_type_ifunc: + block->type = block_type_ifunc; + block->as.captured = *VM_BH_TO_IFUNC_BLOCK(block_handler); + break; + case block_handler_type_symbol: + block->type = block_type_symbol; + block->as.symbol = VM_BH_TO_SYMBOL(block_handler); + break; + case block_handler_type_proc: + block->type = block_type_proc; + block->as.proc = VM_BH_TO_PROC(block_handler); + } +} + +int +rb_block_pair_yield_optimizable(void) +{ + int min, max; + const rb_execution_context_t *ec = GET_EC(); + rb_control_frame_t *cfp = ec->cfp; + VALUE block_handler = rb_vm_frame_block_handler(cfp); + struct rb_block block; + + if (block_handler == VM_BLOCK_HANDLER_NONE) { + rb_raise(rb_eArgError, "no block given"); + } + + block_setup(&block, block_handler); + min = rb_vm_block_min_max_arity(&block, &max); + + switch (vm_block_type(&block)) { + case block_type_symbol: + return 0; + + case block_type_proc: + { + VALUE procval = block_handler; + rb_proc_t *proc; + GetProcPtr(procval, proc); + if (proc->is_lambda) return 0; + if (min != max) return 0; + return min > 1; + } + + case block_type_ifunc: + { + const struct vm_ifunc *ifunc = block.as.captured.code.ifunc; + if (ifunc->flags & IFUNC_YIELD_OPTIMIZABLE) return 1; + } + + default: + return min > 1; + } +} + +int +rb_block_arity(void) +{ + int min, max; + const rb_execution_context_t *ec = GET_EC(); + rb_control_frame_t *cfp = ec->cfp; + VALUE block_handler = rb_vm_frame_block_handler(cfp); + struct rb_block block; + + if (block_handler == VM_BLOCK_HANDLER_NONE) { + rb_raise(rb_eArgError, "no block given"); + } + + block_setup(&block, block_handler); + + switch (vm_block_type(&block)) { + case block_type_symbol: + return -1; + + case block_type_proc: + return rb_proc_arity(block_handler); -rb_iseq_t * + default: + min = rb_vm_block_min_max_arity(&block, &max); + return max != UNLIMITED_ARGUMENTS ? min : -min-1; + } +} + +int +rb_block_min_max_arity(int *max) +{ + const rb_execution_context_t *ec = GET_EC(); + rb_control_frame_t *cfp = ec->cfp; + VALUE block_handler = rb_vm_frame_block_handler(cfp); + struct rb_block block; + + if (block_handler == VM_BLOCK_HANDLER_NONE) { + rb_raise(rb_eArgError, "no block given"); + } + + block_setup(&block, block_handler); + return rb_vm_block_min_max_arity(&block, max); +} + +const rb_iseq_t * rb_proc_get_iseq(VALUE self, int *is_proc) { - rb_proc_t *proc; - rb_iseq_t *iseq; + const rb_proc_t *proc; + const struct rb_block *block; GetProcPtr(self, proc); - iseq = proc->block.iseq; + block = &proc->block; if (is_proc) *is_proc = !proc->is_lambda; - if (!RUBY_VM_NORMAL_ISEQ_P(iseq)) { - NODE *node = (NODE *)iseq; - iseq = 0; - if (IS_METHOD_PROC_NODE(node)) { - /* method(:foo).to_proc */ - iseq = rb_method_get_iseq(node->nd_tval); - if (is_proc) *is_proc = 0; - } + + switch (vm_block_type(block)) { + case block_type_iseq: + return rb_iseq_check(block->as.captured.code.iseq); + case block_type_proc: + return rb_proc_get_iseq(block->as.proc, is_proc); + case block_type_ifunc: + { + const struct vm_ifunc *ifunc = block->as.captured.code.ifunc; + if (IS_METHOD_PROC_IFUNC(ifunc)) { + /* method(:foo).to_proc */ + if (is_proc) *is_proc = 0; + return rb_method_iseq((VALUE)ifunc->data); + } + else { + return NULL; + } + } + case block_type_symbol: + return NULL; } - return iseq; + + VM_UNREACHABLE(rb_proc_get_iseq); + return NULL; } +/* call-seq: + * self == other -> true or false + * eql?(other) -> true or false + * + * Returns whether +self+ and +other+ were created from the same code block: + * + * def return_block(&block) + * block + * end + * + * def pass_block_twice(&block) + * [return_block(&block), return_block(&block)] + * end + * + * block1, block2 = pass_block_twice { puts 'test' } + * # Blocks might be instantiated into Proc's lazily, so they may, or may not, + * # be the same object. + * # But they are produced from the same code block, so they are equal + * block1 == block2 + * #=> true + * + * # Another Proc will never be equal, even if the code is the "same" + * block1 == proc { puts 'test' } + * #=> false + * + */ static VALUE -iseq_location(rb_iseq_t *iseq) +proc_eq(VALUE self, VALUE other) { - VALUE loc[2]; + const rb_proc_t *self_proc, *other_proc; + const struct rb_block *self_block, *other_block; - if (!iseq) return Qnil; - loc[0] = iseq->location.path; - if (iseq->line_info_table) { - loc[1] = INT2FIX(rb_iseq_first_lineno(iseq)); + if (rb_obj_class(self) != rb_obj_class(other)) { + return Qfalse; } - else { - loc[1] = Qnil; + + GetProcPtr(self, self_proc); + GetProcPtr(other, other_proc); + + if (self_proc->is_from_method != other_proc->is_from_method || + self_proc->is_lambda != other_proc->is_lambda) { + return Qfalse; } - return rb_ary_new4(2, loc); + + self_block = &self_proc->block; + other_block = &other_proc->block; + + if (vm_block_type(self_block) != vm_block_type(other_block)) { + return Qfalse; + } + + switch (vm_block_type(self_block)) { + case block_type_iseq: + if (self_block->as.captured.ep != \ + other_block->as.captured.ep || + self_block->as.captured.code.iseq != \ + other_block->as.captured.code.iseq) { + return Qfalse; + } + break; + case block_type_ifunc: + if (self_block->as.captured.code.ifunc != \ + other_block->as.captured.code.ifunc) { + return Qfalse; + } + + if (memcmp( + ((cfunc_proc_t *)self_proc)->env, + ((cfunc_proc_t *)other_proc)->env, + sizeof(((cfunc_proc_t *)self_proc)->env))) { + return Qfalse; + } + break; + case block_type_proc: + if (self_block->as.proc != other_block->as.proc) { + return Qfalse; + } + break; + case block_type_symbol: + if (self_block->as.symbol != other_block->as.symbol) { + return Qfalse; + } + break; + } + + return Qtrue; +} + +static VALUE +iseq_location(const rb_iseq_t *iseq) +{ + VALUE loc[5]; + int i = 0; + + if (!iseq) return Qnil; + rb_iseq_check(iseq); + loc[i++] = rb_iseq_path(iseq); + const rb_code_location_t *cl = &ISEQ_BODY(iseq)->location.code_location; + loc[i++] = RB_INT2NUM(cl->beg_pos.lineno); + loc[i++] = RB_INT2NUM(cl->beg_pos.column); + loc[i++] = RB_INT2NUM(cl->end_pos.lineno); + loc[i++] = RB_INT2NUM(cl->end_pos.column); + RUBY_ASSERT_ALWAYS(i == numberof(loc)); + + return rb_ary_new_from_values(i, loc); +} + +VALUE +rb_iseq_location(const rb_iseq_t *iseq) +{ + return iseq_location(iseq); } /* * call-seq: - * prc.source_location -> [String, Fixnum] + * prc.source_location -> [String, Integer, Integer, Integer, Integer] + * + * Returns the location where the Proc was defined. + * The returned Array contains: + * (1) the Ruby source filename + * (2) the line number where the definition starts + * (3) the position where the definition starts, in number of bytes from the start of the line + * (4) the line number where the definition ends + * (5) the position where the definitions ends, in number of bytes from the start of the line * - * Returns the Ruby source filename and line number containing this proc - * or +nil+ if this proc was not defined in Ruby (i.e. native) + * This method will return +nil+ if the Proc was not defined in Ruby (i.e. native). */ VALUE rb_proc_location(VALUE self) { - return iseq_location(get_proc_iseq(self, 0)); + return iseq_location(rb_proc_get_iseq(self, 0)); } -static VALUE -unnamed_parameters(int arity) +VALUE +rb_unnamed_parameters(int arity) { VALUE a, param = rb_ary_new2((arity < 0) ? -arity : arity); int n = (arity < 0) ? ~arity : arity; @@ -749,32 +1566,59 @@ unnamed_parameters(int arity) a = rb_ary_new3(1, ID2SYM(req)); OBJ_FREEZE(a); for (; n; --n) { - rb_ary_push(param, a); + rb_ary_push(param, a); } if (arity < 0) { - CONST_ID(rest, "rest"); - rb_ary_store(param, ~arity, rb_ary_new3(1, ID2SYM(rest))); + CONST_ID(rest, "rest"); + rb_ary_store(param, ~arity, rb_ary_new3(1, ID2SYM(rest))); } return param; } /* * call-seq: - * prc.parameters -> array + * prc.parameters(lambda: nil) -> array * - * Returns the parameter information of this proc. + * Returns the parameter information of this proc. If the lambda + * keyword is provided and not nil, treats the proc as a lambda if + * true and as a non-lambda if false. * + * prc = proc{|x, y=42, *other|} + * prc.parameters #=> [[:opt, :x], [:opt, :y], [:rest, :other]] * prc = lambda{|x, y=42, *other|} * prc.parameters #=> [[:req, :x], [:opt, :y], [:rest, :other]] + * prc = proc{|x, y=42, *other|} + * prc.parameters(lambda: true) #=> [[:req, :x], [:opt, :y], [:rest, :other]] + * prc = lambda{|x, y=42, *other|} + * prc.parameters(lambda: false) #=> [[:opt, :x], [:opt, :y], [:rest, :other]] */ static VALUE -rb_proc_parameters(VALUE self) +rb_proc_parameters(int argc, VALUE *argv, VALUE self) { - int is_proc; - rb_iseq_t *iseq = get_proc_iseq(self, &is_proc); + static ID keyword_ids[1]; + VALUE opt, lambda; + VALUE kwargs[1]; + int is_proc ; + const rb_iseq_t *iseq; + + iseq = rb_proc_get_iseq(self, &is_proc); + + if (!keyword_ids[0]) { + CONST_ID(keyword_ids[0], "lambda"); + } + + rb_scan_args(argc, argv, "0:", &opt); + if (!NIL_P(opt)) { + rb_get_kwargs(opt, keyword_ids, 0, 1, kwargs); + lambda = kwargs[0]; + if (!NIL_P(lambda)) { + is_proc = !RTEST(lambda); + } + } + if (!iseq) { - return unnamed_parameters(rb_proc_arity(self)); + return rb_unnamed_parameters(rb_proc_arity(self)); } return rb_iseq_parameters(iseq, is_proc); } @@ -784,9 +1628,82 @@ rb_hash_proc(st_index_t hash, VALUE prc) { rb_proc_t *proc; GetProcPtr(prc, proc); - hash = rb_hash_uint(hash, (st_index_t)proc->block.iseq); - hash = rb_hash_uint(hash, (st_index_t)proc->envval); - return rb_hash_uint(hash, (st_index_t)proc->block.ep >> 16); + + switch (vm_block_type(&proc->block)) { + case block_type_iseq: + hash = rb_st_hash_uint(hash, (st_index_t)proc->block.as.captured.code.iseq->body); + break; + case block_type_ifunc: + hash = rb_st_hash_uint(hash, (st_index_t)proc->block.as.captured.code.ifunc->func); + hash = rb_st_hash_uint(hash, (st_index_t)proc->block.as.captured.code.ifunc->data); + break; + case block_type_symbol: + hash = rb_st_hash_uint(hash, rb_any_hash(proc->block.as.symbol)); + break; + case block_type_proc: + hash = rb_st_hash_uint(hash, rb_any_hash(proc->block.as.proc)); + break; + default: + rb_bug("rb_hash_proc: unknown block type %d", vm_block_type(&proc->block)); + } + + /* ifunc procs have their own allocated ep. If an ifunc is duplicated, they + * will point to different ep but they should return the same hash code, so + * we cannot include the ep in the hash. */ + if (vm_block_type(&proc->block) != block_type_ifunc) { + hash = rb_hash_uint(hash, (st_index_t)proc->block.as.captured.ep); + } + + return hash; +} + +static VALUE sym_proc_cache = Qfalse; + +/* + * call-seq: + * to_proc + * + * Returns a Proc object which calls the method with name of +self+ + * on the first parameter and passes the remaining parameters to the method. + * + * proc = :to_s.to_proc # => #<Proc:0x000001afe0e48680(&:to_s) (lambda)> + * proc.call(1000) # => "1000" + * proc.call(1000, 16) # => "3e8" + * (1..3).collect(&:to_s) # => ["1", "2", "3"] + * + */ + +VALUE +rb_sym_to_proc(VALUE sym) +{ + enum {SYM_PROC_CACHE_SIZE = 67}; + + if (rb_ractor_main_p()) { + if (!sym_proc_cache) { + sym_proc_cache = rb_ary_hidden_new(SYM_PROC_CACHE_SIZE); + rb_ary_store(sym_proc_cache, SYM_PROC_CACHE_SIZE - 1, Qnil); + } + + ID id = SYM2ID(sym); + long index = (id % SYM_PROC_CACHE_SIZE); + VALUE procval = RARRAY_AREF(sym_proc_cache, index); + if (RTEST(procval)) { + rb_proc_t *proc; + GetProcPtr(procval, proc); + + if (proc->block.as.symbol == sym) { + return procval; + } + } + + procval = sym_proc_new(rb_cProc, sym); + RARRAY_ASET(sym_proc_cache, index, procval); + + return RB_GC_GUARD(procval); + } + else { + return sym_proc_new(rb_cProc, sym); + } } /* @@ -794,6 +1711,8 @@ rb_hash_proc(st_index_t hash, VALUE prc) * prc.hash -> integer * * Returns a hash value corresponding to proc body. + * + * See also Object#hash. */ static VALUE @@ -803,7 +1722,39 @@ proc_hash(VALUE self) hash = rb_hash_start(0); hash = rb_hash_proc(hash, self); hash = rb_hash_end(hash); - return LONG2FIX(hash); + return ST2FIX(hash); +} + +VALUE +rb_block_to_s(VALUE self, const struct rb_block *block, const char *additional_info) +{ + VALUE cname = rb_obj_class(self); + VALUE str = rb_sprintf("#<%"PRIsVALUE":", cname); + + again: + switch (vm_block_type(block)) { + case block_type_proc: + block = vm_proc_block(block->as.proc); + goto again; + case block_type_iseq: + { + const rb_iseq_t *iseq = rb_iseq_check(block->as.captured.code.iseq); + rb_str_catf(str, "%p %"PRIsVALUE":%d", (void *)self, + rb_iseq_path(iseq), + ISEQ_BODY(iseq)->location.first_lineno); + } + break; + case block_type_symbol: + rb_str_catf(str, "%p(&%+"PRIsVALUE")", (void *)self, block->as.symbol); + break; + case block_type_ifunc: + rb_str_catf(str, "%p", (void *)block->as.captured.code.ifunc); + break; + } + + if (additional_info) rb_str_cat_cstr(str, additional_info); + rb_str_cat_cstr(str, ">"); + return str; } /* @@ -817,44 +1768,17 @@ proc_hash(VALUE self) static VALUE proc_to_s(VALUE self) { - VALUE str = 0; - rb_proc_t *proc; - const char *cname = rb_obj_classname(self); - rb_iseq_t *iseq; - const char *is_lambda; - + const rb_proc_t *proc; GetProcPtr(self, proc); - iseq = proc->block.iseq; - is_lambda = proc->is_lambda ? " (lambda)" : ""; - - if (RUBY_VM_NORMAL_ISEQ_P(iseq)) { - int first_lineno = 0; - - if (iseq->line_info_table) { - first_lineno = rb_iseq_first_lineno(iseq); - } - str = rb_sprintf("#<%s:%p@%s:%d%s>", cname, (void *)self, - RSTRING_PTR(iseq->location.path), - first_lineno, is_lambda); - } - else { - str = rb_sprintf("#<%s:%p%s>", cname, (void *)proc->block.iseq, - is_lambda); - } - - if (OBJ_TAINTED(self)) { - OBJ_TAINT(str); - } - return str; + return rb_block_to_s(self, &proc->block, proc->is_lambda ? " (lambda)" : NULL); } /* * call-seq: - * prc.to_proc -> prc + * prc.to_proc -> proc * - * Part of the protocol for converting objects to <code>Proc</code> - * objects. Instances of class <code>Proc</code> simply return - * themselves. + * Part of the protocol for converting objects to Proc objects. + * Instances of class Proc simply return themselves. */ static VALUE @@ -864,148 +1788,177 @@ proc_to_proc(VALUE self) } static void -bm_mark(void *ptr) +bm_mark_and_move(void *ptr) { struct METHOD *data = ptr; - rb_gc_mark(data->defined_class); - rb_gc_mark(data->rclass); - rb_gc_mark(data->recv); - if (data->me) rb_mark_method_entry(data->me); -} - -static void -bm_free(void *ptr) -{ - struct METHOD *data = ptr; - struct unlinked_method_entry_list_entry *ume = data->ume; - data->me->mark = 0; - ume->me = data->me; - ume->next = GET_VM()->unlinked_method_entry_list; - GET_VM()->unlinked_method_entry_list = ume; - xfree(ptr); -} - -static size_t -bm_memsize(const void *ptr) -{ - return ptr ? sizeof(struct METHOD) : 0; + rb_gc_mark_and_move((VALUE *)&data->recv); + rb_gc_mark_and_move((VALUE *)&data->klass); + rb_gc_mark_and_move((VALUE *)&data->iclass); + rb_gc_mark_and_move((VALUE *)&data->owner); + rb_gc_mark_and_move_ptr((rb_method_entry_t **)&data->me); } static const rb_data_type_t method_data_type = { "method", { - bm_mark, - bm_free, - bm_memsize, + bm_mark_and_move, + RUBY_TYPED_DEFAULT_FREE, + NULL, // No external memory to report, + bm_mark_and_move, }, + 0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE | RUBY_TYPED_FROZEN_SHAREABLE_NO_REC }; VALUE rb_obj_is_method(VALUE m) { - if (rb_typeddata_is_kind_of(m, &method_data_type)) { - return Qtrue; - } - else { - return Qfalse; - } + return RBOOL(rb_typeddata_is_kind_of(m, &method_data_type)); } +static int +respond_to_missing_p(VALUE klass, VALUE obj, VALUE sym, int scope) +{ + /* TODO: merge with obj_respond_to() */ + ID rmiss = idRespond_to_missing; + + if (UNDEF_P(obj)) return 0; + if (rb_method_basic_definition_p(klass, rmiss)) return 0; + return RTEST(rb_funcall(obj, rmiss, 2, sym, RBOOL(!scope))); +} + + static VALUE -mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope) +mnew_missing(VALUE klass, VALUE obj, ID id, VALUE mclass) { - VALUE method; - VALUE rclass = klass, defined_class; - ID rid = id; struct METHOD *data; - rb_method_entry_t *me, meb; - rb_method_definition_t *def = 0; - rb_method_flag_t flag = NOEX_UNDEF; + VALUE method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data); + rb_method_entry_t *me; + rb_method_definition_t *def; + + RB_OBJ_WRITE(method, &data->recv, obj); + RB_OBJ_WRITE(method, &data->klass, klass); + RB_OBJ_WRITE(method, &data->owner, klass); + + def = ZALLOC(rb_method_definition_t); + def->type = VM_METHOD_TYPE_MISSING; + def->original_id = id; + + me = rb_method_entry_create(id, klass, METHOD_VISI_UNDEF, def); + + RB_OBJ_WRITE(method, &data->me, me); + + return method; +} + +static VALUE +mnew_missing_by_name(VALUE klass, VALUE obj, VALUE *name, int scope, VALUE mclass) +{ + VALUE vid = rb_str_intern(*name); + *name = vid; + if (!respond_to_missing_p(klass, obj, vid, scope)) return Qfalse; + return mnew_missing(klass, obj, SYM2ID(vid), mclass); +} + +static VALUE +mnew_internal(const rb_method_entry_t *me, VALUE klass, VALUE iclass, + VALUE obj, ID id, VALUE mclass, int scope, int error) +{ + struct METHOD *data; + VALUE method; + const rb_method_entry_t *original_me = me; + rb_method_visibility_t visi = METHOD_VISI_UNDEF; again: - me = rb_method_entry_without_refinements(klass, id, &defined_class); if (UNDEFINED_METHOD_ENTRY_P(me)) { - ID rmiss = idRespond_to_missing; - VALUE sym = ID2SYM(id); - - if (obj != Qundef && !rb_method_basic_definition_p(klass, rmiss)) { - if (RTEST(rb_funcall(obj, rmiss, 2, sym, scope ? Qfalse : Qtrue))) { - def = ALLOC(rb_method_definition_t); - def->type = VM_METHOD_TYPE_MISSING; - def->original_id = id; - def->alias_count = 0; - defined_class = klass; - - meb.flag = 0; - meb.mark = 0; - meb.called_id = id; - meb.klass = klass; - meb.def = def; - me = &meb; - def = 0; - - goto gen_method; - } - } - rb_print_undef(klass, id, 0); - } - def = me->def; - if (flag == NOEX_UNDEF) { - flag = me->flag; - if (scope && (flag & NOEX_MASK) != NOEX_PUBLIC) { - const char *v = ""; - switch (flag & NOEX_MASK) { - case NOEX_PRIVATE: v = "private"; break; - case NOEX_PROTECTED: v = "protected"; break; - } - rb_name_error(id, "method `%s' for %s `%s' is %s", - rb_id2name(id), - (RB_TYPE_P(klass, T_MODULE)) ? "module" : "class", - rb_class2name(klass), - v); - } - } - if (def && def->type == VM_METHOD_TYPE_ZSUPER) { - klass = RCLASS_SUPER(defined_class); - id = def->original_id; - goto again; - } - - klass = defined_class; - - while (rclass != klass && - (FL_TEST(rclass, FL_SINGLETON) || RB_TYPE_P(rclass, T_ICLASS))) { - rclass = RCLASS_SUPER(rclass); - } - - gen_method: - method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data); + if (respond_to_missing_p(klass, obj, ID2SYM(id), scope)) { + return mnew_missing(klass, obj, id, mclass); + } + if (!error) return Qnil; + rb_print_undef(klass, id, METHOD_VISI_UNDEF); + } + if (visi == METHOD_VISI_UNDEF) { + visi = METHOD_ENTRY_VISI(me); + RUBY_ASSERT(visi != METHOD_VISI_UNDEF); /* !UNDEFINED_METHOD_ENTRY_P(me) */ + if (scope && (visi != METHOD_VISI_PUBLIC)) { + if (!error) return Qnil; + rb_print_inaccessible(klass, id, visi); + } + } + if (me->def->type == VM_METHOD_TYPE_ZSUPER) { + if (me->defined_class) { + VALUE klass = RCLASS_SUPER(RCLASS_ORIGIN(me->defined_class)); + id = me->def->original_id; + me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass); + } + else { + VALUE klass = RCLASS_SUPER(RCLASS_ORIGIN(me->owner)); + id = me->def->original_id; + me = rb_method_entry_without_refinements(klass, id, &iclass); + } + goto again; + } - data->recv = obj; - data->rclass = rclass; - data->defined_class = defined_class; - data->id = rid; - data->me = ALLOC(rb_method_entry_t); - *data->me = *me; - data->me->def->alias_count++; - data->ume = ALLOC(struct unlinked_method_entry_list_entry); + method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data); - OBJ_INFECT(method, klass); + if (UNDEF_P(obj)) { + RB_OBJ_WRITE(method, &data->recv, Qundef); + RB_OBJ_WRITE(method, &data->klass, Qundef); + } + else { + RB_OBJ_WRITE(method, &data->recv, obj); + RB_OBJ_WRITE(method, &data->klass, klass); + } + RB_OBJ_WRITE(method, &data->iclass, iclass); + RB_OBJ_WRITE(method, &data->owner, original_me->owner); + RB_OBJ_WRITE(method, &data->me, me); return method; } +static VALUE +mnew_from_me(const rb_method_entry_t *me, VALUE klass, VALUE iclass, + VALUE obj, ID id, VALUE mclass, int scope) +{ + return mnew_internal(me, klass, iclass, obj, id, mclass, scope, TRUE); +} + +static VALUE +mnew_callable(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope) +{ + const rb_method_entry_t *me; + VALUE iclass = Qnil; + + ASSUME(!UNDEF_P(obj)); + me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass); + return mnew_from_me(me, klass, iclass, obj, id, mclass, scope); +} + +static VALUE +mnew_unbound(VALUE klass, ID id, VALUE mclass, int scope) +{ + const rb_method_entry_t *me; + VALUE iclass = Qnil; + + me = rb_method_entry_with_refinements(klass, id, &iclass); + return mnew_from_me(me, klass, iclass, Qundef, id, mclass, scope); +} + +static inline VALUE +method_entry_defined_class(const rb_method_entry_t *me) +{ + VALUE defined_class = me->defined_class; + return defined_class ? defined_class : me->owner; +} /********************************************************************** * - * Document-class : Method + * Document-class: Method * - * Method objects are created by <code>Object#method</code>, and are - * associated with a particular object (not just with a class). They - * may be used to invoke the method within the object, and as a block - * associated with an iterator. They may also be unbound from one - * object (creating an <code>UnboundMethod</code>) and bound to - * another. + * +Method+ objects are created by Object#method, and are associated + * with a particular object (not just with a class). They may be + * used to invoke the method within the object, and as a block + * associated with an iterator. They may also be unbound from one + * object (creating an UnboundMethod) and bound to another. * * class Thing * def square(n) @@ -1018,35 +1971,45 @@ mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope) * meth.call(9) #=> 81 * [ 1, 2, 3 ].collect(&meth) #=> [1, 4, 9] * + * [ 1, 2, 3 ].each(&method(:puts)) #=> prints 1, 2, 3 + * + * require 'date' + * %w[2017-03-01 2017-03-02].collect(&Date.method(:parse)) + * #=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>] */ /* * call-seq: - * meth == other_meth -> true or false + * self == other -> true or false * - * Two method objects are equal if they are bound to the same - * object and refer to the same method definition and their owners are the - * same class or module. + * Returns whether +self+ and +other+ are bound to the same + * object and refer to the same method definition and the classes + * defining the methods are the same class or module. */ static VALUE method_eq(VALUE method, VALUE other) { struct METHOD *m1, *m2; + VALUE klass1, klass2; if (!rb_obj_is_method(other)) - return Qfalse; + return Qfalse; if (CLASS_OF(method) != CLASS_OF(other)) - return Qfalse; + return Qfalse; Check_TypedStruct(method, &method_data_type); - m1 = (struct METHOD *)DATA_PTR(method); - m2 = (struct METHOD *)DATA_PTR(other); + m1 = (struct METHOD *)RTYPEDDATA_GET_DATA(method); + m2 = (struct METHOD *)RTYPEDDATA_GET_DATA(other); + + klass1 = method_entry_defined_class(m1->me); + klass2 = method_entry_defined_class(m2->me); if (!rb_method_entry_eq(m1->me, m2->me) || - m1->rclass != m2->rclass || - m1->recv != m2->recv) { - return Qfalse; + klass1 != klass2 || + m1->klass != m2->klass || + m1->recv != m2->recv) { + return Qfalse; } return Qtrue; @@ -1054,9 +2017,27 @@ method_eq(VALUE method, VALUE other) /* * call-seq: + * meth.eql?(other_meth) -> true or false + * meth == other_meth -> true or false + * + * Two unbound method objects are equal if they refer to the same + * method definition. + * + * Array.instance_method(:each_slice) == Enumerable.instance_method(:each_slice) + * #=> true + * + * Array.instance_method(:sum) == Enumerable.instance_method(:sum) + * #=> false, Array redefines the method for efficiency + */ +#define unbound_method_eq method_eq + +/* + * call-seq: * meth.hash -> integer * * Returns a hash value corresponding to the method object. + * + * See also Object#hash. */ static VALUE @@ -1066,12 +2047,11 @@ method_hash(VALUE method) st_index_t hash; TypedData_Get_Struct(method, struct METHOD, &method_data_type, m); - hash = rb_hash_start((st_index_t)m->rclass); - hash = rb_hash_uint(hash, (st_index_t)m->recv); + hash = rb_hash_start((st_index_t)m->recv); hash = rb_hash_method_entry(hash, m->me); hash = rb_hash_end(hash); - return INT2FIX(hash); + return ST2FIX(hash); } /* @@ -1079,8 +2059,8 @@ method_hash(VALUE method) * meth.unbind -> unbound_method * * Dissociates <i>meth</i> from its current receiver. The resulting - * <code>UnboundMethod</code> can subsequently be bound to a new object - * of the same class (see <code>UnboundMethod</code>). + * UnboundMethod can subsequently be bound to a new object of the + * same class (see UnboundMethod). */ static VALUE @@ -1091,16 +2071,12 @@ method_unbind(VALUE obj) TypedData_Get_Struct(obj, struct METHOD, &method_data_type, orig); method = TypedData_Make_Struct(rb_cUnboundMethod, struct METHOD, - &method_data_type, data); - data->recv = Qundef; - data->id = orig->id; - data->me = ALLOC(rb_method_entry_t); - *data->me = *orig->me; - if (orig->me->def) orig->me->def->alias_count++; - data->rclass = orig->rclass; - data->defined_class = orig->defined_class; - data->ume = ALLOC(struct unlinked_method_entry_list_entry); - OBJ_INFECT(method, obj); + &method_data_type, data); + RB_OBJ_WRITE(method, &data->recv, Qundef); + RB_OBJ_WRITE(method, &data->klass, Qundef); + RB_OBJ_WRITE(method, &data->iclass, orig->iclass); + RB_OBJ_WRITE(method, &data->owner, orig->me->owner); + RB_OBJ_WRITE(method, &data->me, rb_method_entry_clone(orig->me)); return method; } @@ -1110,6 +2086,8 @@ method_unbind(VALUE obj) * meth.receiver -> object * * Returns the bound receiver of the method object. + * + * (1..3).method(:map).receiver # => 1..3 */ static VALUE @@ -1134,53 +2112,119 @@ method_name(VALUE obj) struct METHOD *data; TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data); - return ID2SYM(data->id); + return ID2SYM(data->me->called_id); +} + +/* + * call-seq: + * meth.original_name -> symbol + * + * Returns the original name of the method. + * + * class C + * def foo; end + * alias bar foo + * end + * C.instance_method(:bar).original_name # => :foo + */ + +static VALUE +method_original_name(VALUE obj) +{ + struct METHOD *data; + + TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data); + return ID2SYM(data->me->def->original_id); } /* * call-seq: * meth.owner -> class_or_module * - * Returns the class or module that defines the method. + * Returns the class or module on which this method is defined. + * In other words, + * + * meth.owner.instance_methods(false).include?(meth.name) # => true + * + * holds as long as the method is not removed/undefined/replaced, + * (with private_instance_methods instead of instance_methods if the method + * is private). + * + * See also Method#receiver. + * + * (1..3).method(:map).owner #=> Enumerable */ static VALUE method_owner(VALUE obj) { struct METHOD *data; - VALUE defined_class; - TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data); - defined_class = data->defined_class; + return data->owner; +} - if (RB_TYPE_P(defined_class, T_ICLASS)) { - defined_class = RBASIC(defined_class)->klass; - } +/* + * call-seq: + * meth.box -> box or nil + * + * Returns the Ruby::Box where +meth+ is defined in. + */ +static VALUE +method_box(VALUE obj) +{ + struct METHOD *data; + const rb_box_t *box; - return defined_class; + TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data); + box = data->me->def->box; + if (!box) return Qnil; + if (box->box_object) return box->box_object; + rb_bug("Unexpected box on the method definition: %p", (void*) box); + UNREACHABLE_RETURN(Qnil); } void rb_method_name_error(VALUE klass, VALUE str) { - const char *s0 = " class"; +#define MSG(s) rb_fstring_lit("undefined method '%1$s' for"s" '%2$s'") VALUE c = klass; - - if (FL_TEST(c, FL_SINGLETON)) { - VALUE obj = rb_ivar_get(klass, attached); - - switch (TYPE(obj)) { - case T_MODULE: - case T_CLASS: - c = obj; - s0 = ""; - } + VALUE s = Qundef; + + if (RCLASS_SINGLETON_P(c)) { + VALUE obj = RCLASS_ATTACHED_OBJECT(klass); + + switch (BUILTIN_TYPE(obj)) { + case T_MODULE: + case T_CLASS: + c = obj; + break; + default: + break; + } } else if (RB_TYPE_P(c, T_MODULE)) { - s0 = " module"; + s = MSG(" module"); + } + if (UNDEF_P(s)) { + s = MSG(" class"); } - rb_name_error_str(str, "undefined method `%"PRIsVALUE"' for%s `%"PRIsVALUE"'", - QUOTE(str), s0, rb_class_name(c)); + rb_name_err_raise_str(s, c, str); +#undef MSG +} + +static VALUE +obj_method(VALUE obj, VALUE vid, int scope) +{ + ID id = rb_check_id(&vid); + const VALUE klass = CLASS_OF(obj); + const VALUE mclass = rb_cMethod; + + if (!id) { + VALUE m = mnew_missing_by_name(klass, obj, &vid, scope, mclass); + if (m) return m; + rb_method_name_error(klass, vid); + } + return mnew_callable(klass, obj, id, mclass, scope); } /* @@ -1188,10 +2232,9 @@ rb_method_name_error(VALUE klass, VALUE str) * obj.method(sym) -> method * * Looks up the named method as a receiver in <i>obj</i>, returning a - * <code>Method</code> object (or raising <code>NameError</code>). The - * <code>Method</code> object acts as a closure in <i>obj</i>'s object - * instance, so instance variables and the value of <code>self</code> - * remain available. + * +Method+ object (or raising NameError). The +Method+ object acts as a + * closure in <i>obj</i>'s object instance, so instance variables and + * the value of <code>self</code> remain available. * * class Demo * def initialize(n) @@ -1209,16 +2252,24 @@ rb_method_name_error(VALUE klass, VALUE str) * l = Demo.new('Fred') * m = l.method("hello") * m.call #=> "Hello, @iv = Fred" + * + * Note that +Method+ implements <code>to_proc</code> method, which + * means it can be used with iterators. + * + * [ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout + * + * out = File.open('test.txt', 'w') + * [ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file + * + * require 'date' + * %w[2017-03-01 2017-03-02].collect(&Date.method(:parse)) + * #=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>] */ VALUE rb_obj_method(VALUE obj, VALUE vid) { - ID id = rb_check_id(&vid); - if (!id) { - rb_method_name_error(CLASS_OF(obj), vid); - } - return mnew(CLASS_OF(obj), obj, id, rb_cMethod, FALSE); + return obj_method(obj, vid, FALSE); } /* @@ -1231,11 +2282,87 @@ rb_obj_method(VALUE obj, VALUE vid) VALUE rb_obj_public_method(VALUE obj, VALUE vid) { + return obj_method(obj, vid, TRUE); +} + +static VALUE +rb_obj_singleton_method_lookup(VALUE arg) +{ + VALUE *args = (VALUE *)arg; + return rb_obj_method(args[0], args[1]); +} + +static VALUE +rb_obj_singleton_method_lookup_fail(VALUE arg1, VALUE arg2) +{ + return Qfalse; +} + +/* + * call-seq: + * obj.singleton_method(sym) -> method + * + * Similar to _method_, searches singleton method only. + * + * class Demo + * def initialize(n) + * @iv = n + * end + * def hello() + * "Hello, @iv = #{@iv}" + * end + * end + * + * k = Demo.new(99) + * def k.hi + * "Hi, @iv = #{@iv}" + * end + * m = k.singleton_method(:hi) + * m.call #=> "Hi, @iv = 99" + * m = k.singleton_method(:hello) #=> NameError + */ + +VALUE +rb_obj_singleton_method(VALUE obj, VALUE vid) +{ + VALUE sc = rb_singleton_class_get(obj); + VALUE klass; ID id = rb_check_id(&vid); - if (!id) { - rb_method_name_error(CLASS_OF(obj), vid); + + if (NIL_P(sc) || + NIL_P(klass = RCLASS_ORIGIN(sc)) || + !NIL_P(rb_special_singleton_class(obj))) { + /* goto undef; */ + } + else if (! id) { + VALUE m = mnew_missing_by_name(klass, obj, &vid, FALSE, rb_cMethod); + if (m) return m; + /* else goto undef; */ } - return mnew(CLASS_OF(obj), obj, id, rb_cMethod, TRUE); + else { + VALUE args[2] = {obj, vid}; + VALUE ruby_method = rb_rescue(rb_obj_singleton_method_lookup, (VALUE)args, rb_obj_singleton_method_lookup_fail, Qfalse); + if (ruby_method) { + struct METHOD *method = (struct METHOD *)RTYPEDDATA_GET_DATA(ruby_method); + VALUE lookup_class = RBASIC_CLASS(obj); + VALUE stop_class = rb_class_superclass(sc); + VALUE method_class = method->iclass; + + /* Determine if method is in singleton class, or module included in or prepended to it */ + do { + if (lookup_class == method_class) { + return ruby_method; + } + lookup_class = RCLASS_SUPER(lookup_class); + } while (lookup_class && lookup_class != stop_class); + } + } + + /* undef: */ + vid = ID2SYM(id); + rb_name_err_raise("undefined singleton method '%1$s' for '%2$s'", + obj, vid); + UNREACHABLE_RETURN(Qundef); } /* @@ -1244,29 +2371,29 @@ rb_obj_public_method(VALUE obj, VALUE vid) * * Returns an +UnboundMethod+ representing the given * instance method in _mod_. + * See +UnboundMethod+ about how to utilize it * - * class Interpreter - * def do_a() print "there, "; end - * def do_d() print "Hello "; end - * def do_e() print "!\n"; end - * def do_v() print "Dave"; end - * Dispatcher = { - * "a" => instance_method(:do_a), - * "d" => instance_method(:do_d), - * "e" => instance_method(:do_e), - * "v" => instance_method(:do_v) - * } - * def interpret(string) - * string.each_char {|b| Dispatcher[b].bind(self).call } - * end - * end + * class Person + * def initialize(name) + * @name = name + * end + * + * def hi + * puts "Hi, I'm #{@name}!" + * end + * end * - * interpreter = Interpreter.new - * interpreter.interpret('dave') + * dave = Person.new('Dave') + * thomas = Person.new('Thomas') + * + * hi = Person.instance_method(:hi) + * hi.bind_call(dave) + * hi.bind_call(thomas) * * <em>produces:</em> * - * Hello there, Dave! + * Hi, I'm Dave! + * Hi, I'm Thomas! */ static VALUE @@ -1274,9 +2401,9 @@ rb_mod_instance_method(VALUE mod, VALUE vid) { ID id = rb_check_id(&vid); if (!id) { - rb_method_name_error(mod, vid); + rb_method_name_error(mod, vid); } - return mnew(mod, Qundef, id, rb_cUnboundMethod, FALSE); + return mnew_unbound(mod, id, rb_cUnboundMethod, FALSE); } /* @@ -1291,31 +2418,100 @@ rb_mod_public_instance_method(VALUE mod, VALUE vid) { ID id = rb_check_id(&vid); if (!id) { - rb_method_name_error(mod, vid); + rb_method_name_error(mod, vid); } - return mnew(mod, Qundef, id, rb_cUnboundMethod, TRUE); + return mnew_unbound(mod, id, rb_cUnboundMethod, TRUE); +} + +static VALUE +rb_mod_define_method_with_visibility(int argc, VALUE *argv, VALUE mod, const struct rb_scope_visi_struct* scope_visi) +{ + ID id; + VALUE body; + VALUE name; + int is_method = FALSE; + + rb_check_arity(argc, 1, 2); + name = argv[0]; + id = rb_check_id(&name); + if (argc == 1) { + body = rb_block_lambda(); + } + else { + body = argv[1]; + + if (rb_obj_is_method(body)) { + is_method = TRUE; + } + else if (rb_obj_is_proc(body)) { + is_method = FALSE; + } + else { + rb_raise(rb_eTypeError, + "wrong argument type %s (expected Proc/Method/UnboundMethod)", + rb_obj_classname(body)); + } + } + if (!id) id = rb_to_id(name); + + if (is_method) { + struct METHOD *method = (struct METHOD *)RTYPEDDATA_GET_DATA(body); + if (method->me->owner != mod && !RB_TYPE_P(method->me->owner, T_MODULE) && + !RTEST(rb_class_inherited_p(mod, method->me->owner))) { + if (RCLASS_SINGLETON_P(method->me->owner)) { + rb_raise(rb_eTypeError, + "can't bind singleton method to a different class"); + } + else { + rb_raise(rb_eTypeError, + "bind argument must be a subclass of % "PRIsVALUE, + method->me->owner); + } + } + rb_method_entry_set(mod, id, method->me, scope_visi->method_visi); + if (scope_visi->module_func) { + rb_method_entry_set(rb_singleton_class(mod), id, method->me, METHOD_VISI_PUBLIC); + } + RB_GC_GUARD(body); + } + else { + VALUE procval = rb_proc_dup(body); + if (vm_proc_iseq(procval) != NULL) { + rb_proc_t *proc; + GetProcPtr(procval, proc); + proc->is_lambda = TRUE; + proc->is_from_method = TRUE; + } + rb_add_method(mod, id, VM_METHOD_TYPE_BMETHOD, (void *)procval, scope_visi->method_visi); + if (scope_visi->module_func) { + rb_add_method(rb_singleton_class(mod), id, VM_METHOD_TYPE_BMETHOD, (void *)body, METHOD_VISI_PUBLIC); + } + } + + return ID2SYM(id); } /* * call-seq: - * define_method(symbol, method) -> new_method - * define_method(symbol) { block } -> proc + * define_method(symbol, method) -> symbol + * define_method(symbol) { block } -> symbol * * Defines an instance method in the receiver. The _method_ * parameter can be a +Proc+, a +Method+ or an +UnboundMethod+ object. - * If a block is specified, it is used as the method body. This block - * is evaluated using <code>instance_eval</code>, a point that is - * tricky to demonstrate because <code>define_method</code> is private. - * (This is why we resort to the +send+ hack in this example.) + * If a block is specified, it is used as the method body. + * If a block or the _method_ parameter has parameters, + * they're used as method parameters. + * This block is evaluated using #instance_eval. * * class A * def fred * puts "In Fred" * end * def create_method(name, &block) - * self.class.send(:define_method, name, &block) + * self.class.define_method(name, &block) * end * define_method(:wilma) { puts "Charge it!" } + * define_method(:flint) {|name| puts "I'm #{name}!"} * end * class B < A * define_method(:barney, instance_method(:fred)) @@ -1323,6 +2519,7 @@ rb_mod_public_instance_method(VALUE mod, VALUE vid) * a = B.new * a.barney * a.wilma + * a.flint('Dino') * a.create_method(:betty) { p self } * a.betty * @@ -1330,78 +2527,33 @@ rb_mod_public_instance_method(VALUE mod, VALUE vid) * * In Fred * Charge it! + * I'm Dino! * #<B:0x401b39e8> */ static VALUE rb_mod_define_method(int argc, VALUE *argv, VALUE mod) { - ID id; - VALUE body; - int noex = NOEX_PUBLIC; + const rb_cref_t *cref = rb_vm_cref_in_context(mod, mod); + const rb_scope_visibility_t default_scope_visi = {METHOD_VISI_PUBLIC, FALSE}; + const rb_scope_visibility_t *scope_visi = &default_scope_visi; - if (argc == 1) { - id = rb_to_id(argv[0]); - body = rb_block_lambda(); - } - else { - rb_check_arity(argc, 1, 2); - id = rb_to_id(argv[0]); - body = argv[1]; - if (!rb_obj_is_method(body) && !rb_obj_is_proc(body)) { - rb_raise(rb_eTypeError, - "wrong argument type %s (expected Proc/Method)", - rb_obj_classname(body)); - } - } - - if (rb_obj_is_method(body)) { - struct METHOD *method = (struct METHOD *)DATA_PTR(body); - VALUE rclass = method->rclass; - if (rclass != mod && !RB_TYPE_P(rclass, T_MODULE) && - !RTEST(rb_class_inherited_p(mod, rclass))) { - if (FL_TEST(rclass, FL_SINGLETON)) { - rb_raise(rb_eTypeError, - "can't bind singleton method to a different class"); - } - else { - rb_raise(rb_eTypeError, - "bind argument must be a subclass of %s", - rb_class2name(rclass)); - } - } - rb_method_entry_set(mod, id, method->me, noex); - RB_GC_GUARD(body); - } - else if (rb_obj_is_proc(body)) { - rb_proc_t *proc; - body = proc_dup(body); - GetProcPtr(body, proc); - if (BUILTIN_TYPE(proc->block.iseq) != T_NODE) { - proc->block.iseq->defined_method_id = id; - proc->block.iseq->klass = mod; - proc->is_lambda = TRUE; - proc->is_from_method = TRUE; - proc->block.klass = mod; - } - rb_add_method(mod, id, VM_METHOD_TYPE_BMETHOD, (void *)body, noex); - } - else { - /* type error */ - rb_raise(rb_eTypeError, "wrong argument type (expected Proc/Method)"); + if (cref) { + scope_visi = CREF_SCOPE_VISI(cref); } - return body; + return rb_mod_define_method_with_visibility(argc, argv, mod, scope_visi); } /* * call-seq: - * define_singleton_method(symbol, method) -> new_method - * define_singleton_method(symbol) { block } -> proc + * define_singleton_method(symbol, method) -> symbol + * define_singleton_method(symbol) { block } -> symbol * - * Defines a singleton method in the receiver. The _method_ + * Defines a public singleton method in the receiver. The _method_ * parameter can be a +Proc+, a +Method+ or an +UnboundMethod+ object. * If a block is specified, it is used as the method body. + * If a block or a method has parameters, they're used as method parameters. * * class A * class << self @@ -1418,19 +2570,24 @@ rb_mod_define_method(int argc, VALUE *argv, VALUE mod) * guy = "Bob" * guy.define_singleton_method(:hello) { "#{self}: Hello there!" } * guy.hello #=> "Bob: Hello there!" + * + * chris = "Chris" + * chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" } + * chris.greet("Hi") #=> "Hi, I'm Chris!" */ static VALUE rb_obj_define_method(int argc, VALUE *argv, VALUE obj) { VALUE klass = rb_singleton_class(obj); + const rb_scope_visibility_t scope_visi = {METHOD_VISI_PUBLIC, FALSE}; - return rb_mod_define_method(argc, argv, klass); + return rb_mod_define_method_with_visibility(argc, argv, klass, &scope_visi); } /* - * define_method(symbol, method) -> new_method - * define_method(symbol) { block } -> proc + * define_method(symbol, method) -> symbol + * define_method(symbol) { block } -> symbol * * Defines a global function by _method_ or the block. */ @@ -1438,18 +2595,7 @@ rb_obj_define_method(int argc, VALUE *argv, VALUE obj) static VALUE top_define_method(int argc, VALUE *argv, VALUE obj) { - rb_thread_t *th = GET_THREAD(); - VALUE klass; - - rb_secure(4); - klass = th->top_wrapper; - if (klass) { - rb_warning("main.define_method in the wrapped load is effective only in wrapper module"); - } - else { - klass = rb_cObject; - } - return rb_mod_define_method(argc, argv, klass); + return rb_mod_define_method(argc, argv, rb_top_main_class("define_method")); } /* @@ -1477,98 +2623,129 @@ method_clone(VALUE self) TypedData_Get_Struct(self, struct METHOD, &method_data_type, orig); clone = TypedData_Make_Struct(CLASS_OF(self), struct METHOD, &method_data_type, data); - CLONESETUP(clone, self); - *data = *orig; - data->me = ALLOC(rb_method_entry_t); - *data->me = *orig->me; - if (data->me->def) data->me->def->alias_count++; - data->ume = ALLOC(struct unlinked_method_entry_list_entry); + rb_obj_clone_setup(self, clone, Qnil); + RB_OBJ_WRITE(clone, &data->recv, orig->recv); + RB_OBJ_WRITE(clone, &data->klass, orig->klass); + RB_OBJ_WRITE(clone, &data->iclass, orig->iclass); + RB_OBJ_WRITE(clone, &data->owner, orig->owner); + RB_OBJ_WRITE(clone, &data->me, rb_method_entry_clone(orig->me)); + return clone; +} +/* :nodoc: */ +static VALUE +method_dup(VALUE self) +{ + VALUE clone; + struct METHOD *orig, *data; + + TypedData_Get_Struct(self, struct METHOD, &method_data_type, orig); + clone = TypedData_Make_Struct(CLASS_OF(self), struct METHOD, &method_data_type, data); + rb_obj_dup_setup(self, clone); + RB_OBJ_WRITE(clone, &data->recv, orig->recv); + RB_OBJ_WRITE(clone, &data->klass, orig->klass); + RB_OBJ_WRITE(clone, &data->iclass, orig->iclass); + RB_OBJ_WRITE(clone, &data->owner, orig->owner); + RB_OBJ_WRITE(clone, &data->me, rb_method_entry_clone(orig->me)); return clone; } /* * call-seq: - * meth.call(args, ...) -> obj - * meth[args, ...] -> obj + * call(...) -> obj + * self[...] -> obj + * self === obj -> result_of_method * - * Invokes the <i>meth</i> with the specified arguments, returning the + * Invokes +self+ with the specified arguments, returning the * method's return value. * * m = 12.method("+") * m.call(3) #=> 15 * m.call(20) #=> 32 + * + * Using Method#=== allows a method object to be the target of a +when+ clause + * in a case statement. + * + * require 'prime' + * + * case 1373 + * when Prime.method(:prime?) + * # ... + * end */ +static VALUE +rb_method_call_pass_called_kw(int argc, const VALUE *argv, VALUE method) +{ + return rb_method_call_kw(argc, argv, method, RB_PASS_CALLED_KEYWORDS); +} + VALUE -rb_method_call(int argc, VALUE *argv, VALUE method) +rb_method_call_kw(int argc, const VALUE *argv, VALUE method, int kw_splat) { - VALUE proc = rb_block_given_p() ? rb_block_proc() : Qnil; - return rb_method_call_with_block(argc, argv, method, proc); + VALUE procval = rb_block_given_p() ? rb_block_proc() : Qnil; + return rb_method_call_with_block_kw(argc, argv, method, procval, kw_splat); } VALUE -rb_method_call_with_block(int argc, VALUE *argv, VALUE method, VALUE pass_procval) +rb_method_call(int argc, const VALUE *argv, VALUE method) { - VALUE result = Qnil; /* OK */ - struct METHOD *data; - int state; - volatile int safe = -1; + VALUE procval = rb_block_given_p() ? rb_block_proc() : Qnil; + return rb_method_call_with_block(argc, argv, method, procval); +} + +static const rb_callable_method_entry_t * +method_callable_method_entry(const struct METHOD *data) +{ + if (data->me->defined_class == 0) rb_bug("method_callable_method_entry: not callable."); + return (const rb_callable_method_entry_t *)data->me; +} + +static inline VALUE +call_method_data(rb_execution_context_t *ec, const struct METHOD *data, + int argc, const VALUE *argv, VALUE passed_procval, int kw_splat) +{ + vm_passed_block_handler_set(ec, proc_to_block_handler(passed_procval)); + return rb_vm_call_kw(ec, data->recv, data->me->called_id, argc, argv, + method_callable_method_entry(data), kw_splat); +} + +VALUE +rb_method_call_with_block_kw(int argc, const VALUE *argv, VALUE method, VALUE passed_procval, int kw_splat) +{ + const struct METHOD *data; + rb_execution_context_t *ec = GET_EC(); TypedData_Get_Struct(method, struct METHOD, &method_data_type, data); - if (data->recv == Qundef) { - rb_raise(rb_eTypeError, "can't call unbound method; bind first"); - } - PUSH_TAG(); - if (OBJ_TAINTED(method)) { - const int safe_level_to_run = 4 /*SAFE_LEVEL_MAX*/; - safe = rb_safe_level(); - if (rb_safe_level() < safe_level_to_run) { - rb_set_safe_level_force(safe_level_to_run); - } - } - if ((state = EXEC_TAG()) == 0) { - rb_thread_t *th = GET_THREAD(); - rb_block_t *block = 0; - VALUE defined_class; - - if (!NIL_P(pass_procval)) { - rb_proc_t *pass_proc; - GetProcPtr(pass_procval, pass_proc); - block = &pass_proc->block; - } - - th->passed_block = block; - defined_class = data->defined_class; - if (BUILTIN_TYPE(defined_class) == T_MODULE) defined_class = data->rclass; - result = rb_vm_call(th, data->recv, data->id, argc, argv, data->me, defined_class); - } - POP_TAG(); - if (safe >= 0) - rb_set_safe_level_force(safe); - if (state) - JUMP_TAG(state); - return result; + if (UNDEF_P(data->recv)) { + rb_raise(rb_eTypeError, "can't call unbound method; bind first"); + } + return call_method_data(ec, data, argc, argv, passed_procval, kw_splat); +} + +VALUE +rb_method_call_with_block(int argc, const VALUE *argv, VALUE method, VALUE passed_procval) +{ + return rb_method_call_with_block_kw(argc, argv, method, passed_procval, RB_NO_KEYWORDS); } /********************************************************************** * * Document-class: UnboundMethod * - * Ruby supports two forms of objectified methods. Class - * <code>Method</code> is used to represent methods that are associated - * with a particular object: these method objects are bound to that - * object. Bound method objects for an object can be created using - * <code>Object#method</code>. + * Ruby supports two forms of objectified methods. Class +Method+ is + * used to represent methods that are associated with a particular + * object: these method objects are bound to that object. Bound + * method objects for an object can be created using Object#method. * * Ruby also supports unbound methods; methods objects that are not - * associated with a particular object. These can be created either by - * calling <code>Module#instance_method</code> or by calling - * <code>unbind</code> on a bound method object. The result of both of - * these is an <code>UnboundMethod</code> object. + * associated with a particular object. These can be created either + * by calling Module#instance_method or by calling #unbind on a bound + * method object. The result of both of these is an UnboundMethod + * object. * * Unbound methods can only be called after they are bound to an - * object. That object must be be a kind_of? the method's original + * object. That object must be a kind_of? the method's original * class. * * class Square @@ -1607,13 +2784,66 @@ rb_method_call_with_block(int argc, VALUE *argv, VALUE method, VALUE pass_procva * */ +static void +convert_umethod_to_method_components(const struct METHOD *data, VALUE recv, VALUE *methclass_out, VALUE *klass_out, VALUE *iclass_out, const rb_method_entry_t **me_out, const bool clone) +{ + VALUE methclass = data->owner; + VALUE iclass = data->me->defined_class; + VALUE klass = CLASS_OF(recv); + + if (RB_TYPE_P(methclass, T_MODULE)) { + VALUE refined_class = rb_refinement_module_get_refined_class(methclass); + if (!NIL_P(refined_class)) methclass = refined_class; + } + if (!RB_TYPE_P(methclass, T_MODULE) && !RTEST(rb_obj_is_kind_of(recv, methclass))) { + if (RCLASS_SINGLETON_P(methclass)) { + rb_raise(rb_eTypeError, + "singleton method called for a different object"); + } + else { + rb_raise(rb_eTypeError, "bind argument must be an instance of % "PRIsVALUE, + methclass); + } + } + + const rb_method_entry_t *me; + if (clone) { + me = rb_method_entry_clone(data->me); + } + else { + me = data->me; + } + + if (RB_TYPE_P(me->owner, T_MODULE)) { + if (!clone) { + // if we didn't previously clone the method entry, then we need to clone it now + // because this branch manipulates it in rb_method_entry_complement_defined_class + me = rb_method_entry_clone(me); + } + VALUE ic = rb_class_search_ancestor(klass, me->owner); + if (ic) { + klass = ic; + iclass = ic; + } + else { + klass = rb_include_class_new(methclass, klass); + } + me = (const rb_method_entry_t *) rb_method_entry_complement_defined_class(me, me->called_id, klass); + } + + *methclass_out = methclass; + *klass_out = klass; + *iclass_out = iclass; + *me_out = me; +} + /* * call-seq: * umeth.bind(obj) -> method * - * Bind <i>umeth</i> to <i>obj</i>. If <code>Klass</code> was the class - * from which <i>umeth</i> was obtained, - * <code>obj.kind_of?(Klass)</code> must be true. + * Bind <i>umeth</i> to <i>obj</i>. If Klass was the class from which + * <i>umeth</i> was obtained, <code>obj.kind_of?(Klass)</code> must + * be true. * * class A * def test @@ -1645,116 +2875,151 @@ rb_method_call_with_block(int argc, VALUE *argv, VALUE method, VALUE pass_procva static VALUE umethod_bind(VALUE method, VALUE recv) { - struct METHOD *data, *bound; - VALUE methclass; - VALUE rclass; - + VALUE methclass, klass, iclass; + const rb_method_entry_t *me; + const struct METHOD *data; TypedData_Get_Struct(method, struct METHOD, &method_data_type, data); + convert_umethod_to_method_components(data, recv, &methclass, &klass, &iclass, &me, true); - methclass = data->rclass; - if (!RB_TYPE_P(methclass, T_MODULE) && - methclass != CLASS_OF(recv) && !rb_obj_is_kind_of(recv, methclass)) { - if (FL_TEST(methclass, FL_SINGLETON)) { - rb_raise(rb_eTypeError, - "singleton method called for a different object"); - } - else { - rb_raise(rb_eTypeError, "bind argument must be an instance of %s", - rb_class2name(methclass)); - } - } - + struct METHOD *bound; method = TypedData_Make_Struct(rb_cMethod, struct METHOD, &method_data_type, bound); - *bound = *data; - bound->me = ALLOC(rb_method_entry_t); - *bound->me = *data->me; - if (bound->me->def) bound->me->def->alias_count++; - rclass = CLASS_OF(recv); - if (BUILTIN_TYPE(bound->defined_class) == T_MODULE) { - VALUE ic = rb_class_search_ancestor(rclass, bound->defined_class); - if (ic) { - rclass = ic; - } - else { - rclass = rb_include_class_new(methclass, rclass); - } - } - bound->recv = recv; - bound->rclass = rclass; - data->ume = ALLOC(struct unlinked_method_entry_list_entry); + RB_OBJ_WRITE(method, &bound->recv, recv); + RB_OBJ_WRITE(method, &bound->klass, klass); + RB_OBJ_WRITE(method, &bound->iclass, iclass); + RB_OBJ_WRITE(method, &bound->owner, methclass); + RB_OBJ_WRITE(method, &bound->me, me); return method; } /* + * call-seq: + * umeth.bind_call(recv, args, ...) -> obj + * + * Bind <i>umeth</i> to <i>recv</i> and then invokes the method with the + * specified arguments. + * This is semantically equivalent to <code>umeth.bind(recv).call(args, ...)</code>. + */ +static VALUE +umethod_bind_call(int argc, VALUE *argv, VALUE method) +{ + rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); + VALUE recv = argv[0]; + argc--; + argv++; + + VALUE passed_procval = rb_block_given_p() ? rb_block_proc() : Qnil; + rb_execution_context_t *ec = GET_EC(); + + const struct METHOD *data; + TypedData_Get_Struct(method, struct METHOD, &method_data_type, data); + + const rb_callable_method_entry_t *cme = rb_callable_method_entry(CLASS_OF(recv), data->me->called_id); + if (data->me == (const rb_method_entry_t *)cme) { + vm_passed_block_handler_set(ec, proc_to_block_handler(passed_procval)); + return rb_vm_call_kw(ec, recv, cme->called_id, argc, argv, cme, RB_PASS_CALLED_KEYWORDS); + } + else { + VALUE methclass, klass, iclass; + const rb_method_entry_t *me; + convert_umethod_to_method_components(data, recv, &methclass, &klass, &iclass, &me, false); + struct METHOD bound = { recv, klass, 0, methclass, me }; + + return call_method_data(ec, &bound, argc, argv, passed_procval, RB_PASS_CALLED_KEYWORDS); + } +} + +/* * Returns the number of required parameters and stores the maximum * number of parameters in max, or UNLIMITED_ARGUMENTS * if there is no maximum. */ static int -rb_method_entry_min_max_arity(const rb_method_entry_t *me, int *max) +method_def_min_max_arity(const rb_method_definition_t *def, int *max) { - const rb_method_definition_t *def = me->def; + again: if (!def) return *max = 0; switch (def->type) { case VM_METHOD_TYPE_CFUNC: - if (def->body.cfunc.argc < 0) { - *max = UNLIMITED_ARGUMENTS; - return 0; - } - return *max = check_argc(def->body.cfunc.argc); + if (def->body.cfunc.argc < 0) { + *max = UNLIMITED_ARGUMENTS; + return 0; + } + return *max = check_argc(def->body.cfunc.argc); case VM_METHOD_TYPE_ZSUPER: - *max = UNLIMITED_ARGUMENTS; - return 0; + *max = UNLIMITED_ARGUMENTS; + return 0; case VM_METHOD_TYPE_ATTRSET: - return *max = 1; + return *max = 1; case VM_METHOD_TYPE_IVAR: - return *max = 0; + return *max = 0; + case VM_METHOD_TYPE_ALIAS: + def = def->body.alias.original_me->def; + goto again; case VM_METHOD_TYPE_BMETHOD: - return rb_proc_min_max_arity(def->body.proc, max); - case VM_METHOD_TYPE_ISEQ: { - rb_iseq_t *iseq = def->body.iseq; - return rb_iseq_min_max_arity(iseq, max); - } + return rb_proc_min_max_arity(def->body.bmethod.proc, max); + case VM_METHOD_TYPE_ISEQ: + return rb_iseq_min_max_arity(rb_iseq_check(def->body.iseq.iseqptr), max); case VM_METHOD_TYPE_UNDEF: case VM_METHOD_TYPE_NOTIMPLEMENTED: - return *max = 0; + return *max = 0; case VM_METHOD_TYPE_MISSING: - *max = UNLIMITED_ARGUMENTS; - return 0; + *max = UNLIMITED_ARGUMENTS; + return 0; case VM_METHOD_TYPE_OPTIMIZED: { - switch (def->body.optimize_type) { - case OPTIMIZED_METHOD_TYPE_SEND: - *max = UNLIMITED_ARGUMENTS; - return 0; - default: - break; - } + switch (def->body.optimized.type) { + case OPTIMIZED_METHOD_TYPE_SEND: + *max = UNLIMITED_ARGUMENTS; + return 0; + case OPTIMIZED_METHOD_TYPE_CALL: + *max = UNLIMITED_ARGUMENTS; + return 0; + case OPTIMIZED_METHOD_TYPE_BLOCK_CALL: + *max = UNLIMITED_ARGUMENTS; + return 0; + case OPTIMIZED_METHOD_TYPE_STRUCT_AREF: + *max = 0; + return 0; + case OPTIMIZED_METHOD_TYPE_STRUCT_ASET: + *max = 1; + return 1; + default: + break; + } + break; } case VM_METHOD_TYPE_REFINED: - *max = UNLIMITED_ARGUMENTS; - return 0; + *max = UNLIMITED_ARGUMENTS; + return 0; } - rb_bug("rb_method_entry_min_max_arity: invalid method entry type (%d)", def->type); - UNREACHABLE; + rb_bug("method_def_min_max_arity: invalid method entry type (%d)", def->type); + UNREACHABLE_RETURN(Qnil); +} + +static int +method_def_arity(const rb_method_definition_t *def) +{ + int max, min = method_def_min_max_arity(def, &max); + return min == max ? min : -min-1; } int rb_method_entry_arity(const rb_method_entry_t *me) { - int max, min = rb_method_entry_min_max_arity(me, &max); - return min == max ? min : -min-1; + return method_def_arity(me->def); } /* * call-seq: - * meth.arity -> fixnum + * meth.arity -> integer * * Returns an indication of the number of arguments accepted by a * method. Returns a nonnegative integer for methods that take a fixed * number of arguments. For Ruby methods that take a variable number of - * arguments, returns -n-1, where n is the number of required - * arguments. For methods written in C, returns -1 if the call takes a + * arguments, returns -n-1, where n is the number of required arguments. + * Keyword arguments will be considered as a single additional argument, + * that argument being mandatory if any keyword argument is mandatory. + * For methods written in C, returns -1 if the call takes a * variable number of arguments. * * class C @@ -1764,6 +3029,10 @@ rb_method_entry_arity(const rb_method_entry_t *me) * def four(a, b); end * def five(a, b, *c); end * def six(a, b, *c, &d); end + * def seven(a, b, x:0); end + * def eight(x:, y:); end + * def nine(x:, y:, **z); end + * def ten(*a, x:, y:); end * end * c = C.new * c.method(:one).arity #=> 0 @@ -1772,6 +3041,10 @@ rb_method_entry_arity(const rb_method_entry_t *me) * c.method(:four).arity #=> 2 * c.method(:five).arity #=> -3 * c.method(:six).arity #=> -3 + * c.method(:seven).arity #=> -3 + * c.method(:eight).arity #=> 1 + * c.method(:nine).arity #=> 1 + * c.method(:ten).arity #=> -2 * * "cat".method(:size).arity #=> 0 * "cat".method(:replace).arity #=> 1 @@ -1795,17 +3068,16 @@ method_arity(VALUE method) return rb_method_entry_arity(data->me); } -static rb_method_entry_t * +static const rb_method_entry_t * original_method_entry(VALUE mod, ID id) { - VALUE rclass; - rb_method_entry_t *me; - while ((me = rb_method_entry(mod, id, &rclass)) != 0) { - rb_method_definition_t *def = me->def; - if (!def) break; - if (def->type != VM_METHOD_TYPE_ZSUPER) break; - mod = RCLASS_SUPER(rclass); - id = def->original_id; + const rb_method_entry_t *me; + + while ((me = rb_method_entry(mod, id)) != 0) { + const rb_method_definition_t *def = me->def; + if (def->type != VM_METHOD_TYPE_ZSUPER) break; + mod = RCLASS_SUPER(me->owner); + id = def->original_id; } return me; } @@ -1813,16 +3085,16 @@ original_method_entry(VALUE mod, ID id) static int method_min_max_arity(VALUE method, int *max) { - struct METHOD *data; + const struct METHOD *data; TypedData_Get_Struct(method, struct METHOD, &method_data_type, data); - return rb_method_entry_min_max_arity(data->me, max); + return method_def_min_max_arity(data->me->def, max); } int rb_mod_method_arity(VALUE mod, ID id) { - rb_method_entry_t *me = original_method_entry(mod, id); + const rb_method_entry_t *me = original_method_entry(mod, id); if (!me) return 0; /* should raise? */ return rb_method_entry_arity(me); } @@ -1833,78 +3105,177 @@ rb_obj_method_arity(VALUE obj, ID id) return rb_mod_method_arity(CLASS_OF(obj), id); } -static inline rb_method_definition_t * -method_get_def(VALUE method) +VALUE +rb_callable_receiver(VALUE callable) { - struct METHOD *data; + if (rb_obj_is_proc(callable)) { + VALUE binding = proc_binding(callable); + return rb_funcall(binding, rb_intern("receiver"), 0); + } + else if (rb_obj_is_method(callable)) { + return method_receiver(callable); + } + else { + return Qundef; + } +} + +const rb_method_definition_t * +rb_method_def(VALUE method) +{ + const struct METHOD *data; TypedData_Get_Struct(method, struct METHOD, &method_data_type, data); return data->me->def; } -static rb_iseq_t * -method_get_iseq(rb_method_definition_t *def) +static const rb_iseq_t * +method_def_iseq(const rb_method_definition_t *def) { switch (def->type) { - case VM_METHOD_TYPE_BMETHOD: - return get_proc_iseq(def->body.proc, 0); case VM_METHOD_TYPE_ISEQ: - return def->body.iseq; - default: - return 0; + return rb_iseq_check(def->body.iseq.iseqptr); + case VM_METHOD_TYPE_BMETHOD: + return rb_proc_get_iseq(def->body.bmethod.proc, 0); + case VM_METHOD_TYPE_ALIAS: + return method_def_iseq(def->body.alias.original_me->def); + case VM_METHOD_TYPE_CFUNC: + case VM_METHOD_TYPE_ATTRSET: + case VM_METHOD_TYPE_IVAR: + case VM_METHOD_TYPE_ZSUPER: + case VM_METHOD_TYPE_UNDEF: + case VM_METHOD_TYPE_NOTIMPLEMENTED: + case VM_METHOD_TYPE_OPTIMIZED: + case VM_METHOD_TYPE_MISSING: + case VM_METHOD_TYPE_REFINED: + break; } + return NULL; } -rb_iseq_t * -rb_method_get_iseq(VALUE method) +const rb_iseq_t * +rb_method_iseq(VALUE method) { - return method_get_iseq(method_get_def(method)); + return method_def_iseq(rb_method_def(method)); } -static VALUE -method_def_location(rb_method_definition_t *def) +static const rb_cref_t * +method_cref(VALUE method) { - if (def->type == VM_METHOD_TYPE_ATTRSET || def->type == VM_METHOD_TYPE_IVAR) { - if (!def->body.attr.location) - return Qnil; - return rb_ary_dup(def->body.attr.location); - } - return iseq_location(method_get_iseq(def)); -} + const rb_method_definition_t *def = rb_method_def(method); -VALUE -rb_method_entry_location(rb_method_entry_t *me) -{ - if (!me || !me->def) return Qnil; - return method_def_location(me->def); + again: + switch (def->type) { + case VM_METHOD_TYPE_ISEQ: + return def->body.iseq.cref; + case VM_METHOD_TYPE_ALIAS: + def = def->body.alias.original_me->def; + goto again; + default: + return NULL; + } } -VALUE -rb_mod_method_location(VALUE mod, ID id) +static VALUE +method_def_location(const rb_method_definition_t *def) { - rb_method_entry_t *me = original_method_entry(mod, id); - return rb_method_entry_location(me); + if (def->type == VM_METHOD_TYPE_ATTRSET || def->type == VM_METHOD_TYPE_IVAR) { + if (!def->body.attr.location) + return Qnil; + return rb_ary_dup(def->body.attr.location); + } + return iseq_location(method_def_iseq(def)); } VALUE -rb_obj_method_location(VALUE obj, ID id) +rb_method_entry_location(const rb_method_entry_t *me) { - return rb_mod_method_location(CLASS_OF(obj), id); + if (!me) return Qnil; + return method_def_location(me->def); } /* * call-seq: - * meth.source_location -> [String, Fixnum] + * meth.source_location -> [String, Integer, Integer, Integer, Integer] + * + * Returns the location where the method was defined. + * The returned Array contains: + * (1) the Ruby source filename + * (2) the line number where the definition starts + * (3) the position where the definition starts, in number of bytes from the start of the line + * (4) the line number where the definition ends + * (5) the position where the definitions ends, in number of bytes from the start of the line * - * Returns the Ruby source filename and line number containing this method - * or nil if this method was not defined in Ruby (i.e. native) + * This method will return +nil+ if the method was not defined in Ruby (i.e. native). */ VALUE rb_method_location(VALUE method) { - rb_method_definition_t *def = method_get_def(method); - return method_def_location(def); + return method_def_location(rb_method_def(method)); +} + +static const rb_method_definition_t * +vm_proc_method_def(VALUE procval) +{ + const rb_proc_t *proc; + const struct rb_block *block; + const struct vm_ifunc *ifunc; + + GetProcPtr(procval, proc); + block = &proc->block; + + if (vm_block_type(block) == block_type_ifunc && + IS_METHOD_PROC_IFUNC(ifunc = block->as.captured.code.ifunc)) { + return rb_method_def((VALUE)ifunc->data); + } + else { + return NULL; + } +} + +static VALUE +method_def_parameters(const rb_method_definition_t *def) +{ + const rb_iseq_t *iseq; + const rb_method_definition_t *bmethod_def; + + switch (def->type) { + case VM_METHOD_TYPE_ISEQ: + iseq = method_def_iseq(def); + return rb_iseq_parameters(iseq, 0); + case VM_METHOD_TYPE_BMETHOD: + if ((iseq = method_def_iseq(def)) != NULL) { + return rb_iseq_parameters(iseq, 0); + } + else if ((bmethod_def = vm_proc_method_def(def->body.bmethod.proc)) != NULL) { + return method_def_parameters(bmethod_def); + } + break; + + case VM_METHOD_TYPE_ALIAS: + return method_def_parameters(def->body.alias.original_me->def); + + case VM_METHOD_TYPE_OPTIMIZED: + if (def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_ASET) { + VALUE param = rb_ary_new_from_args(2, ID2SYM(rb_intern("req")), ID2SYM(rb_intern("_"))); + return rb_ary_new_from_args(1, param); + } + break; + + case VM_METHOD_TYPE_CFUNC: + case VM_METHOD_TYPE_ATTRSET: + case VM_METHOD_TYPE_IVAR: + case VM_METHOD_TYPE_ZSUPER: + case VM_METHOD_TYPE_UNDEF: + case VM_METHOD_TYPE_NOTIMPLEMENTED: + case VM_METHOD_TYPE_MISSING: + case VM_METHOD_TYPE_REFINED: + break; + } + + return rb_unnamed_parameters(method_def_arity(def)); + } /* @@ -1912,16 +3283,24 @@ rb_method_location(VALUE method) * meth.parameters -> array * * Returns the parameter information of this method. + * + * def foo(bar); end + * method(:foo).parameters #=> [[:req, :bar]] + * + * def foo(bar, baz, bat, &blk); end + * method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:req, :bat], [:block, :blk]] + * + * def foo(bar, *args); end + * method(:foo).parameters #=> [[:req, :bar], [:rest, :args]] + * + * def foo(bar, baz, *args, &blk); end + * method(:foo).parameters #=> [[:req, :bar], [:req, :baz], [:rest, :args], [:block, :blk]] */ static VALUE rb_method_parameters(VALUE method) { - rb_iseq_t *iseq = rb_method_get_iseq(method); - if (!iseq) { - return unnamed_parameters(method_arity(method)); - } - return rb_iseq_parameters(iseq, 0); + return method_def_parameters(rb_method_def(method)); } /* @@ -1929,9 +3308,32 @@ rb_method_parameters(VALUE method) * meth.to_s -> string * meth.inspect -> string * - * Returns the name of the underlying method. + * Returns a human-readable description of the underlying method. + * + * "cat".method(:count).inspect #=> "#<Method: String#count(*)>" + * (1..3).method(:map).inspect #=> "#<Method: Range(Enumerable)#map()>" + * + * In the latter case, the method description includes the "owner" of the + * original method (+Enumerable+ module, which is included into +Range+). + * + * +inspect+ also provides, when possible, method argument names (call + * sequence) and source location. * - * "cat".method(:count).inspect #=> "#<Method: String#count>" + * require 'net/http' + * Net::HTTP.method(:get).inspect + * #=> "#<Method: Net::HTTP.get(uri_or_host, path=..., port=...) <skip>/lib/ruby/2.7.0/net/http.rb:457>" + * + * <code>...</code> in argument definition means argument is optional (has + * some default value). + * + * For methods defined in C (language core and extensions), location and + * argument names can't be extracted, and only generic information is provided + * in form of <code>*</code> (any number of arguments) or <code>_</code> (some + * positional argument). + * + * "cat".method(:count).inspect #=> "#<Method: String#count(*)>" + * "cat".method(:+).inspect #=> "#<Method: String#+(_)>"" + */ static VALUE @@ -1939,129 +3341,282 @@ method_inspect(VALUE method) { struct METHOD *data; VALUE str; - const char *s; const char *sharp = "#"; + VALUE mklass; + VALUE defined_class; TypedData_Get_Struct(method, struct METHOD, &method_data_type, data); - str = rb_str_buf_new2("#<"); - s = rb_obj_classname(method); - rb_str_buf_cat2(str, s); - rb_str_buf_cat2(str, ": "); - - if (FL_TEST(data->me->klass, FL_SINGLETON)) { - VALUE v = rb_ivar_get(data->me->klass, attached); - - if (data->recv == Qundef) { - rb_str_buf_append(str, rb_inspect(data->me->klass)); - } - else if (data->recv == v) { - rb_str_buf_append(str, rb_inspect(v)); - sharp = "."; - } - else { - rb_str_buf_append(str, rb_inspect(data->recv)); - rb_str_buf_cat2(str, "("); - rb_str_buf_append(str, rb_inspect(v)); - rb_str_buf_cat2(str, ")"); - sharp = "."; - } + str = rb_sprintf("#<% "PRIsVALUE": ", rb_obj_class(method)); + + mklass = data->iclass; + if (!mklass) mklass = data->klass; + + if (RB_TYPE_P(mklass, T_ICLASS)) { + /* TODO: I'm not sure why mklass is T_ICLASS. + * UnboundMethod#bind() can set it as T_ICLASS at convert_umethod_to_method_components() + * but not sure it is needed. + */ + mklass = RBASIC_CLASS(mklass); + } + + if (data->me->def->type == VM_METHOD_TYPE_ALIAS) { + defined_class = data->me->def->body.alias.original_me->owner; + } + else { + defined_class = method_entry_defined_class(data->me); + } + + if (RB_TYPE_P(defined_class, T_ICLASS)) { + defined_class = RBASIC_CLASS(defined_class); + } + + if (UNDEF_P(data->recv)) { + // UnboundMethod + rb_str_buf_append(str, rb_inspect(defined_class)); + } + else if (RCLASS_SINGLETON_P(mklass)) { + VALUE v = RCLASS_ATTACHED_OBJECT(mklass); + + if (UNDEF_P(data->recv)) { + rb_str_buf_append(str, rb_inspect(mklass)); + } + else if (data->recv == v) { + rb_str_buf_append(str, rb_inspect(v)); + sharp = "."; + } + else { + rb_str_buf_append(str, rb_inspect(data->recv)); + rb_str_buf_cat2(str, "("); + rb_str_buf_append(str, rb_inspect(v)); + rb_str_buf_cat2(str, ")"); + sharp = "."; + } } else { - rb_str_buf_cat2(str, rb_class2name(data->rclass)); - if (data->rclass != data->me->klass) { - rb_str_buf_cat2(str, "("); - rb_str_buf_cat2(str, rb_class2name(data->me->klass)); - rb_str_buf_cat2(str, ")"); - } + mklass = data->klass; + if (RCLASS_SINGLETON_P(mklass)) { + VALUE v = RCLASS_ATTACHED_OBJECT(mklass); + if (!(RB_TYPE_P(v, T_CLASS) || RB_TYPE_P(v, T_MODULE))) { + do { + mklass = RCLASS_SUPER(mklass); + } while (RB_TYPE_P(mklass, T_ICLASS)); + } + } + rb_str_buf_append(str, rb_inspect(mklass)); + if (defined_class != mklass) { + rb_str_catf(str, "(% "PRIsVALUE")", defined_class); + } } rb_str_buf_cat2(str, sharp); - rb_str_append(str, rb_id2str(data->me->def->original_id)); + rb_str_append(str, rb_id2str(data->me->called_id)); + if (data->me->called_id != data->me->def->original_id) { + rb_str_catf(str, "(%"PRIsVALUE")", + rb_id2str(data->me->def->original_id)); + } if (data->me->def->type == VM_METHOD_TYPE_NOTIMPLEMENTED) { rb_str_buf_cat2(str, " (not-implemented)"); } - rb_str_buf_cat2(str, ">"); - return str; -} + // parameter information + { + VALUE params = rb_method_parameters(method); + VALUE pair, name, kind; + const VALUE req = ID2SYM(rb_intern("req")); + const VALUE opt = ID2SYM(rb_intern("opt")); + const VALUE keyreq = ID2SYM(rb_intern("keyreq")); + const VALUE key = ID2SYM(rb_intern("key")); + const VALUE rest = ID2SYM(rb_intern("rest")); + const VALUE keyrest = ID2SYM(rb_intern("keyrest")); + const VALUE block = ID2SYM(rb_intern("block")); + const VALUE nokey = ID2SYM(rb_intern("nokey")); + int forwarding = 0; + + rb_str_buf_cat2(str, "("); + + if (RARRAY_LEN(params) == 3 && + RARRAY_AREF(RARRAY_AREF(params, 0), 0) == rest && + RARRAY_AREF(RARRAY_AREF(params, 0), 1) == ID2SYM('*') && + RARRAY_AREF(RARRAY_AREF(params, 1), 0) == keyrest && + RARRAY_AREF(RARRAY_AREF(params, 1), 1) == ID2SYM(idPow) && + RARRAY_AREF(RARRAY_AREF(params, 2), 0) == block && + RARRAY_AREF(RARRAY_AREF(params, 2), 1) == ID2SYM('&')) { + forwarding = 1; + } + + for (int i = 0; i < RARRAY_LEN(params); i++) { + pair = RARRAY_AREF(params, i); + kind = RARRAY_AREF(pair, 0); + if (RARRAY_LEN(pair) > 1) { + name = RARRAY_AREF(pair, 1); + } + else { + // FIXME: can it be reduced to switch/case? + if (kind == req || kind == opt) { + name = rb_str_new2("_"); + } + else if (kind == rest || kind == keyrest) { + name = rb_str_new2(""); + } + else if (kind == block) { + name = rb_str_new2("block"); + } + else if (kind == nokey) { + name = rb_str_new2("nil"); + } + else { + name = Qnil; + } + } + + if (kind == req) { + rb_str_catf(str, "%"PRIsVALUE, name); + } + else if (kind == opt) { + rb_str_catf(str, "%"PRIsVALUE"=...", name); + } + else if (kind == keyreq) { + rb_str_catf(str, "%"PRIsVALUE":", name); + } + else if (kind == key) { + rb_str_catf(str, "%"PRIsVALUE": ...", name); + } + else if (kind == rest) { + if (name == ID2SYM('*')) { + rb_str_cat_cstr(str, forwarding ? "..." : "*"); + } + else { + rb_str_catf(str, "*%"PRIsVALUE, name); + } + } + else if (kind == keyrest) { + if (name != ID2SYM(idPow)) { + rb_str_catf(str, "**%"PRIsVALUE, name); + } + else if (i > 0) { + rb_str_set_len(str, RSTRING_LEN(str) - 2); + } + else { + rb_str_cat_cstr(str, "**"); + } + } + else if (kind == block) { + if (name == ID2SYM('&')) { + if (forwarding) { + rb_str_set_len(str, RSTRING_LEN(str) - 2); + } + else { + rb_str_cat_cstr(str, "..."); + } + } + else { + rb_str_catf(str, "&%"PRIsVALUE, name); + } + } + else if (kind == nokey) { + rb_str_buf_cat2(str, "**nil"); + } + + if (i < RARRAY_LEN(params) - 1) { + rb_str_buf_cat2(str, ", "); + } + } + rb_str_buf_cat2(str, ")"); + } -static VALUE -mproc(VALUE method) -{ - return rb_funcall2(rb_mRubyVMFrozenCore, idProc, 0, 0); -} + { // source location + VALUE loc = rb_method_location(method); + if (!NIL_P(loc)) { + rb_str_catf(str, " %"PRIsVALUE":%"PRIsVALUE, + RARRAY_AREF(loc, 0), RARRAY_AREF(loc, 1)); + } + } -static VALUE -mlambda(VALUE method) -{ - return rb_funcall(rb_mRubyVMFrozenCore, idLambda, 0, 0); + rb_str_buf_cat2(str, ">"); + + return str; } static VALUE -bmcall(VALUE args, VALUE method, int argc, VALUE *argv, VALUE passed_proc) +bmcall(RB_BLOCK_CALL_FUNC_ARGLIST(args, method)) { - volatile VALUE a; - VALUE ret; - - if (CLASS_OF(args) != rb_cArray) { - args = rb_ary_new3(1, args); - argc = 1; - } - else { - argc = check_argc(RARRAY_LEN(args)); - } - ret = rb_method_call_with_block(argc, RARRAY_PTR(args), method, passed_proc); - RB_GC_GUARD(a) = args; - return ret; + return rb_method_call_with_block_kw(argc, argv, method, blockarg, RB_PASS_CALLED_KEYWORDS); } VALUE rb_proc_new( - VALUE (*func)(ANYARGS), /* VALUE yieldarg[, VALUE procarg] */ + rb_block_call_func_t func, VALUE val) { - VALUE procval = rb_iterate(mproc, 0, func, val); + VALUE procval = rb_block_call(rb_mRubyVMFrozenCore, idProc, 0, 0, func, val); return procval; } /* * call-seq: - * meth.to_proc -> prc + * meth.to_proc -> proc * - * Returns a <code>Proc</code> object corresponding to this method. + * Returns a Proc object corresponding to this method. */ static VALUE -method_proc(VALUE method) +method_to_proc(VALUE method) { VALUE procval; - struct METHOD *meth; rb_proc_t *proc; - rb_env_t *env; /* * class Method * def to_proc - * proc{|*args| + * lambda{|*args| * self.call(*args) * } * end * end */ - TypedData_Get_Struct(method, struct METHOD, &method_data_type, meth); - procval = rb_iterate(mlambda, 0, bmcall, method); + procval = rb_block_call(rb_mRubyVMFrozenCore, idLambda, 0, 0, bmcall, method); GetProcPtr(procval, proc); proc->is_from_method = 1; - proc->block.self = meth->recv; - proc->block.klass = meth->defined_class; - GetEnvPtr(proc->envval, env); - env->block.self = meth->recv; - env->block.klass = meth->defined_class; - env->block.iseq = method_get_iseq(meth->me->def); return procval; } +extern VALUE rb_find_defined_class_by_owner(VALUE current_class, VALUE target_owner); + +/* + * call-seq: + * meth.super_method -> method + * + * Returns a +Method+ of superclass which would be called when super is used + * or nil if there is no method on superclass. + */ + +static VALUE +method_super_method(VALUE method) +{ + const struct METHOD *data; + VALUE super_class, iclass; + ID mid; + const rb_method_entry_t *me; + + TypedData_Get_Struct(method, struct METHOD, &method_data_type, data); + iclass = data->iclass; + if (!iclass) return Qnil; + if (data->me->def->type == VM_METHOD_TYPE_ALIAS && data->me->defined_class) { + super_class = RCLASS_SUPER(rb_find_defined_class_by_owner(data->me->defined_class, + data->me->def->body.alias.original_me->owner)); + mid = data->me->def->body.alias.original_me->def->original_id; + } + else { + super_class = RCLASS_SUPER(RCLASS_ORIGIN(iclass)); + mid = data->me->def->original_id; + } + if (!super_class) return Qnil; + me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(super_class, mid, &iclass); + if (!me) return Qnil; + return mnew_internal(me, me->owner, iclass, data->recv, mid, rb_obj_class(method), FALSE, FALSE); +} + /* - * call_seq: + * call-seq: * local_jump_error.exit_value -> obj * * Returns the exit value associated with this +LocalJumpError+. @@ -2086,13 +3641,42 @@ localjump_reason(VALUE exc) return rb_iv_get(exc, "@reason"); } +rb_cref_t *rb_vm_cref_new_toplevel(void); /* vm.c */ + +static const rb_env_t * +env_clone(const rb_env_t *env, const rb_cref_t *cref) +{ + VALUE *new_ep; + VALUE *new_body; + const rb_env_t *new_env; + + VM_ASSERT(env->ep > env->env); + VM_ASSERT(VM_ENV_ESCAPED_P(env->ep)); + + if (cref == NULL) { + cref = rb_vm_cref_new_toplevel(); + } + + new_body = ALLOC_N(VALUE, env->env_size); + new_ep = &new_body[env->ep - env->env]; + new_env = vm_env_new(new_ep, new_body, env->env_size, env->iseq); + + /* The memcpy has to happen after the vm_env_new because it can trigger a + * GC compaction which can move the objects in the env. */ + MEMCPY(new_body, env->env, VALUE, env->env_size); + /* VM_ENV_DATA_INDEX_ENV is set in vm_env_new but will get overwritten + * by the memcpy above. */ + new_ep[VM_ENV_DATA_INDEX_ENV] = (VALUE)new_env; + RB_OBJ_WRITE(new_env, &new_ep[VM_ENV_DATA_INDEX_ME_CREF], (VALUE)cref); + VM_ASSERT(VM_ENV_ESCAPED_P(new_ep)); + return new_env; +} + /* * call-seq: * prc.binding -> binding * - * Returns the binding associated with <i>prc</i>. Note that - * <code>Kernel#eval</code> accepts either a <code>Proc</code> or a - * <code>Binding</code> object as its second parameter. + * Returns the binding associated with <i>prc</i>. * * def fred(param) * proc {} @@ -2104,33 +3688,74 @@ localjump_reason(VALUE exc) static VALUE proc_binding(VALUE self) { - rb_proc_t *proc; - VALUE bindval; + VALUE bindval, binding_self = Qundef; rb_binding_t *bind; + const rb_proc_t *proc; + const rb_iseq_t *iseq = NULL; + const struct rb_block *block; + const rb_env_t *env = NULL; GetProcPtr(self, proc); - if (RB_TYPE_P((VALUE)proc->block.iseq, T_NODE)) { - if (!IS_METHOD_PROC_NODE((NODE *)proc->block.iseq)) { - rb_raise(rb_eArgError, "Can't create Binding from C level Proc"); - } + block = &proc->block; + + if (proc->is_isolated) rb_raise(rb_eArgError, "Can't create Binding from isolated Proc"); + + again: + switch (vm_block_type(block)) { + case block_type_iseq: + iseq = block->as.captured.code.iseq; + binding_self = block->as.captured.self; + env = VM_ENV_ENVVAL_PTR(block->as.captured.ep); + break; + case block_type_proc: + GetProcPtr(block->as.proc, proc); + block = &proc->block; + goto again; + case block_type_ifunc: + { + const struct vm_ifunc *ifunc = block->as.captured.code.ifunc; + if (IS_METHOD_PROC_IFUNC(ifunc)) { + VALUE method = (VALUE)ifunc->data; + VALUE name = rb_fstring_lit("<empty_iseq>"); + rb_iseq_t *empty; + binding_self = method_receiver(method); + iseq = rb_method_iseq(method); + env = VM_ENV_ENVVAL_PTR(block->as.captured.ep); + env = env_clone(env, method_cref(method)); + /* set empty iseq */ + empty = rb_iseq_new(Qnil, name, name, Qnil, 0, ISEQ_TYPE_TOP); + RB_OBJ_WRITE(env, &env->iseq, empty); + break; + } + } + /* FALLTHROUGH */ + case block_type_symbol: + rb_raise(rb_eArgError, "Can't create Binding from C level Proc"); + UNREACHABLE_RETURN(Qnil); } bindval = rb_binding_alloc(rb_cBinding); GetBindingPtr(bindval, bind); - bind->env = proc->envval; - bind->blockprocval = proc->blockprocval; - if (RUBY_VM_NORMAL_ISEQ_P(proc->block.iseq)) { - bind->path = proc->block.iseq->location.path; - bind->first_lineno = rb_iseq_first_lineno(proc->block.iseq); + RB_OBJ_WRITE(bindval, &bind->block.as.captured.self, binding_self); + RB_OBJ_WRITE(bindval, &bind->block.as.captured.code.iseq, env->iseq); + rb_vm_block_ep_update(bindval, &bind->block, env->ep); + RB_OBJ_WRITTEN(bindval, Qundef, VM_ENV_ENVVAL(env->ep)); + + if (iseq) { + rb_iseq_check(iseq); + RB_OBJ_WRITE(bindval, &bind->pathobj, ISEQ_BODY(iseq)->location.pathobj); + bind->first_lineno = ISEQ_BODY(iseq)->location.first_lineno; } else { - bind->path = Qnil; - bind->first_lineno = 0; + RB_OBJ_WRITE(bindval, &bind->pathobj, + rb_iseq_pathobj_new(rb_fstring_lit("(binding)"), Qnil)); + bind->first_lineno = 1; } + return bindval; } -static VALUE curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc); +static rb_block_call_func curry; static VALUE make_curry_proc(VALUE proc, VALUE passed, VALUE arity) @@ -2150,26 +3775,25 @@ make_curry_proc(VALUE proc, VALUE passed, VALUE arity) } static VALUE -curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc) +curry(RB_BLOCK_CALL_FUNC_ARGLIST(_, args)) { VALUE proc, passed, arity; - proc = RARRAY_PTR(args)[0]; - passed = RARRAY_PTR(args)[1]; - arity = RARRAY_PTR(args)[2]; + proc = RARRAY_AREF(args, 0); + passed = RARRAY_AREF(args, 1); + arity = RARRAY_AREF(args, 2); passed = rb_ary_plus(passed, rb_ary_new4(argc, argv)); rb_ary_freeze(passed); if (RARRAY_LEN(passed) < FIX2INT(arity)) { - if (!NIL_P(passed_proc)) { - rb_warn("given block not used"); - } - arity = make_curry_proc(proc, passed, arity); - return arity; + if (!NIL_P(blockarg)) { + rb_warn("given block not used"); + } + arity = make_curry_proc(proc, passed, arity); + return arity; } else { - return rb_proc_call_with_block(proc, check_argc(RARRAY_LEN(passed)), - RARRAY_PTR(passed), passed_proc); + return rb_proc_call_with_block(proc, check_argc(RARRAY_LEN(passed)), RARRAY_CONST_PTR(passed), blockarg); } } @@ -2185,6 +3809,10 @@ curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc) * proc and returns the result. Otherwise, returns another curried proc that * takes the rest of arguments. * + * The optional <i>arity</i> argument should be supplied when currying procs with + * variable arguments to determine how many arguments are needed before the proc is + * called. + * * b = proc {|x, y, z| (x||0) + (y||0) + (z||0) } * p b.curry[1][2][3] #=> 6 * p b.curry[1, 2][3, 4] #=> 6 @@ -2201,41 +3829,323 @@ curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc) * * b = lambda {|x, y, z| (x||0) + (y||0) + (z||0) } * p b.curry[1][2][3] #=> 6 - * p b.curry[1, 2][3, 4] #=> wrong number of arguments (4 for 3) - * p b.curry(5) #=> wrong number of arguments (5 for 3) - * p b.curry(1) #=> wrong number of arguments (1 for 3) + * p b.curry[1, 2][3, 4] #=> wrong number of arguments (given 4, expected 3) + * p b.curry(5) #=> wrong number of arguments (given 5, expected 3) + * p b.curry(1) #=> wrong number of arguments (given 1, expected 3) * * b = lambda {|x, y, z, *w| (x||0) + (y||0) + (z||0) + w.inject(0, &:+) } * p b.curry[1][2][3] #=> 6 * p b.curry[1, 2][3, 4] #=> 10 * p b.curry(5)[1][2][3][4][5] #=> 15 * p b.curry(5)[1, 2][3, 4][5] #=> 15 - * p b.curry(1) #=> wrong number of arguments (1 for 3) + * p b.curry(1) #=> wrong number of arguments (given 1, expected 3) * * b = proc { :foo } * p b.curry[] #=> :foo */ static VALUE -proc_curry(int argc, VALUE *argv, VALUE self) +proc_curry(int argc, const VALUE *argv, VALUE self) { int sarity, max_arity, min_arity = rb_proc_min_max_arity(self, &max_arity); VALUE arity; - rb_scan_args(argc, argv, "01", &arity); - if (NIL_P(arity)) { - arity = INT2FIX(min_arity); + if (rb_check_arity(argc, 0, 1) == 0 || NIL_P(arity = argv[0])) { + arity = INT2FIX(min_arity); } else { - sarity = FIX2INT(arity); - if (rb_proc_lambda_p(self)) { - rb_check_arity(sarity, min_arity, max_arity); - } + sarity = FIX2INT(arity); + if (rb_proc_lambda_p(self)) { + rb_check_arity(sarity, min_arity, max_arity); + } } return make_curry_proc(self, rb_ary_new(), arity); } /* + * call-seq: + * meth.curry -> proc + * meth.curry(arity) -> proc + * + * Returns a curried proc based on the method. When the proc is called with a number of + * arguments that is lower than the method's arity, then another curried proc is returned. + * Only when enough arguments have been supplied to satisfy the method signature, will the + * method actually be called. + * + * The optional <i>arity</i> argument should be supplied when currying methods with + * variable arguments to determine how many arguments are needed before the method is + * called. + * + * def foo(a,b,c) + * [a, b, c] + * end + * + * proc = self.method(:foo).curry + * proc2 = proc.call(1, 2) #=> #<Proc> + * proc2.call(3) #=> [1,2,3] + * + * def vararg(*args) + * args + * end + * + * proc = self.method(:vararg).curry(4) + * proc2 = proc.call(:x) #=> #<Proc> + * proc3 = proc2.call(:y, :z) #=> #<Proc> + * proc3.call(:a) #=> [:x, :y, :z, :a] + */ + +static VALUE +rb_method_curry(int argc, const VALUE *argv, VALUE self) +{ + VALUE proc = method_to_proc(self); + return proc_curry(argc, argv, proc); +} + +static VALUE +compose(RB_BLOCK_CALL_FUNC_ARGLIST(_, args)) +{ + VALUE f, g, fargs; + f = RARRAY_AREF(args, 0); + g = RARRAY_AREF(args, 1); + + if (rb_obj_is_proc(g)) + fargs = rb_proc_call_with_block_kw(g, argc, argv, blockarg, RB_PASS_CALLED_KEYWORDS); + else + fargs = rb_funcall_with_block_kw(g, idCall, argc, argv, blockarg, RB_PASS_CALLED_KEYWORDS); + + if (rb_obj_is_proc(f)) + return rb_proc_call(f, rb_ary_new3(1, fargs)); + else + return rb_funcallv(f, idCall, 1, &fargs); +} + +static VALUE +to_callable(VALUE f) +{ + VALUE mesg; + + if (rb_obj_is_proc(f)) return f; + if (rb_obj_is_method(f)) return f; + if (rb_obj_respond_to(f, idCall, TRUE)) return f; + mesg = rb_fstring_lit("callable object is expected"); + rb_exc_raise(rb_exc_new_str(rb_eTypeError, mesg)); +} + +static VALUE rb_proc_compose_to_left(VALUE self, VALUE g); +static VALUE rb_proc_compose_to_right(VALUE self, VALUE g); + +/* + * call-seq: + * prc << g -> a_proc + * + * Returns a proc that is the composition of this proc and the given <i>g</i>. + * The returned proc takes a variable number of arguments, calls <i>g</i> with them + * then calls this proc with the result. + * + * f = proc {|x| x * x } + * g = proc {|x| x + x } + * p (f << g).call(2) #=> 16 + * + * See Proc#>> for detailed explanations. + */ +static VALUE +proc_compose_to_left(VALUE self, VALUE g) +{ + return rb_proc_compose_to_left(self, to_callable(g)); +} + +static VALUE +rb_proc_compose_to_left(VALUE self, VALUE g) +{ + VALUE proc, args, procs[2]; + rb_proc_t *procp; + int is_lambda; + + procs[0] = self; + procs[1] = g; + args = rb_ary_tmp_new_from_values(0, 2, procs); + + if (rb_obj_is_proc(g)) { + GetProcPtr(g, procp); + is_lambda = procp->is_lambda; + } + else { + VM_ASSERT(rb_obj_is_method(g) || rb_obj_respond_to(g, idCall, TRUE)); + is_lambda = 1; + } + + proc = rb_proc_new(compose, args); + GetProcPtr(proc, procp); + procp->is_lambda = is_lambda; + + return proc; +} + +/* + * call-seq: + * prc >> g -> a_proc + * + * Returns a proc that is the composition of this proc and the given <i>g</i>. + * The returned proc takes a variable number of arguments, calls this proc with them + * then calls <i>g</i> with the result. + * + * f = proc {|x| x * x } + * g = proc {|x| x + x } + * p (f >> g).call(2) #=> 8 + * + * <i>g</i> could be other Proc, or Method, or any other object responding to + * +call+ method: + * + * class Parser + * def self.call(text) + * # ...some complicated parsing logic... + * end + * end + * + * pipeline = File.method(:read) >> Parser >> proc { |data| puts "data size: #{data.count}" } + * pipeline.call('data.json') + * + * See also Method#>> and Method#<<. + */ +static VALUE +proc_compose_to_right(VALUE self, VALUE g) +{ + return rb_proc_compose_to_right(self, to_callable(g)); +} + +static VALUE +rb_proc_compose_to_right(VALUE self, VALUE g) +{ + VALUE proc, args, procs[2]; + rb_proc_t *procp; + int is_lambda; + + procs[0] = g; + procs[1] = self; + args = rb_ary_tmp_new_from_values(0, 2, procs); + + GetProcPtr(self, procp); + is_lambda = procp->is_lambda; + + proc = rb_proc_new(compose, args); + GetProcPtr(proc, procp); + procp->is_lambda = is_lambda; + + return proc; +} + +/* + * call-seq: + * self << g -> a_proc + * + * Returns a proc that is the composition of the given +g+ and this method. + * + * The returned proc takes a variable number of arguments. It first calls +g+ + * with the arguments, then calls +self+ with the return value of +g+. + * + * def f(ary) = ary << 'in f' + * + * f = self.method(:f) + * g = proc { |ary| ary << 'in proc' } + * (f << g).call([]) # => ["in proc", "in f"] + */ +static VALUE +rb_method_compose_to_left(VALUE self, VALUE g) +{ + g = to_callable(g); + self = method_to_proc(self); + return proc_compose_to_left(self, g); +} + +/* + * call-seq: + * self >> g -> a_proc + * + * Returns a proc that is the composition of this method and the given +g+. + * + * The returned proc takes a variable number of arguments. It first calls +self+ + * with the arguments, then calls +g+ with the return value of +self+. + * + * def f(ary) = ary << 'in f' + * + * f = self.method(:f) + * g = proc { |ary| ary << 'in proc' } + * (f >> g).call([]) # => ["in f", "in proc"] + */ +static VALUE +rb_method_compose_to_right(VALUE self, VALUE g) +{ + g = to_callable(g); + self = method_to_proc(self); + return proc_compose_to_right(self, g); +} + +/* + * call-seq: + * proc.ruby2_keywords -> proc + * + * Marks the proc as passing keywords through a normal argument splat. + * This should only be called on procs that accept an argument splat + * (<tt>*args</tt>) but not explicit keywords or a keyword splat. It + * marks the proc such that if the proc is called with keyword arguments, + * the final hash argument is marked with a special flag such that if it + * is the final element of a normal argument splat to another method call, + * and that method call does not include explicit keywords or a keyword + * splat, the final element is interpreted as keywords. In other words, + * keywords will be passed through the proc to other methods. + * + * This should only be used for procs that delegate keywords to another + * method, and only for backwards compatibility with Ruby versions before + * 2.7. + * + * This method will probably be removed at some point, as it exists only + * for backwards compatibility. As it does not exist in Ruby versions + * before 2.7, check that the proc responds to this method before calling + * it. Also, be aware that if this method is removed, the behavior of the + * proc will change so that it does not pass through keywords. + * + * module Mod + * foo = ->(meth, *args, &block) do + * send(:"do_#{meth}", *args, &block) + * end + * foo.ruby2_keywords if foo.respond_to?(:ruby2_keywords) + * end + */ + +static VALUE +proc_ruby2_keywords(VALUE procval) +{ + rb_proc_t *proc; + GetProcPtr(procval, proc); + + rb_check_frozen(procval); + + if (proc->is_from_method) { + rb_warn("Skipping set of ruby2_keywords flag for proc (proc created from method)"); + return procval; + } + + switch (proc->block.type) { + case block_type_iseq: + if (ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.has_rest && + !ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.has_post && + !ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.has_kw && + !ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.has_kwrest) { + ISEQ_BODY(proc->block.as.captured.code.iseq)->param.flags.ruby2_keywords = 1; + } + else { + rb_warn("Skipping set of ruby2_keywords flag for proc (proc accepts keywords or post arguments or proc does not accept argument splat)"); + } + break; + default: + rb_warn("Skipping set of ruby2_keywords flag for proc (proc not defined in Ruby)"); + break; + } + + return procval; +} + +/* * Document-class: LocalJumpError * * Raised when Ruby can't yield as requested. @@ -2279,12 +4189,25 @@ proc_curry(int argc, VALUE *argv, VALUE self) */ /* - * <code>Proc</code> objects are blocks of code that have been bound to - * a set of local variables. Once bound, the code may be called in - * different contexts and still access those variables. + * Document-class: Proc + * + * A +Proc+ object is an encapsulation of a block of code, which can be stored + * in a local variable, passed to a method or another Proc, and can be called. + * Proc is an essential concept in Ruby and a core of its functional + * programming features. + * + * square = Proc.new {|x| x**2 } + * + * square.call(3) #=> 9 + * # shorthands: + * square.(3) #=> 9 + * square[3] #=> 9 + * + * Proc objects are _closures_, meaning they remember and can use the entire + * context in which they were created. * * def gen_times(factor) - * return Proc.new {|n| n*factor } + * Proc.new {|n| n*factor } # remembers the value of factor at the moment of creation * end * * times3 = gen_times(3) @@ -2294,31 +4217,361 @@ proc_curry(int argc, VALUE *argv, VALUE self) * times5.call(5) #=> 25 * times3.call(times5.call(4)) #=> 60 * + * == Creation + * + * There are several methods to create a Proc + * + * * Use the Proc class constructor: + * + * proc1 = Proc.new {|x| x**2 } + * + * * Use the Kernel#proc method as a shorthand of Proc.new: + * + * proc2 = proc {|x| x**2 } + * + * * Receiving a block of code into proc argument (note the <code>&</code>): + * + * def make_proc(&block) + * block + * end + * + * proc3 = make_proc {|x| x**2 } + * + * * Construct a proc with lambda semantics using the Kernel#lambda method + * (see below for explanations about lambdas): + * + * lambda1 = lambda {|x| x**2 } + * + * * Use the {Lambda proc literal}[rdoc-ref:syntax/literals.rdoc@Lambda+Proc+Literals] syntax + * (also constructs a proc with lambda semantics): + * + * lambda2 = ->(x) { x**2 } + * + * == Lambda and non-lambda semantics + * + * Procs are coming in two flavors: lambda and non-lambda (regular procs). + * Differences are: + * + * * In lambdas, +return+ and +break+ means exit from this lambda; + * * In non-lambda procs, +return+ means exit from embracing method + * (and will throw +LocalJumpError+ if invoked outside the method); + * * In non-lambda procs, +break+ means exit from the method which the block given for. + * (and will throw +LocalJumpError+ if invoked after the method returns); + * * In lambdas, arguments are treated in the same way as in methods: strict, + * with +ArgumentError+ for mismatching argument number, + * and no additional argument processing; + * * Regular procs accept arguments more generously: missing arguments + * are filled with +nil+, single Array arguments are deconstructed if the + * proc has multiple arguments, and there is no error raised on extra + * arguments. + * + * Examples: + * + * # +return+ in non-lambda proc, +b+, exits +m2+. + * # (The block +{ return }+ is given for +m1+ and embraced by +m2+.) + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { return }; $a << :m2 end; m2; p $a + * #=> [] + * + * # +break+ in non-lambda proc, +b+, exits +m1+. + * # (The block +{ break }+ is given for +m1+ and embraced by +m2+.) + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { break }; $a << :m2 end; m2; p $a + * #=> [:m2] + * + * # +next+ in non-lambda proc, +b+, exits the block. + * # (The block +{ next }+ is given for +m1+ and embraced by +m2+.) + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { next }; $a << :m2 end; m2; p $a + * #=> [:m1, :m2] + * + * # Using +proc+ method changes the behavior as follows because + * # The block is given for +proc+ method and embraced by +m2+. + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { return }); $a << :m2 end; m2; p $a + * #=> [] + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { break }); $a << :m2 end; m2; p $a + * # break from proc-closure (LocalJumpError) + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { next }); $a << :m2 end; m2; p $a + * #=> [:m1, :m2] + * + * # +return+, +break+ and +next+ in the stubby lambda exits the block. + * # (+lambda+ method behaves same.) + * # (The block is given for stubby lambda syntax and embraced by +m2+.) + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { return }); $a << :m2 end; m2; p $a + * #=> [:m1, :m2] + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { break }); $a << :m2 end; m2; p $a + * #=> [:m1, :m2] + * $a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { next }); $a << :m2 end; m2; p $a + * #=> [:m1, :m2] + * + * p = proc {|x, y| "x=#{x}, y=#{y}" } + * p.call(1, 2) #=> "x=1, y=2" + * p.call([1, 2]) #=> "x=1, y=2", array deconstructed + * p.call(1, 2, 8) #=> "x=1, y=2", extra argument discarded + * p.call(1) #=> "x=1, y=", nil substituted instead of error + * + * l = lambda {|x, y| "x=#{x}, y=#{y}" } + * l.call(1, 2) #=> "x=1, y=2" + * l.call([1, 2]) # ArgumentError: wrong number of arguments (given 1, expected 2) + * l.call(1, 2, 8) # ArgumentError: wrong number of arguments (given 3, expected 2) + * l.call(1) # ArgumentError: wrong number of arguments (given 1, expected 2) + * + * def test_return + * -> { return 3 }.call # just returns from lambda into method body + * proc { return 4 }.call # returns from method + * return 5 + * end + * + * test_return # => 4, return from proc + * + * Lambdas are useful as self-sufficient functions, in particular useful as + * arguments to higher-order functions, behaving exactly like Ruby methods. + * + * Procs are useful for implementing iterators: + * + * def test + * [[1, 2], [3, 4], [5, 6]].map {|a, b| return a if a + b > 10 } + * # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * end + * + * Inside +map+, the block of code is treated as a regular (non-lambda) proc, + * which means that the internal arrays will be deconstructed to pairs of + * arguments, and +return+ will exit from the method +test+. That would + * not be possible with a stricter lambda. + * + * You can tell a lambda from a regular proc by using the #lambda? instance method. + * + * Lambda semantics is typically preserved during the proc lifetime, including + * <code>&</code>-deconstruction to a block of code: + * + * p = proc {|x, y| x } + * l = lambda {|x, y| x } + * [[1, 2], [3, 4]].map(&p) #=> [1, 3] + * [[1, 2], [3, 4]].map(&l) # ArgumentError: wrong number of arguments (given 1, expected 2) + * + * The only exception is dynamic method definition: even if defined by + * passing a non-lambda proc, methods still have normal semantics of argument + * checking. + * + * class C + * define_method(:e, &proc {}) + * end + * C.new.e(1,2) #=> ArgumentError + * C.new.method(:e).to_proc.lambda? #=> true + * + * This exception ensures that methods never have unusual argument passing + * conventions, and makes it easy to have wrappers defining methods that + * behave as usual. + * + * class C + * def self.def2(name, &body) + * define_method(name, &body) + * end + * + * def2(:f) {} + * end + * C.new.f(1,2) #=> ArgumentError + * + * The wrapper <code>def2</code> receives _body_ as a non-lambda proc, + * yet defines a method which has normal semantics. + * + * == Conversion of other objects to procs + * + * Any object that implements the +to_proc+ method can be converted into + * a proc by the <code>&</code> operator, and therefore can be + * consumed by iterators. + * + * class Greeter + * def initialize(greeting) + * @greeting = greeting + * end + * + * def to_proc + * proc {|name| "#{@greeting}, #{name}!" } + * end + * end + * + * hi = Greeter.new("Hi") + * hey = Greeter.new("Hey") + * ["Bob", "Jane"].map(&hi) #=> ["Hi, Bob!", "Hi, Jane!"] + * ["Bob", "Jane"].map(&hey) #=> ["Hey, Bob!", "Hey, Jane!"] + * + * Of the Ruby core classes, this method is implemented by +Symbol+, + * +Method+, and +Hash+. + * + * :to_s.to_proc.call(1) #=> "1" + * [1, 2].map(&:to_s) #=> ["1", "2"] + * + * method(:puts).to_proc.call(1) # prints 1 + * [1, 2].each(&method(:puts)) # prints 1, 2 + * + * {test: 1}.to_proc.call(:test) #=> 1 + * %i[test many keys].map(&{test: 1}) #=> [1, nil, nil] + * + * == Orphaned Proc + * + * +return+ and +break+ in a block exit a method. + * If a Proc object is generated from the block and the Proc object + * survives until the method is returned, +return+ and +break+ cannot work. + * In such case, +return+ and +break+ raises LocalJumpError. + * A Proc object in such situation is called as orphaned Proc object. + * + * Note that the method to exit is different for +return+ and +break+. + * There is a situation that orphaned for +break+ but not orphaned for +return+. + * + * def m1(&b) b.call end; def m2(); m1 { return } end; m2 # ok + * def m1(&b) b.call end; def m2(); m1 { break } end; m2 # ok + * + * def m1(&b) b end; def m2(); m1 { return }.call end; m2 # ok + * def m1(&b) b end; def m2(); m1 { break }.call end; m2 # LocalJumpError + * + * def m1(&b) b end; def m2(); m1 { return } end; m2.call # LocalJumpError + * def m1(&b) b end; def m2(); m1 { break } end; m2.call # LocalJumpError + * + * Since +return+ and +break+ exits the block itself in lambdas, + * lambdas cannot be orphaned. + * + * == Anonymous block parameters + * + * To simplify writing short blocks, Ruby provides two different types of + * anonymous parameters: +it+ (single parameter) and numbered ones: <tt>_1</tt>, + * <tt>_2</tt> and so on. + * + * # Explicit parameter: + * %w[test me please].each { |str| puts str.upcase } # prints TEST, ME, PLEASE + * (1..5).map { |i| i**2 } # => [1, 4, 9, 16, 25] + * + * # it: + * %w[test me please].each { puts it.upcase } # prints TEST, ME, PLEASE + * (1..5).map { it**2 } # => [1, 4, 9, 16, 25] + * + * # Numbered parameter: + * %w[test me please].each { puts _1.upcase } # prints TEST, ME, PLEASE + * (1..5).map { _1**2 } # => [1, 4, 9, 16, 25] + * + * === +it+ + * + * +it+ is a name that is available inside a block when no explicit parameters + * defined, as shown above. + * + * %w[test me please].each { puts it.upcase } # prints TEST, ME, PLEASE + * (1..5).map { it**2 } # => [1, 4, 9, 16, 25] + * + * +it+ is a "soft keyword": it is not a reserved name, and can be used as + * a name for methods and local variables: + * + * it = 5 # no warnings + * def it(&block) # RSpec-like API, no warnings + * # ... + * end + * + * +it+ can be used as a local variable even in blocks that use it as an + * implicit parameter (though this style is obviously confusing): + * + * [1, 2, 3].each { + * # takes a value of implicit parameter "it" and uses it to + * # define a local variable with the same name + * it = it**2 + * p it + * } + * + * In a block with explicit parameters defined +it+ usage raises an exception: + * + * [1, 2, 3].each { |x| p it } + * # syntax error found (SyntaxError) + * # [1, 2, 3].each { |x| p it } + * # ^~ 'it' is not allowed when an ordinary parameter is defined + * + * But if a local name (variable or method) is available, it would be used: + * + * it = 5 + * [1, 2, 3].each { |x| p it } + * # Prints 5, 5, 5 + * + * Blocks using +it+ can be nested: + * + * %w[test me].each { it.each_char { p it } } + * # Prints "t", "e", "s", "t", "m", "e" + * + * Blocks using +it+ are considered to have one parameter: + * + * p = proc { it**2 } + * l = lambda { it**2 } + * p.parameters # => [[:opt]] + * p.arity # => 1 + * l.parameters # => [[:req]] + * l.arity # => 1 + * + * === Numbered parameters + * + * Numbered parameters are another way to name block parameters implicitly. + * Unlike +it+, numbered parameters allow to refer to several parameters + * in one block. + * + * %w[test me please].each { puts _1.upcase } # prints TEST, ME, PLEASE + * {a: 100, b: 200}.map { "#{_1} = #{_2}" } # => "a = 100", "b = 200" + * + * Parameter names from +_1+ to +_9+ are supported: + * + * [10, 20, 30].zip([40, 50, 60], [70, 80, 90]).map { _1 + _2 + _3 } + * # => [120, 150, 180] + * + * Though, it is advised to resort to them wisely, probably limiting + * yourself to +_1+ and +_2+, and to one-line blocks. + * + * Numbered parameters can't be used together with explicitly named + * ones: + * + * [10, 20, 30].map { |x| _1**2 } + * # SyntaxError (ordinary parameter is defined) + * + * Numbered parameters can't be mixed with +it+ either: + * + * [10, 20, 30].map { _1 + it } + * # SyntaxError: 'it' is not allowed when a numbered parameter is already used + * + * To avoid conflicts, naming local variables or method + * arguments +_1+, +_2+ and so on, causes an error. + * + * _1 = 'test' + * # ^~ _1 is reserved for numbered parameters (SyntaxError) + * + * Using implicit numbered parameters affects block's arity: + * + * p = proc { _1 + _2 } + * l = lambda { _1 + _2 } + * p.parameters # => [[:opt, :_1], [:opt, :_2]] + * p.arity # => 2 + * l.parameters # => [[:req, :_1], [:req, :_2]] + * l.arity # => 2 + * + * Blocks with numbered parameters can't be nested: + * + * %w[test me].each { _1.each_char { p _1 } } + * # numbered parameter is already used in outer block (SyntaxError) + * # %w[test me].each { _1.each_char { p _1 } } + * # ^~ + * */ void Init_Proc(void) { +#undef rb_intern /* Proc */ rb_cProc = rb_define_class("Proc", rb_cObject); rb_undef_alloc_func(rb_cProc); rb_define_singleton_method(rb_cProc, "new", rb_proc_s_new, -1); -#if 0 /* incomplete. */ - rb_add_method(rb_cProc, rb_intern("call"), VM_METHOD_TYPE_OPTIMIZED, - (void *)OPTIMIZED_METHOD_TYPE_CALL, 0); - rb_add_method(rb_cProc, rb_intern("[]"), VM_METHOD_TYPE_OPTIMIZED, - (void *)OPTIMIZED_METHOD_TYPE_CALL, 0); - rb_add_method(rb_cProc, rb_intern("==="), VM_METHOD_TYPE_OPTIMIZED, - (void *)OPTIMIZED_METHOD_TYPE_CALL, 0); - rb_add_method(rb_cProc, rb_intern("yield"), VM_METHOD_TYPE_OPTIMIZED, - (void *)OPTIMIZED_METHOD_TYPE_CALL, 0); -#else + rb_add_method_optimized(rb_cProc, idCall, OPTIMIZED_METHOD_TYPE_CALL, 0, METHOD_VISI_PUBLIC); + rb_add_method_optimized(rb_cProc, rb_intern("[]"), OPTIMIZED_METHOD_TYPE_CALL, 0, METHOD_VISI_PUBLIC); + rb_add_method_optimized(rb_cProc, rb_intern("==="), OPTIMIZED_METHOD_TYPE_CALL, 0, METHOD_VISI_PUBLIC); + rb_add_method_optimized(rb_cProc, rb_intern("yield"), OPTIMIZED_METHOD_TYPE_CALL, 0, METHOD_VISI_PUBLIC); + +#if 0 /* for RDoc */ rb_define_method(rb_cProc, "call", proc_call, -1); rb_define_method(rb_cProc, "[]", proc_call, -1); rb_define_method(rb_cProc, "===", proc_call, -1); rb_define_method(rb_cProc, "yield", proc_call, -1); #endif + rb_define_method(rb_cProc, "to_proc", proc_to_proc, 0); rb_define_method(rb_cProc, "arity", proc_arity, 0); rb_define_method(rb_cProc, "clone", proc_clone, 0); @@ -2329,8 +4582,14 @@ Init_Proc(void) rb_define_method(rb_cProc, "lambda?", rb_proc_lambda_p, 0); rb_define_method(rb_cProc, "binding", proc_binding, 0); rb_define_method(rb_cProc, "curry", proc_curry, -1); + rb_define_method(rb_cProc, "<<", proc_compose_to_left, 1); + rb_define_method(rb_cProc, ">>", proc_compose_to_right, 1); + rb_define_method(rb_cProc, "==", proc_eq, 1); + rb_define_method(rb_cProc, "eql?", proc_eq, 1); rb_define_method(rb_cProc, "source_location", rb_proc_location, 0); - rb_define_method(rb_cProc, "parameters", rb_proc_parameters, 0); + rb_define_method(rb_cProc, "parameters", rb_proc_parameters, -1); + rb_define_method(rb_cProc, "ruby2_keywords", proc_ruby2_keywords, 0); + // rb_define_method(rb_cProc, "isolate", rb_proc_isolate, 0); is not accepted. /* Exceptions */ rb_eLocalJumpError = rb_define_class("LocalJumpError", rb_eStandardError); @@ -2338,13 +4597,11 @@ Init_Proc(void) rb_define_method(rb_eLocalJumpError, "reason", localjump_reason, 0); rb_eSysStackError = rb_define_class("SystemStackError", rb_eException); - sysstack_error = rb_exc_new3(rb_eSysStackError, - rb_obj_freeze(rb_str_new2("stack level too deep"))); - OBJ_TAINT(sysstack_error); + rb_vm_register_special_exception(ruby_error_sysstack, rb_eSysStackError, "stack level too deep"); /* utility functions */ - rb_define_global_function("proc", rb_block_proc, 0); - rb_define_global_function("lambda", rb_block_lambda, 0); + rb_define_global_function("proc", f_proc, 0); + rb_define_global_function("lambda", f_lambda, 0); /* Method */ rb_cMethod = rb_define_class("Method", rb_cObject); @@ -2354,61 +4611,75 @@ Init_Proc(void) rb_define_method(rb_cMethod, "eql?", method_eq, 1); rb_define_method(rb_cMethod, "hash", method_hash, 0); rb_define_method(rb_cMethod, "clone", method_clone, 0); - rb_define_method(rb_cMethod, "call", rb_method_call, -1); - rb_define_method(rb_cMethod, "[]", rb_method_call, -1); + rb_define_method(rb_cMethod, "dup", method_dup, 0); + rb_define_method(rb_cMethod, "call", rb_method_call_pass_called_kw, -1); + rb_define_method(rb_cMethod, "===", rb_method_call_pass_called_kw, -1); + rb_define_method(rb_cMethod, "curry", rb_method_curry, -1); + rb_define_method(rb_cMethod, "<<", rb_method_compose_to_left, 1); + rb_define_method(rb_cMethod, ">>", rb_method_compose_to_right, 1); + rb_define_method(rb_cMethod, "[]", rb_method_call_pass_called_kw, -1); rb_define_method(rb_cMethod, "arity", method_arity_m, 0); rb_define_method(rb_cMethod, "inspect", method_inspect, 0); rb_define_method(rb_cMethod, "to_s", method_inspect, 0); - rb_define_method(rb_cMethod, "to_proc", method_proc, 0); + rb_define_method(rb_cMethod, "to_proc", method_to_proc, 0); rb_define_method(rb_cMethod, "receiver", method_receiver, 0); rb_define_method(rb_cMethod, "name", method_name, 0); + rb_define_method(rb_cMethod, "original_name", method_original_name, 0); rb_define_method(rb_cMethod, "owner", method_owner, 0); rb_define_method(rb_cMethod, "unbind", method_unbind, 0); rb_define_method(rb_cMethod, "source_location", rb_method_location, 0); rb_define_method(rb_cMethod, "parameters", rb_method_parameters, 0); + rb_define_method(rb_cMethod, "super_method", method_super_method, 0); rb_define_method(rb_mKernel, "method", rb_obj_method, 1); rb_define_method(rb_mKernel, "public_method", rb_obj_public_method, 1); + rb_define_method(rb_mKernel, "singleton_method", rb_obj_singleton_method, 1); + + rb_define_method(rb_cMethod, "box", method_box, 0); /* UnboundMethod */ rb_cUnboundMethod = rb_define_class("UnboundMethod", rb_cObject); rb_undef_alloc_func(rb_cUnboundMethod); rb_undef_method(CLASS_OF(rb_cUnboundMethod), "new"); - rb_define_method(rb_cUnboundMethod, "==", method_eq, 1); - rb_define_method(rb_cUnboundMethod, "eql?", method_eq, 1); + rb_define_method(rb_cUnboundMethod, "==", unbound_method_eq, 1); + rb_define_method(rb_cUnboundMethod, "eql?", unbound_method_eq, 1); rb_define_method(rb_cUnboundMethod, "hash", method_hash, 0); rb_define_method(rb_cUnboundMethod, "clone", method_clone, 0); + rb_define_method(rb_cUnboundMethod, "dup", method_dup, 0); rb_define_method(rb_cUnboundMethod, "arity", method_arity_m, 0); rb_define_method(rb_cUnboundMethod, "inspect", method_inspect, 0); rb_define_method(rb_cUnboundMethod, "to_s", method_inspect, 0); rb_define_method(rb_cUnboundMethod, "name", method_name, 0); + rb_define_method(rb_cUnboundMethod, "original_name", method_original_name, 0); rb_define_method(rb_cUnboundMethod, "owner", method_owner, 0); rb_define_method(rb_cUnboundMethod, "bind", umethod_bind, 1); + rb_define_method(rb_cUnboundMethod, "bind_call", umethod_bind_call, -1); rb_define_method(rb_cUnboundMethod, "source_location", rb_method_location, 0); rb_define_method(rb_cUnboundMethod, "parameters", rb_method_parameters, 0); + rb_define_method(rb_cUnboundMethod, "super_method", method_super_method, 0); /* Module#*_method */ rb_define_method(rb_cModule, "instance_method", rb_mod_instance_method, 1); rb_define_method(rb_cModule, "public_instance_method", rb_mod_public_instance_method, 1); - rb_define_private_method(rb_cModule, "define_method", rb_mod_define_method, -1); + rb_define_method(rb_cModule, "define_method", rb_mod_define_method, -1); /* Kernel */ rb_define_method(rb_mKernel, "define_singleton_method", rb_obj_define_method, -1); rb_define_private_method(rb_singleton_class(rb_vm_top_self()), - "define_method", top_define_method, -1); + "define_method", top_define_method, -1); } /* - * Objects of class <code>Binding</code> encapsulate the execution - * context at some particular place in the code and retain this context - * for future use. The variables, methods, value of <code>self</code>, - * and possibly an iterator block that can be accessed in this context + * Objects of class Binding encapsulate the execution context at some + * particular place in the code and retain this context for future + * use. The variables, methods, value of <code>self</code>, and + * possibly an iterator block that can be accessed in this context * are all retained. Binding objects can be created using - * <code>Kernel#binding</code>, and are made available to the callback - * of <code>Kernel#set_trace_func</code>. + * Kernel#binding, and are made available to the callback of + * Kernel#set_trace_func and instances of TracePoint. * * These binding objects can be passed as the second argument of the - * <code>Kernel#eval</code> method, establishing an environment for the + * Kernel#eval method, establishing an environment for the * evaluation. * * class Demo @@ -2416,7 +4687,7 @@ Init_Proc(void) * @secret = n * end * def get_binding - * return binding() + * binding * end * end * @@ -2436,13 +4707,22 @@ Init_Proc(void) void Init_Binding(void) { + rb_gc_register_address(&sym_proc_cache); + rb_cBinding = rb_define_class("Binding", rb_cObject); rb_undef_alloc_func(rb_cBinding); rb_undef_method(CLASS_OF(rb_cBinding), "new"); 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_method(rb_cBinding, "local_variables", bind_local_variables, 0); + rb_define_method(rb_cBinding, "local_variable_get", bind_local_variable_get, 1); + rb_define_method(rb_cBinding, "local_variable_set", bind_local_variable_set, 2); + rb_define_method(rb_cBinding, "local_variable_defined?", bind_local_variable_defined_p, 1); + rb_define_method(rb_cBinding, "implicit_parameters", bind_implicit_parameters, 0); + rb_define_method(rb_cBinding, "implicit_parameter_get", bind_implicit_parameter_get, 1); + rb_define_method(rb_cBinding, "implicit_parameter_defined?", bind_implicit_parameter_defined_p, 1); + rb_define_method(rb_cBinding, "receiver", bind_receiver, 0); + rb_define_method(rb_cBinding, "source_location", bind_location, 0); rb_define_global_function("binding", rb_f_binding, 0); - attached = rb_intern("__attached__"); } - |