mt-lang 0.2.0

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module DAP
+    class Server
+      module ServerWire
+        private
+
+        def write_response(request, body)
+          write_message({
+            seq: @session.next_seq,
+            type: "response",
+            request_seq: request["seq"],
+            success: true,
+            command: request["command"],
+            body: body
+          })
+        end
+
+        def write_error_response(request, message)
+          write_message({
+            seq: @session.next_seq,
+            type: "response",
+            request_seq: request && request["seq"],
+            success: false,
+            command: request && request["command"],
+            message: message,
+            body: {
+              error: {
+                id: 1,
+                format: message
+              }
+            }
+          })
+        end
+
+        def write_event(event, body = nil)
+          message = {
+            seq: @session.next_seq,
+            type: "event",
+            event: event
+          }
+          message[:body] = body if body
+          write_message(message)
+        end
+
+        def write_message(message)
+          @write_mutex.synchronize do
+            @protocol.write_message(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/milk_tea/dap/server.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "rbconfig"
+require "tmpdir"
+
+require_relative "../tooling/debug_map"
+
+require_relative "server/handlers"
+require_relative "server/launch"
+require_relative "server/lldb_backend"
+require_relative "server/debug_map"
+require_relative "server/breakpoints"
+require_relative "server/pause_diagnostics"
+require_relative "server/wire"
+require_relative "server/utilities"
+
+module MilkTea
+  module DAP
+    # Minimal DAP server with strict request/response/event envelopes.
+    class Server
+      ADAPTER_CAPABILITIES = {
+        supportsConfigurationDoneRequest: true,
+        supportsFunctionBreakpoints: true,
+        supportsConditionalBreakpoints: false,
+        supportsHitConditionalBreakpoints: false,
+        supportsPauseRequest: true,
+        supportsEvaluateForHovers: false,
+        supportsSetVariable: false,
+        supportsTerminateRequest: true,
+        supportTerminateDebuggee: true,
+        supportsLoadedSourcesRequest: true,
+        exceptionBreakpointFilters: [],
+      }.freeze
+
+      def initialize(protocol: Protocol.new, session: Session.new, backend_factory: nil, preferred_backend_kind: "process", adapter_command: nil)
+        @protocol = protocol
+        @session = session
+        @backend_factory = backend_factory
+        @preferred_backend_kind = preferred_backend_kind.to_s.empty? ? "process" : preferred_backend_kind.to_s
+        @default_adapter_command = adapter_command&.dup
+        @handlers = {}
+        @write_mutex = Mutex.new
+        @client_request_mutex = Mutex.new
+        @pending_client_responses = {}
+        @incoming_messages = Queue.new
+        @reader_thread = nil
+        @background_threads = []
+        @background_threads_mutex = Mutex.new
+        @runtime_mutex = Mutex.new
+        @runtime_pid = nil
+        @runtime_paused = false
+        @tmp_dirs = []
+        @lldb_backend = nil
+        @backend_initialized = false
+        @backend_capabilities = {}
+        @breakpoints_synced_to_backend = false
+        @function_breakpoints_synced_to_backend = false
+        @exception_breakpoints_synced_to_backend = false
+        @backend_start_thread = nil
+        @backend_auto_continue_after_configuration = false
+        @backend_stopped_thread_id = nil
+        @backend_pause_requested = false
+        @last_forwarded_continued_signature = nil
+        @backend_configuration_mutex = Mutex.new
+        @backend_configuration_condition = ConditionVariable.new
+        @backend_configuration_ready = false
+        @debug_map = nil
+        @frame_debug_functions = {}
+        @variables_reference_debug_functions = {}
+        @reverse_request_timeout = Float(ENV.fetch("MILK_TEA_DAP_REVERSE_REQUEST_TIMEOUT", "15"))
+        register_handlers
+      end
+
+      def run
+        start_client_reader
+
+        loop do
+          message = @incoming_messages.pop
+          break if message.nil?
+          next if message.equal?(Protocol::INVALID_MESSAGE)
+
+          process_message(message)
+          break if @session.should_exit?
+        end
+      ensure
+        @backend_start_thread&.join(0.2)
+        join_background_threads
+        @reader_thread&.join(0.2)
+      end
+
+      private
+
+      def start_client_reader
+        return if @reader_thread&.alive?
+
+        @reader_thread = Thread.new do
+          loop do
+            message = @protocol.read_message
+            break if message.nil?
+            next if message.equal?(Protocol::INVALID_MESSAGE)
+
+            if message["type"] == "response"
+              queue = @client_request_mutex.synchronize do
+                @pending_client_responses[message["request_seq"]]
+              end
+              if queue
+                queue.push(message)
+                next
+              end
+            end
+
+            @incoming_messages.push(message)
+          end
+        ensure
+          @incoming_messages.push(nil)
+        end
+      end
+
+      include ServerHandlers
+      include ServerLaunch
+      include ServerLLDBBackend
+      include ServerDebugMap
+      include ServerBreakpoints
+      include ServerPauseDiagnostics
+      include ServerWire
+      include ServerUtilities
+    end
+  end
+end

data/lib/milk_tea/dap/session.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module DAP
+    # Holds mutable state for one DAP session.
+    class Session
+      attr_reader :program_path, :runnable_path, :program_args, :thread_id, :backend_kind,
+          :function_breakpoints, :exception_breakpoints
+
+      def initialize
+        @next_outgoing_seq = 1
+        @next_breakpoint_id = 1
+        @thread_id = 1
+        @initialized = false
+        @configuration_done = false
+        @launched = false
+        @terminated = false
+        @should_exit = false
+        @entry_stop_emitted = false
+        @program_path = nil
+        @runnable_path = nil
+        @program_args = []
+        @backend_kind = "process"
+        @stop_on_entry = true
+        @runtime_started = false
+        @breakpoints_by_source = {}
+        @function_breakpoints = []
+        @exception_breakpoints = nil
+      end
+
+      def next_seq
+        seq = @next_outgoing_seq
+        @next_outgoing_seq += 1
+        seq
+      end
+
+      def initialize!
+        @initialized = true
+      end
+
+      def initialized?
+        @initialized
+      end
+
+      def configuration_done!
+        @configuration_done = true
+      end
+
+      def configuration_done?
+        @configuration_done
+      end
+
+      def request_start!(program_path:, runnable_path:, program_args: [], stop_on_entry: true, backend_kind: "process")
+        @program_path = program_path
+        @runnable_path = runnable_path
+        @program_args = Array(program_args).map(&:to_s)
+        @backend_kind = backend_kind
+        @stop_on_entry = stop_on_entry
+      end
+
+      def launch!
+        @launched = true
+      end
+
+      def launched?
+        @launched
+      end
+
+      def stop_on_entry?
+        @stop_on_entry
+      end
+
+      def entry_stop_emitted?
+        @entry_stop_emitted
+      end
+
+      def mark_entry_stop_emitted!
+        @entry_stop_emitted = true
+      end
+
+      def mark_runtime_started!
+        @runtime_started = true
+      end
+
+      def runtime_started?
+        @runtime_started
+      end
+
+      def terminate!
+        @terminated = true
+      end
+
+      def terminated?
+        @terminated
+      end
+
+      def request_exit!
+        @should_exit = true
+      end
+
+      def should_exit?
+        @should_exit
+      end
+
+      def set_breakpoints(source_path, breakpoints)
+        normalized = breakpoints.map do |bp|
+          raw = normalize_dap_hash(bp)
+          raw["id"] = next_breakpoint_id
+          raw["verified"] = true
+          raw["line"] = raw["line"].to_i
+          raw
+        end
+        @breakpoints_by_source[source_path] = normalized
+        normalized
+      end
+
+      def set_function_breakpoints(breakpoints)
+        @function_breakpoints = breakpoints.map do |bp|
+          raw = normalize_dap_hash(bp)
+          raw["id"] = next_breakpoint_id
+          raw["verified"] = true
+          raw["name"] = raw["name"].to_s
+          raw
+        end
+      end
+
+      def set_exception_breakpoints(arguments)
+        @exception_breakpoints = normalize_dap_hash(arguments)
+      end
+
+      def each_breakpoint_source
+        @breakpoints_by_source.each do |source_path, breakpoints|
+          yield(source_path, breakpoints)
+        end
+      end
+
+      private
+
+      def normalize_dap_hash(value)
+        value.each_with_object({}) do |(key, entry), result|
+          result[key.to_s] = entry
+        end
+      end
+
+      def next_breakpoint_id
+        id = @next_breakpoint_id
+        @next_breakpoint_id += 1
+        id
+      end
+    end
+  end
+end

data/lib/milk_tea/dap.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "dap/protocol"
+require_relative "dap/backends/lldb_dap"
+require_relative "dap/session"
+require_relative "dap/server"

data/lib/milk_tea/lsp/dependency_resolution.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module LSP
+    class DependencyResolution
+      MODES = %i[auto live locked frozen].freeze
+
+      Resolved = Data.define(:mode, :locked, :error_message) do
+        def ok?
+          error_message.nil?
+        end
+      end
+
+      def self.normalize_mode(mode)
+        normalized = mode.to_s.strip.downcase.to_sym
+        MODES.include?(normalized) ? normalized : :auto
+      end
+
+      def self.resolve(path, mode: :auto)
+        normalized_mode = normalize_mode(mode)
+        return Resolved.new(mode: normalized_mode, locked: false, error_message: nil) unless path && File.file?(path)
+
+        case normalized_mode
+        when :live
+          Resolved.new(mode: normalized_mode, locked: false, error_message: nil)
+        when :auto
+          lock_result = PackageLock.check(path)
+          Resolved.new(mode: normalized_mode, locked: lock_result.current?, error_message: nil)
+        when :locked
+          Resolved.new(mode: normalized_mode, locked: true, error_message: nil)
+        when :frozen
+          lock_result = PackageLock.check(path)
+          if lock_result.current?
+            Resolved.new(mode: normalized_mode, locked: true, error_message: nil)
+          elsif lock_result.missing?
+            Resolved.new(mode: normalized_mode, locked: true, error_message: "package.lock is missing: #{lock_result.lock_path}")
+          else
+            Resolved.new(mode: normalized_mode, locked: true, error_message: "package.lock is out of date: #{lock_result.lock_path}")
+          end
+        end
+      rescue PackageManifestError
+        Resolved.new(mode: normalized_mode, locked: false, error_message: nil)
+      rescue PackageLockError => e
+        if normalized_mode == :auto
+          Resolved.new(mode: normalized_mode, locked: false, error_message: nil)
+        else
+          Resolved.new(mode: normalized_mode, locked: true, error_message: e.message)
+        end
+      end
+    end
+  end
+end