Use Session#request_tc to replace manual 'tc <<' calls

This allows the Session to send additional information along with each
request to the ThreadClient.

Author: st0012

lib/debug/server_cdp.rb

@@ -528,12 +528,12 @@ def fail_response req, **result
     def process_protocol_request req
       case req['method']
       when 'Debugger.stepOver', 'Debugger.stepInto', 'Debugger.stepOut', 'Debugger.resume', 'Debugger.getScriptSource', 'Debugger.enable'
-        @tc << [:cdp, :backtrace, req]
+        request_tc [:cdp, :backtrace, req]
       when 'Debugger.evaluateOnCallFrame'
         frame_id = req.dig('params', 'callFrameId')
         if fid = @frame_map[frame_id]
           expr = req.dig('params', 'expression')
-          @tc << [:cdp, :evaluate, req, fid, expr]
+          request_tc [:cdp, :evaluate, req, fid, expr]
         else
           fail_response req,
                         code: INVALID_PARAMS,
@@ -546,9 +546,9 @@ def process_protocol_request req
           when 'local'
             frame_id = ref[1]
             fid = @frame_map[frame_id]
-            @tc << [:cdp, :scope, req, fid]
+            request_tc [:cdp, :scope, req, fid]
           when 'properties'
-            @tc << [:cdp, :properties, req, oid]
+            request_tc [:cdp, :properties, req, oid]
           when 'script', 'global'
             # TODO: Support script and global types
             @ui.respond req

lib/debug/server_dap.rb

@@ -410,15 +410,15 @@ def process_protocol_request req
       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]
+          request_tc [:dap, :backtrace, req]
         else
           fail_response req
         end
@@ -427,7 +427,7 @@ def process_protocol_request req
         if @frame_map[frame_id]
           tid, fid = @frame_map[frame_id]
           if tc = find_waiting_tc(tid)
-            tc << [:dap, :scopes, req, fid]
+            request_tc [:dap, :scopes, req, fid]
           else
             fail_response req
           end
@@ -459,7 +459,7 @@ def process_protocol_request req
             tid, fid = @frame_map[frame_id]
 
             if tc = find_waiting_tc(tid)
-              tc << [:dap, :scope, req, fid]
+              request_tc [:dap, :scope, req, fid]
             else
               fail_response req
             end
@@ -468,7 +468,7 @@ def process_protocol_request req
             tid, vid = ref[1], ref[2]
 
             if tc = find_waiting_tc(tid)
-              tc << [:dap, :variable, req, vid]
+              request_tc [:dap, :variable, req, vid]
             else
               fail_response req
             end
@@ -486,7 +486,7 @@ def process_protocol_request req
           tid, fid = @frame_map[frame_id]
           expr = req.dig('arguments', 'expression')
           if tc = find_waiting_tc(tid)
-            tc << [:dap, :evaluate, req, fid, expr, context]
+            request_tc [:dap, :evaluate, req, fid, expr, context]
           else
             fail_response req
           end
@@ -512,7 +512,7 @@ def process_protocol_request req
           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

lib/debug/session.rb

@@ -202,6 +202,10 @@ def session_server_main
       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
@@ -225,14 +229,14 @@ def process_event evt
         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
@@ -257,7 +261,7 @@ def process_event evt
         if @displays.empty?
           wait_command_loop
         else
-          @tc << [:eval, :display, @displays]
+          request_tc [:eval, :display, @displays]
         end
       when :result
         raise "[BUG] not in subsession" unless @subsession
@@ -640,15 +644,15 @@ def process_command line
       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]`
@@ -661,13 +665,13 @@ def process_command line
       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
@@ -691,7 +695,7 @@ def process_command line
           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).
@@ -718,15 +722,15 @@ def process_command line
 
         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
@@ -742,7 +746,7 @@ def process_command line
       #   * 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.
@@ -751,9 +755,9 @@ def process_command line
       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`
@@ -766,7 +770,7 @@ def process_command line
           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
@@ -781,29 +785,29 @@ def process_command line
       # * `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.
@@ -813,7 +817,7 @@ def process_command line
           @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`
@@ -823,7 +827,7 @@ def process_command line
           @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
@@ -880,7 +884,7 @@ def process_command line
           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]
@@ -918,7 +922,7 @@ def process_command line
       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
@@ -1026,7 +1030,7 @@ def process_command line
         return :retry
       ### END
       else
-        @tc << [:eval, :pp, line]
+        request_tc [:eval, :pp, line]
 =begin
         @repl_prev_line = nil
         @ui.puts "unknown command: #{line}"
@@ -1083,7 +1087,7 @@ def step_command type, arg
       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
@@ -1092,7 +1096,7 @@ def step_command type, arg
           @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}"
@@ -1335,7 +1339,7 @@ def repl_add_breakpoint arg
       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
@@ -1362,7 +1366,7 @@ def repl_add_watch_breakpoint arg
       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
@@ -1546,7 +1550,7 @@ def get_thread_client th = Thread.current
 
       waiting_thread_clients.each{|tc|
         next if @tc == tc
-        tc << :continue
+        request_tc :continue
       }
     end
 
@@ -1562,7 +1566,7 @@ def get_thread_client th = Thread.current
       DEBUGGER__.info "leave_subsession"
       @process_group.unlock
       restart_all_threads
-      @tc << type if type
+      request_tc type if type
       @tc = nil
       @subsession = false
     rescue Exception => e