mt-lang 0.3.41 → 0.3.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91b5015b218da9925b56895b551063fca825ca776fc336fe898ef17e332aae4e
-  data.tar.gz: 46e4a2da80edfb7c64fc847ee10844c9f5d36572df35105ab6ed51e2455d347a
+  metadata.gz: 6842b1cfb6eac5181fdbcd31cd90dbb9f436bb0f3c7b0cc25d49a8c1f8e13a8b
+  data.tar.gz: 4e97091f3da86a115656c6ec7d9bb10fe5cd65360bd59a203fc6595111285aff
 SHA512:
-  metadata.gz: 0c1dcedaf98ef374c9dd21cded75f8512c755a63e4a3a155e494d9edf098b2d53da3b258edab5d63066a2a9eaa3c2a3883aa69241608509085caf398c1edecc1
-  data.tar.gz: a427c7ad0f2475b7dc5cccadcb6cc143ab195f906b7b9b13407a7e754043fd8550495c7dc750f5f27c92e2eca13477d9f6697650bddd515403526812b1dac06b
+  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.41"
+  VERSION = "0.3.43"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/bindings/bindgen/declaration.rb

@@ -280,11 +280,28 @@ module MilkTea
           qual_type = node.dig("type", "qualType")
           if macro_probe_declaration?(node) && qual_type.to_s.include?("typeof")
             node.dig("type", "desugaredQualType") || qual_type
+          elsif constant_typedef_alias_aggregate?(node)
+            node.dig("type", "desugaredQualType") || qual_type
           else
             qual_type
           end
         end
 
+        # A constant whose spelled type is a typedef alias that resolves to an
+        # aggregate (e.g. `typedef b3Vec3 b3Pos` followed by
+        # `static const b3Pos b3Pos_zero`) must lower against the underlying
+        # record, not the alias name, so init-list emission can find the
+        # aggregate declaration.
+        def constant_typedef_alias_aggregate?(node)
+          qual_type = node.dig("type", "qualType").to_s
+          spelled = strip_qualifiers(qual_type)
+          return false unless spelled.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+          return false if @aggregate_declarations.key?(spelled)
+
+          desugared = strip_qualifiers(node.dig("type", "desugaredQualType").to_s)
+          !desugared.empty? && desugared != spelled && desugared.match?(/\A(?:struct|union)\b/)
+        end
+
         def function_return_type(node)
           qual_type = type_qual_type(node)
           match = qual_type&.match(/\A(.+?)\s*\((?:.*)\)\z/)

data/lib/milk_tea/bindings/bindgen/emitter.rb

@@ -75,6 +75,11 @@ module MilkTea
           lines = [header]
           fields = Array(node["inner"]).select { |child| child["kind"] == "FieldDecl" }
           fields.each do |field|
+            anonymous_record = anonymous_record_decl_for_field(field, node)
+            if anonymous_record && field_unnamed?(field)
+              lines.concat(emit_flattened_anonymous_record(anonymous_record, owner_name: name))
+              next
+            end
             field_type = aggregate_field_type(field, owner_name: name, aggregate_node: node)
             mt_name = emitted_name(aggregate_field_name(field, aggregate_node: node))
             lines << "    #{mt_name}: #{field_type}"
@@ -82,6 +87,26 @@ module MilkTea
           lines
         end
 
+        # Anonymous union/struct members are flattened into the owning aggregate,
+        # matching C semantics where their fields are accessible directly on the
+        # enclosing type (e.g. `b3ChildShape.hull`, `b3TreeNode.children`).
+        def emit_flattened_anonymous_record(record, owner_name:)
+          Array(record["inner"]).select { |child| child["kind"] == "FieldDecl" }.flat_map do |field|
+            anonymous_record = anonymous_record_decl_for_field(field, record)
+            if anonymous_record && field_unnamed?(field)
+              emit_flattened_anonymous_record(anonymous_record, owner_name:)
+            else
+              field_type = aggregate_field_type(field, owner_name:, aggregate_node: record)
+              ["    #{emitted_name(field["name"])}: #{field_type}"]
+            end
+          end
+        end
+
+        def field_unnamed?(field)
+          name = field["name"]
+          name.nil? || name.empty?
+        end
+
         def bindgen_param_name(name)
           name = emitted_name(name)
           return [name, nil] unless generated_binding_name_conflict?(name)
@@ -110,6 +135,13 @@ module MilkTea
               anonymous_record = anonymous_record_decl_for_field(field, aggregate_node)
               next unless anonymous_record
 
+              if field_unnamed?(field)
+                # Anonymous member: flattened into the parent. Keep walking so
+                # named nested records still get synthesized.
+                pending << [owner_name, anonymous_record]
+                next
+              end
+
               synthetic_name = synthetic_aggregate_name(owner_name, field, aggregate_node)
               unless @synthetic_declarations.any? { |declaration| declaration[:name] == synthetic_name }
                 @synthetic_declarations << { kind: anonymous_record.fetch("tagUsed"), name: synthetic_name, node: anonymous_record }
@@ -140,12 +172,19 @@ module MilkTea
             seen[key] = true
 
             Array(aggregate_node["inner"]).select { |child| child["kind"] == "FieldDecl" }.each do |field|
-              aggregate_field_type(field, owner_name:, aggregate_node:)
-
               anonymous_record = anonymous_record_decl_for_field(field, aggregate_node)
-              next unless anonymous_record
+              if anonymous_record
+                if field_unnamed?(field)
+                  # Flattened anonymous member: walk its fields under the owner.
+                  pending << [owner_name, anonymous_record]
+                  next
+                end
+
+                pending << [synthetic_aggregate_name(owner_name, field, aggregate_node), anonymous_record]
+                next
+              end
 
-              pending << [synthetic_aggregate_name(owner_name, field, aggregate_node), anonymous_record]
+              aggregate_field_type(field, owner_name:, aggregate_node:)
             end
           end
         end
@@ -155,7 +194,7 @@ module MilkTea
           return override if override
 
           anonymous_record = anonymous_record_decl_for_field(field, aggregate_node)
-          return synthetic_aggregate_name(owner_name, field, aggregate_node) if anonymous_record
+          return synthetic_aggregate_name(owner_name, field, aggregate_node) if anonymous_record && !field_unnamed?(field)
 
           map_type_node(field, context: "field #{owner_name}.#{field["name"]}")
         end

data/lib/milk_tea/bindings/imported_bindings/defaults.rb

@@ -60,6 +60,13 @@ module MilkTea
           raw_module_name: "std.c.box2d",
           policy_path: root.join("bindings/imported/box2d.binding.json"),
         ),
+        Binding.new(
+          name: "box3d",
+          module_name: "std.box3d",
+          binding_path: root.join("std/box3d.mt"),
+          raw_module_name: "std.c.box3d",
+          policy_path: root.join("bindings/imported/box3d.binding.json"),
+        ),
         Binding.new(
           name: "cjson",
           module_name: "std.cjson",

data/lib/milk_tea/bindings/raw_bindings/defaults.rb

@@ -11,6 +11,8 @@ module MilkTea
       vendored_glfw_library = vendored_glfw.library(root:)
       vendored_box2d = MilkTea::VendoredBox2D
       vendored_box2d_library = vendored_box2d.library(root:)
+      vendored_box3d = MilkTea::VendoredBox3D
+      vendored_box3d_library = vendored_box3d.library(root:)
       vendored_cjson = MilkTea::VendoredCJSON
       vendored_cjson_library = vendored_cjson.library(root:)
       vendored_flecs = MilkTea::VendoredFlecs
@@ -960,6 +962,26 @@ module MilkTea
             vendored_box2d.header_root(root:).join("box2d.h").to_s,
           ],
         ),
+        Binding.new(
+          name: "box3d",
+          module_name: "std.c.box3d",
+          binding_path: root.join("std/c/box3d.mt"),
+          include_directives: ["box3d/box3d.h"],
+          link_libraries: ["box3d"],
+          vendored_library: vendored_box3d_library,
+          clang_args: vendored_box3d.include_flags(root:),
+          compiler_flags: vendored_box3d.include_flags(root:),
+          tracked_header_paths: [
+            vendored_box3d.header_root(root:).join("box3d.h").to_s,
+          ],
+          tracked_header_prefixes: [
+            vendored_box3d.header_root(root:).to_s,
+          ],
+          declaration_name_prefixes: ["b3", "B3_"],
+          header_candidates: [
+            vendored_box3d.header_root(root:).join("box3d.h").to_s,
+          ],
+        ),
         Binding.new(
           name: "cjson",
           module_name: "std.c.cjson",

data/lib/milk_tea/bindings/upstream_sources.rb

@@ -195,6 +195,15 @@ module MilkTea
             include/box2d/box2d.h
           ],
         ),
+        Source.new(
+          name: "box3d",
+          checkout_root: data.join("third_party/box3d-upstream"),
+          repository_url: "https://github.com/erincatto/box3d.git",
+          revision: "30c67b5e6d0a3a66f0f506c69ce9e9e0587e3b7c",
+          sentinel_paths: %w[
+            include/box3d/box3d.h
+          ],
+        ),
         Source.new(
           name: "cjson",
           checkout_root: data.join("third_party/cjson-upstream"),

data/lib/milk_tea/bindings/vendored_box3d.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "vendored_c_library"
+
+module MilkTea
+  module VendoredBox3D
+    Error = VendoredCLibrary::Error
+
+    CONFIGURE_ARGS = %w[
+      -DCMAKE_BUILD_TYPE=Release
+      -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+      -DBUILD_SHARED_LIBS=OFF
+      -DBOX3D_SAMPLES=OFF
+      -DBOX3D_BENCHMARKS=OFF
+      -DBOX3D_DOCS=OFF
+      -DBOX3D_PROFILE=OFF
+      -DBOX3D_VALIDATE=OFF
+      -DBOX3D_UNIT_TESTS=OFF
+    ].freeze
+
+    SYSTEM_LINK_FLAGS = %w[
+      -lm
+    ].freeze
+
+    def self.library(root: MilkTea.root)
+      resolved_root = Pathname.new(File.expand_path(root.to_s))
+      @libraries ||= {}
+      @libraries[resolved_root.to_s] ||= VendoredCLibrary::CMake.new(
+        name: "box3d",
+        source_root: source_root(root: resolved_root),
+        build_root: build_root(root: resolved_root),
+        install_root: install_root(root: resolved_root),
+        archive_path: archive_path(root: resolved_root),
+        include_roots: [include_root(root: resolved_root)],
+        configure_args: CONFIGURE_ARGS,
+        system_link_flags: SYSTEM_LINK_FLAGS,
+        cc_env_var: "BOX3D_CC",
+      )
+    end
+
+    def self.source_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("third_party/box3d-upstream")
+    end
+
+    def self.include_root(root: MilkTea.root)
+      source_root(root:).join("include")
+    end
+
+    def self.header_root(root: MilkTea.root)
+      include_root(root:).join("box3d")
+    end
+
+    def self.build_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-box3d")
+    end
+
+    def self.install_root(root: MilkTea.root)
+      MilkTea.writable_root_for(root).join("tmp/vendored-box3d-prefix")
+    end
+
+    def self.archive_path(root: MilkTea.root)
+      install_root(root:).join("lib/libbox3d.a")
+    end
+
+    def self.include_flags(root: MilkTea.root)
+      library(root:).include_flags
+    end
+
+    def self.link_flags(root: MilkTea.root)
+      library(root:).link_flags
+    end
+
+    def self.prepare!(root: MilkTea.root, **kwargs)
+      library(root:).prepare!(**kwargs)
+    end
+  end
+end

data/lib/milk_tea/bindings.rb

@@ -11,6 +11,7 @@ require_relative "bindings/vendored_raylib"
 require_relative "bindings/vendored_sdl3"
 require_relative "bindings/vendored_glfw"
 require_relative "bindings/vendored_box2d"
+require_relative "bindings/vendored_box3d"
 require_relative "bindings/vendored_cjson"
 require_relative "bindings/vendored_flecs"
 require_relative "bindings/vendored_libuv"

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

@@ -17,7 +17,7 @@ module MilkTea
           if (alias_name = checked_index_alias(expression))
             "(*#{alias_name})"
           else
-            "(*#{checked_array_index_helper_name(expression.receiver_type)}(#{emit_address_of_operand(expression.receiver)}, #{emit_expression(expression.index)}))"
+            "(*#{checked_array_index_helper_name(expression.receiver_type)}(#{emit_checked_array_index_argument(expression.receiver)}, #{emit_expression(expression.index)}))"
           end
         when IR::CheckedSpanIndex
           if (alias_name = checked_index_alias(expression))
@@ -26,7 +26,7 @@ module MilkTea
             "(*#{checked_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)}))"
           end
         when IR::NullableIndex
-          "#{nullable_array_index_helper_name(expression.receiver_type)}(#{emit_address_of_operand(expression.receiver)}, #{emit_expression(expression.index)})"
+          "#{nullable_array_index_helper_name(expression.receiver_type)}(#{emit_checked_array_index_argument(expression.receiver)}, #{emit_expression(expression.index)})"
         when IR::NullableSpanIndex
           "#{nullable_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)})"
         when IR::Call
@@ -81,7 +81,7 @@ module MilkTea
           case expression.expression
           when IR::CheckedIndex
             alias_name = checked_index_alias(expression.expression)
-            alias_name || "#{checked_array_index_helper_name(expression.expression.receiver_type)}(#{emit_address_of_operand(expression.expression.receiver)}, #{emit_expression(expression.expression.index)})"
+            alias_name || "#{checked_array_index_helper_name(expression.expression.receiver_type)}(#{emit_checked_array_index_argument(expression.expression.receiver)}, #{emit_expression(expression.expression.index)})"
           when IR::CheckedSpanIndex
             alias_name = checked_index_alias(expression.expression)
             alias_name || "#{checked_span_index_helper_name(expression.expression.receiver_type)}(#{emit_expression(expression.expression.receiver)}, #{emit_expression(expression.expression.index)})"
@@ -344,6 +344,16 @@ module MilkTea
         "(void)#{wrap_expression(expression)}"
       end
 
+      def emit_checked_array_index_argument(receiver)
+        if receiver.is_a?(IR::Unary) && receiver.operator == "*"
+          emit_expression(receiver.operand)
+        elsif c_expression_lvalue?(receiver)
+          emit_expression(receiver)
+        else
+          "&(#{c_type(receiver.type)}[1]){ #{emit_expression(receiver)} }[0]"
+        end
+      end
+
       def emit_address_of_operand(expression)
         return emit_expression(expression.operand) if expression.is_a?(IR::Unary) && expression.operator == "*"
 
@@ -490,8 +500,14 @@ module MilkTea
       def emit_cyclic_array_initializer(field_type, value)
         elem_c_name = c_type(array_element_type(field_type))
         elem_count = array_length(field_type)
-        elements = value.is_a?(IR::ArrayLiteral) ? value.elements.map { |e| emit_initializer(e) }.join(", ") : ""
-        "((#{elem_c_name}*)memcpy(malloc(#{elem_count} * sizeof(#{elem_c_name})), &(#{elem_c_name}[#{elem_count}]){ #{elements} }, #{elem_count} * sizeof(#{elem_c_name})))"
+        source_expr = if value.is_a?(IR::ArrayLiteral)
+          "&(#{elem_c_name}[#{elem_count}]){ #{value.elements.map { |e| emit_initializer(e) }.join(", ")} }"
+        elsif c_expression_lvalue?(value)
+          "&(#{emit_expression(value)})"
+        else
+          "&(#{elem_c_name}[#{elem_count}]){ #{emit_expression(value)} }"
+        end
+        "((#{elem_c_name}*)memcpy(malloc(#{elem_count} * sizeof(#{elem_c_name})), #{source_expr}, #{elem_count} * sizeof(#{elem_c_name})))"
       end
 
       def emit_cyclic_struct_initializer(field_type, value)

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]) }
+          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