mt-lang 0.3.14 → 0.3.17

data/lib/milk_tea/dap/lldb_dap_backend.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "open3"
+require "thread"
+require "timeout"
+
+module MilkTea
+  module DAP
+    class LLDBDAPBackend
+      def initialize(adapter_command: ["lldb-dap"], on_event: nil, on_request: nil)
+        @adapter_command = adapter_command
+        @on_event = on_event
+        @on_request = on_request
+        @protocol = nil
+        @stdin = nil
+        @stdout = nil
+        @stderr = nil
+        @wait_thread = nil
+        @reader_thread = nil
+        @stderr_thread = nil
+        @write_mutex = Mutex.new
+        @pending_mutex = Mutex.new
+        @pending = {}
+        @next_seq = 1
+      end
+
+      def start!
+        return if running?
+
+        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(*@adapter_command)
+        @protocol = Protocol.new(input: @stdout, output: @stdin)
+
+        @reader_thread = Thread.new { read_loop }
+        @stderr_thread = Thread.new { drain_stderr }
+      end
+
+      def running?
+        !@wait_thread.nil? && @wait_thread.alive?
+      end
+
+      def request(command, arguments = {}, timeout: 5)
+        start! unless running?
+
+        seq = next_seq
+        queue = Queue.new
+        @pending_mutex.synchronize do
+          @pending[seq] = queue
+        end
+
+        @write_mutex.synchronize do
+          @protocol.write_message({
+            seq: seq,
+            type: "request",
+            command: command,
+            arguments: arguments
+          })
+        end
+
+        Timeout.timeout(timeout) { queue.pop }
+      rescue Timeout::Error
+        {
+          "type" => "response",
+          "request_seq" => seq,
+          "success" => false,
+          "message" => "backend request timed out: #{command}"
+        }
+      ensure
+        @pending_mutex.synchronize { @pending.delete(seq) }
+      end
+
+      def stop!
+        @stdin&.close
+        @stdout&.close
+        @stderr&.close
+        if @wait_thread&.alive?
+          Process.kill("TERM", @wait_thread.pid)
+        end
+      rescue StandardError
+        nil
+      ensure
+        @wait_thread&.join(0.2)
+        @reader_thread&.join(0.2)
+        @stderr_thread&.join(0.2)
+        @stdin = nil
+        @stdout = nil
+        @stderr = nil
+        @wait_thread = nil
+        @reader_thread = nil
+        @stderr_thread = nil
+      end
+
+      def next_seq
+        seq = @next_seq
+        @next_seq += 1
+        seq
+      end
+
+      def read_loop
+        loop do
+          message = @protocol.read_message
+          break if message.nil?
+
+          if message["type"] == "response"
+            queue = @pending_mutex.synchronize { @pending[message["request_seq"]] }
+            queue&.push(message)
+          elsif message["type"] == "event"
+            @on_event&.call(message)
+          elsif message["type"] == "request"
+            handle_adapter_request(message)
+          end
+        end
+      rescue StandardError
+        nil
+      ensure
+        @pending_mutex.synchronize do
+          @pending.each_value do |queue|
+            queue.push({
+              "type" => "response",
+              "success" => false,
+              "message" => "backend closed"
+            })
+          end
+          @pending.clear
+        end
+      end
+
+      def drain_stderr
+        return unless @stderr
+
+        @stderr.each_line do |_line|
+          # Intentionally ignored in this bridge layer.
+        end
+      rescue StandardError
+        nil
+      end
+
+      def handle_adapter_request(message)
+        response = @on_request&.call(message)
+        response ||= {
+          "type" => "response",
+          "request_seq" => message["seq"],
+          "success" => false,
+          "command" => message["command"],
+          "message" => "unsupported reverse request: #{message['command']}"
+        }
+
+        @write_mutex.synchronize do
+          @protocol.write_message(response)
+        end
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module MilkTea
           @lldb_backend = if @backend_factory
             build_backend_via_factory(adapter_command)
           else
-            Backends::LLDBDAP.new(
+            LLDBDAPBackend.new(
               adapter_command: adapter_command,
               on_event: method(:handle_backend_event),
               on_request: method(:handle_backend_request)

data/lib/milk_tea/dap.rb

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

data/lib/milk_tea/lsp.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
-module MilkTea
-  module LSP
-    # LSP implementation - language server protocol support
-  end
-end
-
 require_relative 'lsp/protocol'
 require_relative 'lsp/dependency_resolution'
 require_relative 'lsp/workspace'
 require_relative 'lsp/diagnostics'
-require_relative 'lsp/server'
+require_relative 'lsp/server'

data/lib/milk_tea/{bindings/cli.rb → tooling/bindgen_cli.rb}

@@ -118,4 +118,4 @@ module MilkTea
       nil
     end
   end
-end
+end

data/lib/milk_tea/tooling/linter/imports_platform.rb

@@ -484,8 +484,7 @@ module MilkTea
         when AST::UnsafeStmt
           stmt.body.each { |child| collect_indirect_import_uses_from_stmt(child, used, binding_resolution, import_module_names) }
         when AST::DeferStmt
-          collect_indirect_import_uses_from_expr(stmt.expression, used, binding_resolution, import_module_names) if stmt.expression
-          stmt.body&.each { |child| collect_indirect_import_uses_from_stmt(child, used, binding_resolution, import_module_names) }
+          stmt.body.each { |child| collect_indirect_import_uses_from_stmt(child, used, binding_resolution, import_module_names) }
         when AST::ReturnStmt
           collect_indirect_import_uses_from_expr(stmt.value, used, binding_resolution, import_module_names) if stmt.value
         when AST::ExpressionStmt
@@ -766,8 +765,7 @@ module MilkTea
         when AST::UnsafeStmt
           stmt.body.each { |s| collect_names_from_statement(s, used) }
         when AST::DeferStmt
-          collect_names_from_expr(stmt.expression, used) if stmt.expression
-          stmt.body&.each { |s| collect_names_from_statement(s, used) }
+          stmt.body.each { |s| collect_names_from_statement(s, used) }
         when AST::ReturnStmt
           collect_names_from_expr(stmt.value, used) if stmt.value
         when AST::ExpressionStmt

data/lib/milk_tea/tooling/linter/release_rules.rb

@@ -169,9 +169,6 @@ module MilkTea
         when AST::UnsafeStmt
           _collect_own_released_names(stmt.body, result)
         when AST::DeferStmt
-          if stmt.expression
-            _collect_heap_release_names(stmt.expression, result)
-          end
           _collect_own_released_names(stmt.body, result) if stmt.body.is_a?(Array)
         end
       end
@@ -476,7 +473,6 @@ module MilkTea
         when AST::UnsafeStmt
           _collect_released_names(stmt.body, result)
         when AST::DeferStmt
-          _collect_released_names_in_expr(stmt.expression, result) if stmt.expression
           _collect_released_names(stmt.body, result) if stmt.body.is_a?(Array)
         end
       end
@@ -611,9 +607,8 @@ module MilkTea
       def release_call_in_stmt?(stmt, name)
         return false unless stmt
 
-        # DeferStmt: inline form `defer x.release()` or block form `defer: …`
+        # DeferStmt: block form `defer: …` (inline defers are a single-statement body)
         if stmt.is_a?(AST::DeferStmt)
-          return true if stmt.expression && _expr_has_release?(stmt.expression, name)
           return stmt.body.is_a?(Array) && stmt.body.any? { |s| release_call_in_stmt?(s, name) }
         end
 

data/lib/milk_tea/tooling/linter/source_helpers.rb

@@ -240,8 +240,6 @@ module MilkTea
           expression_column(statement.expression)
         when AST::ReturnStmt
           expression_column(statement.value)
-        when AST::DeferStmt
-          expression_column(statement.expression)
         when AST::ExpressionStmt
           expression_column(statement.expression) || source_statement_span(statement.line)&.first
         else
@@ -267,8 +265,6 @@ module MilkTea
           expression_length(statement.expression)
         when AST::ReturnStmt
           expression_length(statement.value)
-        when AST::DeferStmt
-          expression_length(statement.expression)
         when AST::ExpressionStmt
           expression_length(statement.expression) || source_statement_span(statement.line)&.last
         else
@@ -326,8 +322,6 @@ module MilkTea
           walk_expression_tree(statement.expression, &block)
         when AST::ReturnStmt
           walk_expression_tree(statement.value, &block)
-        when AST::DeferStmt
-          walk_expression_tree(statement.expression, &block)
         when AST::ExpressionStmt
           walk_expression_tree(statement.expression, &block)
         when AST::StaticAssert

data/lib/milk_tea/tooling/linter/visitors.rb

@@ -225,8 +225,7 @@ module MilkTea
           visit_expression(statement.value) if statement.value
           flag_redundant_widening_cast(statement.value) if statement.value
         when AST::DeferStmt
-          visit_expression(statement.expression) if statement.expression
-          with_scope { visit_statement_list(statement.body) } if statement.body
+          with_scope { visit_statement_list(statement.body) }
         when AST::ExpressionStmt
           visit_expression(statement.expression)
           check_useless_expression(statement)
@@ -1252,8 +1251,7 @@ module MilkTea
         when AST::UnsafeStmt
           stmt.body.each { |s| collect_borrows_from_stmt(s, names) }
         when AST::DeferStmt
-          collect_borrows_from_expr(stmt.expression, names) if stmt.expression
-          stmt.body&.each { |s| collect_borrows_from_stmt(s, names) }
+          stmt.body.each { |s| collect_borrows_from_stmt(s, names) }
         when AST::WhenStmt
           collect_borrows_from_expr(stmt.discriminant, names)
           stmt.branches.each { |b| b.body.each { |s| collect_borrows_from_stmt(s, names) } }
@@ -1319,7 +1317,7 @@ module MilkTea
         when AST::UnsafeStmt
           stmt.body.each { |s| collect_writes_from_stmt(s, names) }
         when AST::DeferStmt
-          stmt.body&.each { |s| collect_writes_from_stmt(s, names) }
+          stmt.body.each { |s| collect_writes_from_stmt(s, names) }
         end
       end
 
@@ -1376,9 +1374,7 @@ module MilkTea
           stmt.body.each { |s| location = find_borrow_location_in_stmt(s, name); return location if location }
           nil
         when AST::DeferStmt
-          location = find_borrow_location_in_expr(stmt.expression, name) if stmt.expression
-          return location if location
-          stmt.body&.each { |s| location = find_borrow_location_in_stmt(s, name); return location if location }
+          stmt.body.each { |s| location = find_borrow_location_in_stmt(s, name); return location if location }
           nil
         when AST::WhenStmt
           location = find_borrow_location_in_expr(stmt.discriminant, name)

data/lib/milk_tea/tooling/sexpr_dumper.rb

@@ -38,6 +38,7 @@ module MilkTea
       when Float   then buf << format_float(value)
       when String  then emit_string(value, buf)
       when Symbol  then buf << ":" << value.to_s.tr("_", "-")
+      when Hash, Set then nil
       else buf << escape_string(value.to_s)
       end
     end
@@ -50,6 +51,7 @@ module MilkTea
       buf << "(" << type_name
       members.each do |field|
         val = node.public_send(field)
+        next if val.is_a?(Hash) || val.is_a?(Set)
         buf << " :" << field.to_s << " "
         emit_value(val, buf)
       end

data/lib/milk_tea/tooling.rb

@@ -18,5 +18,5 @@ require_relative "tooling/linter"
 require_relative "tooling/docs_app"
 require_relative "tooling/project_scaffold"
 require_relative "tooling/toolchain_cli"
-require_relative "bindings/cli"
+require_relative "tooling/bindgen_cli"
 require_relative "tooling/cli"

data/std/asset_pack.mt

@@ -187,7 +187,7 @@ function read_entry_metadata(file: stdio.File?) -> Result[EntryMetadata, Error]:
 
 function read_path_matches(file: stdio.File?, path_length: ptr_uint, logical_path: str) -> Result[bool, Error]:
     let path_buffer = heap.must_alloc[ubyte](path_length)
-    defer heap.release(path_buffer)
+    defer: heap.release(path_buffer)
 
     if not read_exact(file, path_buffer, path_length):
         return Result[bool, Error].failure(error= Error.malformed_index)

data/std/async/libuv_runtime.mt

@@ -475,7 +475,7 @@ public function result[T](task: Task[T]) -> T:
     if not completed[T](task):
         fatal(c"async.result called before task completed")
 
-    defer task.release(task.frame)
+    defer: task.release(task.frame)
     return task.take_result(task.frame)
 
 
@@ -484,7 +484,7 @@ public function wait_on[T](runtime: Runtime, task: Task[T]) -> T:
     while not task.ready(task.frame):
         runtime_poll(runtime)
 
-    defer task.release(task.frame)
+    defer: task.release(task.frame)
     return task.take_result(task.frame)
 
 
@@ -503,7 +503,7 @@ public function wait[T](root: proc() -> Task[T]) -> T:
 
     var runtime = runtime_create()
     runtime_activate(runtime)
-    defer runtime_release(ref_of(runtime))
+    defer: runtime_release(ref_of(runtime))
     return wait_on[T](runtime, root())
 
 
@@ -514,7 +514,7 @@ public function run(root: proc() -> Task[void]) -> void:
 
     var runtime = runtime_create()
     runtime_activate(runtime)
-    defer runtime_release(ref_of(runtime))
+    defer: runtime_release(ref_of(runtime))
     run_on(runtime, root())
 
 
@@ -524,7 +524,7 @@ public function with_runtime[T](body: proc(runtime: Runtime) -> T) -> T:
 
     var runtime = runtime_create()
     runtime_activate(runtime)
-    defer runtime_release(ref_of(runtime))
+    defer: runtime_release(ref_of(runtime))
     return body(runtime)
 
 
@@ -535,5 +535,5 @@ public function run_with_runtime(body: proc(runtime: Runtime) -> void) -> void:
 
     var runtime = runtime_create()
     runtime_activate(runtime)
-    defer runtime_release(ref_of(runtime))
+    defer: runtime_release(ref_of(runtime))
     body(runtime)

data/std/async/mailbox.mt

@@ -138,7 +138,7 @@ extending Mailbox[T]:
 
         var mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
 
         let handle = unsafe: read(state).handle else:
             return Result[bool, Error].failure(error = mailbox_error("mailbox is closed"))
@@ -161,7 +161,7 @@ extending Mailbox[T]:
 
         var mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
         return unsafe: read(state).queue.pop_front()
 
 
@@ -171,7 +171,7 @@ extending Mailbox[T]:
 
         var mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
 
         var drained = vec.Vec[T].with_capacity(unsafe: read(state).queue.len())
         while true:
@@ -187,5 +187,5 @@ extending Mailbox[T]:
 
         var mutex = unsafe: read(state).mutex
         mutex.lock()
-        defer mutex.unlock()
+        defer: mutex.unlock()
         return unsafe: read(state).queue.is_empty()

data/std/cookie.mt

@@ -94,7 +94,7 @@ function apply_attribute(cookie: ref[Cookie], attribute_text: str) -> void:
     match eq:
         Option.none:
             var normalized = ascii_lower(attribute_text)
-            defer normalized.release()
+            defer: normalized.release()
 
             if normalized.as_str().equal("secure"):
                 cookie.secure = true
@@ -106,7 +106,7 @@ function apply_attribute(cookie: ref[Cookie], attribute_text: str) -> void:
             let value_text = attribute_text.slice(e.value + 1, attribute_text.len - e.value - 1).trim_ascii_whitespace()
 
             var normalized_key = ascii_lower(key_text)
-            defer normalized_key.release()
+            defer: normalized_key.release()
 
             if normalized_key.as_str().equal("domain"):
                 cookie.domain = Option[string.String].some(value = string.String.from_str(value_text))

data/std/crypto.mt

@@ -23,7 +23,7 @@ public function sha256(data: span[ubyte]) -> bytes.Bytes:
 
 public function sha256_to_str(data: span[ubyte]) -> string.String:
     var digest = sha256(data)
-    defer digest.release()
+    defer: digest.release()
 
     var result = string.String.with_capacity(raw.SHA256_DIGEST_LENGTH * 2)
     var index: ptr_uint = 0

data/std/curl/runtime.mt

@@ -69,21 +69,21 @@ public function get_bytes(url: str) -> Result[bytes.Bytes, curl.Code]:
         return Result[bytes.Bytes, curl.Code].failure(error= curl.Code<-CURLE_URL_MALFORMAT_CODE)
 
     var scratch = arena.create(url.len + 1)
-    defer scratch.release()
+    defer: scratch.release()
 
     let url_cstr = scratch.to_cstr(url)
 
     let global_status = curl.global_init(curl.CURL_GLOBAL_NOTHING)
     if int<-global_status != CURLE_OK_CODE:
         return Result[bytes.Bytes, curl.Code].failure(error= global_status)
-    defer curl.global_cleanup()
+    defer: curl.global_cleanup()
 
     let handle = curl.easy_init() else:
         return Result[bytes.Bytes, curl.Code].failure(error= curl.Code<-CURLE_FAILED_INIT_CODE)
-    defer curl.easy_cleanup(handle)
+    defer: curl.easy_cleanup(handle)
 
     var body = vec.Vec[ubyte].create()
-    defer body.release()
+    defer: body.release()
 
     let write_function_status = easy_setopt_writefunction(handle, write_response_chunk)
     if int<-write_function_status != CURLE_OK_CODE:
@@ -199,7 +199,7 @@ function do_request(
     let global_status = curl.global_init(curl.CURL_GLOBAL_NOTHING)
     if int<-global_status != CURLE_OK_CODE:
         return Result[HttpResponse, HttpError].failure(error = http_error(global_status))
-    defer curl.global_cleanup()
+    defer: curl.global_cleanup()
 
     let handle = curl.easy_init() else:
         return Result[HttpResponse, HttpError].failure(
@@ -208,10 +208,10 @@ function do_request(
                 message = string.String.from_str("curl_easy_init failed")
             )
         )
-    defer curl.easy_cleanup(handle)
+    defer: curl.easy_cleanup(handle)
 
     var buffer = vec.Vec[ubyte].create()
-    defer buffer.release()
+    defer: buffer.release()
 
     let _wfn = easy_setopt_writefunction(handle, write_response_chunk)
     let _wdata = easy_setopt_writedata(handle, unsafe: ptr[void]<-ptr_of(buffer))
@@ -225,7 +225,7 @@ function do_request(
         )
 
     var scratch = arena.create(url.len + 1)
-    defer scratch.release()
+    defer: scratch.release()
 
     let url_cstr = scratch.to_cstr(url)
     let _url = easy_setopt_url(handle, url_cstr)
@@ -237,12 +237,12 @@ function do_request(
     if body.is_some():
         let body_content = body.unwrap()
         var body_scratch = arena.create(body_content.len + 1)
-        defer body_scratch.release()
+        defer: body_scratch.release()
         let _pf = easy_setopt_postfields(handle, body_scratch.to_cstr(body_content))
 
     if method.len > 0 and not method.starts_with("GET"):
         var method_scratch = arena.create(method.len + 1)
-        defer method_scratch.release()
+        defer: method_scratch.release()
         let _method = easy_setopt_customrequest(handle, method_scratch.to_cstr(method))
 
     if method.starts_with("HEAD"):