mt-lang 0.3.14 → 0.3.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12f7a371c9cb4162851cefb9277292455904b6e0bedcba05312770f00d724481
-  data.tar.gz: 4d73b7c4ef5c45abc731edbfd6e465067230b6772669ad8952a75247cd10e2ad
+  metadata.gz: e2f84289b1bcb599ca81cbada0b1e1a925d9962ffe186471b84026f372fb358b
+  data.tar.gz: 566b98b015518f583e31fa2f0a75753c3b0abfd5a4047210945b3209c3caf1f3
 SHA512:
-  metadata.gz: d434a523bf7e5678512af400a5054765d62976778d27c1d647203fa03a39145509648d82d32d56d02218da1324d66717b1eb1da75543ea513e49fcc2e9fc5410
-  data.tar.gz: d2fa42eb284fd01df9492fa772d69c46853712862dd6f8d4f1f0f20aa8c40fc996abf821763175419cb58abb2ffe2da94a750e30b8c47d7b0c9ae9c31ec75f75
+  metadata.gz: ee114072cb26ed2527e0b3703cb7f8a913e37234e6937b3a307ce72363e8a6e10a34e0a149d508a8c02e64c1a0a0f5e9b1ae482b76f068bfb6bf0b8784f34a44
+  data.tar.gz: 9b29c88530cf6110381123ef8135434caa47aa85abf955a8bd9f25d93fa1b8059691d52804c17e4080a2a3d0ad916aa689470ec8d7719a7186fa62eddb026525

data/README.md

@@ -477,7 +477,7 @@ Rules:
 - Conditions must be `bool`.
 - There is no truthy or falsy coercion from integers or pointers.
 - `pass` is an explicit no-op statement for intentionally empty block bodies.
-- `if` supports an inline single-statement form: `if cond: stmt else: stmt`. The body is a single statement on the same line instead of an indented block.
+- Every block-taking statement accepts a `:`-newline-indented block, or a single statement on the same line after `:`. This applies to `if`/`else` (e.g. `if cond: stmt else: stmt`), `while`, `for`, `defer` (e.g. `defer: cleanup()`), and `unsafe`. `match` arms are the exception: their inline form is a single value expression.
 
 `match` supports the following scrutinee types:
 
@@ -615,7 +615,7 @@ Rules:
 
 `defer`:
 
-- `defer expr`
+- `defer: expr` — single-statement inline form
 - `defer:` block form
 - `return` is not allowed inside defer blocks.
 

data/docs/index.html

@@ -658,12 +658,12 @@ function main() -> int:
 
     ## Collections: Vec and Map (import std.hash for primitive keys)
     var entities = vec.Vec[Entity].create()
-    defer entities.release()
+    defer: entities.release()
     entities.push(Entity.create(1, EntityKind.player, "Hero"))
     entities.push(Entity.create(2, EntityKind.enemy, "Goblin"))
 
     var name_counts = map.Map[str, int].create()
-    defer name_counts.release()
+    defer: name_counts.release()
     name_counts.set("player", 1)
     name_counts.set("enemy", 5)
 
@@ -742,7 +742,7 @@ function main() -> int:
     io.print_line(f"Position: #{position.x:.2}, #{position.y:.2}")
     io.print_line(f"ID hex: #{player.entity.id:x}")
     var msg = fmt.format(f"Score: #{score}")
-    defer msg.release()
+    defer: msg.release()
 
     ## Heredoc string
     let help = <<-HELP
@@ -753,7 +753,7 @@ function main() -> int:
 
     ## Defer: cleanup at scope exit (lowers to C cleanup labels)
     let data: own[int] = heap.must_alloc[int](1)
-    defer heap.release[int](data)
+    defer: heap.release[int](data)
 
     ## Proc / closure
     let scale = make_scaler(2.5)
@@ -1598,11 +1598,11 @@ match record:
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>function main() -> int:
     rl.init_window(800, 600, "Game")
-    defer rl.close_window()
+    defer: rl.close_window()
 
     while not rl.window_should_close():
         rl.begin_drawing()
-        defer rl.end_drawing()
+        defer: rl.end_drawing()
         render_frame()
 
     return 0</code></pre>
@@ -2149,8 +2149,8 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
     let closed_sub = window.closed.subscribe(on_close)?
     let resized_sub = window.resized.subscribe(on_resize)?
 
-    defer window.closed.unsubscribe(closed_sub)
-    defer window.resized.unsubscribe(resized_sub)
+    defer: window.closed.unsubscribe(closed_sub)
+    defer: window.resized.unsubscribe(resized_sub)
 
     return Result[void, EventError].success()</code></pre>
 </div>

data/docs/language-design.md

@@ -119,7 +119,7 @@ extending Player:
 
 function main() -> int:
 	rl.init_window(screen_width, screen_height, "Milk Tea")
-	defer rl.close_window()
+	defer: rl.close_window()
 
 	var player = Player(
 		position = rl.Vector2(x = 400.0, y = 300.0),
@@ -132,7 +132,7 @@ function main() -> int:
 		player.update(dt)
 
 		rl.begin_drawing()
-		defer rl.end_drawing()
+		defer: rl.end_drawing()
 
 		rl.clear_background(rl.BLACK)
 		rl.draw_circle_v(player.position, player.radius, rl.GOLD)
@@ -423,16 +423,12 @@ Milk Tea should include a small number of control-flow features that materially
 
 #### `defer`
 
-`defer` registers cleanup code at scope exit and lowers to obvious cleanup labels in C.
+`defer` registers cleanup code at scope exit and lowers to obvious cleanup labels in C. Both forms use the block-header `:`:
 
 ```mt
-
-
 function load_texture(path: str) -> Result[Texture, LoadError]:
 	let texture = rl.load_texture(path)
-
-	if texture.id == 0:
-		return Result[Texture, LoadError].failure(error= LoadError.file_not_found)
+	defer: rl.unload_texture(texture)
 
 	return Result[Texture, LoadError].success(value= texture)
 ```
@@ -525,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`
@@ -591,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.
@@ -654,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
@@ -665,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

@@ -596,6 +596,8 @@ if x > 10: return "big" else if x > 5: return "med" else: return "small"
 
 The inline form supports all statement kinds in the body (`return`, `let`, `var`, `defer`, assignment, expression statement, etc.). Blocks and inline form may be mixed: any branch may use either form independently.
 
+Every block-taking statement follows the same rule: a `:` followed by a newline starts an indented block, while a `:` followed by anything else on the same line introduces exactly one inline statement. This applies uniformly to `if`/`else`, `while`, `for`, `defer`, and `unsafe` (§4.3, §4.4, §4.5). `match` arms are the exception: their inline form is a single value expression (§4.2).
+
 ### 4.2 Match
 
 Scrutinee types supported:
@@ -717,6 +719,13 @@ Single-form `for` supports:
 - `span[T]`
 - custom structural iterables with a non-editable zero-argument `iter()` method
 
+Every loop body accepts either a `:`-newline-indented block or a single statement on the same line as the header:
+
+```mt
+while ready: poll()
+for value in values: accumulate(value)
+```
+
 Iterator protocol for custom structural iterables:
 
 - the iterable value must expose `iter()` with no parameters
@@ -795,10 +804,10 @@ Rules:
 
 ### 4.4 Defer
 
-Forms:
+Both forms use the block-header `:` introduced in §4:
 
 ```mt
-defer cleanup()
+defer: cleanup()
 
 # or
 
@@ -807,7 +816,10 @@ defer:
     release_b()
 ```
 
-`return` is not allowed inside defer blocks.
+Rules:
+
+- `defer` always requires `:`. A single statement may follow on the same line (`defer: release_a()`), or a `:`-newline-indented block may hold several statements.
+- `return` is not allowed inside defer blocks.
 
 ### 4.5 Unsafe
 
@@ -995,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.
 
@@ -1031,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.
@@ -1042,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
@@ -1363,8 +1375,8 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
     let closed_sub = window.closed.subscribe(on_close)?
     let resized_sub = window.resized.subscribe(on_resize)?
 
-    defer window.closed.unsubscribe(closed_sub)
-    defer window.resized.unsubscribe(resized_sub)
+    defer: window.closed.unsubscribe(closed_sub)
+    defer: window.resized.unsubscribe(resized_sub)
 
     return Result[void, EventError].success()
 ```

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/ast.rb

@@ -212,8 +212,8 @@ module MilkTea
     ReturnStmt = Data.define(:value, :line, :column, :length) do
       def initialize(value:, line: nil, column: nil, length: nil) = super
     end
-    DeferStmt = Data.define(:expression, :body, :line, :column, :length) do
-      def initialize(expression:, body:, line: nil, column: nil, length: nil) = super
+    DeferStmt = Data.define(:body, :line, :column, :length) do
+      def initialize(body:, line: nil, column: nil, length: nil) = super
     end
     ErrorBlockStmt = Data.define(:body, :line, :column, :length, :message, :header_type, :header_expression, :header_bindings, :header_iterables) do
       def initialize(body:, line: nil, column: nil, length: nil, message: nil, header_type: nil, header_expression: nil, header_bindings: nil, header_iterables: nil) = super

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/builder.rb

@@ -212,8 +212,8 @@ module MilkTea
         when AST::UnsafeStmt
           build_block(stmt.body, next_id, break_target:, continue_target:)
         when AST::DeferStmt
-          body_entry = stmt.body ? build_block(stmt.body, next_id, break_target:, continue_target:) : next_id
-          expression_reads, expression_reads_info = stmt.expression ? read_identifiers_with_sites(stmt.expression) : [Set.new, []]
+          body_entry = build_block(stmt.body, next_id, break_target:, continue_target:)
+          expression_reads, expression_reads_info = statement_list_reads_with_sites(stmt.body)
           defer_id = @graph.add_node(
             kind: :defer,
             statement: stmt,
@@ -315,6 +315,66 @@ module MilkTea
         [reads, reads_info]
       end
 
+      def statement_list_reads_with_sites(statements)
+        reads = Set.new
+        reads_info = []
+        statement_list_read_identifiers(statements, reads, reads_info)
+        [reads, reads_info]
+      end
+
+      def statement_list_read_identifiers(statements, reads, reads_info)
+        Array(statements).each do |statement|
+          statement_read_identifiers(statement, reads, reads_info)
+        end
+      end
+
+      def statement_read_identifiers(statement, reads, reads_info)
+        case statement
+        when AST::ExpressionStmt
+          read_identifiers(statement.expression, reads, reads_info)
+        when AST::DeferStmt
+          statement_list_read_identifiers(statement.body, reads, reads_info)
+        when AST::LocalDecl
+          read_identifiers(statement.value, reads, reads_info)
+          statement_list_read_identifiers(statement.else_body, reads, reads_info)
+        when AST::Assignment
+          read_identifiers(statement.target, reads, reads_info)
+          read_identifiers(statement.value, reads, reads_info)
+        when AST::ReturnStmt
+          read_identifiers(statement.value, reads, reads_info)
+        when AST::IfStmt
+          statement.branches.each do |branch|
+            read_identifiers(branch.condition, reads, reads_info)
+            statement_list_read_identifiers(branch.body, reads, reads_info)
+          end
+          statement_list_read_identifiers(statement.else_body, reads, reads_info)
+        when AST::WhileStmt
+          read_identifiers(statement.condition, reads, reads_info)
+          statement_list_read_identifiers(statement.body, reads, reads_info)
+        when AST::ForStmt
+          statement.iterables.each { |iterable| read_identifiers(iterable, reads, reads_info) }
+          statement_list_read_identifiers(statement.body, reads, reads_info)
+        when AST::UnsafeStmt
+          statement_list_read_identifiers(statement.body, reads, reads_info)
+        when AST::MatchStmt
+          read_identifiers(statement.expression, reads, reads_info)
+          statement.arms.each do |arm|
+            read_identifiers(arm.pattern, reads, reads_info)
+            statement_list_read_identifiers(arm.body, reads, reads_info)
+          end
+        when AST::StaticAssert
+          read_identifiers(statement.condition, reads, reads_info)
+          read_identifiers(statement.message, reads, reads_info)
+        when AST::WhenStmt
+          read_identifiers(statement.discriminant, reads, reads_info)
+          statement.branches.each do |branch|
+            read_identifiers(branch.pattern, reads, reads_info)
+            statement_list_read_identifiers(branch.body, reads, reads_info)
+          end
+          statement_list_read_identifiers(statement.else_body, reads, reads_info)
+        end
+      end
+
       def read_identifiers(expression, names = Set.new, reads_info = [])
         case expression
         when nil

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:,