debug 1.4.0 → 1.9.2

data/lib/debug/server_dap.rb

@@ -3,52 +3,51 @@
 require 'json'
 require 'irb/completion'
 require 'tmpdir'
-require 'json'
 require 'fileutils'
 
 module DEBUGGER__
   module UI_DAP
     SHOW_PROTOCOL = ENV['DEBUG_DAP_SHOW_PROTOCOL'] == '1' || ENV['RUBY_DEBUG_DAP_SHOW_PROTOCOL'] == '1'
 
-    def self.setup sock_path
-      dir = Dir.mktmpdir("ruby-debug-vscode-")
-      at_exit{
-        CONFIG[:skip_path] = [//] # skip all
-        FileUtils.rm_rf dir
-      }
+    def self.setup debug_port
+      if File.directory? '.vscode'
+        dir = Dir.pwd
+      else
+        dir = Dir.mktmpdir("ruby-debug-vscode-")
+        tempdir = true
+      end
+
+      at_exit do
+        DEBUGGER__.skip_all
+        FileUtils.rm_rf dir if tempdir
+      end
+
+      key = rand.to_s
+
       Dir.chdir(dir) do
-        Dir.mkdir('.vscode')
-        open('README.rb', 'w'){|f|
-          f.puts <<~MSG
-          # Wait for starting the attaching to the Ruby process
-          # This file will be removed at the end of the debuggee process.
-          #
-          # Note that vscode-rdbg extension is needed. Please install if you don't have.
-          MSG
-        }
-        open('.vscode/launch.json', 'w'){|f|
+        Dir.mkdir('.vscode') if tempdir
+
+        # vscode-rdbg 0.0.9 or later is needed
+        open('.vscode/rdbg_autoattach.json', 'w') do |f|
           f.puts JSON.pretty_generate({
-            version: '0.2.0',
-            configurations: [
-            {
-              type: "rdbg",
-              name: "Attach with rdbg",
-              request: "attach",
-              rdbgPath: File.expand_path('../../exe/rdbg', __dir__),
-              debugPort: sock_path,
-              autoAttach: true,
-            }
-            ]
+            type: "rdbg",
+            name: "Attach with rdbg",
+            request: "attach",
+            rdbgPath: File.expand_path('../../exe/rdbg', __dir__),
+            debugPort: debug_port,
+            localfs: true,
+            autoAttach: key,
           })
-        }
+        end
       end
 
-      cmds = ['code', "#{dir}/", "#{dir}/README.rb"]
+      cmds = ['code', "#{dir}/"]
       cmdline = cmds.join(' ')
-      ssh_cmdline = "code --remote ssh-remote+[SSH hostname] #{dir}/ #{dir}/README.rb"
+      ssh_cmdline = "code --remote ssh-remote+[SSH hostname] #{dir}/"
 
       STDERR.puts "Launching: #{cmdline}"
       env = ENV.delete_if{|k, h| /RUBY/ =~ k}.to_h
+      env['RUBY_DEBUG_AUTOATTACH'] = key
 
       unless system(env, *cmds)
         DEBUGGER__.warn <<~MESSAGE
@@ -71,9 +70,71 @@ module DEBUGGER__
       end
     end
 
+    # true: all localfs
+    # Array: part of localfs
+    # nil: no localfs
+    @local_fs_map = nil
+
+    def self.remote_to_local_path path
+      case @local_fs_map
+      when nil
+        nil
+      when true
+        path
+      else # Array
+        @local_fs_map.each do |(remote_path_prefix, local_path_prefix)|
+          if path.start_with? remote_path_prefix
+            return path.sub(remote_path_prefix){ local_path_prefix }
+          end
+        end
+
+        nil
+      end
+    end
+
+    def self.local_to_remote_path path
+      case @local_fs_map
+      when nil
+        nil
+      when true
+        path
+      else # Array
+        @local_fs_map.each do |(remote_path_prefix, local_path_prefix)|
+          if path.start_with? local_path_prefix
+            return path.sub(local_path_prefix){ remote_path_prefix }
+          end
+        end
+
+        nil
+      end
+    end
+
+    def self.local_fs_map_set map
+      return if @local_fs_map # already setup
+
+      case map
+      when String
+        @local_fs_map = map.split(',').map{|e| e.split(':').map{|path| path.delete_suffix('/') + '/'}}
+      when true
+        @local_fs_map = map
+      when nil
+        @local_fs_map = CONFIG[:local_fs_map]
+      end
+    end
+
     def dap_setup bytes
       CONFIG.set_config no_color: true
       @seq = 0
+      @send_lock = Mutex.new
+
+      case self
+      when UI_UnixDomainServer
+        # If the user specified a mapping, respect it, otherwise, make sure that no mapping is used
+        UI_DAP.local_fs_map_set CONFIG[:local_fs_map] || true
+      when UI_TcpServer
+        # TODO: loopback address can be used to connect other FS env, like Docker containers
+        # UI_DAP.local_fs_set if @local_addr.ipv4_loopback? || @local_addr.ipv6_loopback?
+      end
 
       show_protocol :>, bytes
       req = JSON.load(bytes)
@@ -90,14 +151,13 @@ module DEBUGGER__
                {
                  filter: 'any',
                  label: 'rescue any exception',
-                 #supportsCondition: true,
+                 supportsCondition: true,
                  #conditionDescription: '',
                },
                {
                  filter: 'RuntimeError',
                  label: 'rescue RuntimeError',
-                 default: true,
-                 #supportsCondition: true,
+                 supportsCondition: true,
                  #conditionDescription: '',
                },
              ],
@@ -140,13 +200,26 @@ module DEBUGGER__
              # supportsInstructionBreakpoints:
       )
       send_event 'initialized'
+      puts <<~WELCOME
+        Ruby REPL: You can run any Ruby expression here.
+        Note that output to the STDOUT/ERR printed on the TERMINAL.
+        [experimental]
+          `,COMMAND` runs `COMMAND` debug command (ex: `,info`).
+          `,help` to list all debug commands.
+      WELCOME
     end
 
     def send **kw
-      kw[:seq] = @seq += 1
-      str = JSON.dump(kw)
-      show_protocol '<', str
-      @sock.write "Content-Length: #{str.bytesize}\r\n\r\n#{str}"
+      if sock = @sock
+        kw[:seq] = @seq += 1
+        str = JSON.dump(kw)
+        @send_lock.synchronize do
+          sock.write "Content-Length: #{str.bytesize}\r\n\r\n#{str}"
+        end
+        show_protocol '<', str
+      end
+    rescue Errno::EPIPE => e
+      $stderr.puts "#{e.inspect} rescued during sending message"
     end
 
     def send_response req, success: true, message: nil, **kw
@@ -178,17 +251,17 @@ module DEBUGGER__
     end
 
     def recv_request
-      r = IO.select([@sock])
+      IO.select([@sock])
 
       @session.process_group.sync do
         raise RetryBecauseCantRead unless IO.select([@sock], nil, nil, 0)
 
-        case header = @sock.gets
+        case @sock.gets
         when /Content-Length: (\d+)/
           b = @sock.read(2)
           raise b.inspect unless b == "\r\n"
 
-          l = @sock.read(s = $1.to_i)
+          l = @sock.read($1.to_i)
           show_protocol :>, l
           JSON.load(l)
         when nil
@@ -201,26 +274,81 @@ 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.inpsect}" 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')
+
+      case req['command']
+
+      ## 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
+
+        load_extensions req
+
+      when 'attach'
+        send_response req
+        UI_DAP.local_fs_map_set req.dig('arguments', 'localfs') || req.dig('arguments', 'localfsMap')
+
+        if req.dig('arguments', 'nonstop') == true
+          @nonstop = true
+        else
+          @nonstop = false
+        end
+
+        load_extensions req
+
+      when 'configurationDone'
+        send_response req
+
+        if @nonstop
+          @q_msg << 'continue'
+        else
+          if SESSION.in_subsession?
+            send_event 'stopped', reason: 'pause',
+                                  threadId: 1, # maybe ...
+                                  allThreadsStopped: true
+          end
+        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
 
-        ## boot/configuration
-        when 'launch'
-          send_response req
-          @is_attach = false
-        when 'attach'
-          send_response req
-          Process.kill(:SIGURG, Process.pid)
-          @is_attach = true
-        when 'setBreakpoints'
-          path = args.dig('source', 'path')
-          bp_args = args['breakpoints']
           bps = []
-          bp_args.each{|bp|
+          args['breakpoints'].each{|bp|
             line = bp['line']
             if cond = bp['condition']
               bps << SESSION.add_line_breakpoint(path, line, cond: cond)
@@ -229,114 +357,138 @@ module DEBUGGER__
             end
           }
           send_response req, breakpoints: (bps.map do |bp| {verified: true,} end)
-        when 'setFunctionBreakpoints'
-          send_response req
-        when 'setExceptionBreakpoints'
-          process_filter = ->(filter_id) {
+        else
+          send_response req, success: false, message: "#{req_path} is not available"
+        end
+
+      when 'setFunctionBreakpoints'
+        send_response req
+
+      when 'setExceptionBreakpoints'
+        process_filter = ->(filter_id, cond = nil) {
+          bp =
             case filter_id
             when 'any'
-              bp = SESSION.add_catch_breakpoint 'Exception'
+              SESSION.add_catch_breakpoint 'Exception', cond: cond
             when 'RuntimeError'
-              bp = SESSION.add_catch_breakpoint 'RuntimeError'
+              SESSION.add_catch_breakpoint 'RuntimeError', cond: cond
             else
-              bp = nil
+              nil
             end
             {
-              verified: bp ? true : false,
+              verified: !bp.nil?,
               message: bp.inspect,
             }
           }
 
+          SESSION.clear_catch_breakpoints 'Exception', 'RuntimeError'
+
           filters = args.fetch('filters').map {|filter_id|
             process_filter.call(filter_id)
           }
 
           filters += args.fetch('filterOptions', {}).map{|bp_info|
-            process_filter.call(bp_info.dig('filterId'))
-          }
+          process_filter.call(bp_info['filterId'], bp_info['condition'])
+        }
 
-          send_response req, breakpoints: filters
-        when 'configurationDone'
-          send_response req
-          if defined?(@is_attach) && @is_attach
-            @q_msg << 'p'
-            send_event 'stopped', reason: 'pause',
-                                  threadId: 1,
-                                  allThreadsStopped: true
+        send_response req, breakpoints: filters
+
+      when 'disconnect'
+        terminate = args.fetch("terminateDebuggee", false)
+
+        SESSION.clear_all_breakpoints
+        send_response req
+
+        if SESSION.in_subsession?
+          if terminate
+            @q_msg << 'kill!'
           else
             @q_msg << 'continue'
           end
-        when 'disconnect'
-          if args.fetch("terminateDebuggee", false)
+        else
+          if terminate
             @q_msg << 'kill!'
-          else
-            @q_msg << 'continue'
+            pause
           end
-          send_response req
+        end
 
-        ## 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"
-          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'
+      ## 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(:SIGURG, 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 'stackTrace',
-             'scopes',
-             'variables',
-             'evaluate',
-             'source',
-             'completions'
+      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'
+        @q_msg << req
 
+      else
+        if respond_to? mid = "custom_dap_request_#{req['command']}"
+          __send__ mid, req
         else
           raise "Unknown request: #{req.inspect}"
         end
@@ -345,25 +497,31 @@ module DEBUGGER__
 
     ## called by the SESSION thread
 
-    def readline prompt
-      @q_msg.pop || 'kill!'
-    end
-
-    def sock skip: false
-      yield $stderr
-    end
-
     def respond req, res
       send_response(req, **res)
     end
 
     def puts result
       # STDERR.puts "puts: #{result}"
-      # send_event 'output', category: 'stderr', output: "PUTS!!: " + result.to_s
+      send_event 'output', category: 'console', output: "#{result&.chomp}\n"
+    end
+
+    def ignore_output_on_suspend?
+      true
     end
 
     def event type, *args
       case type
+      when :load
+        file_path, reloaded = *args
+
+        if file_path
+          send_event 'loadedSource',
+                     reason: (reloaded ? :changed : :new),
+                     source: {
+                       path: file_path,
+                     }
+        end
       when :suspend_bp
         _i, bp, tid = *args
         if bp.kind_of?(CatchBreakpoint)
@@ -394,6 +552,8 @@ module DEBUGGER__
   end
 
   class Session
+    include GlobalVariablesHelper
+
     def find_waiting_tc id
       @th_clients.each{|th, tc|
         return tc if tc.id == id && tc.waiting?
@@ -410,15 +570,16 @@ module DEBUGGER__
       case req['command']
       when 'stepBack'
         if @tc.recorder&.can_step_back?
-          @tc << [:step, :back]
+          request_tc [:step, :back]
         else
           fail_response req, message: 'cancelled'
         end
 
       when 'stackTrace'
         tid = req.dig('arguments', 'threadId')
-        if tc = find_waiting_tc(tid)
-          tc << [:dap, :backtrace, req]
+
+        if find_waiting_tc(tid)
+          request_tc [:dap, :backtrace, req]
         else
           fail_response req
         end
@@ -426,8 +587,8 @@ module DEBUGGER__
         frame_id = req.dig('arguments', 'frameId')
         if @frame_map[frame_id]
           tid, fid = @frame_map[frame_id]
-          if tc = find_waiting_tc(tid)
-            tc << [:dap, :scopes, req, fid]
+          if find_waiting_tc(tid)
+            request_tc [:dap, :scopes, req, fid]
           else
             fail_response req
           end
@@ -439,8 +600,12 @@ module DEBUGGER__
         if ref = @var_map[varid]
           case ref[0]
           when :globals
-            vars = global_variables.map do |name|
-              gv = 'Not implemented yet...'
+            vars = safe_global_variables.sort.map do |name|
+              begin
+                gv = eval(name.to_s)
+              rescue Exception => e
+                gv = e.inspect
+              end
               {
                 name: name,
                 value: gv.inspect,
@@ -458,8 +623,8 @@ module DEBUGGER__
             frame_id = ref[1]
             tid, fid = @frame_map[frame_id]
 
-            if tc = find_waiting_tc(tid)
-              tc << [:dap, :scope, req, fid]
+            if find_waiting_tc(tid)
+              request_tc [:dap, :scope, req, fid]
             else
               fail_response req
             end
@@ -467,8 +632,8 @@ module DEBUGGER__
           when :variable
             tid, vid = ref[1], ref[2]
 
-            if tc = find_waiting_tc(tid)
-              tc << [:dap, :variable, req, vid]
+            if find_waiting_tc(tid)
+              request_tc [:dap, :variable, req, vid]
             else
               fail_response req
             end
@@ -485,8 +650,10 @@ module DEBUGGER__
         if @frame_map[frame_id]
           tid, fid = @frame_map[frame_id]
           expr = req.dig('arguments', 'expression')
-          if tc = find_waiting_tc(tid)
-            tc << [:dap, :evaluate, req, fid, expr, context]
+
+          if find_waiting_tc(tid)
+            restart_all_threads
+            request_tc [:dap, :evaluate, req, fid, expr, context]
           else
             fail_response req
           end
@@ -496,7 +663,7 @@ module DEBUGGER__
       when 'source'
         ref = req.dig('arguments', 'sourceReference')
         if src = @src_map[ref]
-          @ui.respond req, content: src.join
+          @ui.respond req, content: src.join("\n")
         else
           fail_response req, message: 'not found...'
         end
@@ -506,34 +673,43 @@ module DEBUGGER__
         frame_id = req.dig('arguments', 'frameId')
         tid, fid = @frame_map[frame_id]
 
-        if tc = find_waiting_tc(tid)
+        if find_waiting_tc(tid)
           text = req.dig('arguments', 'text')
           line = req.dig('arguments', 'line')
           if col  = req.dig('arguments', 'column')
             text = text.split(/\n/)[line.to_i - 1][0...(col.to_i - 1)]
           end
-          tc << [:dap, :completions, req, fid, text]
+          request_tc [:dap, :completions, req, fid, text]
         else
           fail_response req
         end
       else
-        raise "Unknown DAP request: #{req.inspect}"
+        if respond_to? mid = "custom_dap_request_#{req['command']}"
+          __send__ mid, req
+        else
+          raise "Unknown request: #{req.inspect}"
+        end
       end
     end
 
-    def dap_event args
+    def process_protocol_result args
       # puts({dap_event: args}.inspect)
       type, req, result = args
 
       case type
       when :backtrace
-        result[:stackFrames].each.with_index{|fi, i|
+        result[:stackFrames].each{|fi|
+          frame_depth = fi[:id]
           fi[:id] = id = @frame_map.size + 1
-          @frame_map[id] = [req.dig('arguments', 'threadId'), i]
-          if fi[:source] && src = fi[:source][:sourceReference]
-            src_id = @src_map.size + 1
-            @src_map[src_id] = src
-            fi[:source][:sourceReference] = src_id
+          @frame_map[id] = [req.dig('arguments', 'threadId'), frame_depth]
+          if fi[:source]
+            if src = fi[:source][:sourceReference]
+              src_id = @src_map.size + 1
+              @src_map[src_id] = src
+              fi[:source][:sourceReference] = src_id
+            else
+              fi[:source][:sourceReference] = 0
+            end
           end
         }
         @ui.respond req, result
@@ -553,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
@@ -564,7 +741,11 @@ module DEBUGGER__
       when :completions
         @ui.respond req, result
       else
-        raise "unsupported: #{args.inspect}"
+        if respond_to? mid = "custom_dap_request_event_#{type}"
+          __send__ mid, req, result
+        else
+          raise "unsupported: #{args.inspect}"
+        end
       end
     end
 
@@ -584,7 +765,37 @@ module DEBUGGER__
     end
   end
 
+  class NaiveString
+    attr_reader :str
+    def initialize str
+      @str = str
+    end
+  end
+
   class ThreadClient
+    MAX_LENGTH = 180
+
+    def value_inspect obj, short: true
+      # TODO: max length should be configuarable?
+      str = DEBUGGER__.safe_inspect obj, short: short, max_length: MAX_LENGTH
+
+      if str.encoding == Encoding::UTF_8
+        str.scrub
+      else
+        str.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+      end
+    end
+
+    def dap_eval b, expr, _context, prompt: '(repl_eval)'
+      begin
+        tp_allow_reentry do
+          b.eval(expr.to_s, prompt)
+        end
+      rescue Exception => e
+        e
+      end
+    end
+
     def process_dap args
       # pp tc: self, args: args
       type = args.shift
@@ -592,27 +803,43 @@ module DEBUGGER__
 
       case type
       when :backtrace
-        event! :dap_result, :backtrace, req, {
-          stackFrames: @target_frames.map{|frame|
-            path = frame.realpath || frame.path
-            ref = frame.file_lines unless path && File.exist?(path)
+        start_frame = req.dig('arguments', 'startFrame') || 0
+        levels = req.dig('arguments', 'levels') || 1_000
+        frames = []
+        @target_frames.each_with_index do |frame, i|
+          next if i < start_frame
+
+          path = frame.realpath || frame.path
+          next if skip_path?(path) && !SESSION.stop_stepping?(path, frame.location.lineno)
+          break if (levels -= 1) < 0
+          source_name = path ? File.basename(path) : frame.location.to_s
+
+          if (path && File.exist?(path)) && (local_path = UI_DAP.remote_to_local_path(path))
+            # ok
+          else
+            ref = frame.file_lines
+          end
 
-            {
-              # id: ??? # filled by SESSION
-              name: frame.name,
-              line: frame.location.lineno,
-              column: 1,
-              source: {
-                name: File.basename(frame.path),
-                path: path,
-                sourceReference: ref,
-              },
-            }
+          frames << {
+            id: i, # id is refilled by SESSION
+            name: frame.name,
+            line: frame.location.lineno,
+            column: 1,
+            source: {
+              name: source_name,
+              path: (local_path || path),
+              sourceReference: ref,
+            },
           }
+        end
+
+        event! :protocol_result, :backtrace, req, {
+          stackFrames: frames,
+          totalFrames: @target_frames.size,
         }
       when :scopes
         fid = args.shift
-        frame = @target_frames[fid]
+        frame = get_frame(fid)
 
         lnum =
           if frame.binding
@@ -623,7 +850,7 @@ module DEBUGGER__
             0
           end
 
-        event! :dap_result, :scopes, req, scopes: [{
+        event! :protocol_result, :scopes, req, scopes: [{
           name: 'Local variables',
           presentationHint: 'locals',
           # variablesReference: N, # filled by SESSION
@@ -634,34 +861,18 @@ module DEBUGGER__
           name: 'Global variables',
           presentationHint: 'globals',
           variablesReference: 1, # GLOBAL
-          namedVariables: global_variables.size,
+          namedVariables: safe_global_variables.size,
           indexedVariables: 0,
           expensive: false,
         }]
       when :scope
         fid = args.shift
-        frame = @target_frames[fid]
-        if b = frame.binding
-          vars = b.local_variables.map{|name|
-            v = b.local_variable_get(name)
-            variable(name, v)
-          }
-          special_local_variables frame do |name, val|
-            vars.unshift variable(name, val)
-          end
-          vars.unshift variable('%self', b.receiver)
-        elsif lvars = frame.local_variables
-          vars = lvars.map{|var, val|
-            variable(var, val)
-          }
-        else
-          vars = [variable('%self', frame.self)]
-          special_local_variables frame do |name, val|
-            vars.push variable(name, val)
-          end
+        frame = get_frame(fid)
+        vars = collect_locals(frame).map do |var, val|
+          variable(var, val)
         end
-        event! :dap_result, :scope, req, variables: vars, tid: self.id
 
+        event! :protocol_result, :scope, req, variables: vars, tid: self.id
       when :variable
         vid = args.shift
         obj = @var_map[vid]
@@ -679,7 +890,7 @@ module DEBUGGER__
             case obj
             when Hash
               vars = obj.map{|k, v|
-                variable(DEBUGGER__.safe_inspect(k), v,)
+                variable(value_inspect(k), v,)
               }
             when Struct
               vars = obj.members.map{|m|
@@ -688,13 +899,12 @@ module DEBUGGER__
             when String
               vars = [
                 variable('#length', obj.length),
-                variable('#encoding', obj.encoding)
+                variable('#encoding', obj.encoding),
               ]
+              printed_str = value_inspect(obj)
+              vars << variable('#dump', NaiveString.new(obj)) if printed_str.end_with?('...')
             when Class, Module
-              vars = obj.instance_variables.map{|iv|
-                variable(iv, obj.instance_variable_get(iv))
-              }
-              vars.unshift variable('%ancestors', obj.ancestors[1..])
+              vars << variable('%ancestors', obj.ancestors[1..])
             when Range
               vars = [
                 variable('#begin', obj.begin),
@@ -702,62 +912,57 @@ module DEBUGGER__
               ]
             end
 
-            vars += obj.instance_variables.map{|iv|
-              variable(iv, obj.instance_variable_get(iv))
-            }
-            vars.unshift variable('#class', obj.class)
+            unless NaiveString === obj
+              vars += M_INSTANCE_VARIABLES.bind_call(obj).sort.map{|iv|
+                variable(iv, M_INSTANCE_VARIABLE_GET.bind_call(obj, iv))
+              }
+              vars.unshift variable('#class', M_CLASS.bind_call(obj))
+            end
           end
         end
-        event! :dap_result, :variable, req, variables: (vars || []), tid: self.id
+        event! :protocol_result, :variable, req, variables: (vars || []), tid: self.id
 
       when :evaluate
         fid, expr, context = args
-        frame = @target_frames[fid]
+        frame = get_frame(fid)
         message = nil
 
-        if frame && (b = frame.binding)
-          b = b.dup
-          special_local_variables current_frame do |name, var|
+        if frame && (b = frame.eval_binding)
+          special_local_variables frame do |name, var|
             b.local_variable_set(name, var) if /\%/ !~ name
           end
 
           case context
           when 'repl', 'watch'
-            begin
-              result = b.eval(expr.to_s, '(DEBUG CONSOLE)')
-            rescue Exception => e
-              result = e
-            end
-
+            result = dap_eval b, expr, context, prompt: '(DEBUG CONSOLE)'
           when 'hover'
             case expr
             when /\A\@\S/
               begin
-                (r = b.receiver).instance_variable_defined?(expr) or raise(NameError)
-                result = r.instance_variable_get(expr)
+                result = M_INSTANCE_VARIABLE_GET.bind_call(b.receiver, expr)
               rescue NameError
                 message = "Error: Not defined instance variable: #{expr.inspect}"
               end
             when /\A\$\S/
-              global_variables.each{|gvar|
+              safe_global_variables.each{|gvar|
                 if gvar.to_s == expr
                   result = eval(gvar.to_s)
                   break false
                 end
               } and (message = "Error: Not defined global variable: #{expr.inspect}")
-            when /\A[A-Z]/
-              unless result = search_const(b, expr)
+            when /\Aself$/
+              result = b.receiver
+            when /(\A((::[A-Z]|[A-Z])\w*)+)/
+              unless result = search_const(b, $1)
                 message = "Error: Not defined constants: #{expr.inspect}"
               end
             else
               begin
-                # try to check local variables
-                b.local_variable_defined?(expr) or raise NameError
                 result = b.local_variable_get(expr)
               rescue NameError
                 # try to check method
-                if b.receiver.respond_to? expr, include_all: true
-                  result = b.receiver.method(expr)
+                if M_RESPOND_TO_P.bind_call(b.receiver, expr, include_all: true)
+                  result = M_METHOD.bind_call(b.receiver, expr)
                 else
                   message = "Error: Can not evaluate: #{expr.inspect}"
                 end
@@ -770,17 +975,19 @@ module DEBUGGER__
           result = 'Error: Can not evaluate on this frame'
         end
 
-        event! :dap_result, :evaluate, req, message: message, tid: self.id, **evaluate_result(result)
+        event! :protocol_result, :evaluate, req, message: message, tid: self.id, **evaluate_result(result)
 
       when :completions
         fid, text = args
-        frame = @target_frames[fid]
+        frame = get_frame(fid)
 
         if (b = frame&.binding) && word = text&.split(/[\s\{]/)&.last
           words = IRB::InputCompletor::retrieve_completion_data(word, bind: b).compact
         end
 
-        event! :dap_result, :completions, req, targets: (words || []).map{|phrase|
+        event! :protocol_result, :completions, req, targets: (words || []).map{|phrase|
+          detail = nil
+
           if /\b([_a-zA-Z]\w*[!\?]?)\z/ =~ phrase
             w = $1
           else
@@ -788,30 +995,37 @@ module DEBUGGER__
           end
 
           begin
-            if b&.local_variable_defined?(w)
-              v = b.local_variable_get(w)
-              phrase += " (variable:#{DEBUGGER__.safe_inspect(v)})"
-            end
+            v = b.local_variable_get(w)
+            detail ="(variable: #{value_inspect(v)})"
           rescue NameError
           end
 
           {
             label: phrase,
             text: w,
+            detail: detail,
           }
         }
 
       else
-        raise "Unknown req: #{args.inspect}"
+        if respond_to? mid = "custom_dap_request_#{type}"
+          __send__ mid, req
+        else
+          raise "Unknown request: #{args.inspect}"
+        end
       end
     end
 
     def search_const b, expr
-      cs = expr.split('::')
-      [Object, *b.eval('Module.nesting')].reverse_each{|mod|
+      cs = expr.delete_prefix('::').split('::')
+      [Object, *b.eval('::Module.nesting')].reverse_each{|mod|
         if cs.all?{|c|
              if mod.const_defined?(c)
-               mod = mod.const_get(c)
+               begin
+                 mod = mod.const_get(c)
+               rescue Exception
+                 false
+               end
              else
                false
              end
@@ -824,11 +1038,17 @@ module DEBUGGER__
     end
 
     def evaluate_result r
-      v = variable nil, r
-      v.delete :name
-      v.delete :value
-      v[:result] = DEBUGGER__.safe_inspect(r)
-      v
+      variable nil, r
+    end
+
+    def type_name obj
+      klass = M_CLASS.bind_call(obj)
+
+      begin
+        M_NAME.bind_call(klass) || klass.to_s
+      rescue Exception => e
+        "<Error: #{e.message} (#{e.backtrace.first}>"
+      end
     end
 
     def variable_ name, obj, indexedVariables: 0, namedVariables: 0
@@ -839,15 +1059,31 @@ module DEBUGGER__
         vid = 0
       end
 
-      ivnum = obj.instance_variables.size
+      namedVariables += M_INSTANCE_VARIABLES.bind_call(obj).size
 
-      { name: name,
-        value: DEBUGGER__.safe_inspect(obj),
-        type: obj.class.name || obj.class.to_s,
-        variablesReference: vid,
-        indexedVariables: indexedVariables,
-        namedVariables: namedVariables + ivnum,
-      }
+      if NaiveString === obj
+        str = obj.str.dump
+        vid = indexedVariables = namedVariables = 0
+      else
+        str = value_inspect(obj)
+      end
+
+      if name
+        { name: name,
+          value: str,
+          type: type_name(obj),
+          variablesReference: vid,
+          indexedVariables: indexedVariables,
+          namedVariables: namedVariables,
+        }
+      else
+        { result: str,
+          type: type_name(obj),
+          variablesReference: vid,
+          indexedVariables: indexedVariables,
+          namedVariables: namedVariables,
+        }
+      end
     end
 
     def variable name, obj
@@ -857,7 +1093,7 @@ module DEBUGGER__
       when Hash
         variable_ name, obj, namedVariables: obj.size
       when String
-        variable_ name, obj, namedVariables: 3 # #to_str, #length, #encoding
+        variable_ name, obj, namedVariables: 3 # #length, #encoding, #to_str
       when Struct
         variable_ name, obj, namedVariables: obj.size
       when Class, Module