mt-lang 0.3.42 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 927d840392dcd8afb43392ab7ef3f0b620ff267a13107c1f539ad17596364c6c
-  data.tar.gz: f9f09a4989def57fbb058b3cc1ceeea62a23d1bfcec0c6bfe030c58e4ea26e8e
+  metadata.gz: 990a1e0ede945713a31152caccc4a7de798dc6ead6078d46d5a376f19054a52a
+  data.tar.gz: 97d7877587ca50ab673212d1d0d80d6d60ad8f97a74c439965feb32c2f5a4e37
 SHA512:
-  metadata.gz: a7d0a57ff106227cc3e59d3ac1b425ad8cc0deecf4f0f9016f09984074cd624f43ddc7e178935c4af31a472cdd79eff6275c18a410030d678c0e1a0567666343
-  data.tar.gz: 53edd11a322c1145dbab6d63209dd321e720a22c0f269b08f84be31638fac77f7bb092aa5920611cb12603905eb2260612f49e325d0644ebc35bb95295b134c1
+  metadata.gz: c04b4d611724c8b4f42ae14929b3d8d98b4aa4da5157f7c3ee765afb6356be643b6ada8c96ed45a8e61103e71792c7855c25d87f65865b9609cdb0cc85544507
+  data.tar.gz: 82416c2665d49928f0d6dd5e9b8f225177f9df0f782e973339545a6375cc673e082bccc3bbb6126cbdc50875dc6fa29880b5e23b8e3ccd458934b32f5d2f6718

data/README.md

@@ -746,6 +746,7 @@ Postfix forms:
 
 - member access: `a.b`
 - indexing: `a[i]`
+- range index: `a[start..stop]` — `str` yields a borrowed `str` view; `array[T, N]` and `span[T]` yield a borrowed `span[T]` view; half-open `[start, stop)`, no copy, no allocation
 - call: `f(x)`
 - partial field update: `v.with(x = 10.0)` — returns a copy with specified fields replaced
 - specialization: `name[T]`, `name[32]`, `mod.name[T]`
@@ -939,7 +940,7 @@ See module source for full method surface. Iterator forms:
 
 Text categories:
 
-- `str` -> string view. The `+` operator concatenates two `str` values into a per-thread scratch buffer (no heap allocation), returning a borrowed `str`; the result stays valid while cumulative concatenations on that thread remain within the scratch buffer budget. For loops or repeated concatenation, prefer `string.String` for amortized building.
+- `str` -> string view. `s[i]` reads the byte at `i` as `ubyte` (bounds-checked). `s[start..stop]` returns a borrowed `str` view using byte offsets; bounds must be UTF-8 code-unit boundaries or the slice traps. The `+` operator concatenates two `str` values into a per-thread scratch buffer (no heap allocation), returning a borrowed `str`; the result stays valid while cumulative concatenations on that thread remain within the scratch buffer budget. For loops or repeated concatenation, prefer `string.String` for amortized building.
 - `cstr` -> C ABI string
 - `str_buffer[N]` -> fixed-capacity mutable UTF-8 text buffer
 
@@ -989,6 +990,7 @@ Heredoc notes:
 - Shift operators require integer operands.
 - Safe array indexing requires an addressable array value.
 - Safe indexing (`arr[i]`) is bounds-checked and calls `fatal` on out-of-bounds access.
+- Range indexing (`arr[start..stop]`, `span[start..stop]`, `str[start..stop]`) returns a borrowed view: `span[T]` for arrays and spans, `str` for strings. Bounds may be any integer types (converted to `ptr_uint`); `start > stop` or `stop > len` traps at runtime. Array range slices require an addressable array value; str slices must land on UTF-8 code-unit boundaries. Bounds-checked with no copy or allocation.
 - Use `get(arr, i)` for recoverable indexing that returns `ptr[T]?` (null on out-of-bounds) instead of aborting.
 - Pointer indexing requires `unsafe`.
 - `read(ptr)` requires `unsafe`.
@@ -1145,7 +1147,8 @@ Current compiler rejects:
 
 - `+` concatenates `str`; `cstr` and mixed `str`/`cstr` concatenation are not supported
 - `==`/`!=` on structs and variants requires all fields equality-comparable; use `equal[T]` otherwise
-- range expressions are restricted to `for`-loop iterables and range-index assignment targets
+- range expressions are restricted to `for`-loop iterables, range index reads (`a[start..stop]`), and range-index assignment targets
+- `str` is an immutable borrowed view: index and range-index results cannot be assigned through
 - 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 `()`

data/docs/index.html

@@ -1262,7 +1262,7 @@ let d: dyn[Drawable] = adapt[Drawable](ref_of(entity))</code></pre>
       <tr><td><code>ptr_int</code> <code>ptr_uint</code></td><td>Pointer-sized integers</td></tr>
       <tr><td><code>float</code> <code>double</code></td><td>Floating-point</td></tr>
       <tr><td><code>void</code></td><td>No value</td></tr>
-      <tr><td><code>str</code></td><td>UTF-8 string view (borrowed). The <code>+</code> operator concatenates two <code>str</code> values into a per-thread scratch buffer (no allocation); the result is valid while the scratch budget lasts.</td></tr>
+      <tr><td><code>str</code></td><td>UTF-8 string view (borrowed). <code>s[i]</code> reads the byte at <code>i</code> as <code>ubyte</code> (bounds-checked); <code>s[start..stop]</code> returns a borrowed view using byte offsets and traps off UTF-8 boundaries. The <code>+</code> operator concatenates two <code>str</code> values into a per-thread scratch buffer (no allocation); the result is valid while the scratch budget lasts.</td></tr>
       <tr><td><code>cstr</code></td><td>NUL-terminated C string</td></tr>
       <tr><td><code>vec2</code> <code>vec3</code> <code>vec4</code></td><td>Float vectors with <code>.x .y .z .w</code></td></tr>
       <tr><td><code>ivec2</code> <code>ivec3</code> <code>ivec4</code></td><td>Integer vectors</td></tr>
@@ -1487,8 +1487,18 @@ else:
     do_work()</code></pre>
 </div>
 
+  <h3>Range Index</h3>
+  <p>Range-index reads borrow a sub-view with no copy and no allocation. The result is a borrowed <code class="code-inline">str</code> for string receivers and a borrowed <code class="code-inline">span[T]</code> for arrays and spans. Bounds may be any integer types. The range is start-inclusive and end-exclusive. <code>start &gt; stop</code> or <code>stop &gt; len</code> traps at runtime; string slices additionally require UTF-8 code-unit boundaries at both bounds.</p>
+<div class="code-wrap">
+<button class="copy-btn" onclick="copyCode(this)">Copy</button>
+<pre><code>let text: str = "hello world"
+let head = text[0..5]              # str view: "hello"
+var values: array[int, 4] = (10, 20, 30, 40)
+let middle = values[1..3]          # span[int] view over 20, 30</code></pre>
+</div>
+
   <h3>Range Index Assignment</h3>
-  <p>Assign a tuple to a contiguous slice using an exclusive range with literal bounds. The tuple width must match the slice width exactly.</p>
+  <p>Assign a tuple to a contiguous slice using an exclusive range with literal bounds. The tuple width must match the slice width exactly. String views are immutable and cannot be assigned through.</p>
 <div class="code-wrap">
 <button class="copy-btn" onclick="copyCode(this)">Copy</button>
 <pre><code>var buf: array[float, 4]
@@ -1749,6 +1759,10 @@ value.field
 arr[i]
 func(arg)
 
+## Range index: str returns str view; arrays and spans return span[T] view
+let head = text[0..5]
+let middle = values[1..3]
+
 ## Partial field update (returns copy)
 let moved = v.with(x = 10.0)
 
@@ -1871,7 +1885,7 @@ function field_equal[T](a: const_ptr[T], b: const_ptr[T]) -&gt; bool:
   <div class="table-wrap">
     <table class="attr-table">
       <tr><th>Type</th><th>Ownership</th><th>Use Case</th></tr>
-      <tr><td><code>str</code></td><td>Borrowed</td><td>Read-only UTF-8 view (literals, format strings, slicing); a stored or returned dynamic format string carries its own heap buffer</td></tr>
+      <tr><td><code>str</code></td><td>Borrowed</td><td>Read-only UTF-8 view (literals, format strings, slicing, <code>x[start..stop]</code>); a stored or returned dynamic format string carries its own heap buffer</td></tr>
       <tr><td><code>cstr</code></td><td>Borrowed</td><td>NUL-terminated C ABI string (<code>c"hello"</code>)</td></tr>
       <tr><td><code>str_buffer[N]</code></td><td>Owned (stack)</td><td>Fixed-capacity mutable UTF-8 builder</td></tr>
       <tr><td><code>std.string.String</code></td><td>Owned (heap)</td><td>Growable owned text via <code>fmt.format(f"...")</code></td></tr>
@@ -1980,7 +1994,7 @@ MSG</code></pre>
       <tr><td>Conditions must be <code>bool</code></td><td>No truthy/falsy coercion from integers or pointers</td></tr>
       <tr><td>Explicit casts for mixed signed/unsigned</td><td>Mixed signed/unsigned arithmetic requires <code>T&lt;-value</code></td></tr>
       <tr><td>Enum/flags don't auto-coerce</td><td>Outside external-call boundaries, no implicit conversion to backing integers</td></tr>
-      <tr><td>Safe indexing is bounds-checked</td><td><code>arr[i]</code> calls <code>fatal</code> on OOB; use <code>get(arr, i)</code> for recoverable access</td></tr>
+      <tr><td>Safe indexing is bounds-checked</td><td><code>arr[i]</code> and <code>a[start..stop]</code> call <code>fatal</code> on OOB; string slices additionally require UTF-8 boundaries; use <code>get(arr, i)</code> for recoverable single-element access</td></tr>
       <tr><td>Pointer indexing requires <code>unsafe</code></td><td>Raw pointer dereference, arithmetic, casts, <code>reinterpret</code> all need <code>unsafe</code></td></tr>
       <tr><td><code>%</code> requires integer operands</td><td></td></tr>
       <tr><td>Bitwise ops require matching types</td><td>Integer or flags types</td></tr>
@@ -2429,6 +2443,8 @@ 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> concatenates <code>str</code>; <code>cstr</code> and mixed <code>str</code>/<code>cstr</code> are not concatenable</li>
     <li><code>==</code>/<code>!=</code> on structs and variants requires all fields equality-comparable; use <code>equal[T]</code> for non-comparable types</li>
+    <li>Range expressions are restricted to <code>for</code>-loop iterables, range-index reads (<code>a[start..stop]</code>), and range-index assignment targets</li>
+    <li><code>str</code> views are immutable borrowed text; index and range-index results cannot be assigned through</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

@@ -409,13 +409,15 @@ Rules:
 - Parallel `for` accepts multiple array/span iterables and binds them in lockstep.
 - Parallel `for` does not accept ranges, and iterable lengths must match.
 
+Range-index reads borrow sub-views with the same syntax. `a[start..stop]` on `array[T, N]` or `span[T]` returns a borrowed `span[T]`; on `str` it returns a borrowed `str`. The range is end-exclusive, bounds may be any integer types, and out-of-bounds or inverted bounds trap at runtime like all safe indexing. These reads copy nothing and allocate nothing — they only form a pointer-plus-length view.
+
 Range-index assignment is also part of the control-flow-and-mutation surface when code wants an explicit fixed-width slice update:
 
 ```mt
 buf[0..3] = (1.0, 2.0, 3.0)
 ```
 
-The bounds are integer literals, the range is end-exclusive, and the right-hand tuple width must match the slice width exactly.
+The bounds are integer literals, the range is end-exclusive, and the right-hand tuple width must match the slice width exactly. Range-index assignment writes element-wise into array or span storage; `str` views are immutable and cannot be assigned through.
 
 ### Useful structured features
 
@@ -580,6 +582,7 @@ Notes:
 - Fixed-array indexing is bounds-checked and safe by default.
 - Safe array indexing requires an addressable array value; bind temporaries before indexing them.
 - Safe indexing (`arr[i]`) aborts on out-of-bounds via `fatal`. Use `get(arr, i)` for recoverable bounds-checked access that returns `ptr[T]?`.
+- Range indexing (`arr[start..stop]` on arrays and spans) returns a borrowed `span[T]` view; it copies nothing and requires an addressable array value.
 - When a `span[T]` boundary is expected, addressable `array[T, N]` values coerce directly. Arrays also expose `.as_span()` for explicit conversion when the target type is not a call boundary.
 - `array[char, N]` and `span[char]` are the ordinary source-level forms for raw writable character storage and byte-oriented foreign buffers. They are not alternate text objects and should not grow a parallel everyday text API.
 - `str_buffer[N]` is the one source-level mutable UTF-8 text type. It owns `N` writable text bytes plus an implementation-managed trailing NUL slot, tracks current text length, and refreshes that length when a writable buffer alias mutates the underlying storage.
@@ -592,7 +595,7 @@ Notes:
 - `.len()` returns the tracked text length, revalidating UTF-8 and rescanning for the trailing NUL if the builder was passed through a writable `span[char]` or `ptr[char]` alias.
 - `.capacity()` reports the maximum writable text bytes, not counting the reserved trailing NUL slot.
 - `.as_str()` and `.as_cstr()` borrow from the same builder storage and revalidate through that same dirty-refresh path before returning.
-- `str.slice(start, len)` uses byte offsets and byte lengths, but both the start and end position must be UTF-8 code-unit boundaries or the slice traps at runtime.
+- `str[start..stop]` is the language-level slice surface: it returns a borrowed `str` view using byte offsets with an end-exclusive range, and both bounds must be UTF-8 code-unit boundaries or the slice traps at runtime. `s[i]` reads the byte at `i` as `ubyte`, bounds-checked. `str.slice(start, len)` remains the library spelling for start-plus-length slicing.
 - Ordinary string lists stay `array[str, N]` or `span[str]` in source. If an imported foreign declaration chooses that public surface for a raw `char **`, `span[cstr]`, or pointer-plus-length text-list API, the boundary owns the temporary marshalling.
 - Imported foreign declarations may map `str_buffer[N] as ptr[char]` directly when the public surface wants writable UTF-8 text with fixed caller capacity.
 - If the raw call also needs the caller buffer size, a `str_buffer[N]` public signature should pass `text_public.capacity() + 1` in the foreign mapping so the raw side sees the full writable byte count including the trailing NUL slot.

data/docs/language-manual.md

@@ -934,22 +934,41 @@ Unsafe context is required for raw-pointer-level operations such as:
 - pointer casts
 - `reinterpret[...]`
 
-### 4.6 Range index assignment
+### 4.6 Range indexing
 
-Contiguous indexed slices may be assigned from an expression list:
+Range index reads borrow a sub-view with no copy and no allocation:
+
+```mt
+let text: str = "hello world"
+let head = text[0..5]              # str view: "hello"
+var values: array[int, 4] = (10, 20, 30, 40)
+let middle = values[1..3]          # span[int] view over 20, 30
+```
+
+Rules for range index reads:
+
+- the receiver must be `str`, `array[T, N]`, or `span[T]`
+- the result is a borrowed view: `str` for string receivers, `span[T]` for arrays and spans
+- the range is start-inclusive and end-exclusive; bounds may be any integer types
+- `start > stop` or `stop > len` traps at runtime
+- array receivers require an addressable array value; literal bounds are checked at compile time
+- `str` slices use byte offsets and both bounds must be UTF-8 code-unit boundaries or the slice traps
+
+Range index assignment writes elements in place:
 
 ```mt
 var buf: array[float, 4]
 buf[0..3] = (1.0, 2.0, 3.0)
 ```
 
-Rules:
+Rules for range index assignment:
 
 - the target must be an addressable array-, span-, or pointer-indexable lvalue
 - the index must be a range expression with integer literal bounds
 - the range is start-inclusive and end-exclusive
 - the right-hand side must be an expression list whose length exactly matches the range width
 - each element must be assignable to the indexed element type
+- `str` receivers cannot be assigned through; str views are immutable
 
 ### 4.7 When (compile-time conditional)
 
@@ -1051,6 +1070,7 @@ Rules:
 
 - member access: `a.b`
 - indexing: `a[i]`
+- range index: `a[start..stop]` — `str` yields a borrowed `str` view; `array[T, N]` and `span[T]` yield a borrowed `span[T]` view; half-open `[start, stop)` with no copy (§4.6)
 - call: `f(x)`
 - partial field update: `v.with(x = 10.0)` — returns a copy with specified fields replaced; supported on structs and native types (vector, matrix, quaternion)
 - specialization: `name[T]`, `name[32]`, `mod.name[T]`
@@ -1306,7 +1326,7 @@ Iterator notes for those collection modules:
 
 String categories:
 
-- `str` -> string view
+- `str` -> string view. `s[i]` reads the byte at `i` as `ubyte` (bounds-checked); `s[start..stop]` returns a borrowed `str` view using byte offsets (UTF-8 boundary-checked)
 - `cstr` -> C ABI string
 - `str_buffer[N]` -> fixed-capacity mutable UTF-8 text buffer
 
@@ -1373,6 +1393,8 @@ Custom formatting hook notes:
 - shift operators require integer operands
 - safe array indexing requires an addressable array value
 - safe indexing (`arr[i]`) is bounds-checked and calls `fatal` on out-of-bounds access
+- safe range indexing (`a[start..stop]`) is bounds-checked and calls `fatal` on out-of-bounds or out-of-order bounds
+- `str` range slices require UTF-8 code-unit boundaries at both bounds
 - use `get(arr, i)` for recoverable indexing that returns `ptr[T]?` (null on out-of-bounds) instead of aborting
 - pointer indexing requires `unsafe`
 - `read(...)` of raw pointer requires `unsafe`
@@ -1622,7 +1644,8 @@ The compiler intentionally rejects the following patterns. These are design cons
 
 - `+` concatenates `str`; `cstr` and mixed `str`/`cstr` are not concatenable
 - `==`/`!=` on structs and variants requires all fields equality-comparable; use `equal[T]` otherwise (§3.4b)
-- range expressions are restricted to `for`-loop iterables and range-index assignment targets
+- range expressions are restricted to `for`-loop iterables, range-index reads (`a[start..stop]`), and range-index assignment targets
+- `str` views are immutable borrowed text; index and range-index results cannot be assigned through
 - functions, methods, generic functions, and variant arms must be called — they are not usable as bare values
 - `read(...)` of a raw pointer requires `unsafe`
 

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/ast.rb

@@ -120,8 +120,8 @@ module MilkTea
     FunctionDef = Data.define(:name, :type_params, :params, :return_type, :body, :visibility, :async, :const, :attributes, :line, :column) do
       def initialize(name:, type_params:, params:, return_type:, body:, visibility:, async:, const: false, attributes: [], line: nil, column: nil) = super
     end
-    MethodDef = Data.define(:name, :type_params, :params, :return_type, :body, :kind, :visibility, :async, :attributes, :line, :column) do
-      def initialize(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, attributes: [], line: nil, column: nil) = super
+    MethodDef = Data.define(:name, :type_params, :params, :return_type, :body, :kind, :visibility, :async, :const, :attributes, :line, :column) do
+      def initialize(name:, type_params:, params:, return_type:, body:, kind:, visibility:, async:, const: false, attributes: [], line: nil, column: nil) = super
     end
     ExternFunctionDecl = Data.define(:name, :type_params, :params, :return_type, :variadic, :attributes, :line, :column, :mapping) do
       def initialize(name:, type_params:, params:, return_type:, variadic:, attributes: [], line: nil, column: nil, mapping: nil) = super

data/lib/milk_tea/core/c_backend/feature_detection.rb

@@ -136,8 +136,9 @@ module MilkTea
         return true if @debug_guards
 
         collect_checked_array_index_types.any? || collect_checked_span_index_types.any? ||
+          !collect_span_slice_helper_names.empty? ||
           uses_format_helpers? ||
-          emitted_functions.any? { |function| function_uses_named_call?(function, %w[mt_fatal mt_str_buffer_len mt_str_buffer_as_cstr mt_str_buffer_assign mt_str_buffer_append mt_foreign_str_to_cstr_temp mt_foreign_strs_to_cstrs_temp mt_str_concat]) }
+          emitted_functions.any? { |function| function_uses_named_call?(function, %w[mt_fatal mt_str_buffer_len mt_str_buffer_as_cstr mt_str_buffer_assign mt_str_buffer_append mt_foreign_str_to_cstr_temp mt_foreign_strs_to_cstrs_temp mt_str_concat mt_str_index mt_str_slice]) }
       end
 
       def uses_mt_fatal_str_helper?
@@ -297,6 +298,10 @@ module MilkTea
         end
       end
 
+      def uses_str_slice_helpers?
+        emitted_functions.any? { |function| function_uses_named_call?(function, %w[mt_str_index mt_str_slice]) }
+      end
+
       def uses_variant_equality_helper?
         !variant_equality_types.empty?
       end

data/lib/milk_tea/core/c_backend/runtime_helpers.rb

@@ -64,6 +64,36 @@ module MilkTea
         ]
       end
 
+      def emit_str_slice_helpers
+        [
+          "static uint8_t mt_str_index(mt_str text, uintptr_t index) {",
+          "#{INDENT}if (index >= text.len) mt_fatal(\"str index out of bounds\");",
+          "#{INDENT}return (uint8_t)text.data[index];",
+          "}",
+          "",
+          "static bool mt_str_utf8_boundary(mt_str text, uintptr_t index) {",
+          "#{INDENT}if (index == 0 || index == text.len) return true;",
+          "#{INDENT}return ((uint8_t)text.data[index] & 0xC0) != 0x80;",
+          "}",
+          "",
+          "static mt_str mt_str_slice(mt_str text, uintptr_t start, uintptr_t stop) {",
+          "#{INDENT}if (start > stop || stop > text.len) mt_fatal(\"str slice out of bounds\");",
+          "#{INDENT}if (!mt_str_utf8_boundary(text, start) || !mt_str_utf8_boundary(text, stop)) mt_fatal(\"str slice bounds must be UTF-8 code-unit boundaries\");",
+          "#{INDENT}return (mt_str){ .data = text.data + start, .len = stop - start };",
+          "}",
+        ]
+      end
+
+      def emit_span_slice_helper(helper_name)
+        span_name = helper_name.sub("mt_span_slice_", "mt_span_")
+        [
+          "static inline #{span_name} #{helper_name}(#{span_name} span, uintptr_t start, uintptr_t stop) {",
+          "#{INDENT}if (start > stop || stop > span.len) mt_fatal(\"span slice out of bounds\");",
+          "#{INDENT}return (#{span_name}){ .data = span.data + start, .len = stop - start };",
+          "}",
+        ]
+      end
+
       def emit_variant_equality_helpers
         variant_decls_by_linkage = (emitted_aggregate_variants + collect_generic_variant_decls).each_with_object({}) { |decl, map| map[decl.linkage_name] = decl }
         variant_equality_types

data/lib/milk_tea/core/c_backend/type_collectors.rb

@@ -19,6 +19,80 @@ module MilkTea
         span_types.uniq
       end
 
+      def collect_span_slice_helper_names
+        names = []
+        emitted_functions.each do |function|
+          collect_span_slice_helper_names_from_statements(function.body, names)
+        end
+        names.uniq
+      end
+
+      def collect_span_slice_helper_names_from_statements(statements, names)
+        statements.each do |statement|
+          case statement
+          when IR::LocalDecl
+            collect_span_slice_helper_names_from_expression(statement.value, names)
+          when IR::Assignment
+            collect_span_slice_helper_names_from_expression(statement.target, names)
+            collect_span_slice_helper_names_from_expression(statement.value, names)
+          when IR::BlockStmt
+            collect_span_slice_helper_names_from_statements(statement.body, names)
+          when IR::WhileStmt
+            collect_span_slice_helper_names_from_expression(statement.condition, names)
+            collect_span_slice_helper_names_from_statements(statement.body, names)
+          when IR::ForStmt
+            collect_span_slice_helper_names_from_statements([statement.init], names)
+            collect_span_slice_helper_names_from_expression(statement.condition, names)
+            collect_span_slice_helper_names_from_statements(statement.body, names)
+            collect_span_slice_helper_names_from_statements([statement.post], names)
+          when IR::IfStmt
+            collect_span_slice_helper_names_from_expression(statement.condition, names)
+            collect_span_slice_helper_names_from_statements(statement.then_body, names)
+            collect_span_slice_helper_names_from_statements(statement.else_body, names) if statement.else_body
+          when IR::SwitchStmt
+            collect_span_slice_helper_names_from_expression(statement.expression, names)
+            statement.cases.each { |switch_case| collect_span_slice_helper_names_from_statements(switch_case.body, names) }
+          when IR::ReturnStmt
+            collect_span_slice_helper_names_from_expression(statement.value, names) if statement.value
+          when IR::ExpressionStmt
+            collect_span_slice_helper_names_from_expression(statement.expression, names)
+          end
+        end
+      end
+
+      def collect_span_slice_helper_names_from_expression(expression, names)
+        return unless expression
+
+        case expression
+        when IR::Call
+          names << expression.callee if expression.callee.is_a?(String) && expression.callee.start_with?("mt_span_slice_")
+          collect_span_slice_helper_names_from_expression(expression.callee, names) unless expression.callee.is_a?(String)
+          expression.arguments.each { |argument| collect_span_slice_helper_names_from_expression(argument, names) }
+        when IR::Member
+          collect_span_slice_helper_names_from_expression(expression.receiver, names)
+        when IR::Index, IR::CheckedIndex, IR::CheckedSpanIndex, IR::NullableIndex, IR::NullableSpanIndex
+          collect_span_slice_helper_names_from_expression(expression.receiver, names)
+          collect_span_slice_helper_names_from_expression(expression.index, names)
+        when IR::Unary
+          collect_span_slice_helper_names_from_expression(expression.operand, names)
+        when IR::Binary
+          collect_span_slice_helper_names_from_expression(expression.left, names)
+          collect_span_slice_helper_names_from_expression(expression.right, names)
+        when IR::Conditional
+          collect_span_slice_helper_names_from_expression(expression.condition, names)
+          collect_span_slice_helper_names_from_expression(expression.then_expression, names)
+          collect_span_slice_helper_names_from_expression(expression.else_expression, names)
+        when IR::Cast, IR::AddressOf
+          collect_span_slice_helper_names_from_expression(expression.expression, names)
+        when IR::AggregateLiteral
+          expression.fields.each { |field| collect_span_slice_helper_names_from_expression(field.value, names) }
+        when IR::ArrayLiteral
+          expression.elements.each { |element| collect_span_slice_helper_names_from_expression(element, names) }
+        when IR::VariantLiteral
+          expression.fields.each { |field| collect_span_slice_helper_names_from_expression(field.value, names) }
+        end
+      end
+
       def collect_checked_array_index_types_from_statements(statements, array_types, nullable_only: false)
         statements.each do |statement|
           case statement

data/lib/milk_tea/core/c_backend.rb

@@ -162,6 +162,10 @@ module MilkTea
         lines.concat(emit_str_concat_helper)
         lines << ""
       end
+      if uses_str_slice_helpers?
+        lines.concat(emit_str_slice_helpers)
+        lines << ""
+      end
       if uses_str_buffer_helpers?
         lines.concat(emit_utf8_validation_helpers)
         lines << ""
@@ -335,6 +339,11 @@ module MilkTea
         lines << ""
       end
 
+      collect_span_slice_helper_names.each do |helper_name|
+        lines.concat(emit_span_slice_helper(helper_name))
+        lines << ""
+      end
+
       collect_checked_array_index_types(nullable_only: true).each do |type|
         lines.concat(emit_nullable_array_index_helper(type))
         lines << ""

data/lib/milk_tea/core/compile_time/method_folding.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module MilkTea
+  module CompileTime
+    # Compile-time folding for const-method calls and the resolution helpers
+    # behind them. Included by both the semantic checker and the lowering
+    # engine so the folding behavior lives in one place instead of two
+    # near-identical copies. Each includer supplies a small set of `comptime_*`
+    # adapters for the phase-specific lookups (ctx maps, scope/env evaluation,
+    # and the BlockContext factory).
+    module MethodFolding
+      def comptime_methods_map_for_binding(type, keys)
+        dispatch_type = type.respond_to?(:definition) ? type.definition : type
+        method_map = comptime_methods_map.fetch(dispatch_type, nil)
+        method_map ||= comptime_methods_map_by_to_s(dispatch_type)
+        return nil unless method_map
+
+        keys.each do |key|
+          binding = method_map[key]
+          next unless binding
+
+          ast = binding.ast
+          next unless ast.respond_to?(:const) && ast.const && ast.body
+          next unless binding.type_params.empty?
+
+          return binding
+        end
+        nil
+      end
+
+      def comptime_method_binding(member_access, ctx)
+        member = member_access.member
+        keys = ["static:#{member}", member]
+
+        if (type = resolve_type_expression(member_access.receiver)) &&
+           (binding = comptime_methods_map_for_binding(type, keys))
+          return binding
+        end
+
+        receiver_type = comptime_receiver_type(member_access.receiver, ctx)
+        return nil unless receiver_type
+
+        comptime_methods_map_for_binding(receiver_type, keys)
+      end
+
+      def comptime_method_binding_for_receiver(receiver_type, member)
+        comptime_methods_map_for_binding(receiver_type, ["static:#{member}", member])
+      end
+
+      def comptime_receiver_type(receiver, ctx)
+        case receiver
+        when AST::Identifier
+          type = comptime_scoped_value_type(receiver.name, ctx)
+          return type if type
+
+          comptime_value_type(receiver.name)
+        when AST::MemberAccess
+          return nil unless receiver.receiver.is_a?(AST::Identifier)
+
+          comptime_imported_value_type(receiver.receiver.name, receiver.member)
+        when AST::Call, AST::Specialization
+          comptime_call_return_type(receiver, ctx)
+        end
+      end
+
+      def comptime_member_receiver_value(receiver, ctx)
+        return nil if resolve_type_expression(receiver)
+
+        comptime_eval(receiver, ctx)
+      end
+
+      def comptime_call_return_type(call_expr, ctx)
+        case call_expr.callee
+        when AST::MemberAccess
+          binding = comptime_method_binding(call_expr.callee, ctx)
+          return binding.body_return_type if binding
+        when AST::Identifier
+          func = comptime_const_function(call_expr.callee.name)
+          return func.body_return_type if comptime_const_function_return?(func)
+        when AST::Specialization
+          callee_name = call_expr.callee.callee.is_a?(AST::Identifier) ? call_expr.callee.callee.name : nil
+          if callee_name
+            func = comptime_const_function(callee_name)
+            return func.body_return_type if comptime_const_function_return?(func)
+          end
+        end
+        nil
+      end
+
+      def comptime_expression_type(expression, scopes:)
+        case expression
+        when AST::Call, AST::Specialization
+          comptime_call_return_type(expression, scopes)
+        end
+      end
+
+      def comptime_struct_field_names(type_name)
+        parts = type_name.is_a?(Array) ? type_name.map(&:to_s) : [type_name.to_s]
+        return nil if parts.empty?
+
+        type = resolve_type_expression(::MilkTea::AST.build_chain_from_parts(parts))
+        return nil unless type
+        return nil unless type.respond_to?(:fields) && type.fields
+
+        type.fields.keys
+      end
+
+      def comptime_folded_value?(value)
+        return false if value.nil?
+        return false if value.is_a?(Types::Base)
+
+        true
+      end
+
+      def comptime_const_function_return?(func)
+        func && func.respond_to?(:ast) && func.ast.respond_to?(:const) && func.ast.const
+      end
+
+      def comptime_const_method_body(binding, arguments, scopes:, receiver_value:)
+        method = binding.ast
+        return nil unless method.respond_to?(:body) && method.body
+        return nil if binding.type_params.any?
+        return nil unless method.params.length == arguments.length
+
+        initial_vars = {}
+        if binding.type.receiver_type
+          return nil unless comptime_folded_value?(receiver_value)
+
+          initial_vars["this"] = receiver_value
+        end
+
+        method.params.each_with_index do |param, idx|
+          arg_value = comptime_eval(arguments[idx].value, scopes)
+          return nil unless arg_value
+
+          initial_vars[param.name] = arg_value
+        end
+
+        variable_types = binding.body_params.each_with_object({}) do |param, acc|
+          acc[param.name] = param.type
+        end
+        block_context = comptime_block_context(initial_vars, variable_types)
+        result = block_context.evaluate_block(method.body, scopes: nil)
+        result.is_a?(CompileTime::ReturnOutcome) ? result.value : result
+      rescue CompileTime::Error => e
+        comptime_raise_error(e)
+      end
+
+      def comptime_imported_value_type(import_name, member)
+        imported_module = @ctx.imports.fetch(import_name, nil)
+        return nil unless imported_module
+
+        imported_module.values[member]&.type
+      end
+    end
+  end
+end