mt-lang 0.3.13 → 0.3.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccbf498d3496c9dac904d8f2b43442e971507874b856149171b78f7eed90e949
-  data.tar.gz: '090885ac2d6181ba4cabb1ef6ed5c5a6e79cb3e60fe4fa61315c6f2404d5e00f'
+  metadata.gz: b5cd3c1ef5e380b8d0c5d4e20f829400d01c6fdfd3e495e8c98050f4af8b59ba
+  data.tar.gz: 0e083d1780c9d591b996604a8b489726fa0f0c6fb85b8dc03da87b681383d5ca
 SHA512:
-  metadata.gz: '08b68224eb3b428b8fab0845a98f79605c06f95ffc66a6a653586da99f230720f177781ac481debee8aede3cda843f34f12fb953f62846fc8d7048d3b97726c1'
-  data.tar.gz: cd69cddcf5b0cf2bb86fe4443c502c214fc73dda6318532f14e9548b8bbc7b84186956b9bf4a975148ad0f45d8bb9b86f1093956c089af293f1755ca2c8b6589
+  metadata.gz: 44f866e7d6bf6fc4998e0a9054bf898b27ed47ef38149de1881baf1d810e845b94e3d1f3ff304486654ea339329d726a10d969bcff4021943cc98b03bfe3fe01
+  data.tar.gz: 0fa7237c14aa9e038b4d51ae08a5971430d0e47b97fb19caf619aeb80a5e562de99aae1cf342a11ffea41e3b2268a128454bbf022b3e9182ddd94ff2ff0aff45

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
 
@@ -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.
 
@@ -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
@@ -658,12 +658,12 @@ function main() -&gt; 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)
 
@@ -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:
@@ -742,7 +742,7 @@ function main() -&gt; 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 = &lt;&lt;-HELP
@@ -753,7 +753,7 @@ function main() -&gt; 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)
@@ -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:
@@ -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>
@@ -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>
@@ -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>
@@ -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
 
@@ -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)
@@ -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()`.
@@ -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)
 ```
@@ -484,7 +480,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 +790,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 +872,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 +1096,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 +1424,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
 
@@ -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
 
@@ -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()
 ```
@@ -1508,7 +1520,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.13"
+  VERSION = "0.3.16"
 
   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/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/lowering/async/analysis.rb

@@ -145,15 +145,9 @@ module MilkTea
         when AST::UnsafeStmt
           await_counter = analyze_async_statements!(statement.body, await_counter, env, param_fields, local_fields, await_fields)
         when AST::DeferStmt
-          if statement.body
-            cleanup_env = duplicate_env(env)
-            cleanup_env[:return_context] = cleanup_env[:return_context]&.merge(allow_return: false)
-            await_counter = analyze_async_statements!(statement.body, await_counter, cleanup_env, param_fields, local_fields, await_fields)
-          end
-          if statement.expression.is_a?(AST::AwaitExpr)
-            await_fields[statement.expression.object_id] = build_async_await_field_info(statement.expression, await_counter, env:, param_fields:, local_fields:)
-            await_counter += 1
-          end
+          cleanup_env = duplicate_env(env)
+          cleanup_env[:return_context] = cleanup_env[:return_context]&.merge(allow_return: false)
+          await_counter = analyze_async_statements!(statement.body, await_counter, cleanup_env, param_fields, local_fields, await_fields)
         else
           nil
         end

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

@@ -194,7 +194,7 @@ module MilkTea
         when AST::UnsafeStmt
           statements_contain_await?(s.body, async_info)
         when AST::DeferStmt
-          (s.body && statements_contain_await?(s.body, async_info)) || (s.expression && async_expression_contains_await?(s.expression))
+          statements_contain_await?(s.body, async_info)
         else
           false
         end
@@ -1237,15 +1237,7 @@ module MilkTea
     end
 
     def lower_async_defer_cleanup(statement, env:, async_info:)
-      body = if statement.body
-                statement.body
-              elsif statement.expression
-                [AST::ExpressionStmt.new(expression: statement.expression, line: statement.line)]
-              else
-                []
-              end
-
-      { body:, env: snapshot_env(env) }
+      { body: statement.body, env: snapshot_env(env) }
     end
 
     def lower_async_cleanup_entries(local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)

data/lib/milk_tea/core/lowering/async/normalization.rb

@@ -154,13 +154,8 @@ module MilkTea
       when AST::DeferStmt
         cleanup_env = duplicate_env(env)
         cleanup_env[:return_context] = cleanup_env[:return_context]&.merge(allow_return: false)
-        cleanup_body = if statement.body
-                         normalize_async_statements(statement.body, counter, cleanup_env, return_type:)
-                       else
-                         expression_setup, expression = normalize_async_expression(statement.expression, counter, env: cleanup_env)
-                         expression_setup + [AST::ExpressionStmt.new(expression:, line: statement.line)]
-                       end
-        [AST::DeferStmt.new(expression: nil, body: cleanup_body, line: statement.line, column: statement.column, length: statement.length)]
+        cleanup_body = normalize_async_statements(statement.body, counter, cleanup_env, return_type:)
+        [AST::DeferStmt.new(body: cleanup_body, line: statement.line, column: statement.column, length: statement.length)]
       when AST::BreakStmt, AST::ContinueStmt, AST::StaticAssert, AST::PassStmt
         [statement]
       else

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

@@ -16,11 +16,7 @@ module MilkTea
       statements.each do |statement|
         case statement
         when AST::DeferStmt
-          local_defers << if statement.body
-            lower_defer_cleanup_body(statement.body, env: local_env, return_type:)
-          else
-            lower_defer_cleanup_expression(statement.expression, env: local_env)
-          end
+          local_defers << lower_defer_cleanup_body(statement.body, env: local_env, return_type:)
         when AST::UnsafeStmt
           lower_block_unsafe_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
         when AST::LocalDecl