debug 1.3.3 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2f3adfa33baa3d7ef0a8ff1924d4d148be909f8cbdfc1992efda7e4ef564a17
-  data.tar.gz: 43085e7bec187d698d42bf7a4fc7c3ee2f4cde387cf411b2648411dc6cbb1721
+  metadata.gz: 121cdb1003971d234dbeb40878f693d06053fa32f28024c5d2a7c0e0fd6d3719
+  data.tar.gz: fd95c68d4bf99b38a83cef1a6851680bb9abb65d39fa9fc69a94d248295a5829
 SHA512:
-  metadata.gz: 5bafcaeeb661378a3696968655cfc9b24aadb6c0ada385d143406472db4cc1a51d55bb460431ef9679d8e6ffe846c269f731335380999256565b2d259139f2d9
-  data.tar.gz: 961d6a453a4f117af9e056658d31afc39e173668f32eb1745f0bdad842c4891a2b6bff0bfec45d6e17fc94108da3ac4a5274118a4f0213ae0a2a5a181de89f99
+  metadata.gz: 4354a11670db6e0fd49e4b8151b268a08c7843c80ccd36b5c492cf5fabc7b42c6632939905b9912c81434f5513e36dac8378686b5d47c274248c523eea88a0c8
+  data.tar.gz: e22274473f567bed800c25d46a46d32adf263f070e8147cd71778ef9cbd95b8e239e2912b226892f032266a92322045a62e7f9c908f176e601a984e254acd2a7

data/CONTRIBUTING.md

@@ -26,11 +26,17 @@ $ ruby test/debug/bp_test.rb -h # to see all the test options
 ```
 
 ## Generate Tests
+
 There is a test generator in `debug.rb` project to make it easier to write tests.
+
 ### Quickstart
-This section shows you how to create test file by test generator. For more advanced informations on creating tests, please take a look at [gentest options](#gentest-options). (You can also check by `$bin/gentest -h`)
+
+This section shows you how to create test file by test generator. For more advanced information on creating tests, please take a look at [gentest options](#gentest-options). (You can also check by `$bin/gentest -h`)
+
 #### 1. Create a target file for debuggee.
+
 Let's say, we created `target.rb` which is located in top level directory of debugger.
+
 ```ruby
 module Foo
   class Bar
@@ -42,11 +48,15 @@ module Foo
   bar = Bar.new
 end
 ```
+
 #### 2. Run `gentest` as shown in the example below.
+
 ```shell
 $ bin/gentest target.rb
 ```
+
 #### 3. Debugger will be executed. You can type any debug commands.
+
 ```shell
 $ bin/gentest target.rb
 DEBUGGER: Session start (pid: 11139)
@@ -119,8 +129,11 @@ created: /Users/naotto/workspace/debug/test/tool/../debug/foo_test.rb
     class: FooTest
     method: test_1629720194
 ```
+
 #### 4. The test file will be created as `test/debug/foo_test.rb`.
+
 If the file already exists, **only method** will be added to it.
+
 ```ruby
 # frozen_string_literal: true
 
@@ -204,17 +217,161 @@ end
 ```
 
 #### gentest options
+
 You can get more information about `gentest` here.
 
-The default method name is `test_#{some integer numbers}`, the class name is `FooTest`, and the file name will be `foo_test.rb`.
+The default method name is `test_#{some integer numbers}`, the class name is `FooTest#{some integer numbers}`, and the file name will be `foo_test.rb`.
 The following table shows examples of the gentest options.
 
 | Command | Description | File | Class | Method |
 | --- | --- | --- | --- | --- |
-| `$ bin/gentest target.rb` | Run without any options | `foo_test.rb` | `FooTest` | `test_#{some integer numbers}` |
-| `$ bin/gentest target.rb -c step` | Specify the class name | `step_test.rb` | `StepTest` | `test_#{some integer numbers}` |
-| `$ bin/gentest target.rb -m test_step` | Specify the method name | `foo_test.rb` | `FooTest` | `test_step` |
-| `$ bin/gentest target.rb -c step -m test_step` | Specify the class name and the method name | `step_test.rb` | `StepTest` | `test_step` |
+| `$ bin/gentest target.rb` | Run without any options | `foo_test.rb` | `FooTest...` | `test_...` |
+| `$ bin/gentest target.rb --open=vscode` | Run the debugger with VScode | `foo_test.rb` | `FooTest...` | `test_...` |
+| `$ bin/gentest target.rb -c step` | Specify the class name | `step_test.rb` | `StepTest...` | `test_...` |
+| `$ bin/gentest target.rb -m test_step` | Specify the method name | `foo_test.rb` | `FooTest...` | `test_step` |
+| `$ bin/gentest target.rb -c step -m test_step` | Specify the class name and the method name | `step_test.rb` | `StepTest...` | `test_step` |
+
+### Assertions
+
+- assert_line_num(expected)
+
+Passes if `expected` is equal to the location where debugger stops.
+
+- assert_line_text(text)
+
+Passes if `text` is included in the last debugger log.
+
+- assert_no_line_text(text)
+
+Passes if `text` is not included in the last debugger log.
+
+- assert_debuggee_line_text(text)
+
+Passes if `text` is included in the debuggee log.
+
+### Tests for DAP and CDP
+
+Currently, there are 2 kinds of test frameworks for DAP and CDP.
+
+1. Protocol-based tests
+
+If you want to write protocol-based tests, you should use the test generator.
+To run the test generator, you can enter `$ bin/gentest target.rb --open=vscode` in the terminal, VSCode will be executed.
+Also, if you enter ``$ bin/gentest target.rb --open=chrome` there, Chrome will be executed.
+If you need to modify existing tests, it is basically a good idea to regenerate them by the test generator instead of rewriting them directly.
+Please refer to [the Microsoft "Debug Adapter Protocol" article](https://microsoft.github.io/debug-adapter-protocol/specification) to learn more about DAP formats.
+Please refer to [Procol viewer for "Chrome DevTools Protocol"](https://chromedevtools.github.io/devtools-protocol/) to learn more about CDP formats.
+
+2. High-level tests
+
+High-level tests are designed to test both DAP and CDP for a single method.
+You can write tests as follows:
+**NOTE:** Use `req_terminate_debuggee` to finish debugging. You can't use any methods such as `req_continue`, `req_next` and so on.
+
+```ruby
+require_relative '../support/test_case'
+module DEBUGGER__
+  class BreakTest < TestCase
+    # PROGRAM is the target script.
+    PROGRAM = <<~RUBY
+      1| module Foo
+      2|   class Bar
+      3|     def self.a
+      4|       "hello"
+      5|     end
+      6|   end
+      7|   Bar.a
+      8|   bar = Bar.new
+      9| end
+    RUBY
+
+    def test_break1
+      run_protocol_scenario PROGRAM do # Start debugging with DAP and CDP
+        req_add_breakpoint 5 # Set a breakpoint on line 5.
+        req_add_breakpoint 8 # Set a breakpoint on line 8.
+        req_continue # Resume the program.
+        assert_line_num 5 # Check if debugger stops at line 5.
+        req_continue # Resume the program.
+        assert_line_num 8 # Check if debugger stops at line 8.
+        req_terminate_debuggee # Terminate debugging.
+      end
+    end
+  end
+end
+```
+
+#### API
+
+- run_protocol_scenario program, dap: true, cdp: true, &scenario
+
+Execute debugging `program` with `&scenario`. If you want to test it only for DAP, you can write as follows:
+
+`run_protocol_scenario program, cdp: false ...`
+
+- req_add_breakpoint(lineno, path: temp_file_path, cond: nil)
+
+Sends request to rdbg to add a breakpoint.
+
+- req_delete_breakpoint bpnum
+
+Sends request to rdbg to delete a breakpoint.
+
+- req_set_exception_breakpoints
+
+Sends request to rdbg to set exception breakpoints.
+
+- req_continue
+
+Sends request to rdbg to resume the program.
+
+- req_step
+
+Sends request to rdbg to step into next method.
+
+- req_next
+
+Sends request to rdbg to step over next method.
+
+- req_finish
+
+Sends request to rdbg to step out of current method.
+
+- req_step_back
+
+Sends request to rdbg to step back from current method.
+
+- req_terminate_debuggee
+
+Sends request to rdbg to terminate the debuggee.
+
+- assert_reattach
+
+Passes if reattaching to rdbg is successful.
+
+- assert_hover_result(expected, expression: nil)
+
+Passes if result of `expression` is equal to `expected`.
+
+- assert_repl_result(expected, expression: nil)
+
+Passes if result of `expression` is equal to `expected`.
+
+- assert_watch_result(expected, expression: nil)
+
+Passes if result of `expression` is equal to `expected`.
+
+- assert_line_num(expected)
+
+Passes if `expected` is equal to the location where debugger stops.
+
+- assert_locals_result(expected)
+
+Passes if all of `expected` local variable entries match the ones returned by debugger.
+
+An variable entry looks like this: `{ name: "bar", value: "nil", type: "NilClass" }`.
+
+Please note that both `value` and `type` need to be strings.
+
 
 ## To Update README
 

data/Gemfile

@@ -6,3 +6,4 @@ gem "rake"
 gem "rake-compiler"
 gem "test-unit", "~> 3.0"
 gem "test-unit-rr"
+gem "json-schema"

data/README.md

@@ -1,8 +1,8 @@
-[![Ruby](https://github.com/ruby/debug/actions/workflows/ruby.yml/badge.svg?branch=master)](https://github.com/ruby/debug/actions/workflows/ruby.yml?query=branch%3Amaster)
+[![Ruby](https://github.com/ruby/debug/actions/workflows/ruby.yml/badge.svg?branch=master)](https://github.com/ruby/debug/actions/workflows/ruby.yml?query=branch%3Amaster) [![Protocol](https://github.com/ruby/debug/actions/workflows/protocol.yml/badge.svg)](https://github.com/ruby/debug/actions/workflows/protocol.yml)
 
 # debug.rb
 
-This library provides debugging functionality to Ruby.
+This library provides debugging functionality to Ruby (MRI) 2.6 and later.
 
 This debug.rb is replacement of traditional lib/debug.rb standard library which is implemented by `set_trace_func`.
 New debug.rb has several advantages:
@@ -60,8 +60,14 @@ There are several options for (1) and (2). Please choose your favorite way.
 
 ### Modify source code with [`binding.break`](#bindingbreak-method) (similar to `binding.pry` or `binding.irb`)
 
-If you can modify the source code, you can use the debugger by adding `require 'debug'` line at the top of your program and putting [`binding.break`](#bindingbreak-method) method (`binding.b` for short) into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
-After that, you run the program as usual and you will enter the debug console at breakpoints you inserted.
+If you can modify the source code, you can use the debugger by adding `require 'debug'` at the top of your program and putting [`binding.break`](#bindingbreak-method) method into lines where you want to stop as breakpoints like `binding.pry` and `binding.irb`.
+
+You can also use its 2 aliases in the same way:
+
+- `binding.b`
+- `debugger`
+
+After that, run the program as usual and you will enter the debug console at breakpoints you inserted.
 
 The following example shows the demonstration of [`binding.break`](#bindingbreak-method).
 
@@ -107,7 +113,7 @@ d => nil
       5| binding.break
       6| c = 3
       7| d = 4
-=>    8| binding.break                 # Again the program stops at here
+=>    8| binding.break                 # Again the program stops here
       9| p [a, b, c, d]
      10|
      11| __END__
@@ -346,12 +352,14 @@ You can attach with external debugger frontend with VSCode and Chrome.
 $ rdbg --open=[frontend] target.rb
 ```
 
-will open a debug port and `[frontned]` can attache to the port.
+will open a debug port and `[frontend]` can attach to the port.
 
 Also `open` command allows opening the debug port.
 
 #### VSCode integration
 
+([vscode-rdbg v0.0.9](https://marketplace.visualstudio.com/items?itemName=KoichiSasada.vscode-rdbg) or later is required)
+
 If you don't run a debuggee Ruby process on VSCode, you can attach with VSCode later with the following steps.
 
 `rdbg --open=vscode` opens the debug port and tries to invoke the VSCode (`code` command).
@@ -411,7 +419,7 @@ Note that you can attach with `rdbg --attach` and continue REPL debugging.
 
 #### Chrome DevTool integration
 
-With `rdbg --open=chrome` command will shows the following message.
+With `rdbg --open=chrome` command will show the following message.
 
 ```
 $ rdbg target.rb --open=chrome
@@ -427,7 +435,7 @@ Type `devtools://devtools/bundled/inspector.html?ws=127.0.0.1:43633` in the addr
 
 Also `open chrome` command works like `open vscode`.
 
-For more information about how to use Chrome debugging, you might want to read [here](https://developer.chrome.com/docs/devtools/)
+For more information about how to use Chrome debugging, you might want to read [here](https://developer.chrome.com/docs/devtools/).
 
 ## Configuration
 
@@ -479,6 +487,7 @@ config set no_color true
   * `RUBY_DEBUG_SOCK_DIR` (`sock_dir`): UNIX Domain Socket remote debugging: socket directory
   * `RUBY_DEBUG_COOKIE` (`cookie`): Cookie for negotiation
   * `RUBY_DEBUG_OPEN_FRONTEND` (`open_frontend`): frontend used by open command (vscode, chrome, default: rdbg).
+  * `RUBY_DEBUG_CHROME_PATH` (`chrome_path`): Platform dependent path of Chrome (For more information, See [here](https://github.com/ruby/debug/pull/334/files#diff-5fc3d0a901379a95bc111b86cf0090b03f857edfd0b99a0c1537e26735698453R55-R64))
 
 * OBSOLETE
   * `RUBY_DEBUG_PARENT_ON_FORK` (`parent_on_fork`): Keep debugging parent process on fork (default: false)
@@ -525,7 +534,7 @@ The `<...>` notation means the argument.
 * `fin[ish]`
   * Finish this frame. Resume the program until the current frame is finished.
 * `fin[ish] <n>`
-  * Finish frames, same as `step <n>`.
+  * Finish `<n>`th frames.
 * `c[ontinue]`
   * Resume the program.
 * `q[uit]` or `Ctrl-D`
@@ -533,11 +542,11 @@ The `<...>` notation means the argument.
 * `q[uit]!`
   * Same as q[uit] but without the confirmation prompt.
 * `kill`
-  * Stop the debuggee process with `Kernal#exit!`.
+  * Stop the debuggee process with `Kernel#exit!`.
 * `kill!`
   * Same as kill but without the confirmation prompt.
 * `sigint`
-  * Execute SIGINT handler registerred by the debuggee.
+  * Execute SIGINT handler registered by the debuggee.
   * Note that this command should be used just after stop by `SIGINT`.
 
 ### Breakpoint
@@ -558,14 +567,32 @@ The `<...>` notation means the argument.
   * break and run `<command>` before stopping.
 * `b[reak] ... do: <command>`
   * break and run `<command>`, and continue.
+* `b[reak] ... path: <path>`
+  * break if the path matches to `<path>`. `<path>` can be a regexp with `/regexp/`.
 * `b[reak] if: <expr>`
   * break if: `<expr>` is true at any lines.
   * Note that this feature is super slow.
 * `catch <Error>`
   * Set breakpoint on raising `<Error>`.
+* `catch ... if: <expr>`
+  * stops only if `<expr>` is true as well.
+* `catch ... pre: <command>`
+  * runs `<command>` before stopping.
+* `catch ... do: <command>`
+  * stops and run `<command>`, and continue.
+* `catch ... path: <path>`
+  * stops if the exception is raised from a `<path>`. `<path>` can be a regexp with `/regexp/`.
 * `watch @ivar`
   * Stop the execution when the result of current scope's `@ivar` is changed.
   * Note that this feature is super slow.
+* `watch ... if: <expr>`
+  * stops only if `<expr>` is true as well.
+* `watch ... pre: <command>`
+  * runs `<command>` before stopping.
+* `watch ... do: <command>`
+  * stops and run `<command>`, and continue.
+* `watch ... path: <path>`
+  * stops if the path matches `<path>`. `<path>` can be a regexp with `/regexp/`.
 * `del[ete]`
   * delete all breakpoints.
 * `del[ete] <bpnum>`
@@ -604,8 +631,8 @@ The `<...>` notation means the argument.
   * Show information about accessible constants except toplevel constants.
 * `i[nfo] g[lobal[s]]`
   * Show information about global variables
-* `i[nfo] ... </pattern/>`
-  * Filter the output with `</pattern/>`.
+* `i[nfo] ... /regexp/`
+  * Filter the output with `/regexp/`.
 * `i[nfo] th[read[s]]`
   * Show all threads (same as `th[read]`).
 * `o[utline]` or `ls`
@@ -656,8 +683,8 @@ The `<...>` notation means the argument.
   * Add an exception tracer. It indicates raising exceptions.
 * `trace object <expr>`
   * Add an object tracer. It indicates that an object by `<expr>` is passed as a parameter or a receiver on method call.
-* `trace ... </pattern/>`
-  * Indicates only matched events to `</pattern/>` (RegExp).
+* `trace ... /regexp/`
+  * Indicates only matched events to `/regexp/`.
 * `trace ... into: <file>`
   * Save trace information into: `<file>`.
 * `trace off <num>`

data/Rakefile

@@ -2,8 +2,6 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
@@ -17,7 +15,6 @@ begin
 rescue LoadError
 end
 
-
 task :default => [:clobber, :compile, 'README.md', :test]
 
 file 'README.md' => ['lib/debug/session.rb', 'lib/debug/config.rb',
@@ -28,7 +25,10 @@ file 'README.md' => ['lib/debug/session.rb', 'lib/debug/config.rb',
   puts 'README.md is updated.'
 end
 
-task :run => :compile do
-  system(RbConfig.ruby, *%w(-I ./lib test.rb))
+task :test_protocol do
+  ENV['RUBY_DEBUG_PROTOCOL_TEST'] = '1'
 end
 
+Rake::TestTask.new(:test_protocol) do |t|
+  t.test_files = FileList["test/protocol/*_test.rb"]
+end

data/debug.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["ko1@atdot.net"]
 
   spec.summary       = %q{Debugging functionality for Ruby}
-  spec.description   = %q{Debugging functionality for Ruby. This is completely rewritten debug.rb which was contained by the encient Ruby versions.}
+  spec.description   = %q{Debugging functionality for Ruby. This is completely rewritten debug.rb which was contained by the ancient Ruby versions.}
   spec.homepage      = "https://github.com/ruby/debug"
   spec.licenses      = ["Ruby", "BSD-2-Clause"]
   spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
@@ -17,11 +17,13 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
   end
   spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions    = ['ext/debug/extconf.rb']
 

data/ext/debug/debug.c

@@ -32,7 +32,10 @@ di_entry(VALUE loc, VALUE self, VALUE binding, VALUE iseq, VALUE klass, VALUE de
                          // :show_line, :local_variables
                          Qnil,
                          // :_local_variables, :_callee # for recorder
-                         Qnil, Qnil);
+                         Qnil, Qnil,
+                         // :dupped_binding
+                         Qnil
+                         );
 }
 
 static int
@@ -115,11 +118,82 @@ create_method_added_tracker(VALUE self)
     return rb_tracepoint_new(0, RUBY_EVENT_CALL, method_added_tracker, NULL);
 }
 
+// iseq
+
+const struct rb_iseq *rb_iseqw_to_iseq(VALUE iseqw);
+
+#ifdef HAVE_RB_ISEQ_TYPE
+VALUE rb_iseq_type(const struct rb_iseq *);
+
+static VALUE
+iseq_type(VALUE iseqw)
+{
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    return rb_iseq_type(iseq);
+}
+#endif
+
+#ifdef HAVE_RB_ISEQ_PARAMETERS
+VALUE rb_iseq_parameters(const struct rb_iseq *, int is_proc);
+
+static VALUE
+iseq_parameters_symbols(VALUE iseqw)
+{
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    VALUE params = rb_iseq_parameters(iseq, 0);
+    VALUE ary = rb_ary_new();
+
+    static VALUE sym_ast, sym_astast, sym_amp;
+
+    if (sym_ast == 0) {
+        sym_ast = ID2SYM(rb_intern("*"));
+        sym_astast = ID2SYM(rb_intern("**"));
+        sym_amp = ID2SYM(rb_intern("&"));
+    }
+
+    for (long i=0; i<RARRAY_LEN(params); i++) {
+        VALUE e = RARRAY_AREF(params, i);
+        if (RARRAY_LEN(e) == 2) {
+            VALUE sym = RARRAY_AREF(e, 1);
+            if (sym != sym_ast &&
+                sym != sym_astast &&
+                sym != sym_amp) rb_ary_push(ary, RARRAY_AREF(e, 1));
+        }
+    }
+
+    return ary;
+}
+#endif
+
+#ifdef HAVE_RB_ISEQ_CODE_LOCATION
+void rb_iseq_code_location(const struct rb_iseq *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);
+
+static VALUE
+iseq_first_line(VALUE iseqw)
+{
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    int line;
+    rb_iseq_code_location(iseq, &line, NULL, NULL, NULL);
+    return INT2NUM(line);
+}
+
+static VALUE
+iseq_last_line(VALUE iseqw)
+{
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    int line;
+    rb_iseq_code_location(iseq, NULL, NULL, &line, NULL);
+    return INT2NUM(line);
+}
+#endif
+
 void Init_iseq_collector(void);
 
 void
 Init_debug(void)
 {
+    VALUE rb_mRubyVM = rb_const_get(rb_cObject, rb_intern("RubyVM"));
+    VALUE rb_cISeq = rb_const_get(rb_mRubyVM, rb_intern("InstructionSequence"));
     rb_mDebugger = rb_const_get(rb_cObject, rb_intern("DEBUGGER__"));
     rb_cFrameInfo = rb_const_get(rb_mDebugger, rb_intern("FrameInfo"));
 
@@ -131,5 +205,18 @@ Init_debug(void)
     rb_define_singleton_method(rb_mDebugger, "frame_depth", frame_depth, 0);
     rb_define_singleton_method(rb_mDebugger, "create_method_added_tracker", create_method_added_tracker, 0);
     rb_define_const(rb_mDebugger, "SO_VERSION", rb_str_new2(RUBY_DEBUG_VERSION));
+
+    // iseq
+#ifdef HAVE_RB_ISEQ_TYPE
+    rb_define_method(rb_cISeq, "type", iseq_type, 0);
+#endif
+#ifdef HAVE_RB_ISEQ_PARAMETERS
+    rb_define_method(rb_cISeq, "parameters_symbols", iseq_parameters_symbols, 0);
+#endif
+#ifdef HAVE_RB_ISEQ_CODE_LOCATION
+    rb_define_method(rb_cISeq, "first_line", iseq_first_line, 0);
+    rb_define_method(rb_cISeq, "last_line", iseq_last_line, 0);
+#endif
+
     Init_iseq_collector();
 }

data/ext/debug/extconf.rb

@@ -1,4 +1,15 @@
 require 'mkmf'
 require_relative '../../lib/debug/version'
 File.write("debug_version.h", "#define RUBY_DEBUG_VERSION \"#{DEBUGGER__::VERSION}\"\n")
+
+have_func "rb_iseq_parameters(NULL, 0)",
+          [["VALUE rb_iseq_parameters(void *, int is_proc);"]]
+
+have_func "rb_iseq_code_location(NULL, NULL, NULL, NULL, NULL)",
+          [["void rb_iseq_code_location(void *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);"]]
+
+# from Ruby 3.1
+have_func "rb_iseq_type(NULL)",
+          [["VALUE rb_iseq_type(void *);"]]
+
 create_makefile 'debug/debug'