mt-lang 0.3.11 → 0.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efa0075ce73ffd0c92161f778399c599c6443e4375194a8bfeda883b3c29ea09
-  data.tar.gz: 978ab66cd06f4261edb72629f528c020890250ed7b57bbd75bee8cbe01e7e6a1
+  metadata.gz: bc80c3a3240cbcf4770dd067aa33559e74e3f139322b8fdb757316f3c7faf8af
+  data.tar.gz: a623e5ecaa9617aa161a83e96c4cb0e7a75b08855edae27fb56c8ddc47c7cd75
 SHA512:
-  metadata.gz: b0516d11fd07ed4c2db9bfaa4d59735821cfc3245aca280118f87593e7fa1fb2fec3be0c8208efc87b91c4cd79215e3a593602b43e1d9811572fcdcced93c280
-  data.tar.gz: 1a27eb0e66b9b15330ae28273b59ddfa430a6e7439811c2ca196b685cb6e8379b56016bb3a6eed60b347582fd013d8ba29f0c7024fbec0c13b67592aff3e0eba
+  metadata.gz: c90aa51a21411fdcfe612f2ded69afdde6e055a012a4e886f5aa9ac69110d39a8bf93a36dde0543d1375a8bfa75ffd2f287eb082833a28b42efe19ab45c62ae6
+  data.tar.gz: a87ac20f1228f059e3508818be58e11e5491a90299e56d5ab569ab3ebf1ae3dc1f7ddff8761321754bd2bfc8c520dc9ac3876360714ced2baf6e06a82bbf635d

data/README.md

@@ -43,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:
@@ -71,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:
 
@@ -315,7 +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]`), and named constructor arguments (`Meta(return = 1)`). Primitive type names (`int`, `str`, `ref`, etc.) remain reserved and cannot be used in these positions.
+- 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 (`|`, `&`, `^`, `~`).
 
@@ -869,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
@@ -1113,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
 
@@ -1163,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
@@ -1185,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:
@@ -1199,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 `#`.

data/docs/language-manual.md

@@ -83,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
 
@@ -369,6 +379,7 @@ Language-level keywords and reserved words are accepted as:
 - 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.
 

data/lib/milk_tea/base.rb

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

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/parser/expressions.rb

@@ -394,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)
@@ -404,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)

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 : {}
@@ -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,
@@ -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/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.11
+  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.11 installed!
+  Milk Tea 0.3.12 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH