debug 1.5.0 → 1.6.3

data/lib/debug/session.rb

@@ -19,6 +19,15 @@ if $0.end_with?('bin/bundle') && ARGV.first == 'exec'
   return
 end
 
+# restore RUBYOPT
+if (added_opt = ENV['RUBY_DEBUG_ADDED_RUBYOPT']) &&
+   (rubyopt = ENV['RUBYOPT']) &&
+   rubyopt.end_with?(added_opt)
+
+  ENV['RUBYOPT'] = rubyopt.delete_suffix(added_opt)
+  ENV['RUBY_DEBUG_ADDED_RUBYOPT'] = nil
+end
+
 require_relative 'frame_info'
 require_relative 'config'
 require_relative 'thread_client'
@@ -32,6 +41,7 @@ $LOADED_FEATURES << File.expand_path(File.join(__dir__, '..', 'debug.rb'))
 require 'debug' # invalidate the $LOADED_FEATURE cache
 
 require 'json' if ENV['RUBY_DEBUG_TEST_UI'] == 'terminal'
+require 'pp'
 
 class RubyVM::InstructionSequence
   def traceable_lines_norec lines
@@ -197,35 +207,44 @@ module DEBUGGER__
       deactivate
     end
 
+    def request_tc(req)
+      @tc << req
+    end
+
     def process_event evt
       # variable `@internal_info` is only used for test
       tc, output, ev, @internal_info, *ev_args = evt
-      output.each{|str| @ui.puts str} if ev != :suspend
 
-      case ev
+      output.each{|str| @ui.puts str} if ev != :suspend
 
-      when :thread_begin # special event, tc is nil
+      # special event, tc is nil
+      # and we don't want to set @tc to the newly created thread's ThreadClient
+      if ev == :thread_begin
         th = ev_args.shift
         q = ev_args.shift
         on_thread_begin th
         q << true
 
+        return
+      end
+
+      @tc = tc
+
+      case ev
       when :init
         enter_subsession
-        wait_command_loop tc
-
+        wait_command_loop
       when :load
         iseq, src = ev_args
         on_load iseq, src
-        @ui.event :load
-        tc << :continue
+        request_tc :continue
 
       when :trace
         trace_id, msg = ev_args
         if t = @tracers.values.find{|t| t.object_id == trace_id}
           t.puts msg
         end
-        tc << :continue
+        request_tc :continue
 
       when :suspend
         enter_subsession if ev_args.first != :replay
@@ -235,24 +254,23 @@ module DEBUGGER__
         when :breakpoint
           bp, i = bp_index ev_args[1]
           clean_bps unless bp
-          @ui.event :suspend_bp, i, bp, tc.id
+          @ui.event :suspend_bp, i, bp, @tc.id
         when :trap
-          @ui.event :suspend_trap, sig = ev_args[1], tc.id
+          @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 registered as SIGINT handler."
             @ui.puts "`sigint` command execute it."
           end
         else
-          @ui.event :suspended, tc.id
+          @ui.event :suspended, @tc.id
         end
 
         if @displays.empty?
-          wait_command_loop tc
+          wait_command_loop
         else
-          tc << [:eval, :display, @displays]
+          request_tc [:eval, :display, @displays]
         end
-
       when :result
         raise "[BUG] not in subsession" if @subsession_stack.empty?
 
@@ -283,14 +301,14 @@ module DEBUGGER__
           # ignore
         end
 
-        wait_command_loop tc
+        wait_command_loop
 
       when :dap_result
         dap_event ev_args # server.rb
-        wait_command_loop tc
+        wait_command_loop
       when :cdp_result
         cdp_event ev_args
-        wait_command_loop tc
+        wait_command_loop
       end
     end
 
@@ -323,9 +341,7 @@ module DEBUGGER__
       "DEBUGGER__::SESSION"
     end
 
-    def wait_command_loop tc
-      @tc = tc
-
+    def wait_command_loop
       loop do
         case wait_command
         when :retry
@@ -529,32 +545,6 @@ module DEBUGGER__
           end
         end
 
-      # skip
-      when 'bv'
-        check_postmortem
-        require 'json'
-
-        h = Hash.new{|h, k| h[k] = []}
-        @bps.each_value{|bp|
-          if LineBreakpoint === bp
-            h[bp.path] << {lnum: bp.line}
-          end
-        }
-        if h.empty?
-          # TODO: clean?
-        else
-          open(".rdb_breakpoints.json", 'w'){|f| JSON.dump(h, f)}
-        end
-
-        vimsrc = File.join(__dir__, 'bp.vim')
-        system("vim -R -S #{vimsrc} #{@tc.location.path}")
-
-        if File.exist?(".rdb_breakpoints.json")
-          pp JSON.load(File.read(".rdb_breakpoints.json"))
-        end
-
-        return :retry
-
       # * `catch <Error>`
       #   * Set breakpoint on raising `<Error>`.
       # * `catch ... if: <expr>`
@@ -632,15 +622,15 @@ module DEBUGGER__
       when 'bt', 'backtrace'
         case arg
         when /\A(\d+)\z/
-          @tc << [:show, :backtrace, arg.to_i, nil]
+          request_tc [:show, :backtrace, arg.to_i, nil]
         when /\A\/(.*)\/\z/
           pattern = $1
-          @tc << [:show, :backtrace, nil, Regexp.compile(pattern)]
+          request_tc [:show, :backtrace, nil, Regexp.compile(pattern)]
         when /\A(\d+)\s+\/(.*)\/\z/
           max, pattern = $1, $2
-          @tc << [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
+          request_tc [:show, :backtrace, max.to_i, Regexp.compile(pattern)]
         else
-          @tc << [:show, :backtrace, nil, nil]
+          request_tc [:show, :backtrace, nil, nil]
         end
 
       # * `l[ist]`
@@ -653,13 +643,13 @@ module DEBUGGER__
       when 'l', 'list'
         case arg ? arg.strip : nil
         when /\A(\d+)\z/
-          @tc << [:show, :list, {start_line: arg.to_i - 1}]
+          request_tc [:show, :list, {start_line: arg.to_i - 1}]
         when /\A-\z/
-          @tc << [:show, :list, {dir: -1}]
+          request_tc [:show, :list, {dir: -1}]
         when /\A(\d+)-(\d+)\z/
-          @tc << [:show, :list, {start_line: $1.to_i - 1, end_line: $2.to_i}]
+          request_tc [:show, :list, {start_line: $1.to_i - 1, end_line: $2.to_i}]
         when nil
-          @tc << [:show, :list]
+          request_tc [:show, :list]
         else
           @ui.puts "Can not handle list argument: #{arg}"
           return :retry
@@ -683,7 +673,7 @@ module DEBUGGER__
           return :retry
         end
 
-        @tc << [:show, :edit, arg]
+        request_tc [:show, :edit, arg]
 
       # * `i[nfo]`
       #    * Show information about current frame (local/instance variables and defined constants).
@@ -710,15 +700,15 @@ module DEBUGGER__
 
         case sub
         when nil
-          @tc << [:show, :default, pat] # something useful
+          request_tc [:show, :default, pat] # something useful
         when 'l', /^locals?/
-          @tc << [:show, :locals, pat]
+          request_tc [:show, :locals, pat]
         when 'i', /^ivars?/i, /^instance[_ ]variables?/i
-          @tc << [:show, :ivars, pat]
+          request_tc [:show, :ivars, pat]
         when 'c', /^consts?/i, /^constants?/i
-          @tc << [:show, :consts, pat]
+          request_tc [:show, :consts, pat]
         when 'g', /^globals?/i, /^global[_ ]variables?/i
-          @tc << [:show, :globals, pat]
+          request_tc [:show, :globals, pat]
         when 'th', /threads?/
           thread_list
           return :retry
@@ -734,7 +724,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.
       when 'outline', 'o', 'ls'
-        @tc << [:show, :outline, arg]
+        request_tc [:show, :outline, arg]
 
       # * `display`
       #   * Show display setting.
@@ -743,9 +733,9 @@ module DEBUGGER__
       when 'display'
         if arg && !arg.empty?
           @displays << arg
-          @tc << [:eval, :try_display, @displays]
+          request_tc [:eval, :try_display, @displays]
         else
-          @tc << [:eval, :display, @displays]
+          request_tc [:eval, :display, @displays]
         end
 
       # * `undisplay`
@@ -758,7 +748,7 @@ module DEBUGGER__
           if @displays[n = $1.to_i]
             @displays.delete_at n
           end
-          @tc << [:eval, :display, @displays]
+          request_tc [:eval, :display, @displays]
         when nil
           if ask "clear all?", 'N'
             @displays.clear
@@ -773,29 +763,29 @@ module DEBUGGER__
       # * `f[rame] <framenum>`
       #   * Specify a current frame. Evaluation are run on specified frame.
       when 'frame', 'f'
-        @tc << [:frame, :set, arg]
+        request_tc [:frame, :set, arg]
 
       # * `up`
       #   * Specify the upper frame.
       when 'up'
-        @tc << [:frame, :up]
+        request_tc [:frame, :up]
 
       # * `down`
       #   * Specify the lower frame.
       when 'down'
-        @tc << [:frame, :down]
+        request_tc [:frame, :down]
 
       ### Evaluate
 
       # * `p <expr>`
       #   * Evaluate like `p <expr>` on the current frame.
       when 'p'
-        @tc << [:eval, :p, arg.to_s]
+        request_tc [:eval, :p, arg.to_s]
 
       # * `pp <expr>`
       #   * Evaluate like `pp <expr>` on the current frame.
       when 'pp'
-        @tc << [:eval, :pp, arg.to_s]
+        request_tc [:eval, :pp, arg.to_s]
 
       # * `eval <expr>`
       #   * Evaluate `<expr>` on the current frame.
@@ -805,7 +795,7 @@ module DEBUGGER__
           @ui.puts "\nTo evaluate the variable `#{cmd}`, use `pp #{cmd}` instead."
           return :retry
         else
-          @tc << [:eval, :call, arg]
+          request_tc [:eval, :call, arg]
         end
 
       # * `irb`
@@ -815,7 +805,7 @@ module DEBUGGER__
           @ui.puts "not supported on the remote console."
           return :retry
         end
-        @tc << [:eval, :irb]
+        request_tc [:eval, :irb]
 
         # don't repeat irb command
         @repl_prev_line = nil
@@ -872,7 +862,7 @@ module DEBUGGER__
           return :retry
 
         when /\Aobject\s+(.+)/
-          @tc << [:trace, :object, $1.strip, {pattern: pattern, into: into}]
+          request_tc [:trace, :object, $1.strip, {pattern: pattern, into: into}]
 
         when /\Aoff\s+(\d+)\z/
           if t = @tracers.values[$1.to_i]
@@ -910,7 +900,7 @@ module DEBUGGER__
       when 'record'
         case arg
         when nil, 'on', 'off'
-          @tc << [:record, arg&.to_sym]
+          request_tc [:record, arg&.to_sym]
         else
           @ui.puts "unknown command: #{arg}"
           return :retry
@@ -1005,7 +995,7 @@ module DEBUGGER__
 
       ### END
       else
-        @tc << [:eval, :pp, line]
+        request_tc [:eval, :pp, line]
 =begin
         @repl_prev_line = nil
         @ui.puts "unknown command: #{line}"
@@ -1062,7 +1052,7 @@ module DEBUGGER__
       case arg
       when nil, /\A\d+\z/
         if type == :in && @tc.recorder&.replaying?
-          @tc << [:step, type, arg&.to_i]
+          request_tc [:step, type, arg&.to_i]
         else
           leave_subsession [:step, type, arg&.to_i]
         end
@@ -1071,7 +1061,7 @@ module DEBUGGER__
           @ui.puts "only `step #{arg}` is supported."
           :retry
         else
-          @tc << [:step, arg.to_sym]
+          request_tc [:step, arg.to_sym]
         end
       else
         @ui.puts "Unknown option: #{arg}"
@@ -1081,11 +1071,18 @@ module DEBUGGER__
 
     def config_show key
       key = key.to_sym
-      if CONFIG_SET[key]
+      config_detail = CONFIG_SET[key]
+
+      if config_detail
         v = CONFIG[key]
-        kv = "#{key} = #{v.nil? ? '(default)' : v.inspect}"
-        desc = CONFIG_SET[key][1]
-        line = "%-30s \# %s" % [kv, desc]
+        kv = "#{key} = #{v.inspect}"
+        desc = config_detail[1]
+
+        if config_default = config_detail[3]
+          desc += " (default: #{config_default})"
+        end
+
+        line = "%-34s \# %s" % [kv, desc]
         if line.size > SESSION.width
           @ui.puts "\# #{desc}\n#{kv}"
         else
@@ -1135,7 +1132,7 @@ module DEBUGGER__
         config_set $1, $2, append: true
 
       when /\A\s*append\s+(\w+)\s+(.+)\z/
-        config_set $1, $2
+        config_set $1, $2, append: true
 
       when /\A(\w+)\z/
         config_show $1
@@ -1261,9 +1258,12 @@ module DEBUGGER__
       @repl_prev_line = nil
 
       if @bps.has_key? bp.key
-        unless bp.duplicable?
+        if bp.duplicable?
+          bp
+        else
           @ui.puts "duplicated breakpoint: #{bp}"
           bp.disable
+          nil
         end
       else
         @bps[bp.key] = bp
@@ -1320,7 +1320,7 @@ 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, path]
+        request_tc [:breakpoint, :method, $1, $2, $3, cond, cmd, path]
         return :noretry
       when nil
         add_check_breakpoint cond, path, cmd
@@ -1347,11 +1347,11 @@ module DEBUGGER__
       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]
+      request_tc [:breakpoint, :watch, expr[:sig], cond, cmd, path]
     end
 
-    def add_catch_breakpoint pat
-      bp = CatchBreakpoint.new(pat)
+    def add_catch_breakpoint pat, cond: nil
+      bp = CatchBreakpoint.new(pat, cond: cond)
       add_bp bp
     end
 
@@ -1369,15 +1369,34 @@ module DEBUGGER__
       @ui.puts e.message
     end
 
-    def clear_line_breakpoints path
-      path = resolve_path(path)
+    def clear_breakpoints(&condition)
       @bps.delete_if do |k, bp|
-        if (Array === k) && DEBUGGER__.compare_path(k.first, path)
+        if condition.call(k, bp)
           bp.delete
+          true
         end
       end
     end
 
+    def clear_line_breakpoints path
+      path = resolve_path(path)
+      clear_breakpoints do |k, bp|
+        bp.is_a?(LineBreakpoint) && DEBUGGER__.compare_path(k.first, path)
+      end
+    rescue Errno::ENOENT
+      # just ignore
+    end
+
+    def clear_catch_breakpoints *exception_names
+      clear_breakpoints do |k, bp|
+        bp.is_a?(CatchBreakpoint) && exception_names.include?(k[1])
+      end
+    end
+
+    def clear_all_breakpoints
+      clear_breakpoints{true}
+    end
+
     def add_iseq_breakpoint iseq, **kw
       bp = ISeqBreakpoint.new(iseq, [:line], **kw)
       add_bp bp
@@ -1568,7 +1587,7 @@ module DEBUGGER__
         DEBUGGER__.info "Leave subsession (nested #{@subsession_stack.size})"
       end
 
-      @tc << type if type
+      request_tc type if type
       @tc = nil
     rescue Exception => e
       STDERR.puts PP.pp([e, e.backtrace], ''.dup)
@@ -1583,7 +1602,9 @@ module DEBUGGER__
 
     def on_load iseq, src
       DEBUGGER__.info "Load #{iseq.absolute_path || iseq.path}"
-      @sr.add iseq, src
+
+      file_path, reloaded = @sr.add(iseq, src)
+      @ui.event :load, file_path, reloaded
 
       pending_line_breakpoints = @bps.find_all do |key, bp|
         LineBreakpoint === bp && !bp.iseq
@@ -1591,7 +1612,18 @@ module DEBUGGER__
 
       pending_line_breakpoints.each do |_key, bp|
         if DEBUGGER__.compare_path(bp.path, (iseq.absolute_path || iseq.path))
-          bp.try_activate
+          bp.try_activate iseq
+        end
+      end
+
+      if reloaded
+        @bps.find_all do |key, bp|
+          LineBreakpoint === bp && DEBUGGER__.compare_path(bp.path, file_path)
+        end.each do |_key, bp|
+          @bps.delete bp.key # to allow duplicate
+          if nbp = LineBreakpoint.copy(bp, iseq)
+            add_bp nbp
+          end
         end
       end
     end
@@ -1616,9 +1648,10 @@ module DEBUGGER__
 
     def method_added tp
       b = tp.binding
+
       if var_name = b.local_variables.first
         mid = b.local_variable_get(var_name)
-        unresolved = false
+        resolved = true
 
         @bps.each{|k, bp|
           case bp
@@ -1629,15 +1662,57 @@ module DEBUGGER__
               end
             end
 
-            unresolved = true unless bp.enabled?
+            resolved = false if !bp.enabled?
           end
         }
-        unless unresolved
-          METHOD_ADDED_TRACKER.disable
+
+        if resolved
+          Session.deactivate_method_added_trackers
+        end
+
+        case mid
+        when :method_added, :singleton_method_added
+          Session.create_method_added_tracker(tp.self, mid)
+          Session.activate_method_added_trackers unless resolved
         end
       end
     end
 
+    class ::Module
+      undef method_added
+      def method_added mid; end
+    end
+
+    class ::BasicObject
+      undef singleton_method_added
+      def singleton_method_added mid; end
+    end
+
+    def self.create_method_added_tracker mod, method_added_id, method_accessor = :method
+      m = mod.__send__(method_accessor, method_added_id)
+      METHOD_ADDED_TRACKERS[m] = TracePoint.new(:call) do |tp|
+        SESSION.method_added tp
+      end
+    end
+
+    def self.activate_method_added_trackers
+      METHOD_ADDED_TRACKERS.each do |m, tp|
+        tp.enable(target: m) unless tp.enabled?
+      rescue ArgumentError
+        DEBUGGER__.warn "Methods defined under #{m.owner} can not track by the debugger."
+      end
+    end
+
+    def self.deactivate_method_added_trackers
+      METHOD_ADDED_TRACKERS.each do |m, tp|
+        tp.disable if tp.enabled?
+      end
+    end
+
+    METHOD_ADDED_TRACKERS = Hash.new
+    create_method_added_tracker Module, :method_added, :instance_method
+    create_method_added_tracker BasicObject, :singleton_method_added, :instance_method
+
     def width
       @ui.width
     end
@@ -1818,9 +1893,11 @@ module DEBUGGER__
 
     def after_fork child: true
       if child || !@lock_file
-        @m = Mutex.new
-        @lock_level = 0
-        @lock_file = open(@lock_tempfile.path, 'w')
+        @m = Mutex.new unless @m
+        @m.synchronize do
+          @lock_level = 0
+          @lock_file = open(@lock_tempfile.path, 'w')
+        end
       end
     end
 
@@ -2051,34 +2128,53 @@ module DEBUGGER__
     end
   end
 
-  class ::Module
-    undef method_added
-    def method_added mid; end
-    def singleton_method_added mid; end
-  end
+  # Inspector
 
-  def self.method_added tp
-    begin
-      SESSION.method_added tp
-    rescue Exception => e
-      p e
+  SHORT_INSPECT_LENGTH = 40
+
+  class LimitedPP
+    def self.pp(obj, max=80)
+      out = self.new(max)
+      catch out do
+        PP.singleline_pp(obj, out)
+      end
+      out.buf
     end
-  end
 
-  METHOD_ADDED_TRACKER = self.create_method_added_tracker
+    attr_reader :buf
 
-  SHORT_INSPECT_LENGTH = 40
+    def initialize max
+      @max = max
+      @cnt = 0
+      @buf = String.new
+    end
 
-  def self.safe_inspect obj, max_length: SHORT_INSPECT_LENGTH, short: false
-    str = obj.inspect
+    def <<(other)
+      @buf << other
+
+      if @buf.size >= @max
+        @buf = @buf[0..@max] + '...'
+        throw self
+      end
+    end
+  end
 
-    if short && str.length > max_length
-      str[0...max_length] + '...'
+  def self.safe_inspect obj, max_length: SHORT_INSPECT_LENGTH, short: false
+    if short
+      LimitedPP.pp(obj, max_length)
+    else
+      obj.inspect
+    end
+  rescue NoMethodError => e
+    klass, oid = M_CLASS.bind_call(obj), M_OBJECT_ID.bind_call(obj)
+    if obj == (r = e.receiver)
+      "<\##{klass.name}#{oid} does not have \#inspect>"
     else
-      str
+      rklass, roid = M_CLASS.bind_call(r), M_OBJECT_ID.bind_call(r)
+      "<\##{klass.name}:#{roid} contains <\##{rklass}:#{roid} and it does not have #inspect>"
     end
   rescue Exception => e
-    str = "<#inspect raises #{e.inspect}>"
+    "<#inspect raises #{e.inspect}>"
   end
 
   def self.warn msg
@@ -2089,18 +2185,27 @@ module DEBUGGER__
     log :INFO, msg
   end
 
-  def self.log level, msg
-    @logfile = STDERR unless defined? @logfile
-
+  def self.check_loglevel level
     lv = LOG_LEVELS[level]
-    config_lv = LOG_LEVELS[CONFIG[:log_level] || :WARN]
+    config_lv = LOG_LEVELS[CONFIG[:log_level]]
+    lv <= config_lv
+  end
 
-    if defined? SESSION
-      pi = SESSION.process_info
-      process_info = pi ? "[#{pi}]" : nil
+  def self.debug(&b)
+    if check_loglevel :DEBUG
+      log :DEBUG, b.call
     end
+  end
+
+  def self.log level, msg
+    if check_loglevel level
+      @logfile = STDERR unless defined? @logfile
+
+      if defined? SESSION
+        pi = SESSION.process_info
+        process_info = pi ? "[#{pi}]" : nil
+      end
 
-    if lv <= config_lv
       if level == :WARN
         # :WARN on debugger is general information
         @logfile.puts "DEBUGGER#{process_info}: #{msg}"
@@ -2126,7 +2231,7 @@ module DEBUGGER__
     # depend on the file system. So this check is only roughly estimation.
 
     def self.compare_path(a, b)
-      a.downcase == b.downcase
+      a&.downcase == b&.downcase
     end
   else
     def self.compare_path(a, b)
@@ -2137,7 +2242,7 @@ module DEBUGGER__
   module ForkInterceptor
     if Process.respond_to? :_fork
       def _fork
-        return yield unless defined?(SESSION) && SESSION.active?
+        return super unless defined?(SESSION) && SESSION.active?
 
         parent_hook, child_hook = __fork_setup_for_debugger
 
@@ -2153,7 +2258,7 @@ module DEBUGGER__
       end
     else
       def fork(&given_block)
-        return yield unless defined?(SESSION) && SESSION.active?
+        return super unless defined?(SESSION) && SESSION.active?
         parent_hook, child_hook = __fork_setup_for_debugger
 
         if given_block
@@ -2178,12 +2283,10 @@ module DEBUGGER__
     end
 
     private def __fork_setup_for_debugger
-      unless fork_mode = CONFIG[:fork_mode]
-        if CONFIG[:parent_on_fork]
-          fork_mode = :parent
-        else
-          fork_mode = :both
-        end
+      fork_mode = CONFIG[:fork_mode]
+
+      if fork_mode == :both && CONFIG[:parent_on_fork]
+        fork_mode = :parent
       end
 
       parent_pid = Process.pid
@@ -2310,3 +2413,12 @@ class Binding
   alias break debugger
   alias b debugger
 end
+
+# for Ruby 2.6 compatibility
+unless method(:p).unbind.respond_to? :bind_call
+  class UnboundMethod
+    def bind_call(obj, *args)
+      self.bind(obj).call(*args)
+    end
+  end
+end