mt-lang 0.3.10 → 0.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0eb8fe30acd589069404d9a88cba70713a36937acf80299123b7a9b5a909b5da
-  data.tar.gz: 3f7a0240fcfc10f0617e94fdb6d28abe40c1ffbc6bfaa12e87235f4440ffaef6
+  metadata.gz: bc80c3a3240cbcf4770dd067aa33559e74e3f139322b8fdb757316f3c7faf8af
+  data.tar.gz: a623e5ecaa9617aa161a83e96c4cb0e7a75b08855edae27fb56c8ddc47c7cd75
 SHA512:
-  metadata.gz: f9623980449010f1a2895f715153948845edb191cb0164b9e48b615527d6d2aa0809abae016c07fa85197628e2baf190ca08adc2c14b31934b22465b9ca01f45
-  data.tar.gz: 543375cd1021947da13d214f8aacf379d565a6e840564dc9e9233bd7673200d967318c1ef7ca209000182c78fa98c141c2ceddcd9ca1c91d5b221d0caac9d03b
+  metadata.gz: c90aa51a21411fdcfe612f2ded69afdde6e055a012a4e886f5aa9ac69110d39a8bf93a36dde0543d1375a8bfa75ffd2f287eb082833a28b42efe19ab45c62ae6
+  data.tar.gz: a87ac20f1228f059e3508818be58e11e5491a90299e56d5ab569ab3ebf1ae3dc1f7ddff8761321754bd2bfc8c520dc9ac3876360714ced2baf6e06a82bbf635d

data/README.md

@@ -30,6 +30,7 @@ Package manifests, build workflow, and run workflow are documented separately in
 - External files are the dedicated raw ABI surface, usually for generated or low-level `std.c.*` bindings.
 - Module lookup resolves `a.b.c` to `a/b/c.mt`.
 - Inside a package, the file path relative to `package.source_root` defines the module name; platform-specific files such as `name.linux.mt` still map to module `name`.
+- Circular module imports are supported via forward-declaration bindings and two-pass checking. Cycle members see each other's type declarations in the first pass and full type information in the second pass.
 - In ordinary files, `import` statements appear only at the top.
 - In external files, leading `import` statements are allowed after `external`.
 - Only external files accept `include`, `link`, and `compiler_flag` directives.
@@ -42,7 +43,7 @@ Blocks are indentation-based:
 - Tabs are rejected.
 - Indentation must be a multiple of 4 spaces.
 - Indentation can increase by only one level at a time.
-- Newlines end statements except inside `()` and `[]`, or when the previous physical line ends with a binary operator such as `+`, `and`, or `==`.
+- Newlines end statements except inside `()` and `[]`, or when the previous physical line ends with a binary operator such as `+`, `and`, `==`, or `is`.
 - Comma-separated lists inside `()` and `[]` accept trailing commas. Prefer them for multiline parameters, arguments, and type lists.
 
 Long expressions should usually be wrapped with delimiters, following the same broad shape as Python's implicit line joining:
@@ -70,7 +71,15 @@ let values = 1 ..
     4
 ```
 
-Do not rely on starting the next physical line with the operator; wrap the expression in `()` instead if that layout reads better.
+Starting a physical line with an operator is a hard parse error (`operator '<op>' cannot start a statement`). Continue by ending the previous line with the operator, or wrap the expression in `()` if that layout reads better. The continuation operator set is closed: `+` `-` `*` `/` `%`, `|` `&` `^`, `<<` `>>`, `==` `!=` `<` `<=` `>` `>=`, `and` `or` `is`, and `..`. Member-access chains that exceed one line wrap in `()` with leading dots:
+
+```mt
+let total = (
+    values.iter()
+        .filter(pred)
+        .fold(0, add)
+)
+```
 
 Comments:
 
@@ -314,6 +323,7 @@ Rules:
 - Compile-time reflection over validated attributes uses `has_attribute`, `attribute_of`, `attribute_arg[T]`, `field_of`, and `callable_of`.
 - `field_of(...)`, `callable_of(...)`, and `attribute_of(...)` produce compile-time handle values with source-visible handle types `field_handle`, `callable_handle`, and `attribute_handle`.
 - The current C backend lowers `packed` / `align(...)` attributes with GNU-style `__attribute__((...))`, so these layout controls currently require a Clang/GCC-family compiler. On Windows that means Clang or GCC-family toolchains such as MinGW; `cl.exe` is not a supported backend for these attributes today. On wasm/browser targets the same feature works through Emscripten `emcc`, which is Clang-based.
+- Keywords and reserved words are accepted as variant arm names, struct/union field names, enum/flags member names, lifetime parameters (`@return`), type parameters (`Box[return]`), named constructor arguments (`Meta(return = 1)`), and named tuple fields (`(return = 1, let = 2)`). Primitive type names (`int`, `str`, `ref`, etc.) remain reserved and cannot be used in these positions.
 
 Enum and flags values support the full set of comparison operators (`==`, `!=`, `<`, `<=`, `>`, `>=`) against values of the same enum type and against their backing integer type. Comparisons use the underlying integer backing values. Flags also support bitwise operators (`|`, `&`, `^`, `~`).
 
@@ -867,9 +877,9 @@ Core modules in `std/`:
 
 - `std.linear_algebra` — extends native vector/matrix/quaternion types with `dot`, `cross`, `length`, `normalized`, `lerp`, `identity`, `transpose`, `conjugate` (pure Mt, no C dependency beyond `std.math` for `sqrt`)
 - `std.graph.Graph[T]` — adjacency-list graph with `add_node`, `add_edge`, `has_edge`, `remove_edge`, `neighbors`, `bfs`, `dfs`, `toposort`; directed or undirected; `compile()` converts to CSR-based `DenseGraph[T]` for O(degree) neighbor iteration
-- `std.str` — extends `str` with `byte_at`, `equal`, `starts_with`, `ends_with`, `find_substring`, `is_valid_utf8`, `slice`, `to_cstr`, `hash`, `order`
+- `std.str` — extends `str` with `byte_at`, `equal`, `starts_with`, `ends_with`, `find_substring`, `is_valid_utf8`, `slice`, `to_cstr`, `hash`, `order`; also provides C-string conversion helpers (`cstr_len`, `cstr_as_str`, `chars_as_str`, `nullable_cstr_as_str`)
 - `std.hash` — extends the primitive integer types (`byte`/`ubyte`/`short`/`ushort`/`int`/`uint`/`long`/`ulong`/`ptr_int`/`ptr_uint`), `bool`, `float`, `double`, and `char` with canonical `hash`/`equal`/`order` hooks; import once to use primitives as Map/Set/BinaryHeap/OrderedMap keys (`str` keys come from `std.str`). Also provides generic `hash_struct[T]`, `equal_struct[T]`, `order_struct[T]` that dispatch each field through its own canonical hook via `field.type` (content-correct, including `str` and nested-struct fields).
-- `std.cstring` — C string helpers (`cstr_len`, `cstr_as_str`)
+- `std.cstring` — low-level byte and C-string helpers (`copy_bytes`, `move_bytes`, `set_bytes`, `compare_bytes`, `find_byte`, `length`, `compare`, `compare_prefix`, `find_char`, `find_last_char`, `find_substring`)
 - `std.math` — `sqrt`, `sin`, `cos`, `abs`, `pow`, etc. via C math
 - `std.encoding` — UTF-8 validation (`is_valid_utf8`, `utf8_codepoint_count`, `decode_utf8_codepoint`, `utf8_overlong_check`)
 - `std.string.String` — growable owned UTF-8 text
@@ -1111,6 +1121,7 @@ Current compiler rejects:
 - range expressions are restricted to `for`-loop iterables and range-index assignment targets
 - functions, methods, generic functions, and variant arms must be called — they are not usable as bare values
 - `read(...)` of a raw pointer requires `unsafe`
+- a statement cannot begin with a binary operator (including `+`, `-`, `and`, `or`, `is`, `..`); continuation requires ending the previous line with the operator or wrapping in `()`
 
 ### Control flow restrictions
 
@@ -1161,11 +1172,12 @@ mtc build  <path>             # Build only (emit C, compile, link, --no-cache to
 mtc run    <path>             # Build and execute (--no-cache to build and run without cache)
 mtc debug  <file.mt>          # Print debug info (tokens, AST, facts, bindings, diagnostics)
 mtc emit-c <path>             # Emit generated C to stdout
-mtc format <path>             # Format sources in place (--check for dry-run)
+mtc format <path>             # Format source to stdout (--write rewrites in place, --check verifies)
 mtc lint   <path>             # Run linter (--fix to apply fixes, --select/--ignore to filter)
 mtc test   <path>             # Discover and run @[test] functions (--timeout, --mem, --jobs)
 mtc new    <name>             # Scaffold a new package (package.toml + src/main.mt)
 mtc cache status              # Show build cache stats
+mtc cache purge               # Remove the entire build cache
 mtc lex    <file.mt>          # Print lexer token stream
 mtc parse  <path>             # Print parsed AST
 mtc lower  <path>             # Print lowered IR
@@ -1183,10 +1195,10 @@ mtc deps publish <path>       # Publish a package to the local registry
 mtc deps fetch <path>         # Materialize cache-backed sources
 ```
 
-Run a pre-built module (no compilation):
+Resolve a module by name, build it, and run it:
 
 ```
-mtc run-module <module>       # Run compiled module by name (e.g. std.fmt.bench)
+mtc run-module <module>       # Resolve, build, and run a module by name (e.g. std.http.server)
 ```
 
 Toolchain maintenance:
@@ -1197,9 +1209,19 @@ mtc toolchain doctor          # Diagnose toolchain setup
 mtc toolchain tools           # List available native tools
 ```
 
+Tooling and editors:
+
+```
+mtc bindgen <header.h>        # Generate an external binding module from a C header
+mtc snapshot <path>           # Render a highlighted HTML snapshot of a source file
+mtc lsp                       # Start the Language Server Protocol server
+mtc dap                       # Start the Debug Adapter Protocol server
+mtc docs [--open] [--port P]  # Serve the local documentation site
+```
+
 Build and run commands support `--profile`, `--platform`, `--cc`, `--keep-c`, `--locked`, `--frozen`, and `-I` include paths. Dependency-locked flows support `--locked` (use package.lock) and `--frozen` (require current package.lock).
 
-Global options work with any command (before or after the subcommand, up to a `--` separator): `-h`/`--help` (also `mtc help <command>` for command-specific help), `-V`/`--version`, `-q`/`--quiet` (suppress informational output), `-v`/`--verbose` (per-file progress), and `--color auto|always|never`. Generate shell completions with `mtc completions bash|zsh|fish`. Timing breakdowns use `--timings` (on `format`, `lint`, `build`, `run`, `test`); `lint` reports warnings with per-file progress.
+Global options work with any command (before or after the subcommand, up to a `--` separator): `-h`/`--help` (also `mtc help <command>` for command-specific help), `-V`/`--version`, `-q`/`--quiet` (suppress informational output), `-v`/`--verbose` (per-file progress), and `--color auto|always|never`. Generate shell completions with `mtc completions bash|zsh|fish`. Timing breakdowns use `--timings` (on `format` and `lint`); `lint` reports warnings with per-file progress.
 
 Diagnostic output uses standard compiler format (file:line:column with source context, error codes, and caret highlighting):
 

data/docs/index.html

@@ -343,7 +343,7 @@ function main() -> int:
       <tr><td><code>mtc check &lt;path&gt;</code></td><td>Type-check + lint; reports all diagnostics sorted by line</td></tr>
       <tr><td><code>mtc run &lt;path&gt;</code></td><td>Build and execute</td></tr>
       <tr><td><code>mtc build &lt;path&gt;</code></td><td>Build only (emit C, compile, link)</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> to apply fixes)</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</td></tr>
@@ -403,6 +403,7 @@ void main_Vec2_scale(main_Vec2* this, float factor) {
 <pre><code>## ── Imports ──────────────────────────────────────────────────────────
 import std.stdio as io
 import std.hash
+import std.str
 import std.vec
 import std.map
 import std.math
@@ -888,6 +889,7 @@ import mylib.utils</code></pre>
     <li>Indentation must be a multiple of <strong>4 spaces</strong></li>
     <li>Indentation increases by <strong>one level at a time</strong></li>
     <li>Newlines end statements except inside <code>()</code> and <code>[]</code>, or when the previous line ends with a binary operator</li>
+    <li>Starting a line with an operator is a hard parse error (<code>operator '&lt;op&gt;' cannot start a statement</code>); continuation is signaled by ending the previous line with the operator, never by starting the next one with it</li>
   </ul>
 
 <div class="code-wrap">
@@ -902,7 +904,16 @@ let total = (
 ## Also accepted: operator-led continuation.
 let total = subtotal +
     tax -
-    discount</code></pre>
+    discount
+
+## The continuation operator set is closed:
+## + - * / % | &amp; ^ &lt;&lt; &gt;&gt; == != &lt; &lt;= &gt; &gt;= and or is ..
+## Member-access chains exceeding one line wrap in () with leading dots:
+let total = (
+    values.iter()
+        .filter(pred)
+        .fold(0, add)
+)</code></pre>
 </div>
 
   <h3>Naming Conventions</h3>
@@ -1733,14 +1744,16 @@ let sized = name[32]</code></pre>
       <tr><th>Precedence</th><th>Operators</th></tr>
       <tr><td>1 (lowest)</td><td><code>or</code></td></tr>
       <tr><td>2</td><td><code>and</code></td></tr>
-      <tr><td>3</td><td><code>|</code></td></tr>
-      <tr><td>4</td><td><code>^</code></td></tr>
-      <tr><td>5</td><td><code>&amp;</code></td></tr>
-      <tr><td>6</td><td><code>==</code> <code>!=</code></td></tr>
-      <tr><td>7</td><td><code>&lt;</code> <code>&lt;=</code> <code>&gt;</code> <code>&gt;=</code></td></tr>
-      <tr><td>8</td><td><code>&lt;&lt;</code> <code>&gt;&gt;</code></td></tr>
-      <tr><td>9</td><td><code>+</code> <code>-</code></td></tr>
-      <tr><td>10 (highest)</td><td><code>*</code> <code>/</code> <code>%</code></td></tr>
+      <tr><td>3</td><td><code>not</code> (unary prefix)</td></tr>
+      <tr><td>4</td><td><code>is</code></td></tr>
+      <tr><td>5</td><td><code>|</code></td></tr>
+      <tr><td>6</td><td><code>^</code></td></tr>
+      <tr><td>7</td><td><code>&amp;</code></td></tr>
+      <tr><td>8</td><td><code>==</code> <code>!=</code></td></tr>
+      <tr><td>9</td><td><code>&lt;</code> <code>&lt;=</code> <code>&gt;</code> <code>&gt;=</code></td></tr>
+      <tr><td>10</td><td><code>&lt;&lt;</code> <code>&gt;&gt;</code></td></tr>
+      <tr><td>11</td><td><code>+</code> <code>-</code></td></tr>
+      <tr><td>12 (highest)</td><td><code>*</code> <code>/</code> <code>%</code></td></tr>
     </table>
   </div>
 
@@ -2169,7 +2182,7 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
       <tr><td><code>std.spatial</code></td><td><code>SpatialGrid[T]</code></td><td>&mdash;</td><td>Uniform spatial hash grid (returns Vec)</td></tr>
       <tr><td><code>std.ring_buffer</code></td><td><code>RingBuffer[T]</code></td><td>Mutable <code>ptr[T]?</code></td><td>Fixed-capacity circular buffer</td></tr>
       <tr><td><code>std.sparse_set</code></td><td><code>SparseSet[T]</code></td><td>Mutable <code>ptr[T]?</code></td><td>O(1) insert/remove; dense iteration</td></tr>
-      <tr><td><code>std.lru_cache</code></td><td><code>LruCache[K,V]</code></td><td><code>entries()</code></td><td>Capacity-bounded LRU eviction map</td></tr>
+      <tr><td><code>std.lru_cache</code></td><td><code>LruCache[K,V]</code></td><td><code>iter()</code> → <code>linked_map.Entries[K, V]</code></td><td>Capacity-bounded LRU eviction map</td></tr>
     </table>
   </div>
 
@@ -2236,7 +2249,7 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
       <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>
-      <tr><td><code>mtc run-module &lt;module&gt;</code></td><td>Run a pre-built module by name</td></tr>
+      <tr><td><code>mtc run-module &lt;module&gt;</code></td><td>Resolve a module by name, build it, and run it</td></tr>
       <tr><td><code>mtc completions &lt;shell&gt;</code></td><td>Print a bash/zsh/fish completion script</td></tr>
     </table>
   </div>
@@ -2263,10 +2276,22 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
       <tr><td><code>mtc toolchain doctor</code></td><td>Diagnose toolchain setup</td></tr>
       <tr><td><code>mtc toolchain tools</code></td><td>List available native tools</td></tr>
       <tr><td><code>mtc cache status</code></td><td>Show build cache stats</td></tr>
+      <tr><td><code>mtc cache purge</code></td><td>Remove the entire build cache</td></tr>
       <tr><td><code>mtc docs [--open] [--port PORT]</code></td><td>Start a local HTTP server serving the language reference</td></tr>
     </table>
   </div>
 
+  <h3>Tooling</h3>
+  <div class="table-wrap">
+    <table class="attr-table">
+      <tr><th>Command</th><th>Description</th></tr>
+      <tr><td><code>mtc bindgen &lt;header.h&gt;</code></td><td>Generate an external binding module from a C header</td></tr>
+      <tr><td><code>mtc snapshot &lt;path&gt;</code></td><td>Render a highlighted HTML snapshot of a source file</td></tr>
+      <tr><td><code>mtc lsp</code></td><td>Start the Language Server Protocol server (editor IntelliSense)</td></tr>
+      <tr><td><code>mtc dap</code></td><td>Start the Debug Adapter Protocol server (debugging)</td></tr>
+    </table>
+  </div>
+
   <h3>Build Flags</h3>
   <p>Build and run commands support: <code>--profile</code>, <code>--platform</code>, <code>--cc</code>, <code>--keep-c</code>, <code>--locked</code>, <code>--frozen</code>, and <code>-I</code> include paths.</p>
 
@@ -2385,6 +2410,7 @@ import std.math  # intentionally available for downstream</code></pre>
     <li>Enum and flags values do not implicitly coerce to backing integers</li>
     <li><code>+</code> does not support <code>str</code>/<code>cstr</code> concatenation</li>
     <li><code>==</code> and <code>!=</code> not supported on struct types; use <code>equal[T]</code></li>
+    <li>A statement cannot begin with a binary operator (including <code>+</code>, <code>-</code>, <code>and</code>, <code>or</code>, <code>is</code>, <code>..</code>); continuation requires ending the previous line with the operator or wrapping in <code>()</code></li>
     <li>Bare function and method names are not usable as values (cannot be assigned or passed without calling). Use <code>fn(...)</code> function pointer types or <code>proc(...)</code> closures for callable values.</li>
   </ul>
 

data/docs/language-design.md

@@ -88,6 +88,7 @@ The compile-time evaluation surface is described in [Compile-Time Evaluation](co
 - Newlines terminate statements.
 - Newlines inside `()` and `[]` do not terminate statements.
 - A physical line that ends with a binary operator also continues onto the next line.
+- A physical line that begins with an operator is a hard parse error; continuation is signaled by ending the previous line with the operator, never by starting the next one with it.
 - Tabs are illegal in source files; indentation is 4 spaces.
 - Trailing commas are allowed in multiline call arguments and aggregate literals. The linter additionally flags a redundant trailing comma in a call-argument list (`trailing-list-comma` hint); aggregate and array literals keep them for diff-friendliness.
 - Comments use `#`.
@@ -490,7 +491,7 @@ Milk Tea has first-class compiler support for multithreading. The threading mode
 parallel for i in 0..entity_count:
     positions[i] += velocities[i] * dt
 
-# Structured fork-join: each do block runs on a separate thread
+# Structured fork-join: each statement runs on a separate thread
 parallel:
     textures = load_textures(path)
     sounds = load_sounds(path)
@@ -501,7 +502,6 @@ Design choices:
 - **Structured, not fire-and-forget.** All `parallel for` and `parallel:` blocks are synchronous barriers — the calling thread blocks until all work completes. This guarantees that captured local variables remain alive for the duration and eliminates lifetime concerns without ownership annotations.
 - **Compile-time safety.** `ref[T]` captures are rejected because mutable aliases across thread boundaries create data races. The `parallel:` block enforces single-writer-or-multiple-readers: if one statement writes a variable, no other block may read or write it.
 - **Value capture, pointer-based arrays.** Scalars and spans are captured by value (the span's data pointer still references the original storage). Arrays are captured as pointers to their first element, so writes in the worker affect the original array.
-- **`do` is a keyword.** It is recognized inside `parallel:` blocks to introduce each concurrent unit of work.
 - **Real OS threads via libuv.** Thread dispatch uses `uv_thread_create` / `uv_thread_join`, consistent with `std.thread` and `std.sync`. CPU count is detected at runtime via `uv_cpu_info`. The first chunk runs on the calling thread to avoid unnecessary dispatch when the workload is small.
 - **No forced dependency.** The build system automatically detects `parallel for` and `parallel:` usage via a sema-level flag and links libuv only when needed.
 

data/docs/language-manual.md

@@ -51,6 +51,7 @@ Rules:
 - Valid platform filename suffixes are `linux`, `windows`, and `wasm`.
 - The platform suffix is not part of the module name. `import a.b.c` stays the same on every target.
 - Milk Tea does not have a source-level conditional compilation syntax such as `#if`, `#ifdef`, or per-declaration platform attributes.
+- Circular module imports are supported. When two modules import each other, the compiler uses forward-declaration bindings for the first pass and full type-checked bindings for the second pass, enabling cross-module type references and constructors in cycle groups.
 
 ## 2. Lexical Rules
 
@@ -82,7 +83,17 @@ let total = subtotal +
     discount
 ```
 
-Starting a new physical line with the operator is not part of the supported source contract; wrap in `()` instead if that layout is clearer.
+The continuation operator set is closed: `+` `-` `*` `/` `%`, `|` `&` `^`, `<<` `>>`, `==` `!=` `<` `<=` `>` `>=`, `and` `or` `is`, and `..`. Assignment operators and unary `not` are excluded — wrap in `()` when a break is needed there.
+
+Starting a new physical line with an operator is a hard error (`operator '<op>' cannot start a statement`); end the previous line with the operator, or wrap the expression in `()` if that layout is clearer. Member-access chains that exceed one line wrap in `()` with leading dots:
+
+```mt
+let total = (
+    values.iter()
+        .filter(pred)
+        .fold(0, add)
+)
+```
 
 ### 2.2 Comments
 
@@ -360,6 +371,18 @@ Compile-time reflection over validated attributes uses `has_attribute`, `attribu
 
 The current C backend lowers `packed` / `align(...)` attributes with GNU-style `__attribute__((...))`, so these layout controls currently require a Clang/GCC-family compiler. On Windows that means Clang or GCC-family toolchains such as MinGW; `cl.exe` is not a supported backend for these attributes today. On wasm/browser targets the same feature works through Emscripten `emcc`, which is Clang-based.
 
+Language-level keywords and reserved words are accepted as:
+- variant arm names (`return(val: int)`, `if(arg: bool)`)
+- struct and union field names (`return: int`, `let: str`)
+- enum and flags member names (`return = 1`, `if = 6`)
+- variant arm payload field names (`execute(return: int)`)
+- lifetime parameter names (`struct Buf[@return]`)
+- type parameter names (`struct Box[return]`, `identity[type]`)
+- named arguments in struct/variant literals (`Meta(return = 1)`)
+- named tuple fields (`(return = 1, let = 2)`)
+
+Primitive type names (`int`, `str`, `bool`, `ref`, `ptr`, `span`, `type`, etc.) remain reserved and cannot be used as names.
+
 ### 3.4a Enum and flags operators
 
 Enum and flags values support the full set of comparison operators (`==`, `!=`, `<`, `<=`, `>`, `>=`) against values of the same enum type and against their backing integer type. Comparisons use the underlying integer backing values.
@@ -746,7 +769,6 @@ parallel:
 Rules:
 
 - A `parallel:` block must contain at least two statements.
-- `do` is a contextual keyword — only recognized inside `parallel:` blocks, not reserved globally.
 - Each statement must not contain `break`, `continue`, `return`, or `defer`.
 - The compiler enforces single-writer-or-multiple-readers: if a variable is written in one statement, no other block may access it.
 - Captured `ref[T]` values are rejected at compile time.

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/ast.rb

@@ -153,17 +153,17 @@ module MilkTea
     VariantArm = Data.define(:name, :fields, :line, :column) do
       def initialize(name:, fields:, line: nil, column: nil) = super
     end
-    MatchArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body) do
-      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil) = super
+    MatchArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body, :line, :column) do
+      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
     MatchStmt = Data.define(:expression, :arms, :inline, :line, :column, :length) do
       def initialize(expression:, arms:, inline: false, line: nil, column: nil, length: nil) = super
     end
-    MatchExprArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :value) do
-      def initialize(pattern:, binding_name:, value:, binding_line: nil, binding_column: nil) = super
+    MatchExprArm = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :value, :line, :column) do
+      def initialize(pattern:, binding_name:, value:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
-    WhenBranch = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body) do
-      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil) = super
+    WhenBranch = Data.define(:pattern, :binding_name, :binding_line, :binding_column, :body, :line, :column) do
+      def initialize(pattern:, binding_name:, body:, binding_line: nil, binding_column: nil, line: nil, column: nil) = super
     end
     WhenStmt = Data.define(:discriminant, :branches, :else_body, :line, :column, :length) do
       def initialize(discriminant:, branches:, else_body:, line: nil, column: nil, length: nil) = super

data/lib/milk_tea/core/lexer.rb

@@ -42,15 +42,7 @@ module MilkTea
       link opaque public static_assert struct type union var variant extending event
     ].freeze
 
-    LINE_CONTINUATION_OPERATORS = %i[
-      dot_dot
-      plus minus star slash percent
-      pipe amp caret
-      or and
-      equal_equal bang_equal
-      less less_equal greater greater_equal
-      shift_left shift_right
-    ].freeze
+    LINE_CONTINUATION_OPERATORS = Token::LINE_CONTINUATION_OPERATORS
 
     THREE_CHAR_TOKENS = {
       "..." => :ellipsis,
@@ -358,7 +350,7 @@ module MilkTea
       newline_start = line_offset + line.length
       newline_end = has_newline ? (newline_start + 1) : newline_start
       if @grouping_depth.zero?
-        if LINE_CONTINUATION_OPERATORS.include?(@tokens.last&.type)
+        if Token::LINE_CONTINUATION_OPERATORS.include?(@tokens.last&.type)
           @continuation_pending = true
         else
           @tokens << token(:newline, "\n", nil, line_number, line.length + 1, start_offset: newline_start, end_offset: newline_end)

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

@@ -93,7 +93,7 @@ module MilkTea
         arms = statement.arms.map do |arm|
           arm_env = duplicate_env(env)
           bind_async_variant_match_arm_env!(arm_env, scrutinee_type, arm)
-          AST::MatchArm.new(pattern: arm.pattern, binding_name: arm.binding_name, body: normalize_async_statements(arm.body, counter, arm_env, return_type:))
+          AST::MatchArm.new(pattern: arm.pattern, binding_name: arm.binding_name, body: normalize_async_statements(arm.body, counter, arm_env, return_type:), line: arm.line, column: arm.column)
         end
         expr_setup + [AST::MatchStmt.new(expression:, arms:)]
       when AST::WhileStmt
@@ -307,6 +307,8 @@ module MilkTea
             binding_line: arm.binding_line,
             binding_column: arm.binding_column,
             value: normalized_value,
+            line: arm.line,
+            column: arm.column,
           )]
         end
 
@@ -326,6 +328,8 @@ module MilkTea
                 binding_line: arm.binding_line,
                 binding_column: arm.binding_column,
                 body: pattern_setup + value_setup + [AST::Assignment.new(target: AST::Identifier.new(name: temp_name), operator: "=", value: arm.value)],
+                line: arm.line,
+                column: arm.column,
               )
             end,
             line: expression.line,

data/lib/milk_tea/core/parser/declarations.rb

@@ -372,10 +372,10 @@ module MilkTea
           break if check(:rbracket)
 
           if match(:at)
-            name_token = consume_name("expected lifetime name after @")
+            name_token = consume_name_allowing_keywords("expected lifetime name after @")
             lifetime_params << "@#{name_token.lexeme}"
           else
-            name_token = consume_name("expected type parameter name")
+            name_token = consume_name_allowing_keywords("expected type parameter name")
             if match(:colon)
               value_type = parse_type_ref
               type_params << AST::ValueTypeParam.new(
@@ -419,7 +419,7 @@ module MilkTea
 
         raise error(visibility_token, "public is only allowed on struct events") if visibility == :public
 
-        field_token = consume_name("expected field name")
+        field_token = consume_name_allowing_keywords("expected field name")
         field_name = field_token.lexeme
         consume(:colon, "expected ':' after field name")
         field_type = parse_type_ref
@@ -440,7 +440,7 @@ module MilkTea
         name = name_token.lexeme
         c_name = parse_optional_explicit_c_name
         fields = parse_named_block do
-          field_name = consume_name("expected field name").lexeme
+                       field_name = consume_name_allowing_keywords("expected field name").lexeme
           consume(:colon, "expected ':' after field name")
           field_type = parse_type_ref
           consume_end_of_statement
@@ -471,7 +471,7 @@ module MilkTea
         members = []
         skip_newlines
         until check(:dedent) || eof?
-          member_token = consume_name("expected member name")
+          member_token = consume_name_allowing_keywords("expected member name")
           member_name = member_token.lexeme
           if match(:equal)
             value = parse_expression
@@ -493,10 +493,10 @@ module MilkTea
         name = name_token.lexeme
         type_params = parse_declaration_type_params
         arms = parse_named_block do
-          arm_name = consume_name("expected variant arm name").lexeme
+          arm_name = consume_name_allowing_keywords("expected variant arm name").lexeme
           fields = if match(:lparen)
                      parsed = parse_comma_separated_until(:rparen) do
-                       field_name = consume_name("expected field name").lexeme
+          field_name = consume_name_allowing_keywords("expected field name").lexeme
                        consume(:colon, "expected ':' after field name")
                        field_type = parse_type_ref
                        AST::Field.new(name: field_name, type: field_type)

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

@@ -105,6 +105,8 @@ module MilkTea
             binding_line: binding_token&.line,
             binding_column: binding_token&.column,
             value:,
+            line: pattern.line,
+            column: pattern.column,
           )
         end
       end
@@ -153,6 +155,8 @@ module MilkTea
                 binding_line: nil,
                 binding_column: nil,
                 value: AST::BooleanLiteral.new(value: true),
+                line: arm_pattern.line,
+                column: arm_pattern.column,
               ),
               AST::MatchExprArm.new(
                 pattern: AST::Identifier.new(name: "_", line:, column:),
@@ -160,6 +164,8 @@ module MilkTea
                 binding_line: nil,
                 binding_column: nil,
                 value: AST::BooleanLiteral.new(value: false),
+                line:,
+                column:,
               ),
             ],
             line:,
@@ -338,7 +344,7 @@ module MilkTea
       end
 
       def parse_call_argument
-        if check_name && check_next(:equal)
+        if (check_name || keyword_token?(peek)) && check_next(:equal)
           name = advance.lexeme
           consume(:equal, "expected '=' after named argument name")
           AST::Argument.new(name:, value: parse_expression)
@@ -388,7 +394,7 @@ module MilkTea
         elsif match(:lparen)
           line = previous.line
           column = previous.column
-          first = if check_name && check_next(:equal)
+          first = if (check_name || keyword_token?(peek)) && check_next(:equal)
                     name_token = advance
                     consume(:equal, "expected '=' after named tuple field")
                     AST::Argument.new(name: name_token.lexeme, value: parse_expression)
@@ -398,7 +404,7 @@ module MilkTea
           if match(:comma)
             elements = [first]
             loop do
-              if check_name && check_next(:equal)
+              if (check_name || keyword_token?(peek)) && check_next(:equal)
                 name_token = advance
                 consume(:equal, "expected '=' after named tuple field")
                 value = parse_expression

data/lib/milk_tea/core/parser/statements.rb

@@ -35,7 +35,18 @@ module MilkTea
         check(:when)
       end
 
+      def reject_operator_statement_start!
+        return unless Token::LINE_START_OPERATOR_TYPES.include?(peek.type)
+
+        operator = peek.lexeme
+        raise error(
+          peek,
+          "operator '#{operator}' cannot start a statement; end the previous line with it or wrap the expression in ( )"
+        )
+      end
+
       def parse_statement
+        reject_operator_statement_start!
         if match(:let)
           parse_local_decl(:let)
         elsif match(:var)
@@ -351,6 +362,8 @@ module MilkTea
               binding_line: binding_token&.line,
               binding_column: binding_token&.column,
               value:,
+              line: pattern.line,
+              column: pattern.column,
             )
           end
         else
@@ -362,6 +375,8 @@ module MilkTea
               binding_line: binding_token&.line,
               binding_column: binding_token&.column,
               body:,
+              line: pattern.line,
+              column: pattern.column,
             )
           end
         end
@@ -376,6 +391,8 @@ module MilkTea
           binding_line: binding_token&.line,
           binding_column: binding_token&.column,
           body: recovered_body,
+          line: patterns.first&.line,
+          column: patterns.first&.column,
         )] if recovered_body
 
         raise
@@ -615,6 +632,8 @@ module MilkTea
             binding_line: binding_token.line,
             binding_column: binding_token.column,
             body:,
+            line: pattern.line,
+            column: pattern.column,
           )
           skip_newlines
         end

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

@@ -92,7 +92,7 @@ module MilkTea
 
         first_token = peek
         if match(:at)
-          lt_token = consume_name("expected lifetime name after @")
+          lt_token = consume_name_allowing_keywords("expected lifetime name after @")
           return AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["@#{lt_token.lexeme}"]), arguments: [], nullable: false, lifetime: nil, line: first_token.line, column: first_token.column, length: lt_token.lexeme.length + 1)
         end
         name = parse_qualified_name
@@ -101,7 +101,7 @@ module MilkTea
         if match(:lbracket)
           if check(:at) && name.to_s == "ref"
             match(:at)
-            lt_token = consume_name("expected lifetime name after @")
+            lt_token = consume_name_allowing_keywords("expected lifetime name after @")
             lifetime = "@#{lt_token.lexeme}"
             consume(:comma, "expected ',' after lifetime in type arguments")
           end
@@ -167,7 +167,7 @@ module MilkTea
       end
 
       def parse_function_type_param
-        name_token = consume_name("expected function type parameter name")
+        name_token = consume_name_allowing_keywords("expected function type parameter name")
         name = name_token.lexeme
         consume(:colon, "expected ':' after function type parameter name")
         type = parse_type_ref
@@ -190,7 +190,7 @@ module MilkTea
         return [] unless match(:lbracket)
 
         params = parse_comma_separated_until(:rbracket) do
-          name_token = consume_name("expected type parameter name")
+          name_token = consume_name_allowing_keywords("expected type parameter name")
           name = name_token.lexeme
           if match(:colon)
             value_type = parse_type_ref

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

@@ -208,7 +208,7 @@ module MilkTea
       def resolve_type_param_constraints(type_params)
         type_params.each_with_object({}) do |type_param, constraints|
           if type_param.is_a?(AST::ValueTypeParam)
-            ensure_non_reserved_type_binding_name!(
+            ensure_non_reserved_value_type_name!(
               type_param.name,
               kind_label: "type parameter",
               line: type_param.line,
@@ -218,7 +218,7 @@ module MilkTea
             next
           end
 
-          ensure_non_reserved_type_binding_name!(
+          ensure_non_reserved_value_type_name!(
             type_param.name,
             kind_label: "type parameter",
             line: type_param.line,

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

@@ -314,6 +314,12 @@ module MilkTea
         expanded_declarations.grep(AST::AttributeDecl).each do |decl|
           with_error_node(decl) do
             raise_sema_error("duplicate attribute #{decl.name}") if @ctx.attributes.key?(decl.name)
+            ensure_non_reserved_value_type_name!(
+              decl.name,
+              kind_label: "attribute",
+              line: decl.line,
+              column: decl.column,
+            )
 
             params = []
             seen = {}
@@ -463,6 +469,15 @@ module MilkTea
               {}
             end
             decl.lifetime_params.each do |lt|
+              raw_name = lt.delete_prefix("@")
+              unless raw_module?
+                ensure_non_reserved_value_type_name!(
+                  raw_name,
+                  kind_label: "lifetime parameter #{decl.name}",
+                  line: decl.line,
+                  column: decl.column,
+                )
+              end
               type_params[lt] = Types::LifetimeRef.new(lt)
             end if decl.respond_to?(:lifetime_params)
             type_param_constraints = struct_type.is_a?(Types::GenericStructDefinition) ? struct_type.type_param_constraints : {}
@@ -482,7 +497,7 @@ module MilkTea
               raise_sema_error("duplicate field #{decl.name}.#{field.name}") if fields.key?(field.name)
               raise_sema_error("duplicate member #{decl.name}.#{field.name}") if events.key?(field.name)
               unless raw_module?
-                ensure_non_reserved_type_binding_name!(
+                ensure_non_reserved_value_type_name!(
                   field.name,
                   kind_label: "field #{decl.name}",
                   line: field.line || decl.line,
@@ -528,7 +543,7 @@ module MilkTea
                 raise_sema_error("duplicate event #{decl.name}.#{event_decl.name}") if events.key?(event_decl.name)
                 raise_sema_error("duplicate member #{decl.name}.#{event_decl.name}") if fields.key?(event_decl.name)
                 unless raw_module?
-                  ensure_non_reserved_type_binding_name!(
+                  ensure_non_reserved_value_type_name!(
                     event_decl.name,
                     kind_label: "event #{decl.name}",
                     line: event_decl.line,
@@ -576,7 +591,7 @@ module MilkTea
             decl.members.each do |member|
               raise_sema_error("duplicate member #{decl.name}.#{member.name}") if member_names.include?(member.name)
               unless raw_module?
-                ensure_non_reserved_type_binding_name!(
+                ensure_non_reserved_value_type_name!(
                   member.name,
                   kind_label: "member #{decl.name}",
                   line: member.line || decl.line,
@@ -645,7 +660,7 @@ module MilkTea
               begin
                 raise_sema_error("duplicate arm #{decl.name}.#{arm.name}") if seen_arms.include?(arm.name)
                 unless raw_module?
-                  ensure_non_reserved_type_binding_name!(
+                  ensure_non_reserved_value_type_name!(
                     arm.name,
                     kind_label: "arm #{decl.name}",
                     line: arm.line || decl.line,
@@ -661,7 +676,7 @@ module MilkTea
                   begin
                     raise_sema_error("duplicate field #{arm.name}.#{field.name}") if seen_fields.include?(field.name)
                     unless raw_module?
-                      ensure_non_reserved_type_binding_name!(
+                      ensure_non_reserved_value_type_name!(
                         field.name,
                         kind_label: "field #{decl.name}.#{arm.name}",
                         line: field.line || decl.line,
@@ -811,6 +826,14 @@ module MilkTea
           fields = {}
           nested.fields.each do |field|
             raise_sema_error("duplicate field #{qualified_name}.#{field.name}") if fields.key?(field.name)
+            unless raw_module?
+              ensure_non_reserved_value_type_name!(
+                field.name,
+                kind_label: "field #{qualified_name}",
+                line: field.line || nested.line,
+                column: field.column,
+              )
+            end
             begin
               field_type = resolve_type_ref(field.type, type_params:, type_param_constraints:, nested_types: nested_scope)
               validate_stored_ref_type!(field_type, "field #{qualified_name}.#{field.name}")
@@ -824,6 +847,14 @@ module MilkTea
           nested_events = {}
           nested.events.each do |event_decl|
             raise_sema_error("duplicate event #{qualified_name}.#{event_decl.name}") if nested_events.key?(event_decl.name)
+            unless raw_module?
+              ensure_non_reserved_value_type_name!(
+                event_decl.name,
+                kind_label: "event #{qualified_name}",
+                line: event_decl.line,
+                column: event_decl.column,
+              )
+            end
             begin
               nested_events[event_decl.name] = resolve_event_decl_type(event_decl, type_params:, type_param_constraints:, owner_type_name: qualified_name, nested_types: nested_scope)
             rescue SemanticError => e

data/lib/milk_tea/core/token.rb

@@ -11,6 +11,23 @@ module MilkTea
       amp_equal pipe_equal caret_equal shift_left_equal shift_right_equal
     ].freeze
 
+    # Operator token types that may never begin a statement. A statement
+    # that spans multiple lines must end the previous line with one of
+    # LINE_CONTINUATION_OPERATORS or wrap the expression in ( ) — it must
+    # never start the next line with an operator.
+    LINE_START_OPERATOR_TYPES = %i[
+      dot_dot plus minus star slash percent
+      pipe amp caret tilde
+      or and is
+      equal_equal bang_equal
+      less less_equal greater greater_equal
+      shift_left shift_right
+    ].freeze
+
+    # Binary operators that continue a statement when they end a physical
+    # line. Unary-only `~` is excluded because it has no left operand.
+    LINE_CONTINUATION_OPERATORS = (LINE_START_OPERATOR_TYPES - [:tilde]).freeze
+
     def assignment?
       ASSIGNMENT_TYPES.include?(type)
     end

data/lib/milk_tea/lsp/server/semantic_tokens.rb

@@ -275,6 +275,12 @@ module MilkTea
           end
 
           if KEYWORD_TOKEN_TYPES.include?(tok.type)
+            return [:typeParameter, []] if keyword_lifetime_or_type_param?(tokens, index)
+            return [:type, []] if keyword_type_annotation?(tokens, index)
+            return [:enumMember, [:declaration]] if variant_enum_member_declaration?(tokens, index)
+            return [:property, [:declaration]] if keyword_field_declaration_token?(tokens, index)
+            return [:property, []] if keyword_member_access?(tokens, index)
+            return [:parameter, []] if keyword_named_argument_token?(tokens, index)
             return [:keyword, []]
           end
 
@@ -550,6 +556,64 @@ module MilkTea
           next_tok&.type == :colon
         end
 
+        def keyword_field_declaration_token?(tokens, index)
+          return false if match_arm_binding_token?(tokens, index)
+          return false if destructure_let_binding?(tokens, index)
+
+          next_tok = next_non_trivia_token(tokens, index + 1)
+          next_tok&.type == :colon
+        end
+
+        def keyword_member_access?(tokens, index)
+          prev_index = previous_non_trivia_token_index(tokens, index)
+          return false unless prev_index
+
+          tokens[prev_index].type == :dot
+        end
+
+        def keyword_lifetime_or_type_param?(tokens, index)
+          prev_index = previous_non_trivia_token_index(tokens, index)
+          return false unless prev_index
+
+          prev_type = tokens[prev_index].type
+          return true if prev_type == :at
+          return true if prev_type == :lbracket
+          return true if prev_type == :comma && inside_type_params?(tokens, prev_index)
+          false
+        end
+
+        def inside_type_params?(tokens, comma_index)
+          i = comma_index - 1
+          while i >= 0
+            t = tokens[i]
+            break if t.type == :lbracket
+            return false if t.type == :newline || t.type == :rbracket || t.type == :lparen
+            i -= 1
+          end
+          return false if i < 0
+
+          prev = previous_non_trivia_token_index(tokens, i)
+          return true if prev && %i[struct variant enum flags function fn proc].include?(tokens[prev].type)
+          return true if prev && tokens[prev].type == :rbracket
+          return true if prev && tokens[prev].type == :identifier
+
+          false
+        end
+
+        def keyword_named_argument_token?(tokens, index)
+          next_tok = next_non_trivia_token(tokens, index + 1)
+          next_tok&.type == :equal
+        end
+
+        def keyword_type_annotation?(tokens, index)
+          tok = tokens[index]
+          prev_index = previous_non_trivia_token_index(tokens, index)
+          return false unless prev_index
+          return false unless %i[colon arrow].include?(tokens[prev_index].type)
+
+          tokens[prev_index].line == tok.line
+        end
+
         def destructure_let_binding?(tokens, index)
           tok = tokens[index]
           return false unless tok&.type == :identifier

data/lib/milk_tea/tooling/cli.rb

@@ -1611,6 +1611,7 @@ module MilkTea
       input_path = nil
       theme_path = nil
       output_path = nil
+      textmate_only = false
 
       until @argv.empty?
         arg = @argv.first
@@ -1629,6 +1630,9 @@ module MilkTea
             @err.puts("snapshot: missing value for --output")
             return 1
           end
+        when "--textmate-only"
+          @argv.shift
+          textmate_only = true
         else
           if arg.start_with?("-")
             @err.puts("snapshot: unknown option #{arg}")
@@ -1674,10 +1678,12 @@ module MilkTea
       args.push("-o", output_path) if output_path
 
       semantic_result = nil
-      begin
-        semantic_result = MilkTea::LSP::Server.semantic_tokens_for_path(input_path)
-      rescue => e
-        @err.puts("snapshot: semantic analysis skipped: #{e.message}")
+      unless textmate_only
+        begin
+          semantic_result = MilkTea::LSP::Server.semantic_tokens_for_path(input_path)
+        rescue => e
+          @err.puts("snapshot: semantic analysis skipped: #{e.message}")
+        end
       end
 
       if semantic_result && semantic_result[:entries] && !semantic_result[:entries].empty?

data/lib/milk_tea/tooling/linter/reserved_names.rb

@@ -111,7 +111,7 @@ module MilkTea
             line: type_param.line,
             column: type_param.column,
             kind_label:,
-            reserved_names: RESERVED_TYPE_BINDING_NAMES,
+            reserved_names: RESERVED_VALUE_TYPE_NAMES,
           )
         end
       end

data/lib/milk_tea/tooling/linter/visitors.rb

@@ -150,7 +150,19 @@ module MilkTea
             column: statement.column,
             var: statement.kind == :var
           )
-          with_scope { visit_statement_list(statement.else_body) } if statement.else_body
+          if statement.else_body || statement.else_binding
+            with_scope do
+              if statement.else_binding
+                declare_local(
+                  statement.else_binding.name,
+                  statement.else_binding.line,
+                  column: statement.else_binding.column,
+                  var: false
+                )
+              end
+              visit_statement_list(statement.else_body) if statement.else_body
+            end
+          end
           check_redundant_type_annotation(statement)
           flag_redundant_widening_cast(statement.value) if statement.type && statement.value
           record_ptr_candidate(statement)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.10
+  version: 0.3.12
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -603,7 +603,7 @@ metadata:
   homepage_uri: https://teefan.github.io/mt-lang/
   source_code_uri: https://github.com/teefan/mt-lang
 post_install_message: |
-  Milk Tea 0.3.10 installed!
+  Milk Tea 0.3.12 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH