mt-lang 0.3.16 → 0.3.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5cd3c1ef5e380b8d0c5d4e20f829400d01c6fdfd3e495e8c98050f4af8b59ba
-  data.tar.gz: 0e083d1780c9d591b996604a8b489726fa0f0c6fb85b8dc03da87b681383d5ca
+  metadata.gz: e2f84289b1bcb599ca81cbada0b1e1a925d9962ffe186471b84026f372fb358b
+  data.tar.gz: 566b98b015518f583e31fa2f0a75753c3b0abfd5a4047210945b3209c3caf1f3
 SHA512:
-  metadata.gz: 44f866e7d6bf6fc4998e0a9054bf898b27ed47ef38149de1881baf1d810e845b94e3d1f3ff304486654ea339329d726a10d969bcff4021943cc98b03bfe3fe01
-  data.tar.gz: 0fa7237c14aa9e038b4d51ae08a5971430d0e47b97fb19caf619aeb80a5e562de99aae1cf342a11ffea41e3b2268a128454bbf022b3e9182ddd94ff2ff0aff45
+  metadata.gz: ee114072cb26ed2527e0b3703cb7f8a913e37234e6937b3a307ce72363e8a6e10a34e0a149d508a8c02e64c1a0a0f5e9b1ae482b76f068bfb6bf0b8784f34a44
+  data.tar.gz: 9b29c88530cf6110381123ef8135434caa47aa85abf955a8bd9f25d93fa1b8059691d52804c17e4080a2a3d0ad916aa689470ec8d7719a7186fa62eddb026525

data/docs/language-design.md

@@ -521,7 +521,6 @@ The type system must stay simple, explicit, and close to C.
 ### Primitive types
 
 - `bool`
-- `byte`
 - `char`
 - `byte`, `short`, `int`, `long`
 - `ubyte`, `ushort`, `uint`, `ulong`
@@ -587,7 +586,7 @@ Notes:
 - If low-level code needs to validate raw `array[char, N]` storage as text, that conversion belongs in an explicit helper or imported boundary, not as a built-in method family on raw arrays.
 - Addressable `str_buffer[N]` values also coerce to `span[char]`, so writable foreign text APIs can still accept builders directly when they do not want a second application-facing text abstraction.
 - `str_buffer[N]` is not an ABI type. Raw bindings still spell writable text as `ptr[char]` or `span[char]`; `str_buffer[N]` is the caller-side text object.
-- `str_buffer[N]` has a built-in text surface: `.clear()`, `.assign(str)`, `.append(str)`, `.len()`, `.capacity()`, `.as_str()`, and `.as_cstr()`.
+- `str_buffer[N]` has a built-in text surface: `.clear()`, `.assign(str)`, `.append(str)`, `.assign_format(str)`, `.append_format(str)`, `.len()`, `.capacity()`, `.as_str()`, and `.as_cstr()`.
 - `.assign(...)` replaces the current contents and traps at runtime if the new text exceeds capacity.
 - `.append(...)` extends the current contents and traps at runtime if the appended text would exceed capacity.
 - `.len()` returns the tracked text length, revalidating UTF-8 and rescanning for the trailing NUL if the builder was passed through a writable `span[char]` or `ptr[char]` alias.
@@ -650,7 +649,7 @@ joins the path with underscores (e.g., `module_Rectangle_Edge`).
 
 #### Enums
 
-Enums always have an explicit backing type.
+Enums use an integer backing type, defaulting to `int` when omitted; members auto-increment from 0 or the previous explicit value.
 
 ```mt
 enum WeaponKind: ubyte
@@ -661,7 +660,7 @@ enum WeaponKind: ubyte
 
 #### Flags
 
-Flags are named bitmasks with a fixed integer backing type.
+Flags are named bitmasks with an integer backing type (defaulting to `int` when omitted).
 
 ```mt
 flags WindowFlags: uint

data/docs/language-manual.md

@@ -1007,7 +1007,7 @@ Rules:
 - `ivec2` `ivec3` `ivec4` — integer vectors with `.x` `.y` `.z` `.w` fields
 - `mat3` `mat4` — column-major matrices; `mat3` has columns `.col0`–`.col2` (each `vec3`), `mat4` has `.col0`–`.col3` (each `vec4`)
 - `quat` — quaternion with `.x` `.y` `.z` `.w` fields; memory-layout compatible with `vec4`
-- `simd[T, N]` — SIMD vector with `N` lanes of numeric primitive type `T`; total width must be 128 or 256 bits. Supports component-wise arithmetic (`+` `-` `*` `/`), bitwise (`&` `|` `^` `~`), shift (`<<` `>>`), and compound assignment. Lane access via compile-time constant index `[i]`. Lowers to GCC/Clang `__attribute__((__vector_size__))`.
+- `simd[T, N]` — SIMD vector with `N` lanes of numeric primitive type `T`; total width must be 128 or 256 bits. Supports component-wise arithmetic (`+` `-` `*` `/`, and `%` for integer lanes), bitwise (`&` `|` `^` `~`), shift (`<<` `>>`), and compound assignment. Lane access via compile-time constant index `[i]`. Lowers to GCC/Clang `__attribute__((__vector_size__))`.
 
 Primitive type names are reserved. They cannot be reused for value bindings, parameters, locals, import aliases, or type parameters.
 
@@ -1043,7 +1043,7 @@ let q = quat(x = 0.0, y = 0.0, z = 0.0, w = 1.0)
 - `Option[T]`
 - `Result[T, E]`
 - `SoA[T, N]` — Structure-of-Arrays: transforms `T`'s fields into separate arrays of length `N`; access as `soa[i].field`
-- `simd[T, N]` — SIMD vector: fixed-width vector of `N` numeric lanes. Constructed with `simd[T, N](lane0, lane1, ...)`. Supports component-wise `+` `-` `*` `/`, bitwise `&` `|` `^` `~`, shift `<<` `>>`, unary `-` `~`, and compound assignment. Lane access via compile-time constant `[i]`. Total width must be 128 or 256 bits. Lowers to GCC/Clang vector extensions.
+- `simd[T, N]` — SIMD vector: fixed-width vector of `N` numeric lanes. Constructed with `simd[T, N](lane0, lane1, ...)`. Supports component-wise `+` `-` `*` `/` (and `%` for integer lanes), bitwise `&` `|` `^` `~`, shift `<<` `>>`, unary `-` `~`, and compound assignment. Lane access via compile-time constant `[i]`. Total width must be 128 or 256 bits. Lowers to GCC/Clang vector extensions.
 - `dyn[InterfaceName]` — runtime interface value (fat pointer: data + vtable). Constructed via `adapt[Interface](value: ref[T])`. @see §3.5.
 - `atomic[T]` — atomic value for lock-free concurrent access. `T` must be a primitive integer or `bool`. Methods: `load() -> T`, `store(value: T)`, `add(value: T) -> T`, `sub(value: T) -> T`, `exchange(value: T) -> T`. All operations use sequential consistency. Lowers to C11 `_Atomic T` with `__atomic_*` builtins. `atomic[T]` is zero-initializable and sendable.
 - `(T, U)` — tuple type. Positional fields auto-named `_0`, `_1`. Named fields use `(x = T, y = U)`. Copy by value, returns supported.
@@ -1054,7 +1054,7 @@ let q = quat(x = 0.0, y = 0.0, z = 0.0, w = 1.0)
 - for pointer-like bases (`ptr[T]`, `const_ptr[T]`, `own[T]`, `cstr`, `fn(...)`, `proc(...)`, opaque), `T?` is a nullable pointer with `null` as the absent value
 - for non-pointer value bases (`int`, `bool`, `float`, structs, ...), `T?` is stored inline by value as a tagged optional (a presence flag plus the value); it copies by value with no hidden heap allocation or pointer aliasing
 - `null` expresses absence in any nullable context; the explicit typed `null[...]` form's target must be pointer-like
-- in nullable pointer-like contexts, use `null` instead of `zero[ptr[T]]`
+- in nullable pointer-like contexts, `zero[ptr[T]]` is rejected; use `null` instead
 - at an FFI boundary (`external` / `foreign function` parameters and returns), only pointer-like `T?` is allowed; a non-pointer value nullable such as `int?` is rejected — use `ptr[T]?` or pass an explicit struct
 
 ### 6.4 Generics

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.16"
+  VERSION = "0.3.17"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/{binding_types.rb → bindings.rb}

@@ -15,4 +15,4 @@ module MilkTea
     def each(&block) = @bindings.each(&block)
     def each_with_object(init, &block) = @bindings.each_with_object(init, &block)
   end
-end
+end

data/lib/milk_tea/core/c_backend.rb

@@ -38,6 +38,20 @@ module MilkTea
     # scanning a 600 KB source file) never trigger a false positive, yet low
     # enough that a genuinely infinite loop fires a clear fatal within ~1 s.
     LOOP_GUARD_MAX_ITERATIONS = 50_000_000
+    EQUALITY_OPERATORS = ["==", "!="].freeze
+
+    include AggregateUtils
+    include TypeSystem
+    include Reachability
+    include FeatureDetection
+    include TypeCollectors
+    include Statements
+    include ControlFlowEmission
+    include RuntimeHelpers
+    include FormatHelpers
+    include TypeDeclaration
+    include Expressions
+    include Reinterpret
 
     def self.emit(program, emit_line_directives: true, debug_guards: false)
       new(program, emit_line_directives:, debug_guards:).emit
@@ -294,20 +308,5 @@ module MilkTea
 
       lines.join("\n").rstrip + "\n"
     end
-
-    EQUALITY_OPERATORS = ["==", "!="].freeze
-
-    include AggregateUtils
-    include TypeSystem
-    include Reachability
-    include FeatureDetection
-    include TypeCollectors
-    include Statements
-    include ControlFlowEmission
-    include RuntimeHelpers
-    include FormatHelpers
-    include TypeDeclaration
-    include Expressions
-    include Reinterpret
   end
 end

data/lib/milk_tea/core/compile_time.rb

@@ -1,6 +1,185 @@
 # frozen_string_literal: true
 
-require_relative "compile_time/const_eval"
+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
 
 module MilkTea
   module CompileTime
@@ -354,4 +533,4 @@ module MilkTea
       end
     end
   end
-end
+end

data/lib/milk_tea/core/control_flow/constant_propagation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../compile_time/const_eval"
+require_relative "../compile_time"
 
 module MilkTea
   module ControlFlow

data/lib/milk_tea/core/{compatibility_helpers.rb → intrinsics.rb}

@@ -3,7 +3,7 @@
 require_relative "types/predicates"
 
 module MilkTea
-  module CompatibilityHelpers
+  module Intrinsics
     include Types::Predicates
 
     BUILTIN_CSTR = Types::Registry.primitive("cstr")
@@ -78,4 +78,4 @@ module MilkTea
       expression.is_a?(AST::StringLiteral) && !expression.cstring && expected_type == BUILTIN_CSTR
     end
   end
-end
+end

data/lib/milk_tea/core/lexer.rb

@@ -106,6 +106,16 @@ module MilkTea
     BIN_DIGIT_BYTE = Array.new(256) { |b| b.chr.match?(/[01_]/) }.freeze
     SPACE_BYTE = " ".ord
 
+    include CharacterClasses
+    include Trivia
+    include Indentation
+    include Numbers
+    include Strings
+    include Heredocs
+    include FormatStrings
+    include Symbols
+    include Recovery
+
     def self.lex(source, path: nil, mode: :syntax_only, recovery_errors: nil)
       result = new(source, path: path, mode:, recovery_errors:).lex
       mode == :with_trivia ? result.tokens : result
@@ -170,16 +180,6 @@ module MilkTea
       @tokens
     end
 
-    include CharacterClasses
-    include Trivia
-    include Indentation
-    include Numbers
-    include Strings
-    include Heredocs
-    include FormatStrings
-    include Symbols
-    include Recovery
-
     def lex_line(lines, line_index, line, line_number, line_offset, has_newline:)
       tab_index = line.index("\t")
       if tab_index
@@ -371,8 +371,6 @@ module MilkTea
       1
     end
 
-    # ── newline emission ────────────────────────────────────────────
-
     def emit_line_newline(line, line_number, line_offset, has_newline)
       newline_start = line_offset + line.bytesize
       newline_end = has_newline ? (newline_start + 1) : newline_start
@@ -393,8 +391,6 @@ module MilkTea
       end
     end
 
-    # ── token construction ──────────────────────────────────────────
-
     def token(type, lexeme, literal, line, column, start_offset:, end_offset:)
       Token.new(
         type:,

data/lib/milk_tea/core/lowering.rb

@@ -31,7 +31,7 @@ require_relative "lowering/functions"
 require_relative "lowering/async/analysis"
 require_relative "lowering/async/normalization"
 require_relative "lowering/async/lowering"
-require_relative "lowering/async"
+require_relative "lowering/async/frame_builder"
 require_relative "lowering/block"
 require_relative "lowering/proc"
 require_relative "lowering/loops"
@@ -85,11 +85,27 @@ module MilkTea
   OrderResolution = Data.define(:target_type, :binding, :callee_name)
 
   class Lowerer
-    include CompatibilityHelpers
+    include Intrinsics
 
     attr_accessor :bypass_sema_type_cache
     attr_reader :recorded_expr_types
 
+    include LowererScans
+    include LowererDeclarations
+    include LowererEvents
+    include LowererFunctions
+    include LowererAsync
+    include LowererBlock
+    include LowererProc
+    include LowererLoops
+    include LowererExpressions
+    include LowererCalls
+    include LowererForeignCstr
+    include LowererStrBuffer
+    include LowererResolve
+    include LowererDyn
+    include LowererUtils
+
     def initialize(program)
       @program = program
       @ctx = ModuleContext.new
@@ -358,21 +374,5 @@ module MilkTea
       ordered.concat(modules.values - ordered)
       ordered
     end
-
-    include LowererScans
-    include LowererDeclarations
-    include LowererEvents
-    include LowererFunctions
-    include LowererAsync
-    include LowererBlock
-    include LowererProc
-    include LowererLoops
-    include LowererExpressions
-    include LowererCalls
-    include LowererForeignCstr
-    include LowererStrBuffer
-    include LowererResolve
-    include LowererDyn
-    include LowererUtils
   end
 end

data/lib/milk_tea/core/module_loader.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
-require_relative "module_loader/errors"
-require_relative "module_path_resolver"
-require_relative "module_binder"
-require_relative "async_runtime_installer"
-require_relative "prelude_installer"
-
 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)
     Program = Data.define(:root_path, :root_analysis, :analyses_by_path, :analyses_by_module_name)
     PLATFORM_SUFFIXES = {
       "linux" => :linux,
@@ -90,6 +101,15 @@ module MilkTea
       MilkTea.host_platform
     end
 
+    def self.raise_platform_conflict!(path, pinned_platform, active_platform, error_class: nil)
+      if error_class == ModuleLoadError
+        raise ModuleLoadError.new("source file targets platform #{pinned_platform}; active platform is #{active_platform}", path:)
+      end
+
+      message = "source file #{path} targets platform #{pinned_platform}; active platform is #{active_platform}"
+      raise(error_class || ArgumentError, message)
+    end
+
     def initialize(module_roots: [MilkTea.root], package_graph: nil, shared_cache: nil, source_overrides: nil, platform: nil)
       @module_roots = module_roots.map { |root| File.expand_path(root.to_s) }
       @ast_cache = {}
@@ -380,15 +400,6 @@ module MilkTea
       @collecting_path_errors
     end
 
-    def self.raise_platform_conflict!(path, pinned_platform, active_platform, error_class: nil)
-      if error_class == ModuleLoadError
-        raise ModuleLoadError.new("source file targets platform #{pinned_platform}; active platform is #{active_platform}", path:)
-      end
-
-      message = "source file #{path} targets platform #{pinned_platform}; active platform is #{active_platform}"
-      raise(error_class || ArgumentError, message)
-    end
-
     def check_path(path)
       resolved_path, ast, cached = check_module_cache(path)
       return cached if cached

data/lib/milk_tea/core/parser.rb

@@ -155,6 +155,23 @@ module MilkTea
       next_token.nil? || %i[newline eof].include?(next_token.type)
     end
 
+    def advance
+      @current += 1 unless eof?
+      previous
+    end
+
+    def eof?
+      peek.type == :eof
+    end
+
+    def peek
+      @tokens[@current]
+    end
+
+    def previous
+      @tokens[@current - 1]
+    end
+
     def match(*types)
       return false unless types.any? { |type| check(type) }
 
@@ -219,23 +236,6 @@ module MilkTea
       true
     end
 
-    def advance
-      @current += 1 unless eof?
-      previous
-    end
-
-    def eof?
-      peek.type == :eof
-    end
-
-    def peek
-      @tokens[@current]
-    end
-
-    def previous
-      @tokens[@current - 1]
-    end
-
     def error(token, message)
       ParseError.new(message, token:, path: @path)
     end

data/lib/milk_tea/core/semantic_analyzer.rb

@@ -129,7 +129,7 @@ module MilkTea
     end
 
     class Checker
-      include CompatibilityHelpers
+      include Intrinsics
 
       attr_reader :ctx
 

data/lib/milk_tea/core.rb

@@ -10,11 +10,15 @@ require_relative "core/cst"
 require_relative "core/cst_builder"
 require_relative "core/ast"
 require_relative "core/types"
-require_relative "core/binding_types"
+require_relative "core/bindings"
 require_relative "core/compile_time"
-require_relative "core/compatibility_helpers"
+require_relative "core/intrinsics"
 require_relative "core/parser"
 require_relative "core/module_roots"
+require_relative "core/module_path_resolver"
+require_relative "core/module_binder"
+require_relative "core/async_runtime_installer"
+require_relative "core/prelude_installer"
 require_relative "core/module_loader"
 require_relative "core/semantic_analyzer"
 require_relative "core/ir"

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.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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.16
+  version: 0.3.17
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -158,7 +158,6 @@ files:
 - lib/milk_tea/bindings/bindgen/emitter.rb
 - lib/milk_tea/bindings/bindgen/overrides.rb
 - lib/milk_tea/bindings/bindgen/type_mapper.rb
-- lib/milk_tea/bindings/cli.rb
 - lib/milk_tea/bindings/imported_bindings.rb
 - lib/milk_tea/bindings/imported_bindings/defaults.rb
 - lib/milk_tea/bindings/imported_bindings/generator.rb
@@ -185,7 +184,7 @@ files:
 - lib/milk_tea/core.rb
 - lib/milk_tea/core/ast.rb
 - lib/milk_tea/core/async_runtime_installer.rb
-- lib/milk_tea/core/binding_types.rb
+- lib/milk_tea/core/bindings.rb
 - lib/milk_tea/core/bindings/attribute_binding.rb
 - lib/milk_tea/core/bindings/function_binding.rb
 - lib/milk_tea/core/bindings/module_binding.rb
@@ -203,9 +202,7 @@ files:
 - lib/milk_tea/core/c_backend/type_collectors.rb
 - lib/milk_tea/core/c_backend/type_declaration.rb
 - lib/milk_tea/core/c_backend/type_system.rb
-- lib/milk_tea/core/compatibility_helpers.rb
 - lib/milk_tea/core/compile_time.rb
-- lib/milk_tea/core/compile_time/const_eval.rb
 - lib/milk_tea/core/control_flow.rb
 - lib/milk_tea/core/control_flow/builder.rb
 - lib/milk_tea/core/control_flow/constant_propagation.rb
@@ -218,6 +215,7 @@ files:
 - lib/milk_tea/core/control_flow/termination.rb
 - lib/milk_tea/core/cst.rb
 - lib/milk_tea/core/cst_builder.rb
+- lib/milk_tea/core/intrinsics.rb
 - lib/milk_tea/core/ir.rb
 - lib/milk_tea/core/keywords.rb
 - lib/milk_tea/core/lexer.rb
@@ -232,8 +230,8 @@ files:
 - lib/milk_tea/core/lexer/trivia.rb
 - lib/milk_tea/core/lowering.rb
 - lib/milk_tea/core/lowering/artifacts.rb
-- lib/milk_tea/core/lowering/async.rb
 - lib/milk_tea/core/lowering/async/analysis.rb
+- lib/milk_tea/core/lowering/async/frame_builder.rb
 - lib/milk_tea/core/lowering/async/lowering.rb
 - lib/milk_tea/core/lowering/async/normalization.rb
 - lib/milk_tea/core/lowering/block.rb
@@ -253,7 +251,6 @@ files:
 - lib/milk_tea/core/lowering/utils.rb
 - lib/milk_tea/core/module_binder.rb
 - lib/milk_tea/core/module_loader.rb
-- lib/milk_tea/core/module_loader/errors.rb
 - lib/milk_tea/core/module_path_resolver.rb
 - lib/milk_tea/core/module_roots.rb
 - lib/milk_tea/core/parser.rb
@@ -294,7 +291,7 @@ files:
 - lib/milk_tea/core/types/registry.rb
 - lib/milk_tea/core/types/visitor.rb
 - lib/milk_tea/dap.rb
-- lib/milk_tea/dap/backends/lldb_dap.rb
+- lib/milk_tea/dap/lldb_dap_backend.rb
 - lib/milk_tea/dap/protocol.rb
 - lib/milk_tea/dap/server.rb
 - lib/milk_tea/dap/server/breakpoints.rb
@@ -361,6 +358,7 @@ files:
 - lib/milk_tea/packages/version.rb
 - lib/milk_tea/tooling.rb
 - lib/milk_tea/tooling/asset_pack.rb
+- lib/milk_tea/tooling/bindgen_cli.rb
 - lib/milk_tea/tooling/build.rb
 - lib/milk_tea/tooling/build_cache.rb
 - lib/milk_tea/tooling/cli.rb
@@ -605,7 +603,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.16 installed!
+  Milk Tea 0.3.17 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH

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