mt-lang 0.2.0

data/lib/milk_tea/core/types/visitor.rb

@@ -0,0 +1,442 @@
+# frozen_string_literal: true
+
+require_relative "predicates"
+
+module MilkTea
+  class TypeVisitor
+    def initialize
+      @visited = {}
+    end
+
+    def visit(type)
+      return if type.nil?
+      return if @visited[type.object_id]
+
+      @visited[type.object_id] = true
+      dispatch(type)
+    end
+
+    def dispatch(type)
+      case type
+      when Types::Nullable then visit_nullable(type)
+      when Types::GenericInstance then visit_generic_instance(type)
+      when Types::Span then visit_span(type)
+      when Types::Task then visit_task(type)
+      when Types::GenericStructDefinition then visit_generic_struct_definition(type)
+      when Types::GenericVariantDefinition then visit_generic_variant_definition(type)
+      when Types::Struct then visit_struct(type)
+      when Types::Union then visit_union(type)
+      when Types::StructInstance then visit_struct_instance(type)
+      when Types::Variant then visit_variant(type)
+      when Types::VariantInstance then visit_variant_instance(type)
+      when Types::VariantArmPayload then visit_variant_arm_payload(type)
+      when Types::Proc then visit_proc(type)
+      when Types::Function then visit_function(type)
+      when Types::Parameter then visit_parameter(type)
+      when Types::TypeVar then visit_type_var(type)
+      when Types::Null then visit_null(type)
+      when Types::Tuple then visit_tuple(type)
+      when Types::Dyn then visit_dyn(type)
+      when Types::SoA then visit_soa(type)
+      when Types::Event then visit_event(type)
+      when Types::LifetimeRef then visit_lifetime_ref(type)
+      else visit_default(type)
+      end
+    end
+
+    def visit_children(type)
+      type.children.each { |child| visit(child) }
+    end
+
+    def visit_nullable(type); visit_children(type); end
+    def visit_generic_instance(type); visit_children(type); end
+    def visit_span(type); visit_children(type); end
+    def visit_task(type); visit_children(type); end
+    def visit_generic_struct_definition(type); visit_children(type); end
+    def visit_generic_variant_definition(type); visit_children(type); end
+    def visit_struct(type); visit_children(type); end
+    def visit_union(type); visit_children(type); end
+    def visit_struct_instance(type); visit_children(type); end
+    def visit_variant(type); visit_children(type); end
+    def visit_variant_instance(type); visit_children(type); end
+    def visit_variant_arm_payload(type); visit_children(type); end
+    def visit_proc(type); visit_children(type); end
+    def visit_function(type); visit_children(type); end
+    def visit_parameter(type); visit_children(type); end
+    def visit_tuple(type); visit_children(type); end
+    def visit_dyn(type); visit_children(type); end
+    def visit_soa(type); visit_children(type); end
+    def visit_event(type); visit_children(type); end
+
+    def visit_type_var(type); end
+    def visit_null(type); end
+    def visit_lifetime_ref(type); end
+    def visit_default(type); end
+  end
+
+  class ContainsTypeVarVisitor < TypeVisitor
+    def initialize
+      super
+      @found = false
+    end
+
+    def found?
+      @found
+    end
+
+    def visit_type_var(type)
+      @found = true
+    end
+  end
+
+  class ContainsRefTypeVisitor < TypeVisitor
+    def initialize(allow_lifetimes: [])
+      super()
+      @found = false
+      @allow_lifetimes = allow_lifetimes
+    end
+
+    def found?
+      @found
+    end
+
+    def visit_generic_instance(type)
+      if type.name == "ref" && [1, 2].include?(type.arguments.length)
+        if type.arguments.length == 2
+          lt = type.arguments.first
+          if lt.is_a?(String) && @allow_lifetimes.include?(lt)
+            visit_children(type)
+            return
+          end
+        end
+        @found = true
+        return
+      end
+      visit_children(type)
+    end
+  end
+
+  class ContainsProcTypeVisitor < TypeVisitor
+    def initialize
+      super
+      @found = false
+    end
+
+    def found?
+      @found
+    end
+
+    def visit_proc(type)
+      @found = true
+    end
+
+    def visit_generic_instance(type)
+      if type.name == "array" && type.arguments.first && !type.arguments.first.is_a?(Types::LiteralTypeArg)
+        visit(type.arguments.first)
+      end
+    end
+  end
+
+  class ContainsCallableRefTypeVisitor < TypeVisitor
+    def initialize
+      super
+      @found = false
+    end
+
+    def found?
+      @found
+    end
+
+    def visit_proc(type)
+      checker = ContainsRefTypeVisitor.new
+      checker.visit(type)
+      @found = true if checker.found?
+    end
+    alias visit_function visit_proc
+  end
+
+  class StoredRefSupportedVisitor < TypeVisitor
+    include TypePredicates
+
+    def initialize(allow_lifetimes: [])
+      super()
+      @supported = true
+      @allow_lifetimes = allow_lifetimes
+    end
+
+    def result?
+      @supported
+    end
+
+    def visit_generic_instance(type)
+      if ref_type?(type)
+        lt = ref_lifetime(type)
+        if lt && @allow_lifetimes.include?(lt)
+          visit_children(type)
+          return
+        end
+        @supported = false
+        return
+      end
+      visit_children(type)
+    end
+
+    def visit_proc(type)
+      @supported = false unless callable_param_ref_supported?(type)
+    end
+    alias visit_function visit_proc
+
+    private
+
+    def visit_children(type)
+      type.children.each do |child|
+        visit(child)
+        return unless @supported
+      end
+    end
+  end
+
+  class SendableCheckVisitor < TypeVisitor
+    def initialize
+      super
+      @sendable = true
+    end
+
+    def sendable?
+      @sendable
+    end
+
+    def visit_children(type)
+      type.children.each do |child|
+        visit(child)
+        return unless @sendable
+      end
+    end
+
+    def visit_event(type)
+      @sendable = false
+    end
+
+    def visit_dyn(type)
+      @sendable = false
+    end
+
+    def visit_span(type)
+      @sendable = false
+    end
+
+    def visit_proc(type)
+      @sendable = false
+    end
+
+    def visit_function(type); end
+
+    def visit_generic_instance(type)
+      case type.name
+      when "ptr", "const_ptr", "own", "ref"
+        @sendable = false
+      when "array"
+        el = type.arguments.first
+        visit(el) unless el.is_a?(Types::LiteralTypeArg)
+      when "str_buffer", "atomic"
+        # sendable
+      else
+        @sendable = false
+      end
+    end
+
+    def visit_struct(type)
+      if type.respond_to?(:has_events?) && type.has_events?
+        @sendable = false
+        return
+      end
+      visit_children(type)
+    end
+    alias visit_struct_instance visit_struct
+
+    def visit_default(type)
+      case type
+      when Types::Primitive
+        @sendable = false if type.name == "str"
+      when Types::Error, Types::Opaque, Types::StringView
+        @sendable = false
+      end
+    end
+  end
+
+  class SubstituteTypeVisitor
+    def initialize(substitutions)
+      @substitutions = substitutions
+    end
+
+    def apply(type)
+      case type
+      when Types::TypeVar
+        @substitutions.fetch(type.name, type)
+      when Types::LifetimeRef
+        @substitutions.fetch(type.name, type)
+      when Types::Nullable
+        substituted = apply(type.base)
+        substituted.equal?(type.base) ? type : Types::Registry.nullable(substituted)
+      when Types::GenericInstance
+        new_args = type.arguments.map do |arg|
+          arg.is_a?(Types::LiteralTypeArg) ? arg : apply(arg)
+        end
+        type.arguments.zip(new_args).all? { |old, new| old.equal?(new) } ? type : Types::Registry.generic_instance(type.name, new_args)
+      when Types::Span
+        substituted = apply(type.element_type)
+        substituted.equal?(type.element_type) ? type : Types::Registry.span(substituted)
+      when Types::Task
+        substituted = apply(type.result_type)
+        substituted.equal?(type.result_type) ? type : Types::Registry.task(substituted)
+      when Types::Event
+        new_payload = type.payload_type ? apply(type.payload_type) : nil
+        if new_payload.equal?(type.payload_type)
+          type
+        else
+          Types::Event.new(type.name, capacity: type.capacity, payload_type: new_payload, module_name: type.module_name, visibility: type.visibility, owner_type_name: type.owner_type_name)
+        end
+      when Types::Proc
+        changed = false
+        new_params = type.params.map do |param|
+          new_param_type = apply(param.type)
+          new_boundary = param.boundary_type ? apply(param.boundary_type) : nil
+          changed = true unless new_param_type.equal?(param.type) && new_boundary.equal?(param.boundary_type)
+          Types::Registry.parameter(param.name, new_param_type, mutable: param.mutable, passing_mode: param.passing_mode, boundary_type: new_boundary)
+        end
+        new_return = apply(type.return_type)
+        changed = true unless new_return.equal?(type.return_type)
+        changed ? Types::Registry.proc(params: new_params, return_type: new_return) : type
+      when Types::Function
+        changed = false
+        new_params = type.params.map do |param|
+          new_param_type = apply(param.type)
+          new_boundary = param.boundary_type ? apply(param.boundary_type) : nil
+          changed = true unless new_param_type.equal?(param.type) && new_boundary.equal?(param.boundary_type)
+          Types::Registry.parameter(param.name, new_param_type, mutable: param.mutable, passing_mode: param.passing_mode, boundary_type: new_boundary)
+        end
+        new_return = apply(type.return_type)
+        changed = true unless new_return.equal?(type.return_type)
+        new_receiver = type.receiver_type ? apply(type.receiver_type) : nil
+        changed = true unless new_receiver.equal?(type.receiver_type)
+        changed ? Types::Registry.function(type.name, params: new_params, return_type: new_return, receiver_type: new_receiver, receiver_editable: type.receiver_editable, variadic: type.variadic, external: type.external) : type
+      when Types::StructInstance
+        new_args = type.arguments.map { |arg| apply(arg) }
+        type.arguments.zip(new_args).all? { |old, new| old.equal?(new) } ? type : type.definition.instantiate(new_args)
+      when Types::VariantInstance
+        new_args = type.arguments.map { |arg| apply(arg) }
+        type.arguments.zip(new_args).all? { |old, new| old.equal?(new) } ? type : type.definition.instantiate(new_args)
+      else
+        type
+      end
+    end
+  end
+
+  class ContainsArrayStorageVisitor < TypeVisitor
+    def initialize
+      super
+      @found = false
+    end
+
+    def found?
+      @found
+    end
+
+    def dispatch(type)
+      case type
+      when Types::Nullable, Types::Struct, Types::StructInstance
+        visit_children(type)
+      when Types::GenericInstance
+        if type.name == "array"
+          @found = true
+        end
+      end
+    end
+
+    def visit_children(type)
+      type.children.each do |child|
+        visit(child)
+        return if @found
+      end
+    end
+  end
+
+  class ProcStorageSupportedVisitor < TypeVisitor
+    def initialize
+      super
+      @supported = true
+    end
+
+    def result?
+      @supported
+    end
+
+    def dispatch(type)
+      case type
+      when Types::Nullable, Types::GenericInstance, Types::Struct, Types::Union,
+           Types::StructInstance, Types::Variant, Types::VariantInstance, Types::VariantArmPayload,
+           Types::Tuple, Types::Span
+        visit_children(type)
+      when Types::Proc
+      when Types::Task, Types::Function, Types::Dyn, Types::SoA
+        @supported = false
+      end
+    end
+
+    def visit_children(type)
+      type.children.each do |child|
+        visit(child)
+        return unless @supported
+      end
+    end
+  end
+
+  class ValidateSpecializedTypeVisitor < TypeVisitor
+    def initialize(function_name:, context:, on_error:, on_generic_instance: nil)
+      super()
+      @function_name = function_name
+      @context = context
+      @on_error = on_error
+      @on_generic_instance = on_generic_instance
+    end
+
+    def visit_type_var(type)
+      @on_error.call("cannot infer type argument #{type.name} for function #{@function_name}")
+    end
+
+    def visit_generic_instance(type)
+      @on_generic_instance&.call(type.name, type.arguments)
+      visit_children(type)
+    end
+
+    def visit_proc(type)
+      type.params.each do |param|
+        with_context("#{@context} parameter #{param.name}") { visit(param.type) }
+      end
+      with_context("#{@context} return type") { visit(type.return_type) }
+    end
+
+    def visit_function(type)
+      type.params.each do |param|
+        with_context("#{@context} parameter #{param.name}") { visit(param.type) }
+        if param.boundary_type
+          with_context("#{@context} boundary parameter #{param.name}") { visit(param.boundary_type) }
+        end
+      end
+      with_context("#{@context} return type") { visit(type.return_type) }
+      if type.receiver_type
+        with_context("#{@context} receiver type") { visit(type.receiver_type) }
+      end
+    end
+
+    private
+
+    def with_context(new_context)
+      old = @context
+      @context = new_context
+      yield
+    ensure
+      @context = old
+    end
+  end
+end

data/lib/milk_tea/core.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+require_relative "core/keywords"
+require_relative "core/token"
+require_relative "core/token_stream"
+require_relative "core/lexer"
+require_relative "core/cst"
+require_relative "core/cst_builder"
+require_relative "core/ast"
+require_relative "core/types/types"
+require_relative "core/binding_types"
+require_relative "core/compile_time"
+require_relative "core/compatibility_helpers"
+require_relative "core/parser"
+require_relative "core/module_roots"
+require_relative "core/module_loader"
+require_relative "core/semantic_analyzer"
+require_relative "core/ir"
+require_relative "core/control_flow"
+require_relative "core/pretty_printer"
+require_relative "core/lowering"
+# Codegen wrapper deleted; use CBackend.emit directly
+require_relative "core/c_backend"

data/lib/milk_tea/dap/backends/lldb_dap.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "open3"
+require "thread"
+require "timeout"
+
+module MilkTea
+  module DAP
+    module Backends
+      # Thin bridge to an lldb-dap compatible adapter process.
+      class LLDBDAP
+        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
+
+        private
+
+        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
+end

data/lib/milk_tea/dap/protocol.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "json"
+
+module MilkTea
+  module DAP
+    # Handles DAP framing over stdin/stdout using Content-Length headers.
+    class Protocol
+      INVALID_MESSAGE = Object.new.freeze
+
+      def initialize(input: $stdin, output: $stdout, error_output: nil)
+        @input = input
+        @output = output
+        @error_output = error_output
+      end
+
+      def read_message
+        headers = {}
+        loop do
+          line = @input.gets
+          return nil if line.nil?
+
+          stripped = line.chomp
+          break if stripped.empty?
+
+          key, value = stripped.split(":", 2)
+          headers[key&.strip] = value&.strip
+        end
+
+        content_length = headers["Content-Length"]&.to_i
+        return INVALID_MESSAGE if content_length.nil? || content_length <= 0
+
+        body = @input.read(content_length)
+        JSON.parse(body)
+      rescue StandardError => e
+        log_error("DAP protocol read error: #{e.message}")
+        INVALID_MESSAGE
+      end
+
+      def write_message(message)
+        json = JSON.dump(message)
+        @output.write("Content-Length: #{json.bytesize}\r\n\r\n")
+        @output.write(json)
+        @output.flush
+      rescue StandardError => e
+        log_error("DAP protocol write error: #{e.message}")
+      end
+
+      private def log_error(message)
+        return unless @error_output
+
+        @error_output.puts(message)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end