mt-lang 0.3.42 → 0.3.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 927d840392dcd8afb43392ab7ef3f0b620ff267a13107c1f539ad17596364c6c
-  data.tar.gz: f9f09a4989def57fbb058b3cc1ceeea62a23d1bfcec0c6bfe030c58e4ea26e8e
+  metadata.gz: 6842b1cfb6eac5181fdbcd31cd90dbb9f436bb0f3c7b0cc25d49a8c1f8e13a8b
+  data.tar.gz: 4e97091f3da86a115656c6ec7d9bb10fe5cd65360bd59a203fc6595111285aff
 SHA512:
-  metadata.gz: a7d0a57ff106227cc3e59d3ac1b425ad8cc0deecf4f0f9016f09984074cd624f43ddc7e178935c4af31a472cdd79eff6275c18a410030d678c0e1a0567666343
-  data.tar.gz: 53edd11a322c1145dbab6d63209dd321e720a22c0f269b08f84be31638fac77f7bb092aa5920611cb12603905eb2260612f49e325d0644ebc35bb95295b134c1
+  metadata.gz: 71630831d0eceda79fefdd93b07a9f83b48c3ef3b0cd879c5c7db8b064e459ef321d36b49a2e0d46e8ba20f134fffc65039cdf455d3cc47638ea031c3edddd83
+  data.tar.gz: b7fccbe3f6547fcb7e17c07b9002d278965934a0f0ec68d1b6c79a1ce5b48d807186633a9e57b75e34c8671413ed984a18823a575719ba1f8af4e3777c3309f3

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.3.43"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

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/lowering/async/normalization.rb

@@ -400,6 +400,8 @@ module MilkTea
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["span"]), arguments: [AST::TypeArgument.new(value: ast_type_ref_for(type.element_type))], nullable: false)
         when Types::Task
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["Task"]), arguments: [AST::TypeArgument.new(value: ast_type_ref_for(type.result_type))], nullable: false)
+        when Types::StringView
+          AST::TypeRef.new(name: AST::QualifiedName.new(parts: ["str"]), arguments: [], nullable: false)
         when Types::TypeVar
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: [type.name]), arguments: [], nullable: false)
         when Types::StructInstance

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

@@ -1364,13 +1364,19 @@ module MilkTea
         when AST::IndexAccess
           receiver_type = infer_expression_type(expression.receiver, env:)
           receiver = lower_expression(expression.receiver, env:)
-          index = lower_expression(expression.index, env:)
-          if array_type?(receiver_type) && addressable_storage_expression?(expression.receiver)
-            IR::CheckedIndex.new(receiver:, index:, receiver_type:, type:)
-          elsif receiver_type.is_a?(Types::Span)
-            IR::CheckedSpanIndex.new(receiver:, index:, receiver_type:, type:)
+          if expression.index.is_a?(AST::RangeExpr)
+            lower_range_index_access(receiver, receiver_type, expression.index, env:, type:)
           else
-            IR::Index.new(receiver:, index:, type:)
+            index = lower_expression(expression.index, env:)
+            if array_type?(receiver_type) && addressable_storage_expression?(expression.receiver)
+              IR::CheckedIndex.new(receiver:, index:, receiver_type:, type:)
+            elsif receiver_type.is_a?(Types::Span)
+              IR::CheckedSpanIndex.new(receiver:, index:, receiver_type:, type:)
+            elsif receiver_type.is_a?(Types::StringView)
+              IR::Call.new(callee: "mt_str_index", arguments: [receiver, index], type:)
+            else
+              IR::Index.new(receiver:, index:, type:)
+            end
           end
         when AST::UnaryOp
           raise LoweringError.new("propagation expressions must be prepared before direct lowering", line: 0, column: 0, path: @ctx.current_analysis_path) if expression.operator == "?"
@@ -1452,6 +1458,25 @@ module MilkTea
         end
       end
 
+      def lower_range_index_access(receiver, receiver_type, range, env:, type:)
+        start = lower_range_index_bound(range.start_expr, env:)
+        stop = lower_range_index_bound(range.end_expr, env:)
+
+        if receiver_type.is_a?(Types::StringView)
+          return IR::Call.new(callee: "mt_str_slice", arguments: [receiver, start, stop], type:)
+        end
+
+        span_type = range_index_result_type(receiver_type)
+        span_argument = receiver_type.is_a?(Types::Span) ? receiver : lower_array_to_span_expression(receiver, span_type)
+        IR::Call.new(callee: span_slice_callee(span_type), arguments: [span_argument, start, stop], type: span_type)
+      end
+
+      def lower_range_index_bound(bound, env:)
+        ptr_uint = @ctx.types.fetch("ptr_uint")
+        lowered = lower_expression(bound, env:, expected_type: ptr_uint)
+        lowered.type == ptr_uint ? lowered : IR::Cast.new(target_type: ptr_uint, expression: lowered, type: ptr_uint)
+      end
+
       def lower_member_access(expression, env:, type:)
         if (type_expr = resolve_type_expression(expression.receiver))
           if type_expr.is_a?(Types::Variant)

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

@@ -206,6 +206,9 @@ module MilkTea
         when AST::IndexAccess
           collect_proc_captures_from_expression(expression.receiver, env, local_scopes, captures)
           collect_proc_captures_from_expression(expression.index, env, local_scopes, captures)
+        when AST::RangeExpr
+          collect_proc_captures_from_expression(expression.start_expr, env, local_scopes, captures)
+          collect_proc_captures_from_expression(expression.end_expr, env, local_scopes, captures)
         when AST::Specialization
           collect_proc_captures_from_expression(expression.callee, env, local_scopes, captures)
           expression.arguments.each { |argument| collect_proc_captures_from_expression(argument.value, env, local_scopes, captures) }

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

@@ -786,6 +786,9 @@ module MilkTea
           raise LoweringError.new("unknown member #{expression.member}", line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
         when AST::IndexAccess
           receiver_type = infer_expression_type(expression.receiver, env:)
+          if expression.index.is_a?(AST::RangeExpr)
+            return range_index_result_type(receiver_type)
+          end
           index_type = infer_expression_type(expression.index, env:)
           infer_index_result_type(receiver_type, index_type)
         when AST::UnaryOp

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

@@ -213,6 +213,10 @@ module MilkTea
 
         receiver_type = referenced_type(receiver_type) if ref_type?(receiver_type)
 
+        if receiver_type.is_a?(Types::StringView)
+          return @ctx.types.fetch("ubyte")
+        end
+
         if array_type?(receiver_type)
           return array_element_type(receiver_type)
         end
@@ -236,6 +240,28 @@ module MilkTea
         raise LoweringError.new("cannot index #{receiver_type}", line: 0, column: 0, path: @ctx.current_analysis_path)
       end
 
+      def range_index_result_type(receiver_type)
+        receiver_type = referenced_type(receiver_type) if ref_type?(receiver_type)
+
+        if receiver_type.is_a?(Types::StringView)
+          return @ctx.types.fetch("str")
+        end
+
+        if array_type?(receiver_type)
+          return Types::Span.new(array_element_type(receiver_type))
+        end
+
+        if receiver_type.is_a?(Types::Span)
+          return receiver_type
+        end
+
+        raise LoweringError.new("cannot range-index #{receiver_type}; expected str, array[T, N], or span[T]", line: 0, column: 0, path: @ctx.current_analysis_path)
+      end
+
+      def span_slice_callee(span_type)
+        "mt_span_slice_#{sanitize_identifier(span_type.element_type.to_s)}"
+      end
+
       def stored_ref_supported_type?(type, visited = {})
         return true unless type
 

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

@@ -37,6 +37,8 @@ module MilkTea
             allow_span_param_identifier: true,
           )
 
+          raise_sema_error("cannot assign through str index; str is an immutable borrowed view") if receiver_type.is_a?(Types::StringView)
+
           index_type = infer_expression(expression.index, scopes:)
           infer_index_result_type(receiver_type, index_type)
         when AST::Call
@@ -101,6 +103,8 @@ module MilkTea
             require_mutable_pointer:,
             allow_span_param_identifier:,
           )
+          raise_sema_error("cannot index through str as an assignment receiver; str is an immutable borrowed view") if receiver_type.is_a?(Types::StringView)
+
           index_type = infer_expression(expression.index, scopes:)
           infer_index_result_type(receiver_type, index_type)
         when AST::Call
@@ -470,8 +474,17 @@ module MilkTea
 
       def infer_index_access(expression, scopes:)
         receiver_type = infer_expression(expression.receiver, scopes:)
+
+        if expression.index.is_a?(AST::RangeExpr)
+          return infer_range_index_access(expression, receiver_type, scopes:)
+        end
+
         index_type = infer_expression(expression.index, scopes:)
 
+        if receiver_type.is_a?(Types::StringView) && (literal = integer_literal_bound_value(expression.index)) && literal < 0
+          raise_sema_error("str index #{literal} is negative; str indices must be non-negative", expression)
+        end
+
         if soa_type?(receiver_type)
           return receiver_type.element_type
         end

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

@@ -1022,6 +1022,10 @@ module MilkTea
       def infer_index_result_type(receiver_type, index_type)
         raise_sema_error("index must be an integer type, got #{index_type}") unless integer_type?(index_type)
 
+        if receiver_type.is_a?(Types::StringView)
+          return @ctx.types.fetch("ubyte")
+        end
+
         if array_type?(receiver_type)
           return array_element_type(receiver_type)
         end
@@ -1047,6 +1051,48 @@ module MilkTea
         raise_sema_error("cannot index #{receiver_type}")
       end
 
+      def infer_range_index_access(expression, receiver_type, scopes:)
+        start_type = infer_expression(expression.index.start_expr, scopes:)
+        stop_type = infer_expression(expression.index.end_expr, scopes:)
+        raise_sema_error("range index bounds must be integer types, got #{start_type} and #{stop_type}") unless start_type.integer? && stop_type.integer?
+
+        if array_type?(receiver_type) && !addressable_storage_expression?(expression.receiver, scopes:)
+          raise_sema_error("array range slice requires an addressable array value; bind it to a local first", expression)
+        end
+
+        if array_type?(receiver_type) && (start_val = integer_literal_bound_value(expression.index.start_expr)) && (stop_val = integer_literal_bound_value(expression.index.end_expr))
+          length = array_length(receiver_type)
+          unless start_val >= 0 && start_val <= stop_val && stop_val <= length
+            raise_sema_error("range index [#{start_val}..#{stop_val}] is out of bounds for array[T, #{length}]", expression)
+          end
+        end
+
+        range_index_result_type(receiver_type)
+      end
+
+      def range_index_result_type(receiver_type)
+        if receiver_type.is_a?(Types::StringView)
+          return @ctx.types.fetch("str")
+        end
+
+        if array_type?(receiver_type)
+          return Types::Span.new(array_element_type(receiver_type))
+        end
+
+        if span_type?(receiver_type)
+          return receiver_type
+        end
+
+        raise_sema_error("cannot range-index #{receiver_type}; expected str, array[T, N], or span[T]")
+      end
+
+      def integer_literal_bound_value(expression)
+        return expression.value if expression.is_a?(AST::IntegerLiteral)
+        return -expression.operand.value if expression.is_a?(AST::UnaryOp) && expression.operator == "-" && expression.operand.is_a?(AST::IntegerLiteral)
+
+        nil
+      end
+
       def addressable_storage_expression?(expression, scopes:)
         case expression
         when AST::Identifier

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

@@ -538,6 +538,7 @@ module MilkTea
           require_mutable_pointer: true,
           allow_span_param_identifier: true,
         )
+        raise_sema_error("cannot assign through str index; str is an immutable borrowed view") if receiver_type.is_a?(Types::StringView)
         element_type = infer_index_result_type(receiver_type, @ctx.types.fetch("ptr_uint"))
 
         statement.value.elements.each_with_index do |elem, i|

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

@@ -21,40 +21,63 @@ module MilkTea
       end
 
       def self.nullable(base)
-        _intern([:nullable, base]) { Nullable.new(base) }
+        _intern([:nullable, type_signature(base)]) { Nullable.new(base) }
       end
 
       def self.generic_instance(name, arguments)
         args = arguments.freeze
-        _intern([:generic, name, args]) { GenericInstance.new(name, args) }
+        _intern([:generic, name, args.map { |a| type_signature(a) }.freeze]) { GenericInstance.new(name, args) }
       end
 
       def self.span(element_type)
-        _intern([:span, element_type]) { Span.new(element_type) }
+        _intern([:span, type_signature(element_type)]) { Span.new(element_type) }
       end
 
       def self.task(result_type)
-        _intern([:task, result_type]) { Task.new(result_type) }
+        _intern([:task, type_signature(result_type)]) { Task.new(result_type) }
       end
 
       def self.string_view
         _intern([:string_view]) { StringView.new }
       end
 
-      # Param signature for intern keys. Parameter#eql? is name-insensitive
-      # (assignability must not depend on parameter names), so arrays of
-      # Parameter objects would conflate fn(value: int) with fn(arg0: int) in
-      # the intern pool. Embedding names here keeps distinct signatures
-      # distinct across independent programs sharing a long-lived pool (the LSP
-      # never resets the registry between checks).
+      # Name-sensitive signature for intern keys. Parameter#eql? is
+      # name-insensitive (assignability must not depend on parameter names), so
+      # Function/Proc objects (and any wrapper containing them) that differ only
+      # in parameter names collide under Hash/==. Pool keys that embed such
+      # types raw therefore conflate fn(value: int) with fn(arg0: int) in a
+      # long-lived pool (the LSP never resets the registry between checks),
+      # leaking one program's parameter names into another's generated C.
+      # Embedding names here keeps distinct signatures distinct.
+      def self.type_signature(type)
+        case type
+        when Function
+          [:function, type.name, param_signature(type.params), type_signature(type.return_type), type_signature(type.receiver_type), type.receiver_editable, type.variadic, type.external]
+        when Proc
+          [:proc, param_signature(type.params), type_signature(type.return_type)]
+        when Nullable
+          [:nullable, type_signature(type.base)]
+        when GenericInstance
+          [:generic, type.name, type.arguments.map { |a| type_signature(a) }]
+        when Tuple
+          [:tuple, type.element_types.map { |t| type_signature(t) }, type.field_names]
+        when Span
+          [:span, type_signature(type.element_type)]
+        when Task
+          [:task, type_signature(type.result_type)]
+        else
+          type
+        end
+      end
+
       def self.param_signature(params)
-        params.map { |p| [p.name, p.type, p.mutable, p.passing_mode, p.boundary_type] }
+        params.map { |p| [p.name, type_signature(p.type), p.mutable, p.passing_mode, p.boundary_type] }
       end
 
       def self.function(name, params:, return_type:, receiver_type: nil, receiver_editable: false, variadic: false, external: false)
         params_frozen = params.freeze
         param_key = param_signature(params_frozen)
-        _intern([:function, name, param_key, return_type, receiver_type, receiver_editable, variadic, external]) {
+        _intern([:function, name, param_key, type_signature(return_type), type_signature(receiver_type), receiver_editable, variadic, external]) {
           Function.new(name, params: params_frozen, return_type: return_type, receiver_type: receiver_type, receiver_editable: receiver_editable, variadic: variadic, external: external)
         }
       end
@@ -62,7 +85,7 @@ module MilkTea
       def self.proc(params:, return_type:)
         params_frozen = params.freeze
         param_key = param_signature(params_frozen)
-        _intern([:proc, param_key, return_type]) { Proc.new(params: params_frozen, return_type: return_type) }
+        _intern([:proc, param_key, type_signature(return_type)]) { Proc.new(params: params_frozen, return_type: return_type) }
       end
 
       def self.parameter(name, type, mutable: false, passing_mode: :plain, boundary_type: nil)
@@ -74,15 +97,15 @@ module MilkTea
       def self.tuple(element_types, field_names: nil)
         et_frozen = element_types.freeze
         fn_frozen = field_names&.freeze
-        _intern([:tuple, et_frozen, fn_frozen]) { Tuple.new(et_frozen, field_names: fn_frozen) }
+        _intern([:tuple, et_frozen.map { |t| type_signature(t) }.freeze, fn_frozen]) { Tuple.new(et_frozen, field_names: fn_frozen) }
       end
 
       def self.soa(element_type, count:)
-        _intern([:soa, element_type, count]) { SoA.new(element_type, count: count) }
+        _intern([:soa, type_signature(element_type), count]) { SoA.new(element_type, count: count) }
       end
 
       def self.simd(element_type, lane_count:)
-        _intern([:simd, element_type, lane_count]) { Simd.new(element_type, lane_count: lane_count) }
+        _intern([:simd, type_signature(element_type), lane_count]) { Simd.new(element_type, lane_count: lane_count) }
       end
 
       def self.lifetime_ref(name)

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

@@ -1330,7 +1330,6 @@ module MilkTea
           end
           return nil unless idx && tokens[idx].type == :identifier
 
-          type_name = tokens[idx].lexeme
           type = resolve_arm_receiver_type(facts, tokens, idx)
 
           arm = if type.respond_to?(:arm)

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

@@ -86,7 +86,7 @@ module MilkTea
           rescue StandardError
             nil
           end
-          clear_shared_module_cache if previous_content != disk_content
+          @workspace.clear_shared_module_cache if previous_content != disk_content
           unless defined?(@pull_diagnostics_active) && @pull_diagnostics_active
             @protocol.write_notification('textDocument/publishDiagnostics', {
               uri: uri,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mt-lang
 version: !ruby/object:Gem::Version
-  version: 0.3.42
+  version: 0.3.43
 platform: ruby
 authors:
 - Long (Teefan) Tran
@@ -628,7 +628,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.42 installed!
+  Milk Tea 0.3.43 installed!
 
   System requirements:
     - A C compiler (gcc or clang) must be available on PATH