Set up callable_method_entry for DUMMY frame on ArgumentError

mame · mame · commit 3546cedde3f6 · 2025-06-24T11:39:58.000+09:00
Before the patch: ``` $ ./miniruby -e '[1, 2].inject(:tap)' -e:1:in '<main>': wrong number of arguments (given 1, expected 0) (ArgumentError) from -e:1:in 'Enumerable#inject' from -e:1:in '<main>' ``` After the patch: ``` $ ./miniruby -e '[1, 2].inject(:tap)' -e:1:in 'Kernel#tap': wrong number of arguments (given 1, expected 0) (ArgumentError) from -e:1:in 'Enumerable#inject' from -e:1:in '<main>' ``` Fixes https://bugs.ruby-lang.org/issues/20968#change-113811
diff --git a/test/ruby/test_backtrace.rb b/test/ruby/test_backtrace.rb
@@ -460,4 +460,10 @@ def test_backtrace_internal_frame
     assert_equal(__FILE__, backtrace[1].path) # not "<internal:kernel>"
     assert_equal("Kernel#tap", backtrace[1].label)
   end
+
+  def test_backtrace_on_argument_error
+    lineno = __LINE__; [1, 2].inject(:tap)
+  rescue ArgumentError
+    assert_equal("#{ __FILE__ }:#{ lineno }:in 'Kernel#tap'", $!.backtrace[0].to_s)
+  end
 end
diff --git a/test/ruby/test_method.rb b/test/ruby/test_method.rb
@@ -1612,7 +1612,7 @@ def test_argument_error_location
         begin
           foo(1)
         rescue ArgumentError => e
-          assert_equal "main.rb:#{$line_method}:in 'foo'", e.backtrace.first
+          assert_equal "main.rb:#{$line_method}:in 'Object#foo'", e.backtrace.first
         end
       EOS
     END_OF_BODY
diff --git a/vm_args.c b/vm_args.c
@@ -8,9 +8,9 @@
 
 **********************************************************************/
 
-NORETURN(static void raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const VALUE exc));
-NORETURN(static void argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const int miss_argc, const int min_argc, const int max_argc));
-NORETURN(static void argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const char *error, const VALUE keys));
+NORETURN(static void raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const VALUE exc));
+NORETURN(static void argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const int miss_argc, const int min_argc, const int max_argc));
+NORETURN(static void argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const char *error, const VALUE keys));
 VALUE rb_keyword_error_new(const char *error, VALUE keys); /* class.c */
 static VALUE method_missing(rb_execution_context_t *ec, VALUE obj, ID id, int argc, const VALUE *argv,
                             enum method_missing_reason call_status, int kw_splat);
@@ -321,7 +321,7 @@ args_setup_kw_parameters_lookup(const ID key, VALUE *ptr, const VALUE *const pas
 #define KW_SPECIFIED_BITS_MAX (32-1) /* TODO: 32 -> Fixnum's max bits */
 
 static void
-args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *const iseq,
+args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *const iseq, const rb_callable_method_entry_t *cme,
                          VALUE *const passed_values, const int passed_keyword_len, const VALUE *const passed_keywords,
                          VALUE *const locals)
 {
@@ -345,7 +345,7 @@ args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *cons
         }
     }
 
-    if (missing) argument_kw_error(ec, iseq, "missing", missing);
+    if (missing) argument_kw_error(ec, iseq, cme, "missing", missing);
 
     for (di=0; i<key_num; i++, di++) {
         if (args_setup_kw_parameters_lookup(acceptable_keywords[i], &locals[i], passed_keywords, passed_values, passed_keyword_len)) {
@@ -386,7 +386,7 @@ args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *cons
     else {
         if (found != passed_keyword_len) {
             VALUE keys = make_unknown_kw_hash(passed_keywords, passed_keyword_len, passed_values);
-            argument_kw_error(ec, iseq, "unknown", keys);
+            argument_kw_error(ec, iseq, cme, "unknown", keys);
         }
     }
 
@@ -397,7 +397,7 @@ args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *cons
 }
 
 static void
-args_setup_kw_parameters_from_kwsplat(rb_execution_context_t *const ec, const rb_iseq_t *const iseq,
+args_setup_kw_parameters_from_kwsplat(rb_execution_context_t *const ec, const rb_iseq_t *const iseq, const rb_callable_method_entry_t *cme,
                          VALUE keyword_hash, VALUE *const locals, bool remove_hash_value)
 {
     const ID *acceptable_keywords = ISEQ_BODY(iseq)->param.keyword->table;
@@ -430,7 +430,7 @@ args_setup_kw_parameters_from_kwsplat(rb_execution_context_t *const ec, const rb
         }
     }
 
-    if (missing) argument_kw_error(ec, iseq, "missing", missing);
+    if (missing) argument_kw_error(ec, iseq, cme, "missing", missing);
 
     for (di=0; i<key_num; i++, di++) {
         VALUE key = ID2SYM(acceptable_keywords[i]);
@@ -485,11 +485,11 @@ args_setup_kw_parameters_from_kwsplat(rb_execution_context_t *const ec, const rb
                  * This is simpler than writing code to check which entries in the hash do not match.
                  * This will raise an exception, so the additional performance impact shouldn't be material.
                  */
-                args_setup_kw_parameters_from_kwsplat(ec, iseq, rb_hash_dup(keyword_hash), locals, true);
+                args_setup_kw_parameters_from_kwsplat(ec, iseq, cme, rb_hash_dup(keyword_hash), locals, true);
             }
         }
         else if (!RHASH_EMPTY_P(keyword_hash)) {
-            argument_kw_error(ec, iseq, "unknown", rb_hash_keys(keyword_hash));
+            argument_kw_error(ec, iseq, cme, "unknown", rb_hash_keys(keyword_hash));
         }
     }
 
@@ -607,6 +607,7 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
     VALUE splat_flagged_keyword_hash = 0;
     VALUE converted_keyword_hash = 0;
     VALUE rest_last = 0;
+    const rb_callable_method_entry_t *cme = calling->cc ? vm_cc_cme(calling->cc) : NULL;
 
     vm_check_canary(ec, orig_sp);
     /*
@@ -861,7 +862,7 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
             args_extend(args, min_argc);
         }
         else {
-            argument_arity_error(ec, iseq, given_argc, min_argc, max_argc);
+            argument_arity_error(ec, iseq, cme, given_argc, min_argc, max_argc);
         }
     }
 
@@ -872,7 +873,7 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
             given_argc = max_argc;
         }
         else {
-            argument_arity_error(ec, iseq, given_argc, min_argc, max_argc);
+            argument_arity_error(ec, iseq, cme, given_argc, min_argc, max_argc);
         }
     }
 
@@ -918,15 +919,15 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
 
         if (args->kw_argv != NULL) {
             const struct rb_callinfo_kwarg *kw_arg = args->kw_arg;
-            args_setup_kw_parameters(ec, iseq, args->kw_argv, kw_arg->keyword_len, kw_arg->keywords, klocals);
+            args_setup_kw_parameters(ec, iseq, cme, args->kw_argv, kw_arg->keyword_len, kw_arg->keywords, klocals);
         }
         else if (!NIL_P(keyword_hash)) {
             bool remove_hash_value = false;
             if (ISEQ_BODY(iseq)->param.flags.has_kwrest) {
                 keyword_hash = check_kwrestarg(keyword_hash, &kw_flag);
                 remove_hash_value = true;
             }
-            args_setup_kw_parameters_from_kwsplat(ec, iseq, keyword_hash, klocals, remove_hash_value);
+            args_setup_kw_parameters_from_kwsplat(ec, iseq, cme, keyword_hash, klocals, remove_hash_value);
         }
         else {
 #if VM_CHECK_MODE > 0
@@ -941,15 +942,15 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
                 VM_ASSERT(args_argc(args) == 1);
             }
 #endif
-            args_setup_kw_parameters(ec, iseq, NULL, 0, NULL, klocals);
+            args_setup_kw_parameters(ec, iseq, cme, NULL, 0, NULL, klocals);
         }
     }
     else if (ISEQ_BODY(iseq)->param.flags.has_kwrest) {
         args_setup_kw_rest_parameter(keyword_hash, locals + ISEQ_BODY(iseq)->param.keyword->rest_start,
             kw_flag, ISEQ_BODY(iseq)->param.flags.anon_kwrest);
     }
     else if (!NIL_P(keyword_hash) && RHASH_SIZE(keyword_hash) > 0 && arg_setup_type == arg_setup_method) {
-        argument_kw_error(ec, iseq, "unknown", rb_hash_keys(keyword_hash));
+        argument_kw_error(ec, iseq, cme, "unknown", rb_hash_keys(keyword_hash));
     }
 
     if (ISEQ_BODY(iseq)->param.flags.has_block) {
@@ -975,13 +976,13 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co
 }
 
 static void
-raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const VALUE exc)
+raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const VALUE exc)
 {
     VALUE at;
 
     if (iseq) {
         vm_push_frame(ec, iseq, VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL, Qnil /* self */,
-                      VM_BLOCK_HANDLER_NONE /* specval*/, Qfalse /* me or cref */,
+                      VM_BLOCK_HANDLER_NONE /* specval*/, (VALUE) cme /* me or cref */,
                       ISEQ_BODY(iseq)->iseq_encoded,
                       ec->cfp->sp, 0, 0 /* stack_max */);
         at = rb_ec_backtrace_object(ec);
@@ -997,7 +998,7 @@ raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const VA
 }
 
 static void
-argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const int miss_argc, const int min_argc, const int max_argc)
+argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const int miss_argc, const int min_argc, const int max_argc)
 {
     VALUE exc = rb_arity_error_new(miss_argc, min_argc, max_argc);
     if (ISEQ_BODY(iseq)->param.flags.has_kw) {
@@ -1018,13 +1019,13 @@ argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const in
             RSTRING_PTR(mesg)[RSTRING_LEN(mesg)-1] = ')';
         }
     }
-    raise_argument_error(ec, iseq, exc);
+    raise_argument_error(ec, iseq, cme, exc);
 }
 
 static void
-argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const char *error, const VALUE keys)
+argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const char *error, const VALUE keys)
 {
-    raise_argument_error(ec, iseq, rb_keyword_error_new(error, keys));
+    raise_argument_error(ec, iseq, cme, rb_keyword_error_new(error, keys));
 }
 
 static VALUE
diff --git a/vm_insnhelper.c b/vm_insnhelper.c
@@ -170,7 +170,7 @@ vm_check_frame_detail(VALUE type, int req_block, int req_me, int req_cref, VALUE
         }
         else { /* cref or Qfalse */
             if (cref_or_me != Qfalse && cref_or_me_type != imemo_cref) {
-                if (((type & VM_FRAME_FLAG_LAMBDA) || magic == VM_FRAME_MAGIC_IFUNC) && (cref_or_me_type == imemo_ment)) {
+                if (((type & VM_FRAME_FLAG_LAMBDA) || magic == VM_FRAME_MAGIC_IFUNC || magic == VM_FRAME_MAGIC_DUMMY) && (cref_or_me_type == imemo_ment)) {
                     /* ignore */
                 }
                 else {
@@ -2909,7 +2909,7 @@ vm_call_iseq_setup_tailcall_opt_start(rb_execution_context_t *ec, rb_control_fra
 }
 
 static void
-args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *const iseq,
+args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *const iseq, const rb_callable_method_entry_t *cme,
                          VALUE *const passed_values, const int passed_keyword_len, const VALUE *const passed_keywords,
                          VALUE *const locals);
 
@@ -2953,7 +2953,7 @@ vm_call_iseq_setup_kwparm_kwarg(rb_execution_context_t *ec, rb_control_frame_t *
     const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
     VALUE * const ci_kws = ALLOCA_N(VALUE, ci_kw_len);
     MEMCPY(ci_kws, argv + lead_num, VALUE, ci_kw_len);
-    args_setup_kw_parameters(ec, iseq, ci_kws, ci_kw_len, ci_keywords, klocals);
+    args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), ci_kws, ci_kw_len, ci_keywords, klocals);
 
     int param = ISEQ_BODY(iseq)->param.size;
     int local = ISEQ_BODY(iseq)->local_table_size;
@@ -3084,7 +3084,7 @@ vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
             CALLER_SETUP_ARG(cfp, calling, ci, lead_num);
 
             if (calling->argc != lead_num) {
-                argument_arity_error(ec, iseq, calling->argc, lead_num, lead_num);
+                argument_arity_error(ec, iseq, vm_cc_cme(cc), calling->argc, lead_num, lead_num);
             }
 
             //VM_ASSERT(ci == calling->cd->ci);
@@ -3114,7 +3114,7 @@ vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
             const int opt = argc - lead_num;
 
             if (opt < 0 || opt > opt_num) {
-                argument_arity_error(ec, iseq, argc, lead_num, lead_num + opt_num);
+                argument_arity_error(ec, iseq, vm_cc_cme(cc), argc, lead_num, lead_num + opt_num);
             }
 
             if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {
@@ -3150,7 +3150,7 @@ vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
                     MEMCPY(ci_kws, argv + lead_num, VALUE, ci_kw_len);
 
                     VALUE *const klocals = argv + kw_param->bits_start - kw_param->num;
-                    args_setup_kw_parameters(ec, iseq, ci_kws, ci_kw_len, ci_keywords, klocals);
+                    args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), ci_kws, ci_kw_len, ci_keywords, klocals);
 
                     CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_kwarg,
                                     vm_call_cacheable(ci, cc));
@@ -3161,7 +3161,7 @@ vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
             else if (argc == lead_num) {
                 /* no kwarg */
                 VALUE *const klocals = argv + kw_param->bits_start - kw_param->num;
-                args_setup_kw_parameters(ec, iseq, NULL, 0, NULL, klocals);
+                args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), NULL, 0, NULL, klocals);
 
                 if (klocals[kw_param->num] == INT2FIX(0)) {
                     /* copy from default_values */
@@ -5207,7 +5207,7 @@ vm_callee_setup_block_arg(rb_execution_context_t *ec, struct rb_calling_info *ca
                 }
             }
             else {
-                argument_arity_error(ec, iseq, calling->argc, ISEQ_BODY(iseq)->param.lead_num, ISEQ_BODY(iseq)->param.lead_num);
+                argument_arity_error(ec, iseq, NULL, calling->argc, ISEQ_BODY(iseq)->param.lead_num, ISEQ_BODY(iseq)->param.lead_num);
             }
         }
 
@@ -5229,6 +5229,7 @@ vm_yield_setup_args(rb_execution_context_t *ec, const rb_iseq_t *iseq, const int
     calling->kw_splat = (flags & VM_CALL_KW_SPLAT) ?  1 : 0;
     calling->recv = Qundef;
     calling->heap_argv = 0;
+    calling->cc = NULL;
     struct rb_callinfo dummy_ci = VM_CI_ON_STACK(0, flags, 0, 0);
 
     return vm_callee_setup_block_arg(ec, calling, &dummy_ci, iseq, argv, arg_setup_type);

Original file line number	Diff line number	Diff line change
`@@ -8,9 +8,9 @@`
`8`	`8`
`9`	`9`	`**********************************************************************/`
`10`	`10`
`11`		`-NORETURN(static void raise_argument_error(rb_execution_context_t ec, const rb_iseq_t iseq, const VALUE exc));`
`12`		`-NORETURN(static void argument_arity_error(rb_execution_context_t ec, const rb_iseq_t iseq, const int miss_argc, const int min_argc, const int max_argc));`
`13`		`-NORETURN(static void argument_kw_error(rb_execution_context_t ec, const rb_iseq_t iseq, const char *error, const VALUE keys));`
	`11`	`+NORETURN(static void raise_argument_error(rb_execution_context_t ec, const rb_iseq_t iseq, const rb_callable_method_entry_t *cme, const VALUE exc));`
	`12`	`+NORETURN(static void argument_arity_error(rb_execution_context_t ec, const rb_iseq_t iseq, const rb_callable_method_entry_t *cme, const int miss_argc, const int min_argc, const int max_argc));`
	`13`	`+NORETURN(static void argument_kw_error(rb_execution_context_t ec, const rb_iseq_t iseq, const rb_callable_method_entry_t cme, const char error, const VALUE keys));`
`14`	`14`	`VALUE rb_keyword_error_new(const char error, VALUE keys); / class.c */`
`15`	`15`	`static VALUE method_missing(rb_execution_context_t ec, VALUE obj, ID id, int argc, const VALUE argv,`
`16`	`16`	`enum method_missing_reason call_status, int kw_splat);`
`@@ -321,7 +321,7 @@ args_setup_kw_parameters_lookup(const ID key, VALUE ptr, const VALUE const pas`
`321`	`321`	`#define KW_SPECIFIED_BITS_MAX (32-1) /* TODO: 32 -> Fixnum's max bits */`
`322`	`322`
`323`	`323`	`static void`
`324`		`-args_setup_kw_parameters(rb_execution_context_t const ec, const rb_iseq_t const iseq,`
	`324`	`+args_setup_kw_parameters(rb_execution_context_t const ec, const rb_iseq_t const iseq, const rb_callable_method_entry_t *cme,`
`325`	`325`	`VALUE const passed_values, const int passed_keyword_len, const VALUE const passed_keywords,`
`326`	`326`	`VALUE *const locals)`
`327`	`327`	`{`
`@@ -345,7 +345,7 @@ args_setup_kw_parameters(rb_execution_context_t const ec, const rb_iseq_t cons`
`345`	`345`	`}`
`346`	`346`	`}`
`347`	`347`
`348`		`- if (missing) argument_kw_error(ec, iseq, "missing", missing);`
	`348`	`+ if (missing) argument_kw_error(ec, iseq, cme, "missing", missing);`
`349`	`349`
`350`	`350`	`for (di=0; i<key_num; i++, di++) {`
`351`	`351`	`if (args_setup_kw_parameters_lookup(acceptable_keywords[i], &locals[i], passed_keywords, passed_values, passed_keyword_len)) {`
`@@ -386,7 +386,7 @@ args_setup_kw_parameters(rb_execution_context_t const ec, const rb_iseq_t cons`
`386`	`386`	`else {`
`387`	`387`	`if (found != passed_keyword_len) {`
`388`	`388`	`VALUE keys = make_unknown_kw_hash(passed_keywords, passed_keyword_len, passed_values);`
`389`		`- argument_kw_error(ec, iseq, "unknown", keys);`
	`389`	`+ argument_kw_error(ec, iseq, cme, "unknown", keys);`
`390`	`390`	`}`
`391`	`391`	`}`
`392`	`392`
`@@ -397,7 +397,7 @@ args_setup_kw_parameters(rb_execution_context_t const ec, const rb_iseq_t cons`
`397`	`397`	`}`
`398`	`398`
`399`	`399`	`static void`
`400`		`-args_setup_kw_parameters_from_kwsplat(rb_execution_context_t const ec, const rb_iseq_t const iseq,`
	`400`	`+args_setup_kw_parameters_from_kwsplat(rb_execution_context_t const ec, const rb_iseq_t const iseq, const rb_callable_method_entry_t *cme,`
`401`	`401`	`VALUE keyword_hash, VALUE *const locals, bool remove_hash_value)`
`402`	`402`	`{`
`403`	`403`	`const ID *acceptable_keywords = ISEQ_BODY(iseq)->param.keyword->table;`
`@@ -430,7 +430,7 @@ args_setup_kw_parameters_from_kwsplat(rb_execution_context_t *const ec, const rb`
`430`	`430`	`}`
`431`	`431`	`}`
`432`	`432`
`433`		`- if (missing) argument_kw_error(ec, iseq, "missing", missing);`
	`433`	`+ if (missing) argument_kw_error(ec, iseq, cme, "missing", missing);`
`434`	`434`
`435`	`435`	`for (di=0; i<key_num; i++, di++) {`
`436`	`436`	`VALUE key = ID2SYM(acceptable_keywords[i]);`
`@@ -485,11 +485,11 @@ args_setup_kw_parameters_from_kwsplat(rb_execution_context_t *const ec, const rb`
`485`	`485`	`* This is simpler than writing code to check which entries in the hash do not match.`
`486`	`486`	`* This will raise an exception, so the additional performance impact shouldn't be material.`
`487`	`487`	`*/`
`488`		`- args_setup_kw_parameters_from_kwsplat(ec, iseq, rb_hash_dup(keyword_hash), locals, true);`
	`488`	`+ args_setup_kw_parameters_from_kwsplat(ec, iseq, cme, rb_hash_dup(keyword_hash), locals, true);`
`489`	`489`	`}`
`490`	`490`	`}`
`491`	`491`	`else if (!RHASH_EMPTY_P(keyword_hash)) {`
`492`		`- argument_kw_error(ec, iseq, "unknown", rb_hash_keys(keyword_hash));`
	`492`	`+ argument_kw_error(ec, iseq, cme, "unknown", rb_hash_keys(keyword_hash));`
`493`	`493`	`}`
`494`	`494`	`}`
`495`	`495`
`@@ -607,6 +607,7 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co`
`607`	`607`	`VALUE splat_flagged_keyword_hash = 0;`
`608`	`608`	`VALUE converted_keyword_hash = 0;`
`609`	`609`	`VALUE rest_last = 0;`
	`610`	`+ const rb_callable_method_entry_t *cme = calling->cc ? vm_cc_cme(calling->cc) : NULL;`
`610`	`611`
`611`	`612`	`vm_check_canary(ec, orig_sp);`
`612`	`613`	`/*`
`@@ -861,7 +862,7 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co`
`861`	`862`	`args_extend(args, min_argc);`
`862`	`863`	`}`
`863`	`864`	`else {`
`864`		`- argument_arity_error(ec, iseq, given_argc, min_argc, max_argc);`
	`865`	`+ argument_arity_error(ec, iseq, cme, given_argc, min_argc, max_argc);`
`865`	`866`	`}`
`866`	`867`	`}`
`867`	`868`
`@@ -872,7 +873,7 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co`
`872`	`873`	`given_argc = max_argc;`
`873`	`874`	`}`
`874`	`875`	`else {`
`875`		`- argument_arity_error(ec, iseq, given_argc, min_argc, max_argc);`
	`876`	`+ argument_arity_error(ec, iseq, cme, given_argc, min_argc, max_argc);`
`876`	`877`	`}`
`877`	`878`	`}`
`878`	`879`
`@@ -918,15 +919,15 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co`
`918`	`919`
`919`	`920`	`if (args->kw_argv != NULL) {`
`920`	`921`	`const struct rb_callinfo_kwarg *kw_arg = args->kw_arg;`
`921`		`- args_setup_kw_parameters(ec, iseq, args->kw_argv, kw_arg->keyword_len, kw_arg->keywords, klocals);`
	`922`	`+ args_setup_kw_parameters(ec, iseq, cme, args->kw_argv, kw_arg->keyword_len, kw_arg->keywords, klocals);`
`922`	`923`	`}`
`923`	`924`	`else if (!NIL_P(keyword_hash)) {`
`924`	`925`	`bool remove_hash_value = false;`
`925`	`926`	`if (ISEQ_BODY(iseq)->param.flags.has_kwrest) {`
`926`	`927`	`keyword_hash = check_kwrestarg(keyword_hash, &kw_flag);`
`927`	`928`	`remove_hash_value = true;`
`928`	`929`	`}`
`929`		`- args_setup_kw_parameters_from_kwsplat(ec, iseq, keyword_hash, klocals, remove_hash_value);`
	`930`	`+ args_setup_kw_parameters_from_kwsplat(ec, iseq, cme, keyword_hash, klocals, remove_hash_value);`
`930`	`931`	`}`
`931`	`932`	`else {`
`932`	`933`	`#if VM_CHECK_MODE > 0`
`@@ -941,15 +942,15 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co`
`941`	`942`	`VM_ASSERT(args_argc(args) == 1);`
`942`	`943`	`}`
`943`	`944`	`#endif`
`944`		`- args_setup_kw_parameters(ec, iseq, NULL, 0, NULL, klocals);`
	`945`	`+ args_setup_kw_parameters(ec, iseq, cme, NULL, 0, NULL, klocals);`
`945`	`946`	`}`
`946`	`947`	`}`
`947`	`948`	`else if (ISEQ_BODY(iseq)->param.flags.has_kwrest) {`
`948`	`949`	`args_setup_kw_rest_parameter(keyword_hash, locals + ISEQ_BODY(iseq)->param.keyword->rest_start,`
`949`	`950`	`kw_flag, ISEQ_BODY(iseq)->param.flags.anon_kwrest);`
`950`	`951`	`}`
`951`	`952`	`else if (!NIL_P(keyword_hash) && RHASH_SIZE(keyword_hash) > 0 && arg_setup_type == arg_setup_method) {`
`952`		`- argument_kw_error(ec, iseq, "unknown", rb_hash_keys(keyword_hash));`
	`953`	`+ argument_kw_error(ec, iseq, cme, "unknown", rb_hash_keys(keyword_hash));`
`953`	`954`	`}`
`954`	`955`
`955`	`956`	`if (ISEQ_BODY(iseq)->param.flags.has_block) {`
`@@ -975,13 +976,13 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co`
`975`	`976`	`}`
`976`	`977`
`977`	`978`	`static void`
`978`		`-raise_argument_error(rb_execution_context_t ec, const rb_iseq_t iseq, const VALUE exc)`
	`979`	`+raise_argument_error(rb_execution_context_t ec, const rb_iseq_t iseq, const rb_callable_method_entry_t *cme, const VALUE exc)`
`979`	`980`	`{`
`980`	`981`	`VALUE at;`
`981`	`982`
`982`	`983`	`if (iseq) {`
`983`	`984`	`vm_push_frame(ec, iseq, VM_FRAME_MAGIC_DUMMY \| VM_ENV_FLAG_LOCAL, Qnil /* self */,`
`984`		`- VM_BLOCK_HANDLER_NONE /* specval/, Qfalse / me or cref */,`
	`985`	`+ VM_BLOCK_HANDLER_NONE /* specval/, (VALUE) cme / me or cref */,`
`985`	`986`	`ISEQ_BODY(iseq)->iseq_encoded,`
`986`	`987`	`ec->cfp->sp, 0, 0 /* stack_max */);`
`987`	`988`	`at = rb_ec_backtrace_object(ec);`
`@@ -997,7 +998,7 @@ raise_argument_error(rb_execution_context_t ec, const rb_iseq_t iseq, const VA`
`997`	`998`	`}`
`998`	`999`
`999`	`1000`	`static void`
`1000`		`-argument_arity_error(rb_execution_context_t ec, const rb_iseq_t iseq, const int miss_argc, const int min_argc, const int max_argc)`
	`1001`	`+argument_arity_error(rb_execution_context_t ec, const rb_iseq_t iseq, const rb_callable_method_entry_t *cme, const int miss_argc, const int min_argc, const int max_argc)`
`1001`	`1002`	`{`
`1002`	`1003`	`VALUE exc = rb_arity_error_new(miss_argc, min_argc, max_argc);`
`1003`	`1004`	`if (ISEQ_BODY(iseq)->param.flags.has_kw) {`
`@@ -1018,13 +1019,13 @@ argument_arity_error(rb_execution_context_t ec, const rb_iseq_t iseq, const in`
`1018`	`1019`	`RSTRING_PTR(mesg)[RSTRING_LEN(mesg)-1] = ')';`
`1019`	`1020`	`}`
`1020`	`1021`	`}`
`1021`		`- raise_argument_error(ec, iseq, exc);`
	`1022`	`+ raise_argument_error(ec, iseq, cme, exc);`
`1022`	`1023`	`}`
`1023`	`1024`
`1024`	`1025`	`static void`
`1025`		`-argument_kw_error(rb_execution_context_t ec, const rb_iseq_t iseq, const char *error, const VALUE keys)`
	`1026`	`+argument_kw_error(rb_execution_context_t ec, const rb_iseq_t iseq, const rb_callable_method_entry_t cme, const char error, const VALUE keys)`
`1026`	`1027`	`{`
`1027`		`- raise_argument_error(ec, iseq, rb_keyword_error_new(error, keys));`
	`1028`	`+ raise_argument_error(ec, iseq, cme, rb_keyword_error_new(error, keys));`
`1028`	`1029`	`}`
`1029`	`1030`
`1030`	`1031`	`static VALUE`