mt-lang 0.3.14 → 0.3.17

data/lib/milk_tea/core/compile_time/const_eval.rb

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../types/layout"
-
-module MilkTea
-  module ConstEval
-
-    def self.evaluate(expression, resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
-      Evaluator.new(
-        resolve_identifier:,
-        resolve_member_access:,
-        resolve_type_ref:,
-        resolve_call:,
-      ).evaluate(expression)
-    end
-
-    def self.equality_result(left, right)
-      return left == right if left.is_a?(Numeric) && right.is_a?(Numeric)
-      return left == right if left.is_a?(String) && right.is_a?(String)
-      return left == right if boolean_value?(left) && boolean_value?(right)
-      return left == right if left.is_a?(Types::Base) && right.is_a?(Types::Base)
-
-      nil
-    end
-
-    def self.boolean_value?(value)
-      value == true || value == false
-    end
-
-    class Evaluator
-      def initialize(resolve_identifier:, resolve_member_access:, resolve_type_ref: nil, resolve_call: nil)
-        @resolve_identifier = resolve_identifier
-        @resolve_member_access = resolve_member_access
-        @resolve_type_ref = resolve_type_ref
-        @resolve_call = resolve_call
-      end
-
-      def evaluate(expression)
-        case expression
-        when AST::ErrorExpr
-          nil
-        when AST::ExpressionList
-          expression.elements.filter_map { |element| evaluate(element) }
-        when AST::IntegerLiteral, AST::FloatLiteral, AST::BooleanLiteral
-          expression.value
-        when AST::StringLiteral
-          expression.value
-        when AST::Identifier
-          @resolve_identifier&.call(expression)
-        when AST::MemberAccess
-          @resolve_member_access&.call(expression)
-        when AST::Call
-          @resolve_call&.call(expression)
-        when AST::Specialization
-          @resolve_call&.call(expression)
-        when AST::SizeofExpr
-          type = resolve_layout_type(expression.type)
-          type && Layout.size_of(type)
-        when AST::AlignofExpr
-          type = resolve_layout_type(expression.type)
-          type && Layout.alignment_of(type)
-        when AST::OffsetofExpr
-          type = resolve_layout_type(expression.type)
-          if type
-            result = Layout.offset_of(type, expression.field)
-            return result if result
-
-            id_expr = AST::Identifier.new(name: expression.field)
-            value = @resolve_identifier&.call(id_expr)
-            if value.is_a?(Types::FieldHandle)
-              return Layout.offset_of(type, value.field_name)
-            end
-          end
-          nil
-        when AST::UnaryOp
-          evaluate_unary(expression)
-        when AST::BinaryOp
-          evaluate_binary(expression)
-        when AST::IfExpr
-          condition = evaluate(expression.condition)
-          return unless ConstEval.boolean_value?(condition)
-
-          evaluate(condition ? expression.then_expression : expression.else_expression)
-        else
-          nil
-        end
-      end
-
-      def resolve_layout_type(type_ref)
-        return unless @resolve_type_ref
-
-        @resolve_type_ref.call(type_ref)
-      end
-
-      def evaluate_unary(expression)
-        operand = evaluate(expression.operand)
-
-        case expression.operator
-        when "+"
-          operand.is_a?(Numeric) ? operand : nil
-        when "-"
-          operand.is_a?(Numeric) ? -operand : nil
-        when "~"
-          operand.is_a?(Integer) ? ~operand : nil
-        when "not"
-          ConstEval.boolean_value?(operand) ? !operand : nil
-        end
-      end
-
-      def evaluate_binary(expression)
-        left = evaluate(expression.left)
-
-        case expression.operator
-        when "and"
-          return unless ConstEval.boolean_value?(left)
-          return false if left == false
-
-          right = evaluate(expression.right)
-          return right if ConstEval.boolean_value?(right)
-
-          return nil
-        when "or"
-          return unless ConstEval.boolean_value?(left)
-          return true if left == true
-
-          right = evaluate(expression.right)
-          return right if ConstEval.boolean_value?(right)
-
-          return nil
-        end
-
-        right = evaluate(expression.right)
-
-        case expression.operator
-        when "=="
-          ConstEval.equality_result(left, right)
-        when "!="
-          result = ConstEval.equality_result(left, right)
-          result.nil? ? nil : !result
-        when "+"
-          left.is_a?(Numeric) && right.is_a?(Numeric) ? left + right : nil
-        when "-"
-          left.is_a?(Numeric) && right.is_a?(Numeric) ? left - right : nil
-        when "*"
-          left.is_a?(Numeric) && right.is_a?(Numeric) ? left * right : nil
-        when "/"
-          return unless left.is_a?(Numeric) && right.is_a?(Numeric)
-          raise CompileTime::Error, "division by zero" if zero_numeric?(right)
-
-          left / right
-        when "%"
-          return unless left.is_a?(Integer) && right.is_a?(Integer)
-          raise CompileTime::Error, "modulo by zero" if right.zero?
-
-          left % right
-        when "<<"
-          left.is_a?(Integer) && right.is_a?(Integer) ? left << right : nil
-        when ">>"
-          left.is_a?(Integer) && right.is_a?(Integer) ? left >> right : nil
-        when "&"
-          left.is_a?(Integer) && right.is_a?(Integer) ? left & right : nil
-        when "|"
-          left.is_a?(Integer) && right.is_a?(Integer) ? left | right : nil
-        when "^"
-          left.is_a?(Integer) && right.is_a?(Integer) ? left ^ right : nil
-        when "<"
-          left.is_a?(Numeric) && right.is_a?(Numeric) ? left < right : nil
-        when "<="
-          left.is_a?(Numeric) && right.is_a?(Numeric) ? left <= right : nil
-        when ">"
-          left.is_a?(Numeric) && right.is_a?(Numeric) ? left > right : nil
-        when ">="
-          left.is_a?(Numeric) && right.is_a?(Numeric) ? left >= right : nil
-        end
-      end
-
-      def zero_numeric?(value)
-        (value.is_a?(Integer) && value.zero?) || (value.is_a?(Float) && value.zero?)
-      end
-    end
-  end
-end

data/lib/milk_tea/core/module_loader/errors.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module MilkTea
-  class ModuleLoadError < StandardError
-    attr_reader :path, :line, :column
-
-    def initialize(message, path:, line: nil, column: nil)
-      @path = path
-      @line = line
-      @column = column
-      super("#{message}: #{path}")
-    end
-
-    def code
-      "module/error"
-    end
-  end
-
-  class ModuleLoader
-    ImportResolution = Data.define(:modules, :errors)
-    ImportResolutionError = Data.define(:import, :error)
-  end
-end

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

@@ -1,156 +0,0 @@
-# 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
-
-        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