mt-lang 0.3.12 → 0.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc80c3a3240cbcf4770dd067aa33559e74e3f139322b8fdb757316f3c7faf8af
-  data.tar.gz: a623e5ecaa9617aa161a83e96c4cb0e7a75b08855edae27fb56c8ddc47c7cd75
+  metadata.gz: 12f7a371c9cb4162851cefb9277292455904b6e0bedcba05312770f00d724481
+  data.tar.gz: 4d73b7c4ef5c45abc731edbfd6e465067230b6772669ad8952a75247cd10e2ad
 SHA512:
-  metadata.gz: c90aa51a21411fdcfe612f2ded69afdde6e055a012a4e886f5aa9ac69110d39a8bf93a36dde0543d1375a8bfa75ffd2f287eb082833a28b42efe19ab45c62ae6
-  data.tar.gz: a87ac20f1228f059e3508818be58e11e5491a90299e56d5ab569ab3ebf1ae3dc1f7ddff8761321754bd2bfc8c520dc9ac3876360714ced2baf6e06a82bbf635d
+  metadata.gz: d434a523bf7e5678512af400a5054765d62976778d27c1d647203fa03a39145509648d82d32d56d02218da1324d66717b1eb1da75543ea513e49fcc2e9fc5410
+  data.tar.gz: d2fa42eb284fd01df9492fa772d69c46853712862dd6f8d4f1f0f20aa8c40fc996abf821763175419cb58abb2ffe2da94a750e30b8c47d7b0c9ae9c31ec75f75

data/README.md

@@ -236,7 +236,7 @@ Callable and `ref[...]` rules:
 - External functions still cannot take `ref[...]` parameters, and ordinary functions still cannot return `ref[...]`.
 - `proc` captures are value captures. A captured local is not a mutable alias back to the outer binding. Any storable type may be captured, including scalars, arrays, structs, and other `proc` values. Captured `proc` values participate in the ref-counted lifecycle: the capturing proc retains the captured proc on creation and releases it when the env is freed.
 - `ref[T]` values are not capturable by design since they are non-owning.
-- Shared mutable proc state should use explicit storage such as `std.cell.alloc[T](...)` or other explicit pointer-backed state, not implicit mutable capture.
+- Shared mutable proc state should use explicit storage such as `std.box.alloc[T](...)` or other explicit pointer-backed state, not implicit mutable capture.
 
 ## 5. Data Declarations
 
@@ -902,7 +902,7 @@ Core modules in `std/`:
 
 **Compression**: `std.gzip`, `std.tar`
 
-**Other**: `std.bytes`, `std.ctype`, `std.asset_pack`, `std.cell`
+**Other**: `std.bytes`, `std.ctype`, `std.asset_pack`, `std.box`
 
 See module source for full method surface. Iterator forms:
 - Pointer-returning (`next() -> nullable ptr[T]`): `Vec`, `Deque`, `BinaryHeap`/`PriorityQueue`/`OrderedSet` (read-only), `OrderedMap.keys`/`Map.keys`/`Set`/`LinkedMap.keys`/`LinkedSet`/`Counter.keys`/`MultiSet.values`, `Queue`/`Stack` (mutable), `RingBuffer`, `SparseSet`
@@ -955,7 +955,7 @@ Heredoc notes:
 - Conditions must be `bool`.
 - No truthy or falsy coercion.
 - Outside external-call boundaries, enum and flags values do not implicitly coerce to their backing integer types.
-- Mixed signed and unsigned integer arithmetic requires an explicit cast.
+- Mixed signed and unsigned integer arithmetic promotes to the narrowest signed type that holds both ranges (e.g. `ubyte + int` is `int`, `int + uint` is `long`); mixing with a 64-bit unsigned type such as `ulong` or `ptr_uint` requires an explicit cast.
 - Non-widening integer conversions (narrowing, signed → unsigned) require an explicit cast. Lossless widening conversions (same signedness to wider or equal width, unsigned → wider signed) are implicit.
 - `%` requires integer-compatible operands.
 - Bitwise operators require matching integer or flags types.

data/docs/index.html

@@ -311,7 +311,7 @@ function main() -> int:
   <div class="table-wrap">
     <table class="attr-table">
       <tr><th>Principle</th><th>Description</th></tr>
-      <tr><td><strong>What you see is what runs</strong></td><td>No hidden allocation, dispatch, or heap traffic. Every cost is spelled in source.</td></tr>
+      <tr><td><strong>What you see is what runs</strong></td><td>Ordinary values have no hidden allocation or dispatch. Runtime interface dispatch and closure environments are explicit language features with their own costs.</td></tr>
       <tr><td><strong>C is the ABI ground truth</strong></td><td>Structs, unions, pointers, and calling conventions map directly without lossy translation.</td></tr>
       <tr><td><strong>Safe by default, unsafe by choice</strong></td><td>Pointer operations require <code>unsafe</code>. Indexing is bounds-checked. Conversions are explicit.</td></tr>
       <tr><td><strong>Data-oriented first</strong></td><td>Plain structs, arrays, spans, pools, and arenas matter more than elaborate object systems.</td></tr>
@@ -355,7 +355,7 @@ function main() -> int:
 <!-- ────────────────────────────────────────────────────────────────────────── -->
 <section id="generated-c">
   <h2>Generated C</h2>
-  <p>Milk Tea compiles to readable C that mirrors the source structure. No hidden runtime, no hidden heap traffic, no hidden dispatch. The output is designed for a human to debug, diff, and ship.</p>
+  <p>Milk Tea compiles to readable C that mirrors the source structure. Ordinary value operations do not introduce hidden heap traffic or dispatch; runtime interface values and closure environments remain explicit language features. The output is designed for a human to debug, diff, and ship.</p>
 
 <div class="code-wrap">
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
@@ -466,7 +466,7 @@ variant Action:
     heal(amount: int)
     idle
 
-## ── Interfaces (nominal contracts, no hidden dispatch) ──────────────
+## ── Interfaces (nominal contracts; dyn provides explicit dispatch) ───
 public interface Damageable:
     editable function take_damage(amount: int) -&gt; void
     function is_alive() -&gt; bool
@@ -680,7 +680,7 @@ function main() -&gt; int:
             break
         io.print_line(f"value #{v}")
 
-    ## Parallel for (arrays/spans only, lengths must match)
+    ## Lockstep for over arrays/spans (lengths must match)
     let xs = array[float, 3](1.0, 2.0, 3.0)
     let ys = array[float, 3](4.0, 5.0, 6.0)
     for x, y in xs, ys:
@@ -840,7 +840,7 @@ function main() -&gt; int:
   <p>Milk Tea source files use the <code class="code-inline">.mt</code> extension. A file is either an <strong>ordinary</strong> source file or an <strong>external</strong> file for raw ABI bindings. There are no wildcard imports — every module must be imported by name.</p>
 
   <h3>Ordinary Files</h3>
-  <p>The normal source form. No module header; module identity is inferred from the file path relative to <code class="code-inline">package.source_root</code>. <code class="code-inline">import</code> statements appear only at the top.</p>
+  <p>The normal source form. No module header; module identity is inferred from the file path relative to <code class="code-inline">package.source_root</code>. <code class="code-inline">import</code> statements appear only at the top. Circular module imports are supported through forward-declaration bindings and two-pass checking.</p>
 <div class="code-wrap">
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>import std.math as math
@@ -1184,7 +1184,7 @@ static_assert(MAX_ENTITIES &gt; 0, "need at least one entity")</code></pre>
   <h2>Interfaces &amp; Methods</h2>
 
   <h3>Interfaces</h3>
-  <p>Explicit nominal method-set contracts for static polymorphism. No inheritance, no hidden dispatch.</p>
+  <p>Explicit nominal method-set contracts for static polymorphism. No inheritance or hidden dispatch; runtime polymorphism is explicit through <code>dyn[I]</code>.</p>
 <div class="code-wrap">
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>public interface Damageable:
@@ -1304,7 +1304,7 @@ let handle = null[ptr[char]]</code></pre>
 </div>
 
   <h3>Memory Model</h3>
-  <p>Milk Tea follows <strong>value semantics by default</strong>. Scalars, structs, and fixed arrays copy by value. There is no hidden heap boxing, no garbage collector, and no hidden reference counting. Heap allocation is always explicit and allocator-driven:</p>
+  <p>Milk Tea follows <strong>value semantics by default</strong>. Scalars, structs, and fixed arrays copy by value. Ordinary values do not carry hidden heap boxes or reference counts; captured <code>proc</code> values may allocate ref-counted closure environments as part of their lifecycle. User-owned heap allocation remains explicit and allocator-driven:</p>
   <div class="table-wrap">
     <table class="attr-table">
       <tr><th>Module</th><th>Use Case</th></tr>
@@ -1450,8 +1450,8 @@ for item in items:
     process(item)</code></pre>
 </div>
 
-  <h3>for (Parallel)</h3>
-  <p>Arrays and spans only. Lengths must match.</p>
+  <h3>for (Lockstep)</h3>
+  <p>This is the lockstep multi-iterable form, distinct from <code>parallel for</code>. Arrays and spans only; lengths must match.</p>
 <div class="code-wrap">
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>for entity, position, velocity in entities, positions, velocities:
@@ -1628,7 +1628,7 @@ unsafe:
   <h2>Compile-Time Control Flow</h2>
 
   <h3>when</h3>
-  <p>Evaluates discriminant at compile time; only the chosen branch is type-checked and emitted.</p>
+  <p>Evaluates discriminant at compile time; only the chosen branch is type-checked and emitted. <code>when</code> may also appear at module level to conditionally include declarations, imports, or type definitions.</p>
 <div class="code-wrap">
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>when TARGET_OS:
@@ -2012,7 +2012,7 @@ let r = aio.result(task)</code></pre>
 <!-- ────────────────────────────────────────────────────────────────────────── -->
 <section id="concurrency">
   <h2>Concurrency</h2>
-  <p>Milk Tea has first-class compiler support for multithreading using real OS threads (libuv). All concurrency is structured: spawned work completes before the parent scope continues. No hidden thread pool, no GC interaction, no fire-and-forget.</p>
+  <p>Milk Tea has first-class compiler support for multithreading using real OS threads (libuv). <code>parallel for</code> and <code>parallel:</code> are structured barriers; <code>detach</code> continues asynchronously until an explicit <code>gather</code>. There is no GC interaction or implicit fire-and-forget cleanup.</p>
 
   <h3>Parallel For (data-parallel)</h3>
   <p>Dispatches loop iterations across CPU cores. Each iteration writes to its own index range &mdash; the bread and butter of data-oriented game programming.</p>
@@ -2245,7 +2245,7 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
       <tr><td><code>mtc lower &lt;path&gt;</code></td><td>Print lowered IR</td></tr>
       <tr><td><code>mtc debug &lt;file.mt&gt;</code></td><td>Print debug info (tokens, AST, facts, bindings, diagnostics)</td></tr>
       <tr><td><code>mtc emit-c &lt;path&gt;</code></td><td>Emit generated C to stdout</td></tr>
-      <tr><td><code>mtc format &lt;path&gt;</code></td><td>Format sources in place (<code>--check</code> for dry-run)</td></tr>
+      <tr><td><code>mtc format &lt;path&gt;</code></td><td>Format source to stdout (<code>--write</code> rewrites in place, <code>--check</code> verifies)</td></tr>
       <tr><td><code>mtc lint &lt;path&gt;</code></td><td>Run linter (<code>--fix</code>, <code>--select</code>, <code>--ignore</code>)</td></tr>
       <tr><td><code>mtc test &lt;path&gt;</code></td><td>Discover and run <code>@[test]</code> functions</td></tr>
       <tr><td><code>mtc new &lt;name&gt;</code></td><td>Scaffold a new package (<code>package.toml</code> + <code>src/main.mt</code>)</td></tr>
@@ -2416,9 +2416,17 @@ import std.math  # intentionally available for downstream</code></pre>
 
   <h3>Event Restrictions</h3>
   <ul style="margin-left:1.25rem;margin-bottom:1rem">
-    <li>Event payload cannot be <code>ref[T]</code></li>
-    <li><code>emit</code> is only callable from within the declaring module</li>
-    <li>Events not allowed in external files</li>
+     <li>Event payload types must be storable and cannot be event storage types</li>
+     <li>Event payload cannot be <code>ref[T]</code></li>
+     <li>Event storage types cannot be returned, passed through ordinary value parameters, or copied into locals</li>
+     <li><code>emit</code> is only callable from within the declaring module</li>
+     <li>Events not allowed in external files</li>
+  </ul>
+
+  <h3>Interface Restrictions</h3>
+  <ul style="margin-left:1.25rem;margin-bottom:1rem">
+     <li>Interface methods cannot be <code>async</code> or declare their own type parameters</li>
+     <li>Interface conformance must be declared on the nominal type, not an <code>extending</code> block</li>
   </ul>
 </section>
 

data/docs/language-design.md

@@ -16,7 +16,7 @@ The output target is beautiful C. The generated C should be readable enough that
 2. Stay statically typed. Public APIs must be explicit and unsurprising.
 3. Feel good for game programming. Tight loops, structs, arrays, arenas, handles, and FFI should be first-class.
 4. Interoperate with C as a native citizen. C libraries are not a side feature; they are part of the core story.
-5. Generate C that mirrors the source closely. No hidden runtime, hidden heap traffic, or hidden dispatch.
+5. Generate C that mirrors the source closely. Ordinary value operations do not add hidden heap traffic or dispatch; explicit runtime surfaces such as `dyn` and captured `proc` environments remain visible in the language model.
 
 ## Non-goals
 
@@ -28,7 +28,7 @@ The output target is beautiful C. The generated C should be readable enough that
 - No macro system that rewrites arbitrary ASTs
 - No garbage collector
 - No implicit conversions between unrelated primitive types
-- No user-invisible allocation for strings, collections, closures, or method calls. If a surface allocates owned text or storage, the allocating surface must be spelled in source.
+- No user-invisible allocation for strings, collections, ordinary values, or method calls. Capturing a `proc` may allocate a ref-counted closure environment as part of proc value semantics; owned text and other storage use explicit allocating surfaces.
 
 ## Design rules
 
@@ -291,7 +291,7 @@ The rule is fixed and inspectable. There is no method lookup at runtime.
 ### Interfaces
 
 Interfaces are explicit nominal method-set contracts for static polymorphism.
-They do not introduce inheritance, hidden dispatch, or a second object model.
+They do not introduce inheritance, hidden dispatch, or a second object model. Runtime polymorphism is an explicit `dyn[Interface]` surface.
 
 ```mt
 interface Damageable:
@@ -363,7 +363,7 @@ Because fixed arrays copy by value, mutating interface-constrained collection co
 
 Iteration stays structural in v1 rather than going through a nominal `Iterator[T]` or `Iterable[T]` interface. Arrays, spans, and ranges keep their built-in behavior, and custom iterables participate by exposing the same method shape the compiler already recognizes: a non-editable `iter()` method on the iterable, then either `next() ->` nullable pointer-like item or `next() -> bool` together with `current()` on the iterator.
 
-This is deliberate. Interfaces are compile-time-only nominal contracts and are not generic today, so introducing a central iterator interface hierarchy now would either erase the item type or duplicate type-specific interfaces. The standard library should instead standardize on one iterator convention:
+This is deliberate. Interfaces are nominal contracts, and generic interfaces are supported, but introducing a central iterator interface hierarchy would still either erase the item type or duplicate type-specific interfaces. The standard library should instead standardize on one iterator convention:
 
 - `collection.iter()` is the canonical traversal surface.
 - Alternate traversals use explicit view methods such as `map.keys()`, `map.values()`, and `map.entries()`.
@@ -484,7 +484,7 @@ The default async model is a language-integrated entry boundary. `std.async` rem
 
 #### Concurrency: `parallel for` and `parallel:` blocks
 
-Milk Tea has first-class compiler support for multithreading. The threading model is structured: all spawned work completes before the parent scope continues. There is no hidden thread pool, no garbage collector interaction, and no fire-and-forget. Every thread boundary is visible in source.
+Milk Tea has first-class compiler support for multithreading. The compiler-integrated `parallel for` and `parallel:` forms use structured barriers; explicit `detach` work continues until a matching `gather`. There is no hidden thread pool, no garbage collector interaction, and no implicit fire-and-forget cleanup. Every thread boundary is visible in source.
 
 ```mt
 # Data-parallel: each iteration runs on a separate CPU core
@@ -794,7 +794,7 @@ unsafe:
 Binary arithmetic and numeric comparison operators may promote primitive operands to a common type locally.
 This is limited to `+ - * / % == != < <= > >=` and does not change assignment, return, or aggregate-field typing rules.
 Non-external call boundaries remain strict, but external calls may pass enum or flags values to same-width fixed-width integer parameters without an explicit cast for C ABI interop.
-Mixed signed and unsigned integers still require an explicit cast.
+Mixed signed and unsigned integer operands use the same lossless rule as assignment: they promote to the narrowest signed type that holds both full ranges — a strictly-wider signed type covers an unsigned operand (`ubyte + int` is `int`, `uint + long` is `long`), and equal-width or narrower signed operands widen to the next signed width (`int + uint` is `long`, `byte + ubyte` is `short`). Mixing with a 64-bit unsigned type (`ulong`, `ptr_uint`) has no safe signed common type and still requires an explicit cast.
 
 `char` stays outside the general numeric-promotion rules. If code wants arithmetic on a character value, cast it to an integer type first. If code wants to write bytes back into a `char` buffer, either use `char<-...` explicitly or rely on the expected `char` boundary where a known `char` target is being initialized or assigned.
 
@@ -876,7 +876,7 @@ The memory model must feel like C with better defaults and cleaner surfaces.
 - Fixed arrays copy by value.
 - Returning a struct is allowed and lowers to normal C return or out-parameter lowering as needed.
 
-There is no hidden reference counting and no hidden heap boxing.
+Ordinary values do not carry hidden reference counts or heap boxes. Captured `proc` values are the explicit callable-model exception: their environments retain and release nested captured procs so stored closures have a defined lifecycle.
 
 ### Explicit allocation
 
@@ -1100,7 +1100,7 @@ Rules:
 - one module identity per file, derived from its path
 - explicit imports only
 - no wildcard imports in v1
-- no cyclic imports
+- cyclic imports are supported through forward-declaration bindings and two-pass checking
 - package naming stays filesystem-friendly
 
 Recommended layout:
@@ -1428,7 +1428,7 @@ Callbacks must map directly to C function pointers.
 type LogCallback = fn(level: int, message: cstr, user_data: ptr[void]) -> void
 ```
 
-Capturing closures should not be lowered to hidden heap objects. If user state is needed, pass it explicitly as `user_data` at ABI boundaries or allocate explicit local storage such as `std.cell.alloc[T](...)` in ordinary Milk Tea code.
+Capturing closures should not be lowered to hidden heap objects. If user state is needed, pass it explicitly as `user_data` at ABI boundaries or allocate explicit local storage such as `std.box.alloc[T](...)` in ordinary Milk Tea code.
 
 ## Data layout and ABI controls
 

data/docs/language-manual.md

@@ -292,7 +292,7 @@ Callable and `ref[...]` rules:
 - External functions still cannot take `ref[...]` parameters, and ordinary functions still cannot return `ref[...]`.
 - `proc` captures are value captures. A captured local is not a mutable alias back to the outer binding. Any storable type may be captured, including scalars, arrays, structs, and other `proc` values. Captured `proc` values participate in the ref-counted lifecycle: the capturing proc retains the captured proc on creation and releases it when the env is freed.
 - `ref[T]` values are not capturable by design since they are non-owning.
-- Shared mutable proc state should use explicit storage such as `std.cell.alloc[T](...)` or other explicit pointer-backed state, not implicit mutable capture.
+- Shared mutable proc state should use explicit storage such as `std.box.alloc[T](...)` or other explicit pointer-backed state, not implicit mutable capture.
 
 ### 3.4 Struct, union, enum, flags, opaque
 
@@ -1508,7 +1508,7 @@ The compiler intentionally rejects the following patterns. These are design cons
 ### 13.6 Type system restrictions
 
 - conditions must be `bool`; integers and pointers have no implicit truthy or falsy coercion
-- mixed signed and unsigned integer arithmetic requires an explicit cast
+- mixed signed and unsigned integer arithmetic promotes to the narrowest signed type that holds both ranges (`ubyte + int` is `int`, `int + uint` is `long`, `byte + ubyte` is `short`); mixing with a 64-bit unsigned type (`ulong`, `ptr_uint`) still requires an explicit cast
 - enum and flags values do not implicitly coerce to their backing integer types outside external-call boundaries
 - `enum` backing types must be integer primitives; flags members must be compile-time integer constants
 - variant arm payloads cannot use `ref[T]` in v1

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/bindings/bindgen.rb

@@ -5,7 +5,7 @@ require "open3"
 require "tempfile"
 require_relative "../tooling/formatter"
 require_relative "../core/token"
-require_relative "../core/types/types"
+require_relative "../core/types"
 require_relative "bindgen/ast_parser"
 require_relative "bindgen/declaration"
 require_relative "bindgen/type_mapper"

data/lib/milk_tea/bindings/imported_bindings.rb

@@ -3,7 +3,7 @@
 require "json"
 require_relative "../tooling/formatter"
 require_relative "../core/token"
-require_relative "../core/types/types"
+require_relative "../core/types"
 
 require_relative "imported_bindings/generator"
 require_relative "imported_bindings/method_source"

data/lib/milk_tea/core/lowering/expressions.rb

@@ -1506,10 +1506,54 @@ module MilkTea
       return false unless receiver_type.is_a?(Types::VariantArmPayload)
 
       outer = receiver_type.variant_type
-      return field_type == outer if outer.is_a?(Types::Variant)
-      return field_type == outer if outer.is_a?(Types::VariantInstance)
+      return false unless outer.is_a?(Types::Variant) || outer.is_a?(Types::VariantInstance)
 
-      false
+      # The C backend pointer-breaks every cyclic field, including cycles that
+      # run through generic instantiations such as `Option[Atom]` inside `Atom`.
+      # Deref the access whenever the field type can reach the outer variant.
+      type_reaches_target?(field_type, outer)
+    end
+
+    def type_reaches_target?(type, target)
+      type_reaches_target_with_visited?(type, target, {})
+    end
+
+    def type_reaches_target_with_visited?(type, target, visited)
+      return true if type == target
+      return false if visited[type.object_id]
+
+      visited[type.object_id] = true
+      reachability_children(type).any? do |child|
+        type_reaches_target_with_visited?(child, target, visited)
+      end
+    end
+
+    # Structural expansion used by cyclic-field reachability. Mirrors the
+    # CBackend's `aggregate_type_dependencies` so the deref injected for a
+    # pointer-broken cyclic field agrees with the emitted C struct layout.
+    def reachability_children(type)
+      case type
+      when Types::Nullable
+        [type.base]
+      when Types::GenericInstance
+        if pointer_type?(type)
+          []
+        elsif array_type?(type)
+          [array_element_type(type)]
+        else
+          []
+        end
+      when Types::Span
+        [type.element_type]
+      when Types::Struct, Types::StructInstance, Types::Union
+        type.fields.values
+      when Types::Variant, Types::VariantInstance
+        type.arm_names.flat_map { |name| type.arm(name).values }
+      when Types::VariantArmPayload
+        type.fields.values
+      else
+        []
+      end
     end
 
     def lower_compile_time_handle_member(handle, member, type)

data/lib/milk_tea/core/lowering/resolve.rb

@@ -1137,9 +1137,33 @@ module MilkTea
       return unless left_type.is_a?(Types::Primitive) && right_type.is_a?(Types::Primitive)
       return unless left_type.integer? && right_type.integer?
       return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
-      return unless left_type.signed_integer? == right_type.signed_integer?
 
-      left_type.integer_width >= right_type.integer_width ? left_type : right_type
+      # Mirrors the semantic analyzer's rule: same signedness picks the wider
+      # type; mixed signed/unsigned promotes to the narrowest signed type that
+      # holds both operands' full ranges (a strictly-wider signed type covers
+      # an unsigned operand, otherwise widen to the next signed width). Mixing
+      # with a 64-bit unsigned type has no safe signed common type.
+      if left_type.signed_integer? == right_type.signed_integer?
+        return left_type.integer_width >= right_type.integer_width ? left_type : right_type
+      end
+
+      signed_type, unsigned_type = if left_type.signed_integer?
+        [left_type, right_type]
+      else
+        [right_type, left_type]
+      end
+
+      return signed_type if signed_type.integer_width > unsigned_type.integer_width
+
+      signed_type_above_width(unsigned_type.integer_width)
+    end
+
+    def signed_type_above_width(width)
+      case width
+      when 8 then @ctx.types.fetch("short")
+      when 16 then @ctx.types.fetch("int")
+      when 32 then @ctx.types.fetch("long")
+      end
     end
 
     def wider_float_type(left_type, right_type)

data/lib/milk_tea/core/lowering/utils.rb

@@ -943,7 +943,12 @@ module MilkTea
       payload_type = Types::VariantArmPayload.new(storage_type, arm_name, storage_type.arm(arm_name))
       data_expr = IR::Member.new(receiver: storage_expr, member: "data", type: nil)
       arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
-      IR::Member.new(receiver: arm_expr, member: field_name, type: field_type)
+      member_expr = IR::Member.new(receiver: arm_expr, member: field_name, type: field_type)
+      if type_reaches_target?(field_type, payload_type.variant_type)
+        return IR::Unary.new(operator: "*", operand: member_expr, type: field_type)
+      end
+
+      member_expr
     end
 
     def infer_result_propagation_type(expression, env:)

data/lib/milk_tea/core/semantic_analyzer/type_compatibility.rb

@@ -187,9 +187,36 @@ module MilkTea
         return unless left_type.integer? && right_type.integer?
         return left_type if left_type == right_type
         return unless left_type.fixed_width_integer? && right_type.fixed_width_integer?
-        return unless left_type.signed_integer? == right_type.signed_integer?
 
-        left_type.integer_width >= right_type.integer_width ? left_type : right_type
+        # Same signedness: the wider type wins (both operands are losslessly
+        # assignable to it).
+        if left_type.signed_integer? == right_type.signed_integer?
+          return left_type.integer_width >= right_type.integer_width ? left_type : right_type
+        end
+
+        # Mixed signed/unsigned: promote to the narrowest signed type that holds
+        # both operands' full ranges, mirroring the lossless assignment rule. A
+        # strictly-wider signed type covers an unsigned operand; equal-width or
+        # wider unsigned operands widen to the next signed width. Mixing with a
+        # 64-bit unsigned type has no safe signed common type, so callers fall
+        # back to requiring an explicit cast.
+        signed_type, unsigned_type = if left_type.signed_integer?
+          [left_type, right_type]
+        else
+          [right_type, left_type]
+        end
+
+        return signed_type if signed_type.integer_width > unsigned_type.integer_width
+
+        signed_type_above_width(unsigned_type.integer_width)
+      end
+
+      def signed_type_above_width(width)
+        case width
+        when 8 then @ctx.types.fetch("short")
+        when 16 then @ctx.types.fetch("int")
+        when 32 then @ctx.types.fetch("long")
+        end
       end
 
       def wider_float_type(left_type, right_type)

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "fiddle"
-require_relative "types"
+require_relative "../types"
 
 module MilkTea
   module Layout

data/lib/milk_tea/core/{types/types.rb → types.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require "fiddle"
-require_relative "registry"
-require_relative "visitor"
+require_relative "types/registry"
+require_relative "types/visitor"
 
 module MilkTea
   module Types
@@ -850,9 +850,6 @@ module MilkTea
       end
 
       def field_c_name(name)
-        stripped = name.delete_suffix("_")
-        return stripped if stripped != name && MilkTea::KEYWORDS.key?(stripped)
-
         name
       end
 
@@ -961,9 +958,6 @@ module MilkTea
       end
 
       def field_c_name(name)
-        stripped = name.delete_suffix("_")
-        return stripped if stripped != name && MilkTea::KEYWORDS.key?(stripped)
-
         name
       end
 

data/lib/milk_tea/core.rb

@@ -9,7 +9,7 @@ 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/types"
 require_relative "core/binding_types"
 require_relative "core/compile_time"
 require_relative "core/compatibility_helpers"

data/lib/milk_tea/tooling/cli.rb

@@ -229,6 +229,7 @@ module MilkTea
 
     def lex_command
       path = nil
+      sexpr = false
 
       args = @argv.dup
       @argv = []
@@ -236,6 +237,11 @@ module MilkTea
         arg = args.shift
         next if arg == "--"
 
+        if arg == "--sexpr"
+          sexpr = true
+          next
+        end
+
         if path.nil?
           path = arg
         else
@@ -252,15 +258,24 @@ module MilkTea
       end
 
       tokens = Lexer.lex(read_source_file(path), path: path)
-      @out.write(PP.pp(tokens, +""))
+      if sexpr
+        @out.puts(SexprDumper.dump_tokens(tokens))
+      else
+        @out.write(PP.pp(tokens, +""))
+      end
       0
     end
 
     def parse_command
+      sexpr = false
       args = @argv.dup
       @argv = []
       until args.empty?
         arg = args.shift
+        if arg == "--sexpr"
+          sexpr = true
+          next
+        end
         @argv << arg
       end
 
@@ -283,9 +298,13 @@ module MilkTea
       paths.each_with_index do |path, index|
         ast = make_module_loader(path, locked: resolution[:locked], platform: ModuleLoader.default_host_platform).load_file(path)
         if multiple
-          @out.puts("# --- #{path} ---")
+          @out.puts("# --- #{path} ---") unless sexpr
+        end
+        if sexpr
+          @out.puts(SexprDumper.dump_ast(ast))
+        else
+          @out.write(PrettyPrinter.format_ast(ast))
         end
-        @out.write(PrettyPrinter.format_ast(ast))
         @out.puts if multiple && index < paths.length - 1
       end
       0
@@ -764,10 +783,15 @@ module MilkTea
     end
 
     def lower_command
+      sexpr = false
       args = @argv.dup
       @argv = []
       until args.empty?
         arg = args.shift
+        if arg == "--sexpr"
+          sexpr = true
+          next
+        end
         @argv << arg
       end
 
@@ -790,10 +814,13 @@ module MilkTea
       paths.each_with_index do |path, index|
         program = make_module_loader(path, locked: resolution[:locked], platform: ModuleLoader.default_host_platform).check_program(path)
         if multiple
-          @out.puts("# --- #{path} ---")
+          @out.puts("# --- #{path} ---") unless sexpr
+        end
+        if sexpr
+          @out.puts(SexprDumper.dump_ir(Lowering.lower(program)))
+        else
+          @out.write(PrettyPrinter.format_ir(Lowering.lower(program)))
         end
-        @out.write(PrettyPrinter.format_ir(Lowering.lower(program)))
-        @out.puts if multiple && index < paths.length - 1
       end
       0
     end