Fix a design issue in the debug inspector API

Previously, a user of the debug inspector API was supposed to use
`rb_debug_inspector_backtrace_locations` to get an array of
`Thread::Backtrace::Location`, and then used its index to get more
information from `rb_debug_inspector _frame_binding_get(index)`, etc.

However, `rb_debug_inspector_backtrace_locations` returned an array of
backtraces excluding rescue/ensure frames. On the other hand,
`rb_debug_inspector_frame_binding_get(index)` interprets index with
rescue/ensure frames. This led to inconsistency of the index, and it was
very difficult to correctly use the debug inspector API.

This change deprecates `rb_debug_inspector_backtrace_locations` and
introduces instead `rb_debug_inspector_frame_loc_get(index)`, which
returns a `Thread::Backtrace::Location` object for the frame specified
by `index`. Also `rb_debug_inspector_frame_count` is introduced to get
the length of the backtrace.

Author: mame

ext/-test-/debug/inspector.c

@@ -4,8 +4,7 @@
 static VALUE
 callback(const rb_debug_inspector_t *dbg_context, void *data)
 {
-    VALUE locs = rb_debug_inspector_backtrace_locations(dbg_context);
-    long i, len = RARRAY_LEN(locs);
+    long i, len = rb_debug_inspector_frame_count(dbg_context);
     VALUE binds = rb_ary_new();
     for (i = 0; i < len; ++i) {
         VALUE entry = rb_ary_new();
@@ -14,7 +13,7 @@ callback(const rb_debug_inspector_t *dbg_context, void *data)
         rb_ary_push(entry, rb_debug_inspector_frame_binding_get(dbg_context, i));
         rb_ary_push(entry, rb_debug_inspector_frame_class_get(dbg_context, i));
         rb_ary_push(entry, rb_debug_inspector_frame_iseq_get(dbg_context, i));
-        rb_ary_push(entry, rb_ary_entry(locs, i));
+        rb_ary_push(entry, rb_debug_inspector_frame_loc_get(dbg_context, i));
     }
     return binds;
 }

include/ruby/debug.h

@@ -233,10 +233,22 @@ VALUE rb_debug_inspector_open(rb_debug_inspector_func_t func, void *data);
  * @param[in]  dc  A debug context.
  * @return     An array  of `Thread::Backtrace::Location` which  represents the
  *             current point of execution at `dc`.
+ * @deprecated This API returns a backtrace with makeup applied. (Specifically,
+ *             rescue and ensure frames are excluded.) Therefore, inconsistency
+ *             occurs between the index of this backtrace object and the index of
+ *             arguments such as rb_debug_inspector_frame_self_get.
 
  */
 VALUE rb_debug_inspector_backtrace_locations(const rb_debug_inspector_t *dc);
 
+/**
+ * Returns the frame count of the context.
+ *
+ * @param[in]  dc  A debug context.
+ * @return     The count of the frames.
+ */
+VALUE rb_debug_inspector_frame_count(const rb_debug_inspector_t *dc);
+
 /**
  * Queries the current receiver of the passed context's upper frame.
  *
@@ -280,6 +292,16 @@ VALUE rb_debug_inspector_frame_binding_get(const rb_debug_inspector_t *dc, long
  */
 VALUE rb_debug_inspector_frame_iseq_get(const rb_debug_inspector_t *dc, long index);
 
+/**
+ * Queries the backtrace location object of the passed context's upper frame.
+ *
+ * @param[in]  dc           A debug context.
+ * @param[in]  index        Index of the frame from top to bottom.
+ * @exception  rb_eArgError `index` out of range.
+ * @retval     The backtrace location object at `index`-th frame in Integer.
+ */
+VALUE rb_debug_inspector_frame_loc_get(const rb_debug_inspector_t *dc, long index);
+
 /**
  * Queries the depth of the passed context's upper frame.
  *

vm_backtrace.c

@@ -1504,18 +1504,22 @@ enum {
     CALLER_BINDING_BINDING,
     CALLER_BINDING_ISEQ,
     CALLER_BINDING_CFP,
+    CALLER_BINDING_LOC,
     CALLER_BINDING_DEPTH,
 };
 
 struct collect_caller_bindings_data {
     VALUE ary;
     const rb_execution_context_t *ec;
+    VALUE btobj;
+    rb_backtrace_t *bt;
 };
 
 static void
-collect_caller_bindings_init(void *arg, size_t size)
+collect_caller_bindings_init(void *arg, size_t num_frames)
 {
-    /* */
+    struct collect_caller_bindings_data *data = (struct collect_caller_bindings_data *)arg;
+    data->btobj = backtrace_alloc_capa(num_frames, &data->bt);
 }
 
 static VALUE
@@ -1546,13 +1550,21 @@ static void
 collect_caller_bindings_iseq(void *arg, const rb_control_frame_t *cfp)
 {
     struct collect_caller_bindings_data *data = (struct collect_caller_bindings_data *)arg;
-    VALUE frame = rb_ary_new2(6);
+    VALUE frame = rb_ary_new2(7);
 
     rb_ary_store(frame, CALLER_BINDING_SELF, cfp->self);
     rb_ary_store(frame, CALLER_BINDING_CLASS, get_klass(cfp));
     rb_ary_store(frame, CALLER_BINDING_BINDING, GC_GUARDED_PTR(cfp)); /* create later */
     rb_ary_store(frame, CALLER_BINDING_ISEQ, cfp->iseq ? (VALUE)cfp->iseq : Qnil);
     rb_ary_store(frame, CALLER_BINDING_CFP, GC_GUARDED_PTR(cfp));
+
+    rb_backtrace_location_t *loc = &data->bt->backtrace[RARRAY_LEN(data->ary)];
+    RB_OBJ_WRITE(data->btobj, &loc->cme, rb_vm_frame_method_entry(cfp));
+    RB_OBJ_WRITE(data->btobj, &loc->iseq, cfp->iseq);
+    loc->pc = cfp->pc;
+    VALUE vloc = location_create(loc, (void *)data->btobj);
+    rb_ary_store(frame, CALLER_BINDING_LOC, vloc);
+
     rb_ary_store(frame, CALLER_BINDING_DEPTH, INT2FIX(frame_depth(data->ec, cfp)));
 
     rb_ary_push(data->ary, frame);
@@ -1562,13 +1574,21 @@ static void
 collect_caller_bindings_cfunc(void *arg, const rb_control_frame_t *cfp, ID mid)
 {
     struct collect_caller_bindings_data *data = (struct collect_caller_bindings_data *)arg;
-    VALUE frame = rb_ary_new2(6);
+    VALUE frame = rb_ary_new2(7);
 
     rb_ary_store(frame, CALLER_BINDING_SELF, cfp->self);
     rb_ary_store(frame, CALLER_BINDING_CLASS, get_klass(cfp));
     rb_ary_store(frame, CALLER_BINDING_BINDING, Qnil); /* not available */
     rb_ary_store(frame, CALLER_BINDING_ISEQ, Qnil); /* not available */
     rb_ary_store(frame, CALLER_BINDING_CFP, GC_GUARDED_PTR(cfp));
+
+    rb_backtrace_location_t *loc = &data->bt->backtrace[RARRAY_LEN(data->ary)];
+    RB_OBJ_WRITE(data->btobj, &loc->cme, rb_vm_frame_method_entry(cfp));
+    loc->iseq = NULL;
+    loc->pc = NULL;
+    VALUE vloc = location_create(loc, (void *)data->btobj);
+    rb_ary_store(frame, CALLER_BINDING_LOC, vloc);
+
     rb_ary_store(frame, CALLER_BINDING_DEPTH, INT2FIX(frame_depth(data->ec, cfp)));
 
     rb_ary_push(data->ary, frame);
@@ -1645,12 +1665,18 @@ rb_debug_inspector_open(rb_debug_inspector_func_t func, void *data)
 static VALUE
 frame_get(const rb_debug_inspector_t *dc, long index)
 {
-    if (index < 0 || index >= dc->backtrace_size) {
+    if (index < 0 || index >= RARRAY_LEN(dc->contexts)) {
         rb_raise(rb_eArgError, "no such frame");
     }
     return rb_ary_entry(dc->contexts, index);
 }
 
+VALUE
+rb_debug_inspector_frame_count(const rb_debug_inspector_t *dc)
+{
+    return RARRAY_LEN(dc->contexts);
+}
+
 VALUE
 rb_debug_inspector_frame_self_get(const rb_debug_inspector_t *dc, long index)
 {
@@ -1681,6 +1707,13 @@ rb_debug_inspector_frame_iseq_get(const rb_debug_inspector_t *dc, long index)
     return RTEST(iseq) ? rb_iseqw_new((rb_iseq_t *)iseq) : Qnil;
 }
 
+VALUE
+rb_debug_inspector_frame_loc_get(const rb_debug_inspector_t *dc, long index)
+{
+    VALUE frame = frame_get(dc, index);
+    return rb_ary_entry(frame, CALLER_BINDING_LOC);
+}
+
 VALUE
 rb_debug_inspector_frame_depth(const rb_debug_inspector_t *dc, long index)
 {