debug 1.0.0.alpha1 → 1.0.0.beta5

data/lib/debug/source_repository.rb

@@ -1,20 +1,77 @@
-module DEBUGGER__
-  class SourceRepository
-    def initialize
-      @files = {} # filename => [src, iseq]
-    end
-
-    def add iseq, src
-      begin
-        src = File.read(iseq.path)
-      rescue
-        src = nil
-      end unless src
-      @files[iseq.path] = [src, iseq]
-    end
-
-    def get path
-      @files[path]
-    end
-  end
-end
+require_relative 'color'
+
+module DEBUGGER__
+  class SourceRepository
+    SrcInfo = Struct.new(:src, :colored)
+
+    def initialize
+      @files = {} # filename => SrcInfo
+    end
+
+    def add iseq, src
+      if (path = iseq.absolute_path) && File.exist?(path)
+        add_path path
+      elsif src
+        add_iseq iseq, src
+      end
+    end
+
+    def all_iseq iseq, rs = []
+      rs << iseq
+      iseq.each_child{|ci|
+        all_iseq(ci, rs)
+      }
+      rs
+    end
+
+    private def add_iseq iseq, src
+      line = iseq.first_line
+      if line > 1
+        src = ("\n" * (line - 1)) + src
+      end
+      si = SrcInfo.new(src.lines)
+
+      all_iseq(iseq).each{|e|
+        e.instance_variable_set(:@debugger_si, si)
+        e.freeze
+      }
+    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
+    end
+
+    private def get_si iseq
+      return unless iseq
+
+      if iseq.instance_variable_defined?(:@debugger_si)
+        iseq.instance_variable_get(:@debugger_si)
+      elsif @files.has_key?(path = iseq.absolute_path)
+        @files[path]
+      elsif path
+        add_path(path)
+      end
+    end
+
+    def get iseq
+      if si = get_si(iseq)
+        si.src
+      end
+    end
+
+    include Color
+
+    def get_colored iseq
+      if si = get_si(iseq)
+        si.colored || begin
+          si.colored = colorize_code(si.src.join).lines
+        end
+      end
+    end
+  end
+end

data/lib/debug/thread_client.rb

@@ -1,25 +1,89 @@
+require 'objspace'
+require 'pp'
+
+require_relative 'frame_info'
+require_relative 'color'
+
 module DEBUGGER__
   class ThreadClient
     def self.current
       Thread.current[:DEBUGGER__ThreadClient] || begin
-        tc = SESSION.thread_client
+        tc = ::DEBUGGER__::SESSION.thread_client
         Thread.current[:DEBUGGER__ThreadClient] = tc
       end
     end
 
-    attr_reader :location, :thread
+    include Color
+
+    attr_reader :location, :thread, :mode, :id
+
+    def assemble_arguments(args)
+      args.map do |arg|
+        "#{colorize_cyan(arg[:name])}=#{arg[:value]}"
+      end.join(", ")
+    end
+
+    def default_frame_formatter frame
+      call_identifier_str =
+        case frame.frame_type
+        when :block
+          level, block_loc, args = frame.block_identifier
+
+          if !args.empty?
+            args_str = " {|#{assemble_arguments(args)}|}"
+          end
+
+          "#{colorize_blue("block")}#{args_str} in #{colorize_blue(block_loc + level)}"
+        when :method
+          ci, args = frame.method_identifier
+
+          if !args.empty?
+            args_str = "(#{assemble_arguments(args)})"
+          end
+
+          "#{colorize_blue(ci)}#{args_str}"
+        when :c
+          colorize_blue(frame.c_identifier)
+        when :other
+          colorize_blue(frame.other_identifier)
+        end
+
+      location_str = colorize(frame.location_str, [:GREEN])
+      result = "#{call_identifier_str} at #{location_str}"
+
+      if return_str = frame.return_str
+        return_str = colorize(frame.return_str, [:MAGENTA, :BOLD])
+        result += " #=> #{return_str}"
+      end
+
+      result
+    end
 
-    def initialize q_evt, q_cmd, thr = Thread.current
+    def initialize id, q_evt, q_cmd, thr = Thread.current
+      @id = id
       @thread = thr
+      @target_frames = nil
       @q_evt = q_evt
       @q_cmd = q_cmd
       @step_tp = nil
       @output = []
-      @mode = nil
+      @src_lines_on_stop = (::DEBUGGER__::CONFIG[:show_src_lines]   || 10).to_i
+      @show_frames_on_stop = (::DEBUGGER__::CONFIG[:show_frames] || 2).to_i
+      @frame_formatter = method(:default_frame_formatter)
+      @var_map = {} # { thread_local_var_id => obj } for DAP
+      set_mode nil
+    end
+
+    def name
+      "##{@id} #{@thread.name || @thread.backtrace.last}"
+    end
+
+    def close
+      @q_cmd.close
     end
 
     def inspect
-      "#<DEBUGGER__ThreadClient #{@thread}>"
+      "#<DBG:TC #{self.id}:#{self.mode}@#{@thread.backtrace[-1]}>"
     end
 
     def puts str = ''
@@ -37,18 +101,24 @@ module DEBUGGER__
       @q_cmd << req
     end
 
+    def generate_info
+      return unless current_frame
+
+      { location: current_frame.location_str, line: current_frame.location.lineno }
+    end
+
     def event! ev, *args
-      @q_evt << [self, @output, ev, *args]
+      @q_evt << [self, @output, ev, generate_info, *args]
       @output = []
     end
 
     ## events
 
-    def on_trap
-      if @mode == :wait_next_action
-        raise Interrupt
+    def on_trap sig
+      if self.mode == :wait_next_action
+        # raise Interrupt
       else
-        on_suspend :trap
+        on_suspend :trap, sig: sig
       end
     end
 
@@ -56,18 +126,24 @@ module DEBUGGER__
       on_suspend :pause
     end
 
+    def on_thread_begin th
+      event! :thread_begin, th
+      wait_next_action
+    end
+
     def on_load iseq, eval_src
       event! :load, iseq, eval_src
       wait_next_action
     end
 
-    def on_breakpoint tp
-      on_suspend tp.event, tp
+    def on_breakpoint tp, bp
+      on_suspend tp.event, tp, bp: bp
     end
 
-    def on_suspend event, tp = nil
+    def on_suspend event, tp = nil, bp: nil, sig: nil
       @current_frame_index = 0
-      @target_frames = target_frames
+      @target_frames = DEBUGGER__.capture_frames __dir__
+
       cf = @target_frames.first
       if cf
         @location = cf.location
@@ -76,222 +152,277 @@ module DEBUGGER__
           cf.has_return_value = true
           cf.return_value = tp.return_value
         end
+
+        if CatchBreakpoint === bp
+          cf.has_raised_exception = true
+          cf.raised_exception = bp.last_exc
+        end
       end
 
       if event != :pause
-        show_src
-        print_frames 3
-        event! :suspend, :breakpoint
+        show_src max_lines: @src_lines_on_stop
+        show_frames @show_frames_on_stop
+
+        if bp
+          event! :suspend, :breakpoint, bp.key
+        elsif sig
+          event! :suspend, :trap, sig
+        else
+          event! :suspend, event
+        end
       end
 
       wait_next_action
     end
-    
+
     ## control all
 
+    begin
+      TracePoint.new(:raise){}.enable(target_thread: Thread.current)
+      SUPPORT_TARGET_THREAD = true
+    rescue ArgumentError
+      SUPPORT_TARGET_THREAD = false
+    end
+
     def step_tp
       @step_tp.disable if @step_tp
-      @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
-        next if SESSION.break? tp.path, tp.lineno
-        next if !yield
-        tp.disable
-        on_suspend tp.event, tp
-      }
-
-      @step_tp.enable(target_thread: Thread.current)
-    end
-
-    FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :has_return_value, :return_value)
-
-    def target_frames
-      RubyVM::DebugInspector.open{|dc|
-        locs = dc.backtrace_locations
-        locs.map.with_index{|e, i|
-          unless File.dirname(e.path) == File.dirname(__FILE__)
-            FrameInfo.new(
-              e,
-              dc.frame_self(i),
-              dc.frame_binding(i),
-              dc.frame_iseq(i),
-              dc.frame_class(i))
-          end
-        }.compact
-      }
-    end
 
-    def target_frames_count
-      RubyVM::DebugInspector.open{|dc|
-        locs = dc.backtrace_locations
-        locs.count{|e|
-          e.path != __FILE__
+      thread = Thread.current
+
+      if SUPPORT_TARGET_THREAD
+        @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
+          next if SESSION.break? tp.path, tp.lineno
+          next if !yield
+          next if tp.path.start_with?(__dir__)
+          next unless File.exist?(tp.path) if ::DEBUGGER__::CONFIG[:skip_nosrc]
+
+          tp.disable
+          on_suspend tp.event, tp
+        }
+        @step_tp.enable(target_thread: thread)
+      else
+        @step_tp = TracePoint.new(:line, :b_return, :return){|tp|
+          next if thread != Thread.current
+          next if SESSION.break? tp.path, tp.lineno
+          next if !yield
+          next unless File.exist?(tp.path) if ::DEBUGGER__::CONFIG[:skip_nosrc]
+
+          tp.disable
+          on_suspend tp.event, tp
         }
-      }
+        @step_tp.enable
+      end
     end
 
     def current_frame
-      @target_frames[@current_frame_index]
-    end
-
-    def file_lines path
-      if (src = SESSION.source(path)) && src[0]
-        src[0].lines
-      elsif File.exist?(path)
-        File.readlines(path)
+      if @target_frames
+        @target_frames[@current_frame_index]
+      else
+        nil
       end
     end
 
-    def show_src frame_index = @current_frame_index, max_lines: 10
-      if current_line = @target_frames[frame_index]&.location
-        puts
-        path, line = current_line.path, current_line.lineno - 1
-        if file_lines = file_lines(path)
-          lines = file_lines.map.with_index{|e, i|
-            if i == line
+    def show_src(frame_index: @current_frame_index,
+                 update_line: false,
+                 max_lines: 10,
+                 start_line: nil,
+                 end_line: nil,
+                 dir: +1)
+      if @target_frames && frame = @target_frames[frame_index]
+        if file_lines = frame.file_lines
+          frame_line = frame.location.lineno - 1
+
+          lines = file_lines.map.with_index do |e, i|
+            if i == frame_line
               "=> #{'%4d' % (i+1)}| #{e}"
             else
               "   #{'%4d' % (i+1)}| #{e}"
             end
-          }
-          min = [0, line - max_lines/2].max
-          max = [min+max_lines, lines.size].min
-          puts "[#{min+1}, #{max}] in #{path}"
-          puts lines[min ... max]
+          end
+
+          unless start_line
+            if frame.show_line
+              if dir > 0
+                start_line = frame.show_line
+              else
+                end_line = frame.show_line - max_lines
+                start_line = [end_line - max_lines, 0].max
+              end
+            else
+              start_line = [frame_line - max_lines/2, 0].max
+            end
+          end
+
+          unless end_line
+            end_line = [start_line + max_lines, lines.size].min
+          end
+
+          if update_line
+            frame.show_line = end_line
+          end
+
+          if start_line != end_line && max_lines
+            puts "[#{start_line+1}, #{end_line}] in #{frame.pretty_path}" if !update_line && max_lines != 1
+            puts lines[start_line ... end_line]
+          end
+        else # no file lines
+          puts "# No sourcefile available for #{frame.path}"
         end
       end
+    rescue Exception => e
+      p e
+      pp e.backtrace
+      exit!
+    end
+
+    def show_by_editor path = nil
+      unless path
+        if @target_frames && frame = @target_frames[@current_frame_index]
+          path = frame.path
+        else
+          return # can't get path
+        end
+      end
+
+      if File.exist?(path)
+        if editor = (ENV['RUBY_DEBUG_EDITOR'] || ENV['EDITOR'])
+          puts "command: #{editor}"
+          puts "   path: #{path}"
+          system(editor, path)
+        else
+          puts "can not find editor setting: ENV['RUBY_DEBUG_EDITOR'] or ENV['EDITOR']"
+        end
+      else
+        puts "Can not find file: #{path}"
+      end
     end
 
     def show_locals
       if s = current_frame&.self
-        puts " %self => #{s}"
+        puts " #{colorize_cyan("%self")} => #{colored_inspect(s)}"
       end
       if current_frame&.has_return_value
-        puts " %return => #{current_frame.return_value}"
+        puts " #{colorize_cyan("%return")} => #{colored_inspect(current_frame.return_value)}"
+      end
+      if current_frame&.has_raised_exception
+        puts " #{colorize_cyan("%raised")} => #{colored_inspect(current_frame.raised_exception)}"
       end
       if b = current_frame&.binding
         b.local_variables.each{|loc|
-          puts " #{loc} => #{b.local_variable_get(loc).inspect}"
+          value = b.local_variable_get(loc)
+          puts " #{colorize_cyan(loc)} => #{colored_inspect(value)}"
         }
       end
     end
 
     def show_ivars
       if s = current_frame&.self
-        puts " self => #{s}"
-        s.instance_variables.eaach{|iv|
-          puts " #{iv} => #{s.instance_variable_get(iv)}"
+        s.instance_variables.each{|iv|
+          value = s.instance_variable_get(iv)
+          puts " #{colorize_cyan(iv)} => #{colored_inspect(value)}"
         }
       end
     end
 
-    def frame_eval src, failed_value: nil
+    def frame_eval src, re_raise: false
       begin
+        @success_last_eval = false
+
         b = current_frame.binding
-        if b
-          b.eval(src)
-        else
-          frame_self = current_frame.self
-          frame_self.instance_eval(src)
-          # puts "eval is not supported on this frame."
-        end
+        result = if b
+                   f, _l = b.source_location
+                   b.eval(src, "(rdbg)/#{f}")
+                 else
+                   frame_self = current_frame.self
+                   frame_self.instance_eval(src)
+                 end
+        @success_last_eval = true
+        result
+
       rescue Exception => e
-        return failed_value if failed_value
+        return yield(e) if block_given?
+
+        puts "eval error: #{e}"
 
-        puts "Error: #{e}"
         e.backtrace_locations.each do |loc|
           break if loc.path == __FILE__
           puts "  #{loc}"
         end
-        nil
+        raise if re_raise
       end
     end
 
-    def parameters_info b, vars
-      vars.map{|var|
-        "#{var}=#{short_inspect(b.eval(var.to_s))}"
-      }.join(', ')
+    def frame_str(i)
+      cur_str = (@current_frame_index == i ? '=>' : '  ')
+      prefix = "#{cur_str}##{i}"
+      frame = @target_frames[i]
+      frame_string = @frame_formatter.call(frame)
+      "#{prefix}\t#{frame_string}"
     end
 
-    def klass_sig frame
-      klass = frame.class
-      if klass == frame.self.singleton_class
-        "#{frame.self}."
-      else
-        "#{frame.class}#"
+    def show_frames max = (@target_frames || []).size
+      if max > 0 && @target_frames
+        size = @target_frames.size
+        max += 1 if size == max + 1
+        max.times{|i|
+          break if i >= size
+          puts frame_str(i)
+        }
+        puts "  # and #{size - max} frames (use `bt' command for all frames)" if max < size
       end
     end
 
-    SHORT_INSPECT_LENGTH = 40
-
-    def short_inspect obj
-      str = obj.inspect
-      if str.length > SHORT_INSPECT_LENGTH
-        str[0...SHORT_INSPECT_LENGTH] + '...'
-      else
-        str
-      end
+    def show_frame i=0
+      puts frame_str(i)
     end
 
-    def frame_str i
-      buff = ''.dup
-      frame = @target_frames[i]
-      b = frame.binding
-
-      buff << (@current_frame_index == i ? '--> ' : '    ')
-      if b
-        buff << "##{i}\t#{frame.location}"
+    def show_object_info expr
+      begin
+        result = frame_eval(expr, re_raise: true)
+      rescue Exception
+        # ignore
       else
-        buff << "##{i}\t[C] #{frame.location}"
-      end
-
-      if b && (iseq = frame.iseq)
-        if iseq.type == :block
-          if (argc = iseq.argc) > 0
-            args = parameters_info b, iseq.locals[0...iseq.argc]
-            buff << " {|#{args}|}"
+        klass = ObjectSpace.internal_class_of(result)
+        exists = []
+        klass.ancestors.each{|k|
+          puts "= #{k}"
+          if (ms = (k.instance_methods(false) - exists)).size > 0
+            puts ms.sort.join("\t")
+            exists |= ms
           end
-        else
-          callee = b.eval('__callee__')
-          if callee && (m = frame.self.method(callee))
-            args = parameters_info b, m.parameters.map{|type, v| v}
-            ksig = klass_sig frame
-            buff << " #{ksig}#{callee}(#{args})"
-          end
-        end
+        }
+      end
+    end
 
-        if frame.has_return_value
-          buff << " #=> #{short_inspect(frame.return_value)}"
+    def add_breakpoint args
+      case args.first
+      when :method
+        klass_name, op, method_name, cond = args[1..]
+        bp = MethodBreakpoint.new(current_frame.binding, klass_name, op, method_name, cond)
+        begin
+          bp.enable
+        rescue Exception => e
+          puts e.message
+          ::DEBUGGER__::METHOD_ADDED_TRACKER.enable
         end
+        event! :result, :method_breakpoint, bp
       else
-        # p frame.self
+        raise "unknown breakpoint: #{args}"
       end
-
-      buff
-    end
-
-    def show_frame_all
-      @target_frames.size.times{|i|
-        puts frame_str(i)
-      }
-    end
-
-    def print_frame i
-      puts frame_str(i)
     end
 
-    def print_frames n
-      size = @target_frames.size
-      ([size, n].min).times{|i|
-        print_frame i
-      }
-      if n < size
-        puts "    # and #{size - n} frames (use `bt' command for all frames)"
-      end
+    def set_mode mode
+      @mode = mode
     end
 
     def wait_next_action
-      @mode = :wait_next_action
+      set_mode :wait_next_action
+
+      SESSION.check_forked
 
       while cmds = @q_cmd.pop
+        # pp [self, cmds: cmds]
+
         cmd, *args = *cmds
 
         case cmd
@@ -303,53 +434,105 @@ module DEBUGGER__
           when :in
             step_tp{true}
           when :next
-            size = @target_frames.size
+            frame = @target_frames.first
+            path = frame.location.absolute_path || "!eval:#{frame.path}"
+            line = frame.location.lineno
+            frame.iseq.traceable_lines_norec(lines = {})
+            next_line = lines.keys.bsearch{|e| e > line}
+            if !next_line && (last_line = frame.iseq.last_line) > line
+              next_line = last_line
+            end
+            depth = @target_frames.first.frame_depth
+
             step_tp{
-              target_frames_count() <= size
+              loc = caller_locations(2, 1).first
+              loc_path = loc.absolute_path || "!eval:#{loc.path}"
+
+              # same stack depth
+              (DEBUGGER__.frame_depth - 3 <= depth) ||
+
+              # different frame
+              (next_line && loc_path == path &&
+               (loc_lineno = loc.lineno) > line &&
+               loc_lineno <= next_line)
             }
           when :finish
-            size = @target_frames.size
-            step_tp{target_frames_count() < size}
+            depth = @target_frames.first.frame_depth
+            step_tp{
+              # 3 is debugger's frame count
+              DEBUGGER__.frame_depth - 3 < depth
+            }
           else
             raise
           end
           break
         when :eval
           eval_type, eval_src = *args
-          result = frame_eval(eval_src)
+
+          case eval_type
+          when :display, :try_display
+          else
+            result = frame_eval(eval_src)
+          end
+          result_type = nil
 
           case eval_type
           when :p
             puts "=> " + result.inspect
           when :pp
             puts "=> "
-            PP.pp(result, out = ''.dup)
+            PP.pp(result, out = ''.dup, SESSION.width)
             puts out
           when :call
             result = frame_eval(eval_src)
-          when :display
+          when :display, :try_display
+            failed_results = []
             eval_src.each_with_index{|src, i|
-              puts "#{i}: #{src} = #{frame_eval(src, failed_value: :error).inspect}"
+              result = frame_eval(src){|e|
+                failed_results << [i, e.message]
+                "<error: #{e.message}>"
+              }
+              puts "#{i}: #{src} = #{result}"
             }
-            result = :ok
+
+            result_type = eval_type
+            result = failed_results
+          when :watch
+            if @success_last_eval
+              if eval_src.match?(/@\w+/)
+                object =
+                  if b = current_frame.binding
+                    b.receiver
+                  else
+                    current_frame.self
+                  end
+                puts "#{object} #{eval_src} = #{result}"
+                result = WatchIVarBreakpoint.new(eval_src, object, result)
+              end
+
+              result_type = :watch
+            else
+              result = nil
+            end
           else
-            raise "unknown error option: #{args.inspec}"
+            raise "unknown error option: #{args.inspect}"
           end
-          event! :result, result
+
+          event! :result, result_type, result
         when :frame
           type, arg = *args
           case type
           when :up
             if @current_frame_index + 1 < @target_frames.size
-              @current_frame_index += 1 
+              @current_frame_index += 1
               show_src max_lines: 1
-              print_frame(@current_frame_index)
+              show_frame(@current_frame_index)
             end
           when :down
             if @current_frame_index > 0
               @current_frame_index -= 1
               show_src max_lines: 1
-              print_frame(@current_frame_index)
+              show_frame(@current_frame_index)
             end
           when :set
             if arg
@@ -361,28 +544,47 @@ module DEBUGGER__
               end
             end
             show_src max_lines: 1
-            print_frame(@current_frame_index)
+            show_frame(@current_frame_index)
           else
             raise "unsupported frame operation: #{arg.inspect}"
           end
           event! :result, nil
         when :show
-          type, = *args
+          type = args.shift
+
           case type
           when :backtrace
-            show_frame_all
+            show_frames
+
           when :list
-            show_src
-          when :locals
+            show_src(update_line: true, **(args.first || {}))
+
+          when :edit
+            show_by_editor(args.first)
+
+          when :local
+            show_frame
             show_locals
-          when :ivars
             show_ivars
+
+          when :object_info
+            expr = args.shift
+            show_object_info expr
+
           else
-            raise "unknown show param: " + args.inspect
+            raise "unknown show param: " + [type, *args].inspect
           end
+
           event! :result, nil
+
+        when :breakpoint
+          add_breakpoint args
+
+        when :dap
+          process_dap args
+
         else
-          raise [ev, *args].inspect
+          raise [cmd, *args].inspect
         end
       end
 
@@ -392,11 +594,20 @@ module DEBUGGER__
       pp [__FILE__, __LINE__, e, e.backtrace]
       raise
     ensure
-      @mode = nil
+      set_mode nil
     end
 
     def to_s
-      "(#{@thread.name || @thread.status})@#{current_frame&.location}"
+      loc = current_frame&.location
+
+      if loc
+        str = "(#{@thread.name || @thread.status})@#{loc}"
+      else
+        str = "(#{@thread.name || @thread.status})@#{@thread.to_s}"
+      end
+
+      str += " (not under control)" unless self.mode
+      str
     end
   end
 end