debug 1.7.2 → 1.9.0

data/lib/debug/server_dap.rb

@@ -274,198 +274,225 @@ module DEBUGGER__
       retry
     end
 
+    def load_extensions req
+      if exts = req.dig('arguments', 'rdbgExtensions')
+        exts.each{|ext|
+          require_relative "dap_custom/#{File.basename(ext)}"
+        }
+      end
+
+      if scripts = req.dig('arguments', 'rdbgInitialScripts')
+        scripts.each do |script|
+          begin
+            eval(script)
+          rescue Exception => e
+            puts e.message
+            puts e.backtrace.inspect
+          end
+        end
+      end
+    end
+
     def process
       while req = recv_request
-        raise "not a request: #{req.inspect}" unless req['type'] == 'request'
-        args = req.dig('arguments')
+        process_request(req)
+      end
+    ensure
+      send_event :terminated unless @sock.closed?
+    end
 
-        case req['command']
+    def process_request req
+      raise "not a request: #{req.inspect}" unless req['type'] == 'request'
+      args = req.dig('arguments')
 
-        ## boot/configuration
-        when 'launch'
-          send_response req
-          # `launch` runs on debuggee on the same file system
-          UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap') || true
-          @nonstop = true
+      case req['command']
 
-        when 'attach'
-          send_response req
-          UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap')
+      ## boot/configuration
+      when 'launch'
+        send_response req
+        # `launch` runs on debuggee on the same file system
+        UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap') || true
+        @nonstop = true
 
-          if req.dig('arguments', 'nonstop') == true
-            @nonstop = true
-          else
-            @nonstop = false
-          end
+        load_extensions req
 
-        when 'configurationDone'
-          send_response req
+      when 'attach'
+        send_response req
+        UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap')
 
-          if @nonstop
-            @q_msg << 'continue'
-          else
-            if SESSION.in_subsession?
-              send_event 'stopped', reason: 'pause',
-                                    threadId: 1, # maybe ...
-                                    allThreadsStopped: true
-            end
-          end
+        if req.dig('arguments', 'nonstop') == true
+          @nonstop = true
+        else
+          @nonstop = false
+        end
 
-        when 'setBreakpoints'
-          req_path = args.dig('source', 'path')
-          path = UI_DAP.local_to_remote_path(req_path)
-          if path
-            SESSION.clear_line_breakpoints path
-
-            bps = []
-            args['breakpoints'].each{|bp|
-              line = bp['line']
-              if cond = bp['condition']
-                bps << SESSION.add_line_breakpoint(path, line, cond: cond)
-              else
-                bps << SESSION.add_line_breakpoint(path, line)
-              end
-            }
-            send_response req, breakpoints: (bps.map do |bp| {verified: true,} end)
-          else
-            send_response req, success: false, message: "#{req_path} is not available"
-          end
+        load_extensions req
 
-        when 'setFunctionBreakpoints'
-          send_response req
+      when 'configurationDone'
+        send_response req
 
-        when 'setExceptionBreakpoints'
-          process_filter = ->(filter_id, cond = nil) {
-            bp =
-              case filter_id
-              when 'any'
-                SESSION.add_catch_breakpoint 'Exception', cond: cond
-              when 'RuntimeError'
-                SESSION.add_catch_breakpoint 'RuntimeError', cond: cond
-              else
-                nil
-              end
-              {
-                verified: !bp.nil?,
-                message: bp.inspect,
-              }
-            }
+        if @nonstop
+          @q_msg << 'continue'
+        else
+          if SESSION.in_subsession?
+            send_event 'stopped', reason: 'pause',
+                                  threadId: 1, # maybe ...
+                                  allThreadsStopped: true
+          end
+        end
 
-            SESSION.clear_catch_breakpoints 'Exception', 'RuntimeError'
+      when 'setBreakpoints'
+        req_path = args.dig('source', 'path')
+        path = UI_DAP.local_to_remote_path(req_path)
+        if path
+          SESSION.clear_line_breakpoints path
+
+          bps = []
+          args['breakpoints'].each{|bp|
+            line = bp['line']
+            if cond = bp['condition']
+              bps << SESSION.add_line_breakpoint(path, line, cond: cond)
+            else
+              bps << SESSION.add_line_breakpoint(path, line)
+            end
+          }
+          send_response req, breakpoints: (bps.map do |bp| {verified: true,} end)
+        else
+          send_response req, success: false, message: "#{req_path} is not available"
+        end
 
-            filters = args.fetch('filters').map {|filter_id|
-              process_filter.call(filter_id)
+      when 'setFunctionBreakpoints'
+        send_response req
+
+      when 'setExceptionBreakpoints'
+        process_filter = ->(filter_id, cond = nil) {
+          bp =
+            case filter_id
+            when 'any'
+              SESSION.add_catch_breakpoint 'Exception', cond: cond
+            when 'RuntimeError'
+              SESSION.add_catch_breakpoint 'RuntimeError', cond: cond
+            else
+              nil
+            end
+            {
+              verified: !bp.nil?,
+              message: bp.inspect,
             }
+          }
+
+          SESSION.clear_catch_breakpoints 'Exception', 'RuntimeError'
 
-            filters += args.fetch('filterOptions', {}).map{|bp_info|
-            process_filter.call(bp_info['filterId'], bp_info['condition'])
+          filters = args.fetch('filters').map {|filter_id|
+            process_filter.call(filter_id)
           }
 
-          send_response req, breakpoints: filters
+          filters += args.fetch('filterOptions', {}).map{|bp_info|
+          process_filter.call(bp_info['filterId'], bp_info['condition'])
+        }
 
-        when 'disconnect'
-          terminate = args.fetch("terminateDebuggee", false)
+        send_response req, breakpoints: filters
 
-          SESSION.clear_all_breakpoints
-          send_response req
+      when 'disconnect'
+        terminate = args.fetch("terminateDebuggee", false)
 
-          if SESSION.in_subsession?
-            if terminate
-              @q_msg << 'kill!'
-            else
-              @q_msg << 'continue'
-            end
-          else
-            if terminate
-              @q_msg << 'kill!'
-              pause
-            end
-          end
+        SESSION.clear_all_breakpoints
+        send_response req
 
-        ## control
-        when 'continue'
-          @q_msg << 'c'
-          send_response req, allThreadsContinued: true
-        when 'next'
-          begin
-            @session.check_postmortem
-            @q_msg << 'n'
-            send_response req
-          rescue PostmortemError
-            send_response req,
-                          success: false, message: 'postmortem mode',
-                          result: "'Next' is not supported while postmortem mode"
-          end
-        when 'stepIn'
-          begin
-            @session.check_postmortem
-            @q_msg << 's'
-            send_response req
-          rescue PostmortemError
-            send_response req,
-                          success: false, message: 'postmortem mode',
-                          result: "'stepIn' is not supported while postmortem mode"
+        if SESSION.in_subsession?
+          if terminate
+            @q_msg << 'kill!'
+          else
+            @q_msg << 'continue'
           end
-        when 'stepOut'
-          begin
-            @session.check_postmortem
-            @q_msg << 'fin'
-            send_response req
-          rescue PostmortemError
-            send_response req,
-                          success: false, message: 'postmortem mode',
-                          result: "'stepOut' is not supported while postmortem mode"
+        else
+          if terminate
+            @q_msg << 'kill!'
+            pause
           end
-        when 'terminate'
+        end
+
+      ## control
+      when 'continue'
+        @q_msg << 'c'
+        send_response req, allThreadsContinued: true
+      when 'next'
+        begin
+          @session.check_postmortem
+          @q_msg << 'n'
           send_response req
-          exit
-        when 'pause'
+        rescue PostmortemError
+          send_response req,
+                        success: false, message: 'postmortem mode',
+                        result: "'Next' is not supported while postmortem mode"
+        end
+      when 'stepIn'
+        begin
+          @session.check_postmortem
+          @q_msg << 's'
           send_response req
-          Process.kill(UI_ServerBase::TRAP_SIGNAL, Process.pid)
-        when 'reverseContinue'
+        rescue PostmortemError
           send_response req,
-                        success: false, message: 'cancelled',
-                        result: "Reverse Continue is not supported. Only \"Step back\" is supported."
-        when 'stepBack'
-          @q_msg << req
+                        success: false, message: 'postmortem mode',
+                        result: "'stepIn' is not supported while postmortem mode"
+        end
+      when 'stepOut'
+        begin
+          @session.check_postmortem
+          @q_msg << 'fin'
+          send_response req
+        rescue PostmortemError
+          send_response req,
+                        success: false, message: 'postmortem mode',
+                        result: "'stepOut' is not supported while postmortem mode"
+        end
+      when 'terminate'
+        send_response req
+        exit
+      when 'pause'
+        send_response req
+        Process.kill(UI_ServerBase::TRAP_SIGNAL, Process.pid)
+      when 'reverseContinue'
+        send_response req,
+                      success: false, message: 'cancelled',
+                      result: "Reverse Continue is not supported. Only \"Step back\" is supported."
+      when 'stepBack'
+        @q_msg << req
 
-        ## query
-        when 'threads'
-          send_response req, threads: SESSION.managed_thread_clients.map{|tc|
-            { id: tc.id,
-              name: tc.name,
-            }
+      ## query
+      when 'threads'
+        send_response req, threads: SESSION.managed_thread_clients.map{|tc|
+          { id: tc.id,
+            name: tc.name,
           }
+        }
 
-        when 'evaluate'
-          expr = req.dig('arguments', 'expression')
-          if /\A\s*,(.+)\z/ =~ expr
-            dbg_expr = $1.strip
-            dbg_expr.split(';;') { |cmd| @q_msg << cmd }
+      when 'evaluate'
+        expr = req.dig('arguments', 'expression')
+        if /\A\s*,(.+)\z/ =~ expr
+          dbg_expr = $1.strip
+          dbg_expr.split(';;') { |cmd| @q_msg << cmd }
 
-            send_response req,
-                          result: "(rdbg:command) #{dbg_expr}",
-                          variablesReference: 0
-          else
-            @q_msg << req
-          end
-        when 'stackTrace',
-             'scopes',
-             'variables',
-             'source',
-             'completions'
+          send_response req,
+                        result: "(rdbg:command) #{dbg_expr}",
+                        variablesReference: 0
+        else
           @q_msg << req
+        end
+      when 'stackTrace',
+           'scopes',
+           'variables',
+           'source',
+           'completions'
+        @q_msg << req
 
+      else
+        if respond_to? mid = "custom_dap_request_#{req['command']}"
+          __send__ mid, req
         else
-          if respond_to? mid = "custom_dap_request_#{req['command']}"
-            __send__ mid, req
-          else
-            raise "Unknown request: #{req.inspect}"
-          end
+          raise "Unknown request: #{req.inspect}"
         end
       end
-    ensure
-      send_event :terminated unless @sock.closed?
     end
 
     ## called by the SESSION thread
@@ -625,6 +652,7 @@ module DEBUGGER__
           expr = req.dig('arguments', 'expression')
 
           if find_waiting_tc(tid)
+            restart_all_threads
             request_tc [:dap, :evaluate, req, fid, expr, context]
           else
             fail_response req
@@ -701,6 +729,7 @@ module DEBUGGER__
         register_vars result[:variables], tid
         @ui.respond req, result
       when :evaluate
+        stop_all_threads
         message = result.delete :message
         if message
           @ui.respond req, success: false, message: message
@@ -759,7 +788,9 @@ module DEBUGGER__
 
     def dap_eval b, expr, _context, prompt: '(repl_eval)'
       begin
-        b.eval(expr.to_s, prompt)
+        tp_allow_reentry do
+          b.eval(expr.to_s, prompt)
+        end
       rescue Exception => e
         e
       end
@@ -867,7 +898,7 @@ module DEBUGGER__
               }
             when String
               vars = [
-                variable('#lengthddsfsd', obj.length),
+                variable('#length', obj.length),
                 variable('#encoding', obj.encoding),
               ]
               printed_str = value_inspect(obj)
@@ -1014,7 +1045,7 @@ module DEBUGGER__
       klass = M_CLASS.bind_call(obj)
 
       begin
-        klass.name || klass.to_s
+        M_NAME.bind_call(klass) || klass.to_s
       rescue Exception => e
         "<Error: #{e.message} (#{e.backtrace.first}>"
       end

data/lib/debug/session.rb

@@ -82,7 +82,7 @@ class RubyVM::InstructionSequence
   def first_line
     self.to_a[4][:code_location][0]
   end unless method_defined?(:first_line)
-end
+end if defined?(RubyVM::InstructionSequence)
 
 module DEBUGGER__
   PresetCommands = Struct.new(:commands, :source, :auto_continue)
@@ -133,7 +133,7 @@ module DEBUGGER__
       @commands = {}
       @unsafe_context = false
 
-      @has_keep_script_lines = RubyVM.respond_to? :keep_script_lines
+      @has_keep_script_lines = defined?(RubyVM.keep_script_lines)
 
       @tp_load_script = TracePoint.new(:script_compiled){|tp|
         eval_script = tp.eval_script unless @has_keep_script_lines
@@ -202,6 +202,11 @@ module DEBUGGER__
         end
         @tp_thread_end.enable
 
+        if CONFIG[:irb_console] && !CONFIG[:open]
+          require_relative "irb_integration"
+          thc.activate_irb_integration
+        end
+
         # session start
         q << true
         session_server_main
@@ -256,6 +261,15 @@ module DEBUGGER__
       @tc << req
     end
 
+    def request_tc_with_restarted_threads(req)
+      restart_all_threads
+      request_tc(req)
+    end
+
+    def request_eval type, src
+      request_tc_with_restarted_threads [:eval, type, src]
+    end
+
     def process_event evt
       # variable `@internal_info` is only used for test
       tc, output, ev, @internal_info, *ev_args = evt
@@ -314,7 +328,7 @@ module DEBUGGER__
         if @displays.empty?
           wait_command_loop
         else
-          request_tc [:eval, :display, @displays]
+          request_eval :display, @displays
         end
       when :result
         raise "[BUG] not in subsession" if @subsession_stack.empty?
@@ -329,6 +343,7 @@ module DEBUGGER__
             end
           end
 
+          stop_all_threads
         when :method_breakpoint, :watch_breakpoint
           bp = ev_args[1]
           if bp
@@ -342,6 +357,7 @@ module DEBUGGER__
           obj_inspect = ev_args[2]
           opt = ev_args[3]
           add_tracer ObjectTracer.new(@ui, obj_id, obj_inspect, **opt)
+          stop_all_threads
         else
           stop_all_threads
         end
@@ -685,15 +701,15 @@ module DEBUGGER__
       register_command 'bt', 'backtrace', unsafe: false do |arg|
         case arg
         when /\A(\d+)\z/
-          request_tc [:show, :backtrace, arg.to_i, nil]
+          request_tc_with_restarted_threads [:show, :backtrace, arg.to_i, nil]
         when /\A\/(.*)\/\z/
           pattern = $1
-          request_tc [:show, :backtrace, nil, Regexp.compile(pattern)]
+          request_tc_with_restarted_threads [:show, :backtrace, nil, Regexp.compile(pattern)]
         when /\A(\d+)\s+\/(.*)\/\z/
           max, pattern = $1, $2
-          request_tc [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
+          request_tc_with_restarted_threads [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
         else
-          request_tc [:show, :backtrace, nil, nil]
+          request_tc_with_restarted_threads [:show, :backtrace, nil, nil]
         end
       end
 
@@ -810,15 +826,15 @@ module DEBUGGER__
 
         case sub
         when nil
-          request_tc [:show, :default, pat] # something useful
+          request_tc_with_restarted_threads [:show, :default, pat] # something useful
         when :locals
-          request_tc [:show, :locals, pat]
+          request_tc_with_restarted_threads [:show, :locals, pat]
         when :ivars
-          request_tc [:show, :ivars, pat, opt]
+          request_tc_with_restarted_threads [:show, :ivars, pat, opt]
         when :consts
-          request_tc [:show, :consts, pat, opt]
+          request_tc_with_restarted_threads [:show, :consts, pat, opt]
         when :globals
-          request_tc [:show, :globals, pat]
+          request_tc_with_restarted_threads [:show, :globals, pat]
         when :threads
           thread_list
           :retry
@@ -838,7 +854,7 @@ module DEBUGGER__
       #   * Show you available methods and instance variables of the given object.
       #   * If the object is a class/module, it also lists its constants.
       register_command 'outline', 'o', 'ls', unsafe: false do |arg|
-        request_tc [:show, :outline, arg]
+        request_tc_with_restarted_threads [:show, :outline, arg]
       end
 
       # * `display`
@@ -848,9 +864,9 @@ module DEBUGGER__
       register_command 'display', postmortem: false do |arg|
         if arg && !arg.empty?
           @displays << arg
-          request_tc [:eval, :try_display, @displays]
+          request_eval :try_display, @displays
         else
-          request_tc [:eval, :display, @displays]
+          request_eval :display, @displays
         end
       end
 
@@ -864,7 +880,7 @@ module DEBUGGER__
           if @displays[n = $1.to_i]
             @displays.delete_at n
           end
-          request_tc [:eval, :display, @displays]
+          request_eval :display, @displays
         when nil
           if ask "clear all?", 'N'
             @displays.clear
@@ -925,10 +941,11 @@ module DEBUGGER__
       #   * Invoke `irb` on the current frame.
       register_command 'irb' do |arg|
         if @ui.remote?
-          @ui.puts "not supported on the remote console."
+          @ui.puts "\nIRB is not supported on the remote console."
           :retry
+        else
+          request_eval :irb, nil
         end
-        request_eval :irb, nil
       end
 
       ### Trace
@@ -983,7 +1000,7 @@ module DEBUGGER__
           :retry
 
         when /\Aobject\s+(.+)/
-          request_tc [:trace, :object, $1.strip, {pattern: pattern, into: into}]
+          request_tc_with_restarted_threads [:trace, :object, $1.strip, {pattern: pattern, into: into}]
 
         when /\Aoff\s+(\d+)\z/
           if t = @tracers.values[$1.to_i]
@@ -1164,11 +1181,6 @@ module DEBUGGER__
       return :retry
     end
 
-    def request_eval type, src
-      restart_all_threads
-      request_tc [:eval, type, src]
-    end
-
     def step_command type, arg
       if type == :until
         leave_subsession [:step, type, arg]
@@ -1739,15 +1751,19 @@ module DEBUGGER__
       # check breakpoints
       if file_path
         @bps.find_all do |_key, bp|
-          LineBreakpoint === bp && bp.path_is?(file_path)
+          LineBreakpoint === bp && bp.path_is?(file_path) && (iseq.first_lineno..iseq.last_line).cover?(bp.line)
         end.each do |_key, bp|
           if !bp.iseq
             bp.try_activate iseq
           elsif reloaded
             @bps.delete bp.key # to allow duplicate
-            if nbp = LineBreakpoint.copy(bp, iseq)
-              add_bp nbp
-            end
+
+            # When we delete a breakpoint from the @bps hash, we also need to deactivate it or else its tracepoint event
+            # will continue to be enabled and we'll suspend on ghost breakpoints
+            bp.delete
+
+            nbp = LineBreakpoint.copy(bp, iseq)
+            add_bp nbp
           end
         end
       else # !file_path => file_path is not existing
@@ -1993,6 +2009,13 @@ module DEBUGGER__
     def after_fork_parent
       @ui.after_fork_parent
     end
+
+    # experimental API
+    def extend_feature session: nil, thread_client: nil, ui: nil
+      Session.include session if session
+      ThreadClient.include thread_client if thread_client
+      @ui.extend ui if ui
+    end
   end
 
   class ProcessGroup
@@ -2167,6 +2190,7 @@ module DEBUGGER__
       case loc.absolute_path
       when dir_prefix
       when %r{rubygems/core_ext/kernel_require\.rb}
+      when %r{bundled_gems\.rb}
       else
         return loc if loc.absolute_path
       end
@@ -2517,7 +2541,17 @@ module DEBUGGER__
 
   module TrapInterceptor
     def trap sig, *command, &command_proc
-      case sig&.to_sym
+      sym =
+        case sig
+        when String
+          sig.to_sym
+        when Integer
+          Signal.signame(sig)&.to_sym
+        else
+          sig
+        end
+
+      case sym
       when :INT, :SIGINT
         if defined?(SESSION) && SESSION.active? && SESSION.intercept_trap_sigint?
           return SESSION.save_int_trap(command.empty? ? command_proc : command.first)

data/lib/debug/source_repository.rb

@@ -22,7 +22,7 @@ module DEBUGGER__
       end
     end
 
-    if RubyVM.respond_to? :keep_script_lines
+    if defined?(RubyVM.keep_script_lines)
       # Ruby 3.1 and later
       RubyVM.keep_script_lines = true
       require 'objspace'