mt-lang 0.2.0

data/lib/milk_tea/dap/server/handlers.rb

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module DAP
+    class Server
+      module ServerHandlers
+        private
+
+        def handle_initialize(message)
+          if @session.initialized?
+            write_error_response(message, "initialize can only be called once")
+            return
+          end
+
+          @session.initialize!
+
+          if default_backend_kind == "lldb-dap"
+            start_lldb_backend({})
+            backend_response = ensure_backend_initialized(message["arguments"] || {})
+            return write_backend_response(message, backend_response) unless backend_response["success"]
+          end
+
+          write_response(message, effective_adapter_capabilities)
+
+          write_event("initialized")
+        end
+
+        def handle_set_breakpoints(message)
+          args = message["arguments"] || {}
+          source = args["source"] || {}
+          source_path = source["path"].to_s
+          requested = args["breakpoints"] || Array(args["lines"]).map { |line| { "line" => line } }
+          breakpoints = @session.set_breakpoints(source_path, requested)
+
+          if using_lldb_backend?
+            if backend_configuration_pending?
+              @breakpoints_synced_to_backend = false
+              write_response(message, { breakpoints: breakpoints })
+              return
+            end
+
+            backend_response = backend_request("setBreakpoints", {
+              "source" => source,
+              "breakpoints" => requested
+            })
+            @breakpoints_synced_to_backend = false if backend_response["success"]
+            return write_backend_response(message, backend_response)
+          end
+
+          # Process backend: mark breakpoints unverified
+          if default_backend_kind == "process"
+            breakpoints.each do |bp|
+              bp["verified"] = false
+              bp["message"] = "Process backend runs without a debugger; set breakpoints via lldb-dap backend instead."
+            end
+          end
+
+          write_response(message, { breakpoints: breakpoints })
+        end
+
+        def handle_set_function_breakpoints(message)
+          args = message["arguments"] || {}
+          requested = args["breakpoints"] || []
+          breakpoints = @session.set_function_breakpoints(requested)
+
+          if using_lldb_backend?
+            if backend_configuration_pending?
+              @function_breakpoints_synced_to_backend = false
+              write_response(message, { breakpoints: breakpoints })
+              return
+            end
+
+            backend_response = backend_request("setFunctionBreakpoints", {
+              "breakpoints" => requested
+            })
+            @function_breakpoints_synced_to_backend = false if backend_response["success"]
+            return write_backend_response(message, backend_response)
+          end
+
+          write_response(message, { breakpoints: breakpoints })
+        end
+
+        def handle_configuration_done(message)
+          @session.configuration_done!
+
+          if using_lldb_backend?
+            backend_response = ensure_backend_initialized({})
+            return write_backend_response(message, backend_response) unless backend_response["success"]
+
+            unless wait_for_backend_configuration_ready
+              write_error_response(message, "lldb-dap did not become ready for configuration")
+              return
+            end
+
+            sync_breakpoints_to_backend
+            sync_function_breakpoints_to_backend
+            sync_exception_breakpoints_to_backend
+            backend_response = backend_request("configurationDone", {})
+            return write_backend_response(message, backend_response) unless backend_response["success"]
+
+            if @backend_auto_continue_after_configuration
+              continue_response = backend_request("continue", backend_continue_arguments)
+              @backend_auto_continue_after_configuration = false
+              return write_error_response(message, backend_error_message(continue_response)) unless continue_response["success"]
+            end
+
+            write_response(message, backend_response["body"] || {})
+            return
+          end
+
+          write_response(message, {})
+          maybe_start_or_stop_on_entry
+        end
+
+        def handle_launch(message)
+          request_start(message)
+        end
+
+        def handle_attach(message)
+          args = message["arguments"] || {}
+          unless args["backend"].to_s == "lldb-dap"
+            write_error_response(message, "attach requires the lldb-dap backend")
+            return
+          end
+
+          request_start(message)
+        end
+
+        def handle_threads(message)
+          return write_backend_response(message, backend_request("threads", {})) if using_lldb_backend?
+
+          write_response(message, {
+            threads: [
+              { id: @session.thread_id, name: "main" }
+            ]
+          })
+        end
+
+        def handle_stack_trace(message)
+          if using_lldb_backend?
+            maybe_load_debug_map_from_backend_modules
+            backend_response = backend_request("stackTrace", message["arguments"] || {})
+            rewrite_stack_trace_response(backend_response)
+            return write_backend_response(message, backend_response)
+          end
+
+          source_path = @session.program_path || "(unknown)"
+          write_response(message, {
+            stackFrames: [
+              {
+                id: 1,
+                name: "main",
+                line: 1,
+                column: 1,
+                source: {
+                  name: File.basename(source_path),
+                  path: source_path
+                }
+              }
+            ],
+            totalFrames: 1
+          })
+        end
+
+        def handle_scopes(message)
+          if using_lldb_backend?
+            arguments = message["arguments"] || {}
+            backend_response = backend_request("scopes", arguments)
+            rewrite_scopes_response(backend_response, arguments["frameId"])
+            return write_backend_response(message, backend_response)
+          end
+
+          write_response(message, {
+            scopes: [
+              {
+                name: "Locals",
+                variablesReference: 1,
+                expensive: false
+              }
+            ]
+          })
+        end
+
+        def handle_variables(message)
+          if using_lldb_backend?
+            arguments = message["arguments"] || {}
+            backend_response = backend_request("variables", arguments)
+            rewrite_variables_response(backend_response, arguments["variablesReference"])
+            return write_backend_response(message, backend_response)
+          end
+
+          _args = message["arguments"] || {}
+          write_response(message, { variables: [] })
+        end
+
+        def handle_continue(message)
+          return write_backend_response(message, backend_request("continue", message["arguments"] || {})) if using_lldb_backend?
+
+          start_runtime_if_needed
+          continue_runtime_if_paused
+          write_response(message, { allThreadsContinued: true })
+          write_event("continued", {
+            threadId: @session.thread_id,
+            allThreadsContinued: true
+          })
+        end
+
+        def handle_next(message)
+          return write_backend_response(message, backend_request("next", message["arguments"] || {})) if using_lldb_backend?
+
+          write_error_response(message, "next is not supported by the process backend")
+        end
+
+        def handle_step_in(message)
+          return write_backend_response(message, backend_request("stepIn", message["arguments"] || {})) if using_lldb_backend?
+
+          write_error_response(message, "stepIn is not supported by the process backend")
+        end
+
+        def handle_step_out(message)
+          return write_backend_response(message, backend_request("stepOut", message["arguments"] || {})) if using_lldb_backend?
+
+          write_error_response(message, "stepOut is not supported by the process backend")
+        end
+
+        def handle_pause(message)
+          if using_lldb_backend?
+            @backend_pause_requested = true
+            backend_response = backend_request("pause", message["arguments"] || {})
+            @backend_pause_requested = false unless backend_response["success"]
+            return write_backend_response(message, backend_response)
+          end
+
+          unless pause_runtime_if_running
+            return write_error_response(message, "pause failed: process is not running")
+          end
+
+          write_response(message, {})
+          write_event("stopped", {
+            reason: "pause",
+            threadId: @session.thread_id,
+            allThreadsStopped: true
+          })
+        end
+
+        def handle_terminate(message)
+          if using_lldb_backend?
+            backend_response = request_backend_terminate(message["arguments"] || {})
+            write_backend_response(message, backend_response)
+            return
+          end
+
+          terminate_runtime_if_running
+          write_response(message, {})
+          return if @session.runtime_started?
+
+          @session.terminate!
+          write_event("terminated")
+          write_event("exited", { exitCode: 0 })
+          cleanup_tmp_dirs
+          @session.request_exit!
+        end
+
+        def handle_disconnect(message)
+          if using_lldb_backend?
+            join_background_threads
+            backend_response = backend_request("disconnect", message["arguments"] || {})
+            write_backend_response(message, backend_response)
+            stop_lldb_backend
+            cleanup_tmp_dirs
+            @session.request_exit!
+            return
+          end
+
+          write_response(message, {})
+          terminate_runtime_if_running
+          unless @session.runtime_started?
+            @session.terminate!
+            write_event("terminated")
+            write_event("exited", { exitCode: 0 })
+          end
+          cleanup_tmp_dirs
+          @session.request_exit!
+        end
+
+        def handle_set_exception_breakpoints(message)
+          arguments = message["arguments"] || {}
+          @session.set_exception_breakpoints(arguments)
+
+          if using_lldb_backend?
+            if backend_configuration_pending?
+              @exception_breakpoints_synced_to_backend = false
+              write_response(message, {})
+              return
+            end
+
+            backend_response = backend_request("setExceptionBreakpoints", arguments)
+            @exception_breakpoints_synced_to_backend = false if backend_response["success"]
+            return write_backend_response(message, backend_response)
+          end
+
+          write_response(message, {})
+        end
+
+        def handle_evaluate(message)
+          if using_lldb_backend?
+            arguments = rewrite_evaluate_arguments(message["arguments"] || {})
+            return write_backend_response(message, backend_request("evaluate", arguments))
+          end
+
+          write_error_response(message, "evaluate is not supported by the process backend")
+        end
+
+        def handle_set_expression(message)
+          if using_lldb_backend?
+            arguments = rewrite_set_expression_arguments(message["arguments"] || {})
+            return write_backend_response(message, backend_request("setExpression", arguments))
+          end
+
+          write_error_response(message, "setExpression is not supported by the process backend")
+        end
+
+        def handle_set_variable(message)
+          if using_lldb_backend?
+            arguments = rewrite_set_variable_arguments(message["arguments"] || {})
+            return write_backend_response(message, request_set_variable(arguments))
+          end
+
+          write_error_response(message, "setVariable is not supported by the process backend")
+        end
+
+        def handle_data_breakpoint_info(message)
+          if using_lldb_backend?
+            arguments = rewrite_data_breakpoint_info_arguments(message["arguments"] || {})
+            return write_backend_response(message, backend_request("dataBreakpointInfo", arguments))
+          end
+
+          write_error_response(message, "dataBreakpointInfo is not supported by the process backend")
+        end
+
+        def handle_source(message)
+          return write_backend_response(message, backend_request("source", message["arguments"] || {})) if using_lldb_backend?
+
+          write_error_response(message, "source retrieval is not supported")
+        end
+
+        def handle_loaded_sources(message)
+          return write_backend_response(message, backend_request("loadedSources", message["arguments"] || {})) if using_lldb_backend?
+
+          write_response(message, { sources: [] })
+        end
+
+        def handle_restart(message)
+          return write_backend_response(message, backend_request("restart", message["arguments"] || {})) if using_lldb_backend?
+
+          write_error_response(message, "restart is not supported by the process backend")
+        end
+
+        def handle_cancel(message)
+          args = message["arguments"] || {}
+          request_id = args["requestId"] || args["progressId"]
+
+          if using_lldb_backend?
+            backend_response = backend_request("cancel", { "requestId" => request_id }.compact)
+            write_backend_response(message, backend_response)
+          else
+            join_background_threads(timeout: 0.1)
+            write_response(message, {})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/milk_tea/dap/server/launch.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module DAP
+    class Server
+      module ServerLaunch
+        private
+
+        def request_start(message)
+          if @session.launched?
+            write_error_response(message, "Program already launched")
+            return
+          end
+
+          args = message["arguments"] || {}
+          if message["command"] == "launch" && args["program"].to_s.empty?
+            write_error_response(message, "launch requires a non-empty 'program' argument")
+            return
+          end
+
+          resolved = resolve_debug_program(message["command"], args["program"])
+          unless resolved[:ok]
+            write_error_response(message, resolved[:error])
+            return
+          end
+
+          program_args = args["args"] || []
+          unless program_args.is_a?(Array)
+            write_error_response(message, "launch 'args' must be an array when provided")
+            return
+          end
+
+          no_debug = message["command"] == "launch" && args["noDebug"] == true
+          stop_on_entry = no_debug ? false : (args.key?("stopOnEntry") ? !!args["stopOnEntry"] : true)
+          backend_kind = if no_debug
+                           "process"
+                         else
+                           resolved_backend_kind(args["backend"])
+                         end
+          unless backend_kind
+            write_error_response(message, "unsupported backend: #{args['backend']}")
+            return
+          end
+
+          @session.request_start!(
+            program_path: args["program"].to_s.empty? ? nil : args["program"],
+            runnable_path: resolved[:runnable_path],
+            program_args:,
+            stop_on_entry:,
+            backend_kind:
+          )
+          @session.launch!
+          @backend_auto_continue_after_configuration = using_lldb_backend? && message["command"] == "launch" && !stop_on_entry
+          @backend_stopped_thread_id = nil if using_lldb_backend?
+          @last_forwarded_continued_signature = nil
+          load_debug_map(resolved[:runnable_path])
+
+          if using_lldb_backend?
+            start_lldb_backend(args)
+            reset_backend_configuration_ready
+            init_response = ensure_backend_initialized({})
+            return write_backend_response(message, init_response) unless init_response["success"]
+
+            # Merge backend capabilities with adapter capabilities and notify the client.
+            merged_caps = effective_adapter_capabilities
+            write_event("capabilities", merged_caps)
+
+            launch_arguments = backend_start_arguments(message["command"], args, resolved)
+            @breakpoints_synced_to_backend = false
+            @function_breakpoints_synced_to_backend = false
+            @exception_breakpoints_synced_to_backend = false
+            start_backend_start_request(message, launch_arguments)
+            return
+          end
+
+          write_response(message, {})
+          write_event("process", {
+            name: File.basename(@session.program_path.to_s),
+            startMethod: "launch",
+            isLocalProcess: true
+          })
+          maybe_start_or_stop_on_entry
+        end
+
+        def maybe_start_or_stop_on_entry
+          return if using_lldb_backend?
+
+          return unless @session.launched?
+          return unless @session.configuration_done?
+          return if @session.runtime_started?
+
+          if @session.stop_on_entry?
+            return if @session.entry_stop_emitted?
+
+            write_stopped("entry")
+            @session.mark_entry_stop_emitted!
+          else
+            start_runtime_if_needed
+          end
+        end
+
+        def write_stopped(reason)
+          write_event("stopped", {
+            reason: reason,
+            threadId: @session.thread_id,
+            allThreadsStopped: true
+          })
+        end
+
+        def default_backend_kind
+          @preferred_backend_kind
+        end
+
+        def resolved_backend_kind(requested_backend)
+          backend = requested_backend.to_s.strip
+          backend = default_backend_kind if backend.empty?
+          return backend if backend == "process" || backend == "lldb-dap"
+
+          nil
+        end
+
+        def resolve_launch_program(program)
+          path = program.to_s
+          return { ok: false, error: "launch requires a non-empty 'program' argument" } if path.empty?
+
+          expanded = File.expand_path(path)
+          if expanded.end_with?(".mt")
+            return { ok: false, error: "Milk Tea program not found: #{expanded}" } unless File.file?(expanded)
+
+            tmp_dir = Dir.mktmpdir("milk-tea-dap")
+            @tmp_dirs << tmp_dir
+            output_path = File.join(tmp_dir, File.basename(expanded, ".mt"))
+
+            begin
+              Build.build(expanded, output_path:, debug: true, debug_guards: false)
+            rescue BuildError => e
+              return { ok: false, error: e.message }
+            end
+
+            return { ok: true, runnable_path: output_path }
+          end
+
+          return { ok: false, error: "Program not found: #{expanded}" } unless File.file?(expanded)
+
+          { ok: true, runnable_path: expanded }
+        end
+
+        def resolve_debug_program(command, program)
+          return resolve_launch_program(program) if command == "launch"
+
+          path = program.to_s
+          return { ok: true, runnable_path: nil } if path.empty?
+
+          resolve_launch_program(path)
+        end
+
+        def backend_start_arguments(command, arguments, resolved)
+          rewritten = arguments.dup
+
+          rewritten.delete("backend")
+          rewritten.delete("adapterPath")
+
+          if resolved[:runnable_path]
+            rewritten["program"] = resolved[:runnable_path]
+          elsif rewritten["program"].to_s.empty?
+            rewritten.delete("program")
+          end
+
+          rewritten["stopOnEntry"] = true if command == "launch"
+
+          rewritten["cwd"] = File.expand_path(rewritten["cwd"]) if rewritten["cwd"].is_a?(String) && !rewritten["cwd"].empty?
+          rewritten["coreFile"] = File.expand_path(rewritten["coreFile"]) if rewritten["coreFile"].is_a?(String) && !rewritten["coreFile"].empty?
+          rewritten
+        end
+
+        def start_runtime_if_needed
+          return if @session.runtime_started?
+          return unless @session.runnable_path
+
+          @session.mark_runtime_started!
+          runnable_path = @session.runnable_path
+          command = [runnable_path, *@session.program_args]
+          chdir = File.dirname(File.expand_path(@session.program_path || runnable_path))
+
+          Thread.new do
+            Open3.popen3(*command, chdir:) do |stdin, stdout, stderr, wait_thr|
+              stdin.close
+              @runtime_mutex.synchronize { @runtime_pid = wait_thr.pid }
+
+              out_thread = Thread.new do
+                stdout.each_line do |line|
+                  write_event("output", { category: "stdout", output: line })
+                end
+              end
+
+              err_thread = Thread.new do
+                stderr.each_line do |line|
+                  write_event("output", { category: "stderr", output: line })
+                end
+              end
+
+              out_thread.join
+              err_thread.join
+
+              status = wait_thr.value
+              exit_code = status.exited? ? status.exitstatus : 1
+              @session.terminate!
+
+              write_event("terminated")
+              write_event("exited", { exitCode: exit_code })
+              @session.request_exit!
+            end
+          rescue StandardError => e
+            @session.terminate!
+            write_event("output", { category: "stderr", output: "DAP runtime error: #{e.message}\n" })
+            write_event("terminated")
+            write_event("exited", { exitCode: 1 })
+            @session.request_exit!
+          ensure
+            @runtime_mutex.synchronize do
+              @runtime_pid = nil
+              @runtime_paused = false
+            end
+          end
+        end
+
+        def pause_runtime_if_running
+          pid = @runtime_mutex.synchronize { @runtime_pid }
+          return false if pid.nil?
+
+          Process.kill("STOP", pid)
+          @runtime_mutex.synchronize { @runtime_paused = true }
+          true
+        rescue StandardError
+          false
+        end
+
+        def continue_runtime_if_paused
+          pid, paused = @runtime_mutex.synchronize { [@runtime_pid, @runtime_paused] }
+          return unless paused
+          return if pid.nil?
+
+          Process.kill("CONT", pid)
+          @runtime_mutex.synchronize { @runtime_paused = false }
+        rescue StandardError
+          nil
+        end
+
+        def terminate_runtime_if_running
+          pid = @runtime_mutex.synchronize { @runtime_pid }
+          return if pid.nil?
+
+          Process.kill("TERM", pid)
+          @runtime_mutex.synchronize { @runtime_paused = false }
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end