debug 1.3.1 → 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'
@@ -91,7 +93,7 @@ module DEBUGGER__
                 #   [:check, expr] => CheckBreakpoint
       #
       @tracers = {}
-      @th_clients = nil # {Thread => ThreadClient}
+      @th_clients = {} # {Thread => ThreadClient}
       @q_evt = Queue.new
       @displays = []
       @tc = nil
@@ -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]
@@ -1358,14 +1408,14 @@ module DEBUGGER__
     end
 
     def setup_threads
-      prev_clients = @th_clients || {}
+      prev_clients = @th_clients
       @th_clients = {}
 
       Thread.list.each{|th|
         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,11 +1600,41 @@ 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
 
+    def capture_exception_frames *exclude_path
+      postmortem_hook = TracePoint.new(:raise){|tp|
+        exc = tp.raised_exception
+        frames = DEBUGGER__.capture_frames(__dir__)
+
+        exclude_path.each{|ex|
+          if Regexp === ex
+            frames.delete_if{|e| ex =~ e.path}
+          else
+            frames.delete_if{|e| e.path.start_with? ex.to_s}
+          end
+        }
+        exc.instance_variable_set(:@__debugger_postmortem_frames, frames)
+      }
+      postmortem_hook.enable
+
+      begin
+        yield
+        nil
+      rescue Exception => e
+        if e.instance_variable_defined? :@__debugger_postmortem_frames
+          e
+        else
+          raise
+        end
+      ensure
+        postmortem_hook.disable
+      end
+    end
+
     def postmortem=(is_enable)
       if is_enable
         unless @postmortem_hook
@@ -1792,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
@@ -1930,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
@@ -1970,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