summaryrefslogtreecommitdiff
path: root/proc.c
diff options
context:
space:
mode:
Diffstat (limited to 'proc.c')
-rw-r--r--proc.c2803
1 files changed, 1900 insertions, 903 deletions
diff --git a/proc.c b/proc.c
index 2d931e77f0..5f23e5fed6 100644
--- a/proc.c
+++ b/proc.c
@@ -11,29 +11,30 @@
#include "eval_intern.h"
#include "internal.h"
-#include "gc.h"
-#include "vm_core.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"
-
-/* Proc.new with no block will raise an exception in the future
- * versions */
-#define PROC_NEW_REQUIRES_BLOCK 0
-
-#if !defined(__GNUC__) || __GNUC__ < 5 || defined(__MINGW32__)
-# define NO_CLOBBERED(v) (*(volatile VALUE *)&(v))
-#else
-# define NO_CLOBBERED(v) (v)
-#endif
-
-#define UPDATE_TYPED_REFERENCE(_type, _ref) *(_type*)&_ref = (_type)rb_gc_location((VALUE)_ref)
-#define UPDATE_REFERENCE(_ref) UPDATE_TYPED_REFERENCE(VALUE, _ref)
+#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 {
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 * */
};
@@ -43,77 +44,44 @@ 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);
-
-#define attached id__attached__
+static VALUE proc_binding(VALUE self);
/* Proc */
#define IS_METHOD_PROC_IFUNC(ifunc) ((ifunc)->func == bmcall)
static void
-block_mark(const struct rb_block *block)
-{
- switch (vm_block_type(block)) {
- case block_type_iseq:
- case block_type_ifunc:
- {
- const struct rb_captured_block *captured = &block->as.captured;
- RUBY_MARK_NO_PIN_UNLESS_NULL(captured->self);
- RUBY_MARK_NO_PIN_UNLESS_NULL((VALUE)captured->code.val);
- if (captured->ep && captured->ep[VM_ENV_DATA_INDEX_ENV] != Qundef /* cfunc_proc_t */) {
- RUBY_MARK_NO_PIN_UNLESS_NULL(VM_ENV_ENVVAL(captured->ep));
- }
- }
- break;
- case block_type_symbol:
- RUBY_MARK_NO_PIN_UNLESS_NULL(block->as.symbol);
- break;
- case block_type_proc:
- RUBY_MARK_NO_PIN_UNLESS_NULL(block->as.proc);
- break;
- }
-}
-
-static void
-block_compact(struct rb_block *block)
+block_mark_and_move(struct rb_block *block)
{
switch (block->type) {
case block_type_iseq:
case block_type_ifunc:
- {
- struct rb_captured_block *captured = &block->as.captured;
- captured->self = rb_gc_location(captured->self);
- captured->code.val = rb_gc_location(captured->code.val);
- if (captured->ep && captured->ep[VM_ENV_DATA_INDEX_ENV] != Qundef /* cfunc_proc_t */) {
- UPDATE_REFERENCE(captured->ep[VM_ENV_DATA_INDEX_ENV]);
+ {
+ 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;
+ }
+ break;
case block_type_symbol:
- block->as.symbol = rb_gc_location(block->as.symbol);
- break;
+ rb_gc_mark_and_move(&block->as.symbol);
+ break;
case block_type_proc:
- block->as.proc = rb_gc_location(block->as.proc);
- break;
+ rb_gc_mark_and_move(&block->as.proc);
+ break;
}
}
static void
-proc_compact(void *ptr)
+proc_mark_and_move(void *ptr)
{
rb_proc_t *proc = ptr;
- block_compact((struct rb_block *)&proc->block);
-}
-
-static void
-proc_mark(void *ptr)
-{
- rb_proc_t *proc = ptr;
- block_mark(&proc->block);
- RUBY_MARK_LEAVE("proc");
+ block_mark_and_move((struct rb_block *)&proc->block);
}
typedef struct {
@@ -126,17 +94,17 @@ proc_memsize(const void *ptr)
{
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(cfunc_proc_t);
return sizeof(rb_proc_t);
}
static const rb_data_type_t proc_data_type = {
"proc",
{
- proc_mark,
- RUBY_TYPED_DEFAULT_FREE,
- proc_memsize,
- proc_compact,
+ proc_mark_and_move,
+ RUBY_TYPED_DEFAULT_FREE,
+ proc_memsize,
+ proc_mark_and_move,
},
0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
};
@@ -151,12 +119,7 @@ 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: */
@@ -164,8 +127,15 @@ static VALUE
proc_clone(VALUE self)
{
VALUE procval = rb_proc_dup(self);
- CLONESETUP(procval, self);
- return procval;
+ return rb_obj_clone_setup(self, procval, Qnil);
+}
+
+/* :nodoc: */
+static VALUE
+proc_dup(VALUE self)
+{
+ VALUE procval = rb_proc_dup(self);
+ return rb_obj_dup_setup(self, procval);
}
/*
@@ -277,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 */
@@ -291,23 +261,12 @@ binding_free(void *ptr)
}
static void
-binding_mark(void *ptr)
+binding_mark_and_move(void *ptr)
{
rb_binding_t *bind = ptr;
- RUBY_MARK_ENTER("binding");
- block_mark(&bind->block);
- rb_gc_mark_no_pin(bind->pathobj);
- RUBY_MARK_LEAVE("binding");
-}
-
-static void
-binding_compact(void *ptr)
-{
- rb_binding_t *bind = ptr;
-
- block_compact((struct rb_block *)&bind->block);
- UPDATE_REFERENCE(bind->pathobj);
+ block_mark_and_move((struct rb_block *)&bind->block);
+ rb_gc_mark_and_move((VALUE *)&bind->pathobj);
}
static size_t
@@ -319,10 +278,10 @@ binding_memsize(const void *ptr)
const rb_data_type_t ruby_binding_data_type = {
"binding",
{
- binding_mark,
- binding_free,
- binding_memsize,
- binding_compact,
+ binding_mark_and_move,
+ binding_free,
+ binding_memsize,
+ binding_mark_and_move,
},
0, 0, RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
};
@@ -333,13 +292,14 @@ rb_binding_alloc(VALUE klass)
VALUE obj;
rb_binding_t *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;
@@ -353,11 +313,16 @@ binding_dup(VALUE self)
/* :nodoc: */
static VALUE
+binding_dup(VALUE self)
+{
+ return rb_obj_dup_setup(self, binding_copy(self));
+}
+
+/* :nodoc: */
+static VALUE
binding_clone(VALUE self)
{
- VALUE bindval = binding_dup(self);
- CLONESETUP(bindval, self);
- return bindval;
+ return rb_obj_clone_setup(self, binding_copy(self), Qnil);
}
VALUE
@@ -371,16 +336,44 @@ rb_binding_new(void)
* 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)
- * 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
@@ -416,38 +409,44 @@ bind_eval(int argc, VALUE *argv, VALUE bindval)
}
static const VALUE *
-get_local_variable_ptr(const rb_env_t **envp, ID lid)
+get_local_variable_ptr(const rb_env_t **envp, ID lid, bool search_outer)
{
const rb_env_t *env = *envp;
do {
- if (!VM_ENV_FLAGS(env->ep, VM_FRAME_FLAG_CFRAME)) {
- const rb_iseq_t *iseq = env->iseq;
- unsigned int i;
-
- VM_ASSERT(rb_obj_is_iseq((VALUE)iseq));
-
- for (i=0; i<iseq->body->local_table_size; i++) {
- if (iseq->body->local_table[i] == lid) {
- if (iseq->body->local_iseq == iseq &&
- iseq->body->param.flags.has_block &&
- (unsigned int)iseq->body->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;
- return &env->env[i];
- }
- }
- }
- else {
- *envp = NULL;
- return NULL;
- }
- } while ((env = rb_vm_env_prev_env(env)) != NULL);
+ 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;
@@ -465,17 +464,17 @@ check_local_id(VALUE bindval, volatile VALUE *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));
- }
+ if (!rb_is_local_id(lid)) {
+ rb_name_err_raise("wrong local variable name '%1$s' for %2$s",
+ bindval, ID2SYM(lid));
+ }
}
else {
- if (!rb_is_local_name(name)) {
- rb_name_err_raise("wrong local variable name `%1$s' for %2$s",
- bindval, name);
- }
- return 0;
+ 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;
}
@@ -509,6 +508,18 @@ bind_local_variables(VALUE bindval)
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
@@ -535,18 +546,23 @@ bind_local_variable_get(VALUE bindval, VALUE sym)
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)) == NULL) {
- sym = ID2SYM(lid);
- undefined:
- rb_name_err_raise("local variable `%1$s' is not defined for %2$s",
- bindval, sym);
+ if ((ptr = get_local_variable_ptr(&env, lid, TRUE)) != NULL) {
+ return *ptr;
}
- 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);
}
/*
@@ -583,15 +599,23 @@ bind_local_variable_set(VALUE bindval, VALUE sym, VALUE val)
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)) == 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 ((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;
@@ -622,10 +646,140 @@ bind_local_variable_defined_p(VALUE bindval, VALUE sym)
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));
- return get_local_variable_ptr(&env, lid) ? Qtrue : Qfalse;
+
+ 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 (lid == idIt) lid = idItImplicit;
+
+ 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));
+ if ((ptr = get_local_variable_ptr(&env, lid, FALSE)) != NULL) {
+ return *ptr;
+ }
+
+ 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 (!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));
}
/*
@@ -661,7 +815,7 @@ bind_location(VALUE bindval)
}
static VALUE
-cfunc_proc_new(VALUE klass, VALUE ifunc, int8_t is_lambda)
+cfunc_proc_new(VALUE klass, VALUE ifunc)
{
rb_proc_t *proc;
cfunc_proc_t *sproc;
@@ -679,10 +833,36 @@ cfunc_proc_new(VALUE klass, VALUE ifunc, int8_t is_lambda)
/* self? */
RB_OBJ_WRITE(procval, &proc->block.as.captured.code.ifunc, ifunc);
- proc->is_lambda = is_lambda;
+ 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)
{
@@ -691,51 +871,49 @@ sym_proc_new(VALUE klass, VALUE sym)
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(VALUE (*func)(ANYARGS), const void *data, int min_argc, int max_argc)
+rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc)
{
- union {
- struct vm_ifunc_argc argc;
- VALUE packed;
- } arity;
-
if (min_argc < UNLIMITED_ARGUMENTS ||
#if SIZEOF_INT * 2 > SIZEOF_VALUE
- min_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) ||
+ min_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) ||
#endif
- 0) {
- rb_raise(rb_eRangeError, "minimum argument number out of range: %d",
- min_argc);
+ 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) ||
+ max_argc >= (int)(1U << (SIZEOF_VALUE * CHAR_BIT) / 2) ||
#endif
- 0) {
- rb_raise(rb_eRangeError, "maximum argument number out of range: %d",
- max_argc);
+ 0) {
+ rb_raise(rb_eRangeError, "maximum argument number out of range: %d",
+ max_argc);
}
- arity.argc.min = min_argc;
- arity.argc.max = max_argc;
- return IFUNC_NEW(func, data, arity.packed);
-}
+ rb_execution_context_t *ec = GET_EC();
-MJIT_FUNC_EXPORTED VALUE
-rb_func_proc_new(rb_block_call_func_t func, VALUE val)
-{
- struct vm_ifunc *ifunc = rb_vm_ifunc_proc_new(func, (void *)val);
- return cfunc_proc_new(rb_cProc, (VALUE)ifunc, 0);
+ 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, 1);
+ return cfunc_proc_new(rb_cProc, (VALUE)ifunc);
}
static const char proc_without_block[] = "tried to create Proc object without a block";
@@ -749,49 +927,33 @@ proc_new(VALUE klass, int8_t is_lambda)
VALUE block_handler;
if ((block_handler = rb_vm_frame_block_handler(cfp)) == VM_BLOCK_HANDLER_NONE) {
-#if !PROC_NEW_REQUIRES_BLOCK
- cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-
- if ((block_handler = rb_vm_frame_block_handler(cfp)) != VM_BLOCK_HANDLER_NONE) {
- if (is_lambda) {
- rb_raise(rb_eArgError, proc_without_block);
- }
- else {
- rb_warn("Capturing the given block using Proc.new is deprecated; use `&block` instead");
- }
- }
-#else
- if (0)
-#endif
- else {
- rb_raise(rb_eArgError, proc_without_block);
- }
+ 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);
+ procval = VM_BH_TO_PROC(block_handler);
- if (RBASIC_CLASS(procval) == klass) {
- return procval;
- }
- else {
- VALUE newprocval = rb_proc_dup(procval);
+ if (RBASIC_CLASS(procval) == klass) {
+ return procval;
+ }
+ else {
+ VALUE newprocval = rb_proc_dup(procval);
RBASIC_SET_CLASS(newprocval, klass);
- return newprocval;
- }
- break;
+ 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;
+ 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);
+ return rb_vm_make_proc_lambda(ec, VM_BH_TO_CAPT_BLOCK(block_handler), klass, is_lambda);
}
VM_UNREACHABLE(proc_new);
return Qnil;
@@ -800,18 +962,15 @@ proc_new(VALUE klass, int8_t is_lambda)
/*
* call-seq:
* Proc.new {|...| block } -> a_proc
- * Proc.new -> a_proc
*
- * Creates a new Proc object, bound to the current context. Proc::new
- * may be called without a block only within a method with an
- * attached block, in which case that block is converted to the Proc
- * 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
@@ -819,10 +978,16 @@ 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;
}
+VALUE
+rb_block_proc(void)
+{
+ return proc_new(rb_cProc, FALSE);
+}
+
/*
* call-seq:
* proc { |...| block } -> a_proc
@@ -830,12 +995,49 @@ rb_proc_s_new(int argc, VALUE *argv, VALUE klass)
* Equivalent to Proc.new.
*/
-VALUE
-rb_block_proc(void)
+static VALUE
+f_proc(VALUE _)
{
return proc_new(rb_cProc, FALSE);
}
+VALUE
+rb_block_lambda(void)
+{
+ return proc_new(rb_cProc, TRUE);
+}
+
+static void
+f_lambda_filter_non_literal(void)
+{
+ 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
@@ -844,10 +1046,11 @@ rb_block_proc(void)
* number of parameters passed when called.
*/
-VALUE
-rb_block_lambda(void)
+static VALUE
+f_lambda(VALUE _)
{
- return proc_new(rb_cProc, TRUE);
+ f_lambda_filter_non_literal();
+ return rb_block_lambda();
}
/* Document-method: Proc#===
@@ -868,13 +1071,12 @@ rb_block_lambda(void)
* Document-method: Proc#yield
*
* call-seq:
- * prc.call(params,...) -> obj
- * prc[params,...] -> obj
- * prc.(params,...) -> obj
- * prc.yield(params,...) -> obj
+ * call(...) -> obj
+ * self[...] -> obj
+ * yield(...) -> obj
*
- * Invokes the block, setting the block's parameters to the values in
- * <i>params</i> using something close to method calling semantics.
+ * 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 } }
@@ -913,8 +1115,8 @@ 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;
}
@@ -923,19 +1125,26 @@ 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_EC(), proc,
- check_argc(RARRAY_LEN(args)), RARRAY_CONST_PTR(args),
- VM_BLOCK_HANDLER_NONE);
+ 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(VALUE self, VALUE args)
+{
+ return rb_proc_call_kw(self, args, RB_NO_KEYWORDS);
+}
+
static VALUE
proc_to_block_handler(VALUE procval)
{
@@ -943,17 +1152,23 @@ proc_to_block_handler(VALUE procval)
}
VALUE
-rb_proc_call_with_block(VALUE self, int argc, const VALUE *argv, VALUE passed_procval)
+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;
GetProcPtr(self, proc);
- vret = rb_vm_invoke_proc(ec, proc, argc, argv, proc_to_block_handler(passed_procval));
+ vret = rb_vm_invoke_proc(ec, proc, argc, argv, kw_splat, proc_to_block_handler(passed_procval));
RB_GC_GUARD(self);
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:
@@ -1006,11 +1221,11 @@ proc_arity(VALUE self)
static inline int
rb_iseq_min_max_arity(const rb_iseq_t *iseq, int *max)
{
- *max = iseq->body->param.flags.has_rest == FALSE ?
- iseq->body->param.lead_num + iseq->body->param.opt_num + iseq->body->param.post_num +
- (iseq->body->param.flags.has_kw == TRUE || iseq->body->param.flags.has_kwrest == TRUE)
+ *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->body->param.lead_num + iseq->body->param.post_num + (iseq->body->param.flags.has_kw && iseq->body->param.keyword->required_num > 0);
+ 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
@@ -1019,22 +1234,23 @@ 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);
+ 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;
+ 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;
- }
+ {
+ 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:
- break;
+ *max = UNLIMITED_ARGUMENTS;
+ return 1;
}
*max = UNLIMITED_ARGUMENTS;
return 0;
@@ -1069,25 +1285,25 @@ 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;
+ 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;
+ 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;
+ 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);
+ block->type = block_type_proc;
+ block->as.proc = VM_BH_TO_PROC(block_handler);
}
}
int
-rb_block_arity(void)
+rb_block_pair_yield_optimizable(void)
{
int min, max;
const rb_execution_context_t *ec = GET_EC();
@@ -1096,27 +1312,62 @@ rb_block_arity(void)
struct rb_block block;
if (block_handler == VM_BLOCK_HANDLER_NONE) {
- rb_raise(rb_eArgError, "no block given");
+ 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_handler_type_symbol:
- return -1;
+ case block_type_symbol:
+ return 0;
- case block_handler_type_proc:
- {
- VALUE procval = block_handler;
- rb_proc_t *proc;
- GetProcPtr(procval, proc);
- return (proc->is_lambda ? min == max : max != UNLIMITED_ARGUMENTS) ? min : -min-1;
- /* fall through */
- }
+ 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 max != UNLIMITED_ARGUMENTS ? min : -min-1;
+ 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);
+
+ default:
+ min = rb_vm_block_min_max_arity(&block, &max);
+ return max != UNLIMITED_ARGUMENTS ? min : -min-1;
}
}
@@ -1129,7 +1380,7 @@ rb_block_min_max_arity(int *max)
struct rb_block block;
if (block_handler == VM_BLOCK_HANDLER_NONE) {
- rb_raise(rb_eArgError, "no block given");
+ rb_raise(rb_eArgError, "no block given");
}
block_setup(&block, block_handler);
@@ -1148,48 +1399,155 @@ rb_proc_get_iseq(VALUE self, int *is_proc)
switch (vm_block_type(block)) {
case block_type_iseq:
- return rb_iseq_check(block->as.captured.code.iseq);
+ return rb_iseq_check(block->as.captured.code.iseq);
case block_type_proc:
- return rb_proc_get_iseq(block->as.proc, is_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;
- }
- }
+ {
+ 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 NULL;
}
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
+proc_eq(VALUE self, VALUE other)
+{
+ const rb_proc_t *self_proc, *other_proc;
+ const struct rb_block *self_block, *other_block;
+
+ if (rb_obj_class(self) != rb_obj_class(other)) {
+ return Qfalse;
+ }
+
+ 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;
+ }
+
+ 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[2];
+ VALUE loc[5];
+ int i = 0;
if (!iseq) return Qnil;
rb_iseq_check(iseq);
- loc[0] = rb_iseq_path(iseq);
- loc[1] = iseq->body->location.first_lineno;
+ 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_new4(2, 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, Integer]
+ * prc.source_location -> [String, Integer, Integer, Integer, Integer]
*
- * Returns the Ruby source filename and line number containing this proc
- * or +nil+ if this proc was not defined in Ruby (i.e. native).
+ * 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
+ *
+ * This method will return +nil+ if the Proc was not defined in Ruby (i.e. native).
*/
VALUE
@@ -1208,32 +1566,59 @@ rb_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;
- const rb_iseq_t *iseq = rb_proc_get_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 rb_unnamed_parameters(rb_proc_arity(self));
+ return rb_unnamed_parameters(rb_proc_arity(self));
}
return rb_iseq_parameters(iseq, is_proc);
}
@@ -1243,37 +1628,81 @@ 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.as.captured.code.val);
- hash = rb_hash_uint(hash, (st_index_t)proc->block.as.captured.self);
- return rb_hash_uint(hash, (st_index_t)proc->block.as.captured.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;
}
-MJIT_FUNC_EXPORTED VALUE
+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)
{
- static VALUE sym_proc_cache = Qfalse;
enum {SYM_PROC_CACHE_SIZE = 67};
- VALUE proc;
- long index;
- ID id;
- if (!sym_proc_cache) {
- sym_proc_cache = rb_ary_tmp_new(SYM_PROC_CACHE_SIZE * 2);
- rb_gc_register_mark_object(sym_proc_cache);
- rb_ary_store(sym_proc_cache, SYM_PROC_CACHE_SIZE*2 - 1, Qnil);
- }
+ 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 = SYM2ID(sym);
- index = (id % SYM_PROC_CACHE_SIZE) << 1;
+ 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 (RARRAY_AREF(sym_proc_cache, index) == sym) {
- return RARRAY_AREF(sym_proc_cache, index + 1);
+ 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 {
- proc = sym_proc_new(rb_cProc, ID2SYM(id));
- RARRAY_ASET(sym_proc_cache, index, sym);
- RARRAY_ASET(sym_proc_cache, index + 1, proc);
- return proc;
+ return sym_proc_new(rb_cProc, sym);
}
}
@@ -1305,27 +1734,26 @@ rb_block_to_s(VALUE self, const struct rb_block *block, const char *additional_i
again:
switch (vm_block_type(block)) {
case block_type_proc:
- block = vm_proc_block(block->as.proc);
- goto again;
+ 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),
- FIX2INT(iseq->body->location.first_lineno));
- }
- break;
+ {
+ 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;
+ 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;
+ 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, ">");
- OBJ_INFECT_RAW(str, self);
return str;
}
@@ -1360,51 +1788,31 @@ proc_to_proc(VALUE self)
}
static void
-bm_mark(void *ptr)
-{
- struct METHOD *data = ptr;
- rb_gc_mark_no_pin(data->recv);
- rb_gc_mark_no_pin(data->klass);
- rb_gc_mark_no_pin(data->iclass);
- rb_gc_mark_no_pin((VALUE)data->me);
-}
-
-static void
-bm_compact(void *ptr)
+bm_mark_and_move(void *ptr)
{
struct METHOD *data = ptr;
- UPDATE_REFERENCE(data->recv);
- UPDATE_REFERENCE(data->klass);
- UPDATE_REFERENCE(data->iclass);
- UPDATE_TYPED_REFERENCE(rb_method_entry_t *, data->me);
-}
-
-static size_t
-bm_memsize(const void *ptr)
-{
- return sizeof(struct METHOD);
+ 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,
- RUBY_TYPED_DEFAULT_FREE,
- bm_memsize,
- bm_compact,
+ bm_mark_and_move,
+ RUBY_TYPED_DEFAULT_FREE,
+ NULL, // No external memory to report,
+ bm_mark_and_move,
},
- 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+ 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
@@ -1413,9 +1821,9 @@ respond_to_missing_p(VALUE klass, VALUE obj, VALUE sym, int scope)
/* TODO: merge with obj_respond_to() */
ID rmiss = idRespond_to_missing;
- if (obj == Qundef) return 0;
+ if (UNDEF_P(obj)) return 0;
if (rb_method_basic_definition_p(klass, rmiss)) return 0;
- return RTEST(rb_funcall(obj, rmiss, 2, sym, scope ? Qfalse : Qtrue));
+ return RTEST(rb_funcall(obj, rmiss, 2, sym, RBOOL(!scope)));
}
@@ -1429,6 +1837,7 @@ mnew_missing(VALUE klass, VALUE obj, ID id, VALUE mclass)
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;
@@ -1438,8 +1847,6 @@ mnew_missing(VALUE klass, VALUE obj, ID id, VALUE mclass)
RB_OBJ_WRITE(method, &data->me, me);
- OBJ_INFECT(method, klass);
-
return method;
}
@@ -1454,74 +1861,88 @@ mnew_missing_by_name(VALUE klass, VALUE obj, VALUE *name, int scope, VALUE mclas
static VALUE
mnew_internal(const rb_method_entry_t *me, VALUE klass, VALUE iclass,
- VALUE obj, ID id, VALUE mclass, int scope, int error)
+ 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:
if (UNDEFINED_METHOD_ENTRY_P(me)) {
- 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 (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);
- if (scope && (visi != METHOD_VISI_PUBLIC)) {
- if (!error) return Qnil;
- rb_print_inaccessible(klass, id, visi);
- }
+ 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;
+ 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(me->owner);
- id = me->def->original_id;
- me = rb_method_entry_without_refinements(klass, id, &iclass);
- }
- goto again;
+ }
+ 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;
}
method = TypedData_Make_Struct(mclass, struct METHOD, &method_data_type, data);
- RB_OBJ_WRITE(method, &data->recv, obj);
- RB_OBJ_WRITE(method, &data->klass, 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);
- OBJ_INFECT(method, klass);
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)
+ VALUE obj, ID id, VALUE mclass, int scope)
{
return mnew_internal(me, klass, iclass, obj, id, mclass, scope, TRUE);
}
static VALUE
-mnew(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope)
+mnew_callable(VALUE klass, VALUE obj, ID id, VALUE mclass, int scope)
{
const rb_method_entry_t *me;
VALUE iclass = Qnil;
- if (obj == Qundef) { /* UnboundMethod */
- me = rb_method_entry_with_refinements(klass, id, &iclass);
- }
- else {
- me = (rb_method_entry_t *)rb_callable_method_entry_with_refinements(klass, id, &iclass);
- }
+ 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)
{
@@ -1533,7 +1954,7 @@ method_entry_defined_class(const rb_method_entry_t *me)
*
* Document-class: Method
*
- * Method objects are created by Object#method, and are associated
+ * +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
@@ -1559,12 +1980,11 @@ method_entry_defined_class(const rb_method_entry_t *me)
/*
* call-seq:
- * meth.eql?(other_meth) -> true or false
- * 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
@@ -1574,22 +1994,22 @@ method_eq(VALUE method, VALUE other)
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) ||
- klass1 != klass2 ||
- m1->klass != m2->klass ||
- m1->recv != m2->recv) {
- return Qfalse;
+ klass1 != klass2 ||
+ m1->klass != m2->klass ||
+ m1->recv != m2->recv) {
+ return Qfalse;
}
return Qtrue;
@@ -1597,6 +2017,22 @@ 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.
@@ -1635,11 +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);
+ &method_data_type, data);
RB_OBJ_WRITE(method, &data->recv, Qundef);
- RB_OBJ_WRITE(method, &data->klass, orig->klass);
+ 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));
- OBJ_INFECT(method, obj);
return method;
}
@@ -1704,7 +2141,15 @@ method_original_name(VALUE obj)
* 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
@@ -1715,33 +2160,53 @@ method_owner(VALUE obj)
{
struct METHOD *data;
TypedData_Get_Struct(obj, struct METHOD, &method_data_type, data);
- return data->me->owner;
+ return data->owner;
+}
+
+/*
+ * 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;
+
+ 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)
{
-#define MSG(s) rb_fstring_lit("undefined method `%1$s' for"s" `%2$s'")
+#define MSG(s) rb_fstring_lit("undefined method '%1$s' for"s" '%2$s'")
VALUE c = klass;
- VALUE s;
-
- if (FL_TEST(c, FL_SINGLETON)) {
- VALUE obj = rb_ivar_get(klass, attached);
-
- switch (BUILTIN_TYPE(obj)) {
- case T_MODULE:
- case T_CLASS:
- c = obj;
- s = MSG("");
- }
- goto normal_class;
+ 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)) {
- s = MSG(" module");
+ s = MSG(" module");
}
- else {
- normal_class:
- s = MSG(" class");
+ if (UNDEF_P(s)) {
+ s = MSG(" class");
}
rb_name_err_raise_str(s, c, str);
#undef MSG
@@ -1757,9 +2222,9 @@ obj_method(VALUE obj, VALUE vid, int scope)
if (!id) {
VALUE m = mnew_missing_by_name(klass, obj, &vid, scope, mclass);
if (m) return m;
- rb_method_name_error(klass, vid);
+ rb_method_name_error(klass, vid);
}
- return mnew(klass, obj, id, mclass, scope);
+ return mnew_callable(klass, obj, id, mclass, scope);
}
/*
@@ -1767,7 +2232,7 @@ obj_method(VALUE obj, VALUE vid, int scope)
* obj.method(sym) -> method
*
* Looks up the named method as a receiver in <i>obj</i>, returning a
- * Method object (or raising NameError). The Method object acts as a
+ * +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.
*
@@ -1788,7 +2253,7 @@ obj_method(VALUE obj, VALUE vid, int scope)
* m = l.method("hello")
* m.call #=> "Hello, @iv = Fred"
*
- * Note that Method implements <code>to_proc</code> method, which
+ * 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
@@ -1820,6 +2285,19 @@ 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
@@ -1847,27 +2325,44 @@ rb_obj_public_method(VALUE obj, VALUE vid)
VALUE
rb_obj_singleton_method(VALUE obj, VALUE vid)
{
- const rb_method_entry_t *me;
- VALUE klass = rb_singleton_class_get(obj);
+ VALUE sc = rb_singleton_class_get(obj);
+ VALUE klass;
ID id = rb_check_id(&vid);
- if (NIL_P(klass) || NIL_P(klass = RCLASS_ORIGIN(klass))) {
- undef:
- rb_name_err_raise("undefined singleton method `%1$s' for `%2$s'",
- obj, vid);
+ if (NIL_P(sc) ||
+ NIL_P(klass = RCLASS_ORIGIN(sc)) ||
+ !NIL_P(rb_special_singleton_class(obj))) {
+ /* goto undef; */
}
- if (!id) {
+ else if (! id) {
VALUE m = mnew_missing_by_name(klass, obj, &vid, FALSE, rb_cMethod);
if (m) return m;
- goto undef;
+ /* else goto undef; */
}
- me = rb_method_entry_at(klass, id);
- if (UNDEFINED_METHOD_ENTRY_P(me) ||
- UNDEFINED_REFINED_METHOD_P(me->def)) {
- vid = ID2SYM(id);
- goto undef;
+ 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);
+ }
}
- return mnew_from_me(me, klass, klass, obj, id, rb_cMethod, FALSE);
+
+ /* undef: */
+ vid = ID2SYM(id);
+ rb_name_err_raise("undefined singleton method '%1$s' for '%2$s'",
+ obj, vid);
+ UNREACHABLE_RETURN(Qundef);
}
/*
@@ -1876,29 +2371,29 @@ rb_obj_singleton_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
*
- * interpreter = Interpreter.new
- * interpreter.interpret('dave')
+ * def hi
+ * puts "Hi, I'm #{@name}!"
+ * end
+ * end
+ *
+ * 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
@@ -1906,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);
}
/*
@@ -1923,9 +2418,77 @@ 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);
}
/*
@@ -1935,8 +2498,10 @@ rb_mod_public_instance_method(VALUE mod, VALUE vid)
*
* 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 #instance_eval.
+ * 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
@@ -1946,6 +2511,7 @@ rb_mod_public_instance_method(VALUE mod, VALUE vid)
* 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))
@@ -1953,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
*
@@ -1960,100 +2527,22 @@ 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;
- VALUE name;
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;
- int is_method = FALSE;
if (cref) {
- scope_visi = CREF_SCOPE_VISI(cref);
- }
-
- rb_check_arity(argc, 1, 2);
- name = argv[0];
- id = rb_check_id(&name);
- if (argc == 1) {
-#if PROC_NEW_REQUIRES_BLOCK
- body = rb_block_lambda();
-#else
- const rb_execution_context_t *ec = GET_EC();
- VALUE block_handler = rb_vm_frame_block_handler(ec->cfp);
- if (block_handler == VM_BLOCK_HANDLER_NONE) rb_raise(rb_eArgError, proc_without_block);
-
- switch (vm_block_handler_type(block_handler)) {
- case block_handler_type_proc:
- body = VM_BH_TO_PROC(block_handler);
- break;
- case block_handler_type_symbol:
- body = rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
- break;
- case block_handler_type_iseq:
- case block_handler_type_ifunc:
- body = rb_vm_make_lambda(ec, VM_BH_TO_CAPT_BLOCK(block_handler), rb_cProc);
- }
-#endif
+ scope_visi = CREF_SCOPE_VISI(cref);
}
- 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)",
- rb_obj_classname(body));
- }
- }
- if (!id) id = rb_to_id(name);
- if (is_method) {
- struct METHOD *method = (struct METHOD *)DATA_PTR(body);
- if (method->me->owner != mod && !RB_TYPE_P(method->me->owner, T_MODULE) &&
- !RTEST(rb_class_inherited_p(mod, method->me->owner))) {
- if (FL_TEST(method->me->owner, 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 % "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);
+ return rb_mod_define_method_with_visibility(argc, argv, mod, scope_visi);
}
/*
@@ -2061,9 +2550,10 @@ rb_mod_define_method(int argc, VALUE *argv, VALUE mod)
* 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
@@ -2080,14 +2570,19 @@ 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);
}
/*
@@ -2100,17 +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;
-
- 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"));
}
/*
@@ -2138,20 +2623,47 @@ 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);
+ 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;
}
-/* Document-method: Method#===
- *
+/* :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:
- * method === obj -> result_of_method
+ * call(...) -> obj
+ * self[...] -> obj
+ * self === obj -> result_of_method
+ *
+ * Invokes +self+ with the specified arguments, returning the
+ * method's return value.
+ *
+ * m = 12.method("+")
+ * m.call(3) #=> 15
+ * m.call(20) #=> 32
*
- * Invokes the method with +obj+ as the parameter like #call.
- * This allows a method object to be the target of a +when+ clause
+ * Using Method#=== allows a method object to be the target of a +when+ clause
* in a case statement.
*
* require 'prime'
@@ -2162,19 +2674,18 @@ method_clone(VALUE self)
* 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);
+}
-/*
- * call-seq:
- * meth.call(args, ...) -> obj
- * meth[args, ...] -> obj
- *
- * Invokes the <i>meth</i> with the specified arguments, returning the
- * method's return value.
- *
- * m = 12.method("+")
- * m.call(3) #=> 15
- * m.call(20) #=> 32
- */
+VALUE
+rb_method_call_kw(int argc, const VALUE *argv, VALUE method, int kw_splat)
+{
+ 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(int argc, const VALUE *argv, VALUE method)
@@ -2192,60 +2703,37 @@ method_callable_method_entry(const struct METHOD *data)
static inline VALUE
call_method_data(rb_execution_context_t *ec, const struct METHOD *data,
- int argc, const VALUE *argv, VALUE passed_procval)
+ 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(ec, data->recv, data->me->called_id, argc, argv,
- method_callable_method_entry(data));
+ return rb_vm_call_kw(ec, data->recv, data->me->called_id, argc, argv,
+ method_callable_method_entry(data), kw_splat);
}
-static VALUE
-call_method_data_safe(rb_execution_context_t *ec, const struct METHOD *data,
- int argc, const VALUE *argv, VALUE passed_procval,
- int safe)
+VALUE
+rb_method_call_with_block_kw(int argc, const VALUE *argv, VALUE method, VALUE passed_procval, int kw_splat)
{
- VALUE result = Qnil; /* OK */
- enum ruby_tag_type state;
+ const struct METHOD *data;
+ rb_execution_context_t *ec = GET_EC();
- EC_PUSH_TAG(ec);
- if ((state = EC_EXEC_TAG()) == TAG_NONE) {
- /* result is used only if state == 0, no exceptions is caught. */
- /* otherwise it doesn't matter even if clobbered. */
- NO_CLOBBERED(result) = call_method_data(ec, data, argc, argv, passed_procval);
+ TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
+ if (UNDEF_P(data->recv)) {
+ rb_raise(rb_eTypeError, "can't call unbound method; bind first");
}
- EC_POP_TAG();
- rb_set_safe_level_force(safe);
- if (state)
- EC_JUMP_TAG(ec, state);
- return result;
+ 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)
{
- 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");
- }
- if (OBJ_TAINTED(method)) {
- const int safe_level_to_run = RUBY_SAFE_LEVEL_MAX;
- int safe = rb_safe_level();
- if (safe < safe_level_to_run) {
- rb_set_safe_level_force(safe_level_to_run);
- return call_method_data_safe(ec, data, argc, argv, passed_procval, safe);
- }
- }
- return call_method_data(ec, data, argc, argv, 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 Method is
+ * 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.
@@ -2296,6 +2784,59 @@ rb_method_call_with_block(int argc, const VALUE *argv, VALUE method, VALUE passe
*
*/
+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
@@ -2334,44 +2875,58 @@ rb_method_call_with_block(int argc, const VALUE *argv, VALUE method, VALUE passe
static VALUE
umethod_bind(VALUE method, VALUE recv)
{
- struct METHOD *data, *bound;
- VALUE methclass, klass;
-
+ 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->me->owner;
+ struct METHOD *bound;
+ method = TypedData_Make_Struct(rb_cMethod, struct METHOD, &method_data_type, bound);
+ 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);
- 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 % "PRIsVALUE,
- methclass);
- }
- }
+ 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++;
- klass = CLASS_OF(recv);
+ VALUE passed_procval = rb_block_given_p() ? rb_block_proc() : Qnil;
+ rb_execution_context_t *ec = GET_EC();
- method = TypedData_Make_Struct(rb_cMethod, struct METHOD, &method_data_type, bound);
- RB_OBJ_WRITE(method, &bound->recv, recv);
- RB_OBJ_WRITE(method, &bound->klass, data->klass);
- RB_OBJ_WRITE(method, &bound->me, rb_method_entry_clone(data->me));
+ const struct METHOD *data;
+ TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
- if (RB_TYPE_P(bound->me->owner, T_MODULE)) {
- VALUE ic = rb_class_search_ancestor(klass, bound->me->owner);
- if (ic) {
- klass = ic;
- }
- else {
- klass = rb_include_class_new(methclass, klass);
- }
- RB_OBJ_WRITE(method, &bound->me, rb_method_entry_complement_defined_class(bound->me, bound->me->called_id, klass));
+ 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 method;
+ return call_method_data(ec, &bound, argc, argv, passed_procval, RB_PASS_CALLED_KEYWORDS);
+ }
}
/*
@@ -2380,68 +2935,78 @@ umethod_bind(VALUE method, VALUE recv)
* 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;
+ def = def->body.alias.original_me->def;
+ goto again;
case VM_METHOD_TYPE_BMETHOD:
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);
+ 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;
- case OPTIMIZED_METHOD_TYPE_CALL:
- *max = UNLIMITED_ARGUMENTS;
- return 0;
- case OPTIMIZED_METHOD_TYPE_BLOCK_CALL:
- *max = UNLIMITED_ARGUMENTS;
- return 0;
- default:
- break;
- }
- 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);
+ 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);
}
/*
@@ -2509,10 +3074,10 @@ original_method_entry(VALUE mod, ID 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;
+ 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;
}
@@ -2523,7 +3088,7 @@ method_min_max_arity(VALUE method, int *max)
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
@@ -2540,6 +3105,21 @@ rb_obj_method_arity(VALUE obj, ID id)
return rb_mod_method_arity(CLASS_OF(obj), id);
}
+VALUE
+rb_callable_receiver(VALUE callable)
+{
+ 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)
{
@@ -2554,11 +3134,11 @@ method_def_iseq(const rb_method_definition_t *def)
{
switch (def->type) {
case VM_METHOD_TYPE_ISEQ:
- return rb_iseq_check(def->body.iseq.iseqptr);
+ 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);
+ 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:
@@ -2568,7 +3148,7 @@ method_def_iseq(const rb_method_definition_t *def)
case VM_METHOD_TYPE_OPTIMIZED:
case VM_METHOD_TYPE_MISSING:
case VM_METHOD_TYPE_REFINED:
- break;
+ break;
}
return NULL;
}
@@ -2587,12 +3167,12 @@ method_cref(VALUE method)
again:
switch (def->type) {
case VM_METHOD_TYPE_ISEQ:
- return def->body.iseq.cref;
+ return def->body.iseq.cref;
case VM_METHOD_TYPE_ALIAS:
- def = def->body.alias.original_me->def;
- goto again;
+ def = def->body.alias.original_me->def;
+ goto again;
default:
- return NULL;
+ return NULL;
}
}
@@ -2600,9 +3180,9 @@ static VALUE
method_def_location(const rb_method_definition_t *def)
{
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);
+ if (!def->body.attr.location)
+ return Qnil;
+ return rb_ary_dup(def->body.attr.location);
}
return iseq_location(method_def_iseq(def));
}
@@ -2614,25 +3194,19 @@ rb_method_entry_location(const rb_method_entry_t *me)
return method_def_location(me->def);
}
-VALUE
-rb_mod_method_location(VALUE mod, ID id)
-{
- const rb_method_entry_t *me = original_method_entry(mod, id);
- return rb_method_entry_location(me);
-}
-
-VALUE
-rb_obj_method_location(VALUE obj, ID id)
-{
- return rb_mod_method_location(CLASS_OF(obj), id);
-}
-
/*
* call-seq:
- * meth.source_location -> [String, Integer]
+ * 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
@@ -2641,6 +3215,69 @@ rb_method_location(VALUE method)
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));
+
+}
+
/*
* call-seq:
* meth.parameters -> array
@@ -2663,11 +3300,7 @@ rb_method_location(VALUE method)
static VALUE
rb_method_parameters(VALUE method)
{
- const rb_iseq_t *iseq = rb_method_iseq(method);
- if (!iseq) {
- return rb_unnamed_parameters(method_arity(method));
- }
- return rb_iseq_parameters(iseq, 0);
+ return method_def_parameters(rb_method_def(method));
}
/*
@@ -2677,11 +3310,30 @@ rb_method_parameters(VALUE 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>"
+ * "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.
+ *
+ * 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
@@ -2695,57 +3347,181 @@ method_inspect(VALUE method)
TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
str = rb_sprintf("#<% "PRIsVALUE": ", rb_obj_class(method));
- OBJ_INFECT_RAW(str, method);
- mklass = data->klass;
+ 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;
+ defined_class = data->me->def->body.alias.original_me->owner;
}
else {
- defined_class = method_entry_defined_class(data->me);
+ defined_class = method_entry_defined_class(data->me);
}
if (RB_TYPE_P(defined_class, T_ICLASS)) {
- defined_class = RBASIC_CLASS(defined_class);
- }
-
- if (FL_TEST(mklass, FL_SINGLETON)) {
- VALUE v = rb_ivar_get(mklass, attached);
-
- if (data->recv == Qundef) {
- 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 = ".";
- }
+ 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_append(str, rb_inspect(mklass));
- if (defined_class != mklass) {
- rb_str_catf(str, "(% "PRIsVALUE")", defined_class);
- }
+ 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->called_id));
if (data->me->called_id != data->me->def->original_id) {
- rb_str_catf(str, "(%"PRIsVALUE")",
- rb_id2str(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)");
}
// parameter information
- // TODO
+ {
+ 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, ")");
+ }
{ // source location
VALUE loc = rb_method_location(method);
@@ -2761,29 +3537,17 @@ method_inspect(VALUE method)
}
static VALUE
-mproc(VALUE method)
-{
- return rb_funcallv(rb_mRubyVMFrozenCore, idProc, 0, 0);
-}
-
-static VALUE
-mlambda(VALUE method)
-{
- return rb_funcallv(rb_mRubyVMFrozenCore, idLambda, 0, 0);
-}
-
-static VALUE
-bmcall(VALUE args, VALUE method, int argc, VALUE *argv, VALUE passed_proc)
+bmcall(RB_BLOCK_CALL_FUNC_ARGLIST(args, method))
{
- return rb_method_call_with_block(argc, argv, method, passed_proc);
+ 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;
}
@@ -2809,17 +3573,19 @@ method_to_proc(VALUE method)
* end
* end
*/
- 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;
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
+ * Returns a +Method+ of superclass which would be called when super is used
* or nil if there is no method on superclass.
*/
@@ -2834,8 +3600,15 @@ method_super_method(VALUE method)
TypedData_Get_Struct(method, struct METHOD, &method_data_type, data);
iclass = data->iclass;
if (!iclass) return Qnil;
- super_class = RCLASS_SUPER(RCLASS_ORIGIN(iclass));
- mid = data->me->called_id;
+ 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;
@@ -2881,13 +3654,19 @@ env_clone(const rb_env_t *env, const rb_cref_t *cref)
VM_ASSERT(VM_ENV_ESCAPED_P(env->ep));
if (cref == NULL) {
- cref = rb_vm_cref_new_toplevel();
+ cref = rb_vm_cref_new_toplevel();
}
new_body = ALLOC_N(VALUE, env->env_size);
- MEMCPY(new_body, env->env, 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;
@@ -2919,41 +3698,40 @@ proc_binding(VALUE self)
GetProcPtr(self, 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;
+ 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_symbol:
- goto error;
+ 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(NULL, name, name, Qnil, 0, ISEQ_TYPE_TOP);
- RB_OBJ_WRITE(env, &env->iseq, empty);
- break;
- }
- else {
- error:
- rb_raise(rb_eArgError, "Can't create Binding from C level Proc");
- return Qnil;
- }
- }
+ {
+ 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);
@@ -2964,20 +3742,20 @@ proc_binding(VALUE self)
RB_OBJ_WRITTEN(bindval, Qundef, VM_ENV_ENVVAL(env->ep));
if (iseq) {
- rb_iseq_check(iseq);
- RB_OBJ_WRITE(bindval, &bind->pathobj, iseq->body->location.pathobj);
- bind->first_lineno = FIX2INT(rb_iseq_first_lineno(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 {
- RB_OBJ_WRITE(bindval, &bind->pathobj,
- rb_iseq_pathobj_new(rb_fstring_lit("(binding)"), Qnil));
- bind->first_lineno = 1;
+ 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)
@@ -2997,7 +3775,7 @@ 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_AREF(args, 0);
@@ -3008,14 +3786,14 @@ curry(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc)
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_CONST_PTR(passed), passed_proc);
+ return rb_proc_call_with_block(proc, check_argc(RARRAY_LEN(passed)), RARRAY_CONST_PTR(passed), blockarg);
}
}
@@ -3031,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
@@ -3068,13 +3850,13 @@ proc_curry(int argc, const VALUE *argv, VALUE self)
VALUE arity;
if (rb_check_arity(argc, 0, 1) == 0 || NIL_P(arity = argv[0])) {
- arity = INT2FIX(min_arity);
+ 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);
@@ -3120,16 +3902,16 @@ rb_method_curry(int argc, const VALUE *argv, VALUE self)
}
static VALUE
-compose(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc)
+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(g, argc, argv, passed_proc);
+ fargs = rb_proc_call_with_block_kw(g, argc, argv, blockarg, RB_PASS_CALLED_KEYWORDS);
else
- fargs = rb_funcall_with_block(g, idCall, argc, argv, passed_proc);
+ 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));
@@ -3163,6 +3945,8 @@ static VALUE rb_proc_compose_to_right(VALUE self, VALUE g);
* 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)
@@ -3181,8 +3965,14 @@ rb_proc_compose_to_left(VALUE self, VALUE g)
procs[1] = g;
args = rb_ary_tmp_new_from_values(0, 2, procs);
- GetProcPtr(self, procp);
- is_lambda = procp->is_lambda;
+ 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);
@@ -3196,12 +3986,26 @@ rb_proc_compose_to_left(VALUE self, VALUE g)
* 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.
+ * 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)
@@ -3232,19 +4036,18 @@ rb_proc_compose_to_right(VALUE self, VALUE g)
/*
* call-seq:
- * meth << g -> a_proc
+ * self << g -> a_proc
*
- * Returns a proc that is the composition of this method and the given <i>g</i>.
- * The returned proc takes a variable number of arguments, calls <i>g</i> with them
- * then calls this method with the result.
+ * Returns a proc that is the composition of the given +g+ and this method.
*
- * def f(x)
- * x * x
- * end
+ * 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 {|x| x + x }
- * p (f << g).call(2) #=> 16
+ * g = proc { |ary| ary << 'in proc' }
+ * (f << g).call([]) # => ["in proc", "in f"]
*/
static VALUE
rb_method_compose_to_left(VALUE self, VALUE g)
@@ -3256,19 +4059,18 @@ rb_method_compose_to_left(VALUE self, VALUE g)
/*
* call-seq:
- * meth >> g -> a_proc
+ * self >> g -> a_proc
*
- * Returns a proc that is the composition of this method and the given <i>g</i>.
- * The returned proc takes a variable number of arguments, calls <i>g</i> with them
- * then calls this method with the result.
+ * Returns a proc that is the composition of this method and the given +g+.
*
- * def f(x)
- * x * x
- * end
+ * 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 {|x| x + x }
- * p (f >> g).call(2) #=> 8
+ * g = proc { |ary| ary << 'in proc' }
+ * (f >> g).call([]) # => ["in f", "in proc"]
*/
static VALUE
rb_method_compose_to_right(VALUE self, VALUE g)
@@ -3279,6 +4081,71 @@ rb_method_compose_to_right(VALUE self, VALUE 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.
@@ -3375,7 +4242,8 @@ rb_method_compose_to_right(VALUE self, VALUE g)
*
* lambda1 = lambda {|x| x**2 }
*
- * * Use the Lambda literal syntax (also constructs a proc with lambda semantics):
+ * * 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 }
*
@@ -3475,7 +4343,7 @@ rb_method_compose_to_right(VALUE self, VALUE g)
*
* p = proc {|x, y| x }
* l = lambda {|x, y| x }
- * [[1, 2], [3, 4]].map(&p) #=> [1, 2]
+ * [[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
@@ -3507,10 +4375,9 @@ rb_method_compose_to_right(VALUE self, VALUE g)
* == 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 con be
+ * a proc by the <code>&</code> operator, and therefore can be
* consumed by iterators.
*
-
* class Greeter
* def initialize(greeting)
* @greeting = greeting
@@ -3526,8 +4393,8 @@ rb_method_compose_to_right(VALUE self, VALUE g)
* ["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.
+ * 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"]
@@ -3561,9 +4428,129 @@ rb_method_compose_to_right(VALUE self, VALUE g)
* 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)
{
@@ -3573,14 +4560,10 @@ Init_Proc(void)
rb_undef_alloc_func(rb_cProc);
rb_define_singleton_method(rb_cProc, "new", rb_proc_s_new, -1);
- rb_add_method(rb_cProc, idCall, VM_METHOD_TYPE_OPTIMIZED,
- (void *)OPTIMIZED_METHOD_TYPE_CALL, METHOD_VISI_PUBLIC);
- rb_add_method(rb_cProc, rb_intern("[]"), VM_METHOD_TYPE_OPTIMIZED,
- (void *)OPTIMIZED_METHOD_TYPE_CALL, METHOD_VISI_PUBLIC);
- rb_add_method(rb_cProc, rb_intern("==="), VM_METHOD_TYPE_OPTIMIZED,
- (void *)OPTIMIZED_METHOD_TYPE_CALL, METHOD_VISI_PUBLIC);
- rb_add_method(rb_cProc, rb_intern("yield"), VM_METHOD_TYPE_OPTIMIZED,
- (void *)OPTIMIZED_METHOD_TYPE_CALL, METHOD_VISI_PUBLIC);
+ 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);
@@ -3592,7 +4575,7 @@ Init_Proc(void)
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);
- rb_define_method(rb_cProc, "dup", rb_proc_dup, 0);
+ rb_define_method(rb_cProc, "dup", proc_dup, 0);
rb_define_method(rb_cProc, "hash", proc_hash, 0);
rb_define_method(rb_cProc, "to_s", proc_to_s, 0);
rb_define_alias(rb_cProc, "inspect", "to_s");
@@ -3601,8 +4584,12 @@ Init_Proc(void)
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);
@@ -3613,8 +4600,8 @@ Init_Proc(void)
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);
@@ -3624,12 +4611,13 @@ 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, -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);
@@ -3646,14 +4634,17 @@ Init_Proc(void)
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);
@@ -3661,6 +4652,7 @@ Init_Proc(void)
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);
@@ -3674,7 +4666,7 @@ Init_Proc(void)
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);
}
/*
@@ -3715,6 +4707,8 @@ 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");
@@ -3725,6 +4719,9 @@ Init_Binding(void)
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);
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-19 18:50:35 +0000