debug 1.3.4 → 1.4.0

data/lib/debug/session.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+return if ENV['RUBY_DEBUG_ENABLE'] == '0'
+
 # skip to load debugger for bundle exec
 
 if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
@@ -99,17 +101,17 @@ module DEBUGGER__
       @preset_command = nil
       @postmortem_hook = nil
       @postmortem = false
-      @thread_stopper = nil
       @intercept_trap_sigint = false
       @intercepted_sigint_cmd = 'DEFAULT'
       @process_group = ProcessGroup.new
       @subsession = nil
 
-      @frame_map = {} # {id => [threadId, frame_depth]} for DAP
+      @frame_map = {} # for DAP: {id => [threadId, frame_depth]} and CDP: {id => frame_depth}
       @var_map   = {1 => [:globals], } # {id => ...} for DAP
       @src_map   = {} # {id => src}
 
       @script_paths = [File.absolute_path($0)] # for CDP
+      @obj_map = {} # { object_id => ... } for CDP
 
       @tp_thread_begin = nil
       @tp_load_script = TracePoint.new(:script_compiled){|tp|
@@ -117,6 +119,8 @@ module DEBUGGER__
       }
       @tp_load_script.enable
 
+      @thread_stopper = thread_stopper
+
       activate
 
       self.postmortem = CONFIG[:postmortem]
@@ -147,15 +151,15 @@ module DEBUGGER__
 
         # Thread management
         setup_threads
-        thc = thread_client Thread.current
-        thc.is_management
+        thc = get_thread_client Thread.current
+        thc.mark_as_management
 
-        if @ui.respond_to?(:reader_thread) && thc = thread_client(@ui.reader_thread)
-          thc.is_management
+        if @ui.respond_to?(:reader_thread) && thc = get_thread_client(@ui.reader_thread)
+          thc.mark_as_management
         end
 
         @tp_thread_begin = TracePoint.new(:thread_begin) do |tp|
-          thread_client
+          get_thread_client
         end
         @tp_thread_begin.enable
 
@@ -168,12 +172,12 @@ module DEBUGGER__
     end
 
     def deactivate
-      thread_client.deactivate
-      @thread_stopper.disable if @thread_stopper
+      get_thread_client.deactivate
+      @thread_stopper.disable
       @tp_load_script.disable
       @tp_thread_begin.disable
-      @bps.each{|k, bp| bp.disable}
-      @th_clients.each{|th, thc| thc.close}
+      @bps.each_value{|bp| bp.disable}
+      @th_clients.each_value{|thc| thc.close}
       @tracers.values.each{|t| t.disable}
       @q_evt.close
       @ui&.deactivate
@@ -233,12 +237,13 @@ module DEBUGGER__
         case ev_args.first
         when :breakpoint
           bp, i = bp_index ev_args[1]
+          clean_bps unless bp
           @ui.event :suspend_bp, i, bp, tc.id
         when :trap
           @ui.event :suspend_trap, sig = ev_args[1], tc.id
 
           if sig == :SIGINT && (@intercepted_sigint_cmd.kind_of?(Proc) || @intercepted_sigint_cmd.kind_of?(String))
-            @ui.puts "#{@intercepted_sigint_cmd.inspect} is registerred as SIGINT handler."
+            @ui.puts "#{@intercepted_sigint_cmd.inspect} is registered as SIGINT handler."
             @ui.puts "`sigint` command execute it."
           end
         else
@@ -418,10 +423,15 @@ module DEBUGGER__
       # * `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.
       when 'fin', 'finish'
         cancel_auto_continue
         check_postmortem
+
+        if arg&.to_i == 0
+          raise 'finish command with 0 does not make sense.'
+        end
+
         step_command :finish, arg
 
       # * `c[ontinue]`
@@ -447,7 +457,7 @@ module DEBUGGER__
         leave_subsession nil
 
       # * `kill`
-      #   * Stop the debuggee process with `Kernal#exit!`.
+      #   * Stop the debuggee process with `Kernel#exit!`.
       when 'kill'
         if ask 'Really kill?'
           exit! (arg || 1).to_i
@@ -461,7 +471,7 @@ module DEBUGGER__
         exit! (arg || 1).to_i
 
       # * `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`.
       when 'sigint'
         begin
@@ -500,6 +510,8 @@ module DEBUGGER__
       #   * break and run `<command>` before stopping.
       # * `b[reak] ... do: <command>`
       #   * break and run `<command>`, and continue.
+      # * `b[reak] ... path: <path_regexp>`
+      #   * break if the triggering event's path matches <path_regexp>.
       # * `b[reak] if: <expr>`
       #   * break if: `<expr>` is true at any lines.
       #   * Note that this feature is super slow.
@@ -526,7 +538,7 @@ module DEBUGGER__
         require 'json'
 
         h = Hash.new{|h, k| h[k] = []}
-        @bps.each{|key, bp|
+        @bps.each_value{|bp|
           if LineBreakpoint === bp
             h[bp.path] << {lnum: bp.line}
           end
@@ -548,6 +560,14 @@ module DEBUGGER__
 
       # * `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_regexp>`
+      #   * stops if the exception is raised from a path that matches <path_regexp>.
       when 'catch'
         check_postmortem
 
@@ -562,11 +582,19 @@ module DEBUGGER__
       # * `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_regexp>`
+      #   * stops if the triggering event's path matches <path_regexp>.
       when 'wat', 'watch'
         check_postmortem
 
         if arg && arg.match?(/\A@\w+/)
-          @tc << [:breakpoint, :watch, arg]
+          repl_add_watch_breakpoint(arg)
         else
           show_bps
           return :retry
@@ -902,7 +930,7 @@ module DEBUGGER__
         when nil, 'list', 'l'
           thread_list
         when /(\d+)/
-          thread_switch $1.to_i
+          switch_thread $1.to_i
         else
           @ui.puts "unknown thread command: #{arg}"
         end
@@ -1016,8 +1044,8 @@ module DEBUGGER__
     def repl_open_setup
       @tp_thread_begin.disable
       @ui.activate self
-      if @ui.respond_to?(:reader_thread) && thc = thread_client(@ui.reader_thread)
-        thc.is_management
+      if @ui.respond_to?(:reader_thread) && thc = get_thread_client(@ui.reader_thread)
+        thc.mark_as_management
       end
       @tp_thread_begin.enable
     end
@@ -1195,6 +1223,12 @@ module DEBUGGER__
       }
     end
 
+    def clean_bps
+      @bps.delete_if{|_k, bp|
+        bp.deleted?
+      }
+    end
+
     def add_bp bp
       # don't repeat commands that add breakpoints
       @repl_prev_line = nil
@@ -1225,7 +1259,7 @@ module DEBUGGER__
       end
     end
 
-    BREAK_KEYWORDS = %w(if: do: pre:).freeze
+    BREAK_KEYWORDS = %w(if: do: pre: path:).freeze
 
     def parse_break arg
       mode = :sig
@@ -1245,6 +1279,7 @@ module DEBUGGER__
       expr = parse_break arg.strip
       cond = expr[:if]
       cmd = ['break', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+      path = Regexp.compile(expr[:path]) if expr[:path]
 
       case expr[:sig]
       when /\A(\d+)\z/
@@ -1252,10 +1287,10 @@ module DEBUGGER__
       when /\A(.+)[:\s+](\d+)\z/
         add_line_breakpoint $1, $2.to_i, cond: cond, command: cmd
       when /\A(.+)([\.\#])(.+)\z/
-        @tc << [:breakpoint, :method, $1, $2, $3, cond, cmd]
+        @tc << [:breakpoint, :method, $1, $2, $3, cond, cmd, path]
         return :noretry
       when nil
-        add_check_breakpoint cond
+        add_check_breakpoint cond, path
       else
         @ui.puts "Unknown breakpoint format: #{arg}"
         @ui.puts
@@ -1267,18 +1302,28 @@ module DEBUGGER__
       expr = parse_break arg.strip
       cond = expr[:if]
       cmd = ['catch', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+      path = Regexp.compile(expr[:path]) if expr[:path]
 
-      bp = CatchBreakpoint.new(expr[:sig], cond: cond, command: cmd)
+      bp = CatchBreakpoint.new(expr[:sig], cond: cond, command: cmd, path: path)
       add_bp bp
     end
 
+    def repl_add_watch_breakpoint arg
+      expr = parse_break arg.strip
+      cond = expr[:if]
+      cmd = ['watch', expr[:pre], expr[:do]] if expr[:pre] || expr[:do]
+      path = Regexp.compile(expr[:path]) if expr[:path]
+
+      @tc << [:breakpoint, :watch, expr[:sig], cond, cmd, path]
+    end
+
     def add_catch_breakpoint pat
       bp = CatchBreakpoint.new(pat)
       add_bp bp
     end
 
-    def add_check_breakpoint expr
-      bp = CheckBreakpoint.new(expr)
+    def add_check_breakpoint expr, path
+      bp = CheckBreakpoint.new(expr, path)
       add_bp bp
     end
 
@@ -1291,6 +1336,11 @@ module DEBUGGER__
       @ui.puts e.message
     end
 
+    def add_iseq_breakpoint iseq, **kw
+      bp = ISeqBreakpoint.new(iseq, [:line], **kw)
+      add_bp bp
+    end
+
     # tracers
 
     def add_tracer tracer
@@ -1344,7 +1394,7 @@ module DEBUGGER__
       thcs
     end
 
-    def thread_switch n
+    def switch_thread n
       thcs, _unmanaged_ths = update_thread_list
 
       if tc = thcs[n]
@@ -1365,7 +1415,7 @@ module DEBUGGER__
         if tc = prev_clients[th]
           @th_clients[th] = tc
         else
-          thread_client_create(th)
+          create_thread_client(th)
         end
       }
     end
@@ -1374,17 +1424,17 @@ module DEBUGGER__
       if @th_clients.has_key? th
         # TODO: NG?
       else
-        thread_client_create th
+        create_thread_client th
       end
     end
 
-    private def thread_client_create th
+    private def create_thread_client th
       # TODO: Ractor support
       raise "Only session_server can create thread_client" unless Thread.current == @session_server
       @th_clients[th] = ThreadClient.new((@tc_id += 1), @q_evt, Queue.new, th)
     end
 
-    private def ask_thread_client th = Thread.current
+    private def ask_thread_client th
       # TODO: Ractor support
       q2 = Queue.new
       # tc, output, ev, @internal_info, *ev_args = evt
@@ -1395,30 +1445,18 @@ module DEBUGGER__
     end
 
     # can be called by other threads
-    def thread_client th = Thread.current
+    def get_thread_client th = Thread.current
       if @th_clients.has_key? th
         @th_clients[th]
       else
         if Thread.current == @session_server
-          thread_client_create th
+          create_thread_client th
         else
           ask_thread_client th
         end
       end
     end
 
-    private def thread_stopper
-      @thread_stopper ||= TracePoint.new(:line) do
-        # run on each thread
-        tc = ThreadClient.current
-        next if tc.management?
-        next unless tc.running?
-        next if tc == @tc
-
-        tc.on_pause
-      end
-    end
-
     private def running_thread_clients_count
       @th_clients.count{|th, tc|
         next if tc.management?
@@ -1435,15 +1473,27 @@ module DEBUGGER__
       }.compact
     end
 
+    private def thread_stopper
+      TracePoint.new(:line) do
+        # run on each thread
+        tc = ThreadClient.current
+        next if tc.management?
+        next unless tc.running?
+        next if tc == @tc
+
+        tc.on_pause
+      end
+    end
+
     private def stop_all_threads
       return if running_thread_clients_count == 0
 
-      stopper = thread_stopper
+      stopper = @thread_stopper
       stopper.enable unless stopper.enabled?
     end
 
     private def restart_all_threads
-      stopper = thread_stopper
+      stopper = @thread_stopper
       stopper.disable if stopper.enabled?
 
       waiting_thread_clients.each{|tc|
@@ -1550,7 +1600,7 @@ module DEBUGGER__
 
       frames = exc.instance_variable_get(:@__debugger_postmortem_frames)
       @postmortem = true
-      ThreadClient.current.suspend :postmortem, postmortem_frames: frames
+      ThreadClient.current.suspend :postmortem, postmortem_frames: frames, postmortem_exc: exc
     ensure
       @postmortem = false
     end
@@ -1822,7 +1872,7 @@ module DEBUGGER__
     ::DEBUGGER__::SESSION.add_catch_breakpoint pat
   end
 
-  # String for requring location
+  # String for requiring location
   # nil for -r
   def self.require_location
     locs = caller_locations
@@ -1960,13 +2010,17 @@ module DEBUGGER__
   METHOD_ADDED_TRACKER = self.create_method_added_tracker
 
   SHORT_INSPECT_LENGTH = 40
-  def self.short_inspect obj, use_short = true
+
+  def self.safe_inspect obj, max_length: SHORT_INSPECT_LENGTH, short: false
     str = obj.inspect
-    if use_short && str.length > SHORT_INSPECT_LENGTH
-      str[0...SHORT_INSPECT_LENGTH] + '...'
+
+    if short && str.length > max_length
+      str[0...max_length] + '...'
     else
       str
     end
+  rescue Exception => e
+    str = "<#inspect raises #{e.inspect}>"
   end
 
   def self.warn msg
@@ -2000,6 +2054,14 @@ module DEBUGGER__
     end
   end
 
+  def self.step_in &b
+    if defined?(SESSION) && SESSION.active?
+      SESSION.add_iseq_breakpoint RubyVM::InstructionSequence.of(b), oneshot: true
+    end
+
+    yield
+  end
+
   module ForkInterceptor
     def fork(&given_block)
       return super unless defined?(SESSION) && SESSION.active?

data/lib/debug/source_repository.rb

@@ -40,12 +40,10 @@ module DEBUGGER__
     end
 
     private def add_path path
-      begin
-        src = File.read(path)
-        src = src.gsub("\r\n", "\n") # CRLF -> LF
-        @files[path] = SrcInfo.new(src.lines)
-      rescue SystemCallError
-      end
+      src = File.read(path)
+      src = src.gsub("\r\n", "\n") # CRLF -> LF
+      @files[path] = SrcInfo.new(src.lines)
+    rescue SystemCallError
     end
 
     private def get_si iseq

data/lib/debug/thread_client.rb

@@ -22,7 +22,7 @@ module DEBUGGER__
       if thc = Thread.current[:DEBUGGER__ThreadClient]
         thc
       else
-        thc = SESSION.thread_client
+        thc = SESSION.get_thread_client
         Thread.current[:DEBUGGER__ThreadClient] = thc
       end
     end
@@ -67,7 +67,7 @@ module DEBUGGER__
       result = "#{call_identifier_str} at #{location_str}"
 
       if return_str = frame.return_str
-        result += " #=> #{colorize_magenta(frame.return_str)}"
+        result += " #=> #{colorize_magenta(return_str)}"
       end
 
       result
@@ -84,6 +84,7 @@ module DEBUGGER__
       @output = []
       @frame_formatter = method(:default_frame_formatter)
       @var_map = {} # { thread_local_var_id => obj } for DAP
+      @obj_map = {} # { object_id => obj } for CDP
       @recorder = nil
       @mode = :waiting
       set_mode :running
@@ -100,13 +101,13 @@ module DEBUGGER__
       @is_management
     end
 
-    def is_management
+    def mark_as_management
       @is_management = true
     end
 
     def set_mode mode
       # STDERR.puts "#{@mode} => #{mode} @ #{caller.inspect}"
-      #pp caller
+      # pp caller
 
       # mode transition check
       case mode
@@ -228,7 +229,7 @@ module DEBUGGER__
       suspend :pause
     end
 
-    def suspend event, tp = nil, bp: nil, sig: nil, postmortem_frames: nil, replay_frames: nil
+    def suspend event, tp = nil, bp: nil, sig: nil, postmortem_frames: nil, replay_frames: nil, postmortem_exc: nil
       return if management?
 
       @current_frame_index = 0
@@ -256,10 +257,15 @@ module DEBUGGER__
           cf.has_raised_exception = true
           cf.raised_exception = bp.last_exc
         end
+
+        if postmortem_exc
+          cf.has_raised_exception = true
+          cf.raised_exception = postmortem_exc
+        end
       end
 
       if event != :pause
-        show_src max_lines: (CONFIG[:show_src_lines] || 10)
+        show_src
         show_frames CONFIG[:show_frames] || 2
 
         set_mode :waiting
@@ -292,15 +298,15 @@ module DEBUGGER__
       SUPPORT_TARGET_THREAD = false
     end
 
-    def step_tp iter
+    def step_tp iter, events = [:line, :b_return, :return]
       @step_tp.disable if @step_tp
 
       thread = Thread.current
 
       if SUPPORT_TARGET_THREAD
-        @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
+        @step_tp = TracePoint.new(*events){|tp|
           next if SESSION.break_at? tp.path, tp.lineno
-          next if !yield
+          next if !yield(tp.event)
           next if tp.path.start_with?(__dir__)
           next if tp.path.start_with?('<internal:trace_point>')
           next unless File.exist?(tp.path) if CONFIG[:skip_nosrc]
@@ -313,10 +319,10 @@ module DEBUGGER__
         }
         @step_tp.enable(target_thread: thread)
       else
-        @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
+        @step_tp = TracePoint.new(*events){|tp|
           next if thread != Thread.current
           next if SESSION.break_at? tp.path, tp.lineno
-          next if !yield
+          next if !yield(tp.event)
           next if tp.path.start_with?(__dir__)
           next if tp.path.start_with?('<internal:trace_point>')
           next unless File.exist?(tp.path) if CONFIG[:skip_nosrc]
@@ -338,38 +344,45 @@ module DEBUGGER__
       frame_self.instance_eval(src)
     end
 
+    SPECIAL_LOCAL_VARS = [
+      [:raised_exception, "_raised"],
+      [:return_value,     "_return"],
+    ]
+
     def frame_eval src, re_raise: false
-      begin
-        @success_last_eval = false
+      @success_last_eval = false
 
-        b = current_frame&.eval_binding || TOPLEVEL_BINDING
+      b = current_frame.eval_binding
 
-        result = if b
-                   f, _l = b.source_location
-                   b.eval(src, "(rdbg)/#{f}")
-                 else
-                   frame_self = current_frame.self
-                   instance_eval_for_cmethod(frame_self, src)
-                 end
-        @success_last_eval = true
-        result
+      special_local_variables current_frame do |name, var|
+        b.local_variable_set(name, var) if /\%/ !~ name
+      end
 
-      rescue Exception => e
-        return yield(e) if block_given?
+      result = if b
+                  f, _l = b.source_location
+                  b.eval(src, "(rdbg)/#{f}")
+                else
+                  frame_self = current_frame.self
+                  instance_eval_for_cmethod(frame_self, src)
+                end
+      @success_last_eval = true
+      result
 
-        puts "eval error: #{e}"
+    rescue Exception => e
+      return yield(e) if block_given?
 
-        e.backtrace_locations&.each do |loc|
-          break if loc.path == __FILE__
-          puts "  #{loc}"
-        end
-        raise if re_raise
+      puts "eval error: #{e}"
+
+      e.backtrace_locations&.each do |loc|
+        break if loc.path == __FILE__
+        puts "  #{loc}"
       end
+      raise if re_raise
     end
 
     def show_src(frame_index: @current_frame_index,
                  update_line: false,
-                 max_lines: 10,
+                 max_lines: CONFIG[:show_src_lines] || 10,
                  start_line: nil,
                  end_line: nil,
                  dir: +1)
@@ -428,15 +441,20 @@ module DEBUGGER__
 
     ## cmd: show
 
+    def special_local_variables frame
+      SPECIAL_LOCAL_VARS.each do |mid, name|
+        next unless frame&.send("has_#{mid}")
+        name = name.sub('_', '%') if frame.eval_binding.local_variable_defined?(name)
+        yield name, frame.send(mid)
+      end
+    end
+
     def show_locals pat
       if s = current_frame&.self
         puts_variable_info '%self', s, pat
       end
-      if current_frame&.has_return_value
-        puts_variable_info '%return', current_frame.return_value, pat
-      end
-      if current_frame&.has_raised_exception
-        puts_variable_info "%raised", current_frame.raised_exception, pat
+      special_local_variables current_frame do |name, val|
+        puts_variable_info name, val, pat
       end
 
       if vars = current_frame&.local_variables
@@ -633,8 +651,8 @@ module DEBUGGER__
     def make_breakpoint args
       case args.first
       when :method
-        klass_name, op, method_name, cond, cmd = args[1..]
-        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond: cond, command: cmd)
+        klass_name, op, method_name, cond, cmd, path = args[1..]
+        bp = MethodBreakpoint.new(current_frame.eval_binding, klass_name, op, method_name, cond: cond, command: cmd, path: path)
         begin
           bp.enable
         rescue Exception => e
@@ -644,8 +662,8 @@ module DEBUGGER__
 
         bp
       when :watch
-        ivar, object, result = args[1..]
-        WatchIVarBreakpoint.new(ivar, object, result)
+        ivar, object, result, cond, command, path = args[1..]
+        WatchIVarBreakpoint.new(ivar, object, result, cond: cond, command: command, path: path)
       else
         raise "unknown breakpoint: #{args}"
       end
@@ -732,10 +750,11 @@ module DEBUGGER__
             break
 
           when :finish
-            depth = @target_frames.first.frame_depth
-            step_tp iter do
-              # 3 is debugger's frame count
-              DEBUGGER__.frame_depth - 3 < depth
+            finish_frames = (iter || 1) - 1
+            goal_depth = @target_frames.first.frame_depth - finish_frames
+
+            step_tp nil, [:return, :b_return] do
+              DEBUGGER__.frame_depth - 3 <= goal_depth ? true : false
             end
             break
 
@@ -887,7 +906,7 @@ module DEBUGGER__
             bp = make_breakpoint args
             event! :result, :method_breakpoint, bp
           when :watch
-            ivar = args[1]
+            ivar, cond, command, path = args[1..]
             result = frame_eval(ivar)
 
             if @success_last_eval
@@ -897,7 +916,7 @@ module DEBUGGER__
                 else
                   current_frame.self
                 end
-              bp = make_breakpoint [:watch, ivar, object, result]
+              bp = make_breakpoint [:watch, ivar, object, result, cond, command, path]
               event! :result, :watch_breakpoint, bp
             else
               event! :result, nil
@@ -1067,7 +1086,7 @@ module DEBUGGER__
       end
     end
 
-    # copyed from irb
+    # copied from irb
     class Output
       include Color