mt-lang 0.3.34 → 0.3.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d0786ef5ca9025e069a44b7ea3915199110e1f2397d294ed81122a308c79e2e
-  data.tar.gz: 42e3fa0077192377fa7da61cea865fd04e8ef49d66343c71a1bd5e2e1caa8b59
+  metadata.gz: 84f8e5a5913811a35cd5cd470c43f3827aee62bfe5b151add730d45fe341bee2
+  data.tar.gz: fd76e0d6f88abfe0fda004829430effc5b7030957754b6d3d3eebbd6739b96b5
 SHA512:
-  metadata.gz: fd4a874279ff48b7d0f1de8baf092e92e01ede8a4c969133855c9dd9c9f061490c11ff29dfc24905466fe1df56d1d53a86a5c156ce1cbe5efeed60d78f5a21e8
-  data.tar.gz: 30bb123ddb1939f7694c62dae186152b8f592d78826e7b4aa416c6a010202d07bda5474b72014114d8064b7168ff02b6b7dd252a8b7d007d9b9bcae8b31b4786
+  metadata.gz: cc533975db0511ab0f5ac62887ec101ebae699841d3cdbc5079faf1e2a0be877e1ceb71d56b3605ca7c37c60c43019fd3288e690325a21cf87806ca2cff138b5
+  data.tar.gz: 89d0efc35e9bfec7c1d9c5a612e2f136d3c6fd8f80259f88a657ac46be896ff79c43c0810f98eba8312139151c343c59205b2a3b5fd72af60d2de2fdfc0fd16a

data/README.md

@@ -939,7 +939,7 @@ See module source for full method surface. Iterator forms:
 
 Text categories:
 
-- `str` -> string view. The `+` operator concatenates two `str` values, allocating a new heap-backed string. For loops or repeated concatenation, prefer `string.String` for amortized performance.
+- `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.
 - `cstr` -> C ABI string
 - `str_buffer[N]` -> fixed-capacity mutable UTF-8 text buffer
 
@@ -959,7 +959,7 @@ Format strings:
 
 - `f"count=#{count}"` has type `str`.
 - Allowed interpolations: `str`, `cstr`, `bool`, numeric primitives, integer-backed enums and flags, plus types implementing `format_len() -> ptr_uint` and `append_format(output: ref[std.string.String]) -> void`.
-- `f"..."` is a borrowed temporary on the stack — it cannot be returned from a function as `str`. Use `std.fmt.format(f"...")` returning `string.String` when ownership must escape.
+- Dynamic `f"..."` expressions build into a heap-backed temporary that the compiler releases after use. A dynamic `f"..."` may be returned from a function (or stored in a `str` local): ownership of that buffer transfers to the caller. `std.fmt.format(f"...")` returns an owned `string.String` when you want explicit owned-text lifetime management.
 - Float and double interpolations support `:.N` precision.
 - Integer primitive and integer-backed enum/flags interpolations support `:x` (lowercase hex) and `:X` (uppercase hex).
 - Integer primitive and integer-backed enum/flags interpolations support `:o` / `:O` (octal) and `:b` / `:B` (binary).

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, allocating a new heap-backed string.</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>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>
@@ -1871,7 +1871,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)</td></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>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>
@@ -1889,9 +1889,9 @@ let info = f"value=#{pi:.4}"
 ## Hex format for ints
 let hex = f"address=#{ptr_value:x}"
 
-## Owned text (escape stack lifetime)
+## Owned text with explicit release
 import std.fmt
-let owned = fmt.format(f"count=#{count}")  ## -> string.String</code></pre>
+let owned = fmt.format(f"count=#{count}")  ## -> string.String (call .release())</code></pre>
 </div>
   <p>Interpolated expressions must be <code>str</code>, <code>cstr</code>, <code>bool</code>, a numeric primitive, an integer-backed enum or flags type, or a type implementing <code>format_len()</code> and <code>append_format()</code> (custom formatting hooks). The compiler lowers <code>fmt.format(f"...")</code>, <code>str_buffer.append_format(f"...")</code>, and <code>string.String.append_format(f"...")</code> directly to the formatted output without an intermediate allocation.</p>
 
@@ -2242,7 +2242,7 @@ function attach(window: ref[Window]) -> Result[void, EventError]:
       <tr><td><code>std.gzip</code> <code>std.tar</code></td><td>Compression</td></tr>
       <tr><td><code>std.sync</code> <code>std.thread</code> <code>std.jobs</code></td><td>Concurrency</td></tr>
       <tr><td><code>std.fsm</code> <code>std.goap</code> <code>std.behavior_tree</code></td><td>AI / State machines</td></tr>
-      <tr><td><code>std.cell</code></td><td>Shared mutable cell allocation</td></tr>
+      <tr><td><code>std.box</code></td><td>Explicit single-value heap storage for shared mutable state</td></tr>
     </table>
   </div>
 </section>

data/docs/language-design.md

@@ -28,7 +28,7 @@ The output target is beautiful C. The generated C should be readable enough that
 - No macro system that rewrites arbitrary ASTs
 - No garbage collector
 - No implicit conversions between unrelated primitive types
-- No user-invisible allocation for strings, collections, ordinary values, or method calls. Capturing a `proc` may allocate a ref-counted closure environment as part of proc value semantics; owned text and other storage use explicit allocating surfaces.
+- No user-invisible allocation for collections, ordinary values, or method calls. Capturing a `proc` may allocate a ref-counted closure environment as part of proc value semantics. Dynamic format strings are the one text case that builds a heap-backed temporary, released after use (see the text-construction rule in §1); other owned text and storage use explicit allocating surfaces.
 
 ## Design rules
 
@@ -38,7 +38,7 @@ If code allocates, takes an address, dereferences a raw pointer, performs an FFI
 
 FFI visibility belongs at the declaration site. Raw `external` files expose exact ABI types. Imported foreign declarations may project those raw types into ordinary Milk Tea types, but the projection rule, temporary-storage rule, and ownership rule must be declared there instead of repeated at every call site.
 
-The same rule applies to text construction. Plain string literals and format string literals are borrowed `str` values. The `+` operator on `str` allocates a new heap-backed `str` — the one everyday convenience that does allocate. For loops or amortized building, `string.String` and `str_buffer[N]` remain the explicit surfaces with visible cost. Any other surface that builds owned text must say so explicitly, for example `std.fmt.format(f"...")` when ownership must escape.
+The same rule applies to text construction. Plain string literals are borrowed `str` values. A dynamic format string `f"..."` builds into a heap-backed temporary that the compiler releases after the surrounding statement; returning it (or storing it in a `str` local) transfers ownership of that buffer to the caller. The `+` operator on `str` concatenates into a per-thread scratch buffer without allocating — the result is a borrowed `str` valid until that buffer's budget is exhausted. For loops or amortized building, and whenever ownership should stay explicit and controllable, `string.String` and `str_buffer[N]` remain the explicit surfaces with visible cost; `std.fmt.format(f"...")` is the explicit owned-text path returning a `string.String`.
 
 ### 2. C is the ABI ground truth
 
@@ -762,7 +762,7 @@ Built-in operators should match familiar C behavior where possible:
 
 No user-defined operator overloading.
 
-The `+` operator also concatenates two `str` values, allocating a new heap-backed string; `cstr` values are not concatenable. This is the one operator exception to the arithmetic rules, and it is described in the text-construction rule under Design rules §1.
+The `+` operator also concatenates two `str` values into a per-thread scratch buffer, returning a borrowed `str`; `cstr` values are not concatenable. This is the one operator exception to the arithmetic rules, and it is described in the text-construction rule under Design rules §1.
 
 Built-in vector, matrix, and quaternion types support component-wise arithmetic with the standard operators:
 

data/docs/language-manual.md

@@ -1072,7 +1072,7 @@ Rules:
 11. `+`, `-`
 12. `*`, `/`, `%`
 
-The `+` operator also concatenates two `str` operands, producing a new heap-backed `str` (§2.3). It does not concatenate `cstr` or mixed `str`/`cstr` operands.
+The `+` operator also concatenates two `str` operands into a per-thread scratch buffer, producing a borrowed `str` (no heap allocation) whose validity is bounded by the scratch buffer budget (§2.3). It does not concatenate `cstr` or mixed `str`/`cstr` operands.
 
 ### 5.4 Assignment operators
 

data/lib/milk_tea/base.rb

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

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

@@ -22,8 +22,14 @@ module MilkTea
                 "cstr"
               else
                 pointee = pointer_candidate.sub(/\s*\*\z/, "")
-                pointer_name = top_level_const_qualified?(pointee) ? "const_ptr" : "ptr"
-                "#{pointer_name}[#{map_c_type(pointee, context:)}]"
+                if function_type_typedef?(pointee)
+                  # `Name *` where Name is a function-type typedef is a function
+                  # pointer, which is exactly what the `fn` type already is.
+                  map_c_type(pointee, context:)
+                else
+                  pointer_name = top_level_const_qualified?(pointee) ? "const_ptr" : "ptr"
+                  "#{pointer_name}[#{map_c_type(pointee, context:)}]"
+                end
               end
             else
               unqualified = strip_qualifiers(normalized)
@@ -515,6 +521,10 @@ module MilkTea
           qual_type.end_with?("*")
         end
 
+        def function_type_typedef?(qual_type)
+          @function_type_typedef_names.include?(strip_qualifiers(qual_type))
+        end
+
         def c_string_pointer?(qual_type)
           pointee = qual_type.sub(/\s*\*\z/, "")
           unqualified = strip_qualifiers(pointee)

data/lib/milk_tea/bindings/bindgen.rb

@@ -147,6 +147,11 @@ module MilkTea
         @visible_typedef_names = top_level_nodes.filter_map do |node|
           node["name"] if node["kind"] == "TypedefDecl" && allowed_declaration_name?(node["name"])
         end
+        @function_type_typedef_names = top_level_nodes.filter_map do |node|
+          if node["kind"] == "TypedefDecl" && allowed_declaration_name?(node["name"]) && extract_function_proto(node) && !function_pointer_type?(type_qual_type(node))
+            node["name"]
+          end
+        end
         build_alias_maps(top_level_nodes)
 
         declarations = []

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

@@ -139,6 +139,8 @@ module MilkTea
           end
         when Types::Task
           [task_type_name(type)]
+        when Types::Dyn
+          [dyn_type_name(type)]
         when Types::Proc
           [proc_type_name(type)]
         when Types::GenericInstance
@@ -153,6 +155,8 @@ module MilkTea
           end
         when Types::Function
           []
+        when Types::Tuple
+          [tuple_type_name(type)]
         when Types::Struct, Types::StructInstance, Types::Union, Types::Variant, Types::VariantInstance, Types::Event, Types::Subscription
           [named_type_c_name(type)]
         when Types::VariantArmPayload

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

@@ -347,7 +347,22 @@ module MilkTea
       def emit_address_of_operand(expression)
         return emit_expression(expression.operand) if expression.is_a?(IR::Unary) && expression.operator == "*"
 
-        "&#{wrap_expression(expression)}"
+        return "&#{wrap_expression(expression)}" if c_expression_lvalue?(expression)
+
+        "&(#{c_type(expression.type)}[1]){ #{emit_expression(expression)} }[0]"
+      end
+
+      def c_expression_lvalue?(expression)
+        case expression
+        when IR::Name, IR::CheckedIndex, IR::CheckedSpanIndex, IR::AggregateLiteral, IR::ArrayLiteral, IR::VariantLiteral, IR::ZeroInit
+          true
+        when IR::Member, IR::Index
+          c_expression_lvalue?(expression.receiver)
+        when IR::Unary
+          expression.operator == "*"
+        else
+          false
+        end
       end
 
       def emit_cast_operand(expression)
@@ -464,7 +479,12 @@ module MilkTea
       def emit_addressof_field_initializer(field_type, value)
         c_type_name = named_type_c_name(field_type)
         inner = value.expression
-        "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), &(#{emit_expression(inner)}), sizeof(#{c_type_name})))"
+        source = if c_expression_lvalue?(inner)
+          "&(#{emit_expression(inner)})"
+        else
+          "&(#{c_type(field_type)}[1]){ #{emit_expression(inner)} }[0]"
+        end
+        "((#{c_type_name}*)memcpy(malloc(sizeof(#{c_type_name})), #{source}, sizeof(#{c_type_name})))"
       end
 
       def emit_cyclic_array_initializer(field_type, value)
@@ -479,8 +499,10 @@ module MilkTea
         init = emit_initializer(value)
         source_expr = if init.start_with?("{")
           "&(#{c_type(field_type)})#{init}"
-        else
+        elsif c_expression_lvalue?(value)
           "&(#{init})"
+        else
+          "&(#{c_type(field_type)}[1]){ #{init} }[0]"
         end
         "((#{field_c_name}*)memcpy(malloc(sizeof(#{field_c_name})), #{source_expr}, sizeof(#{field_c_name})))"
       end

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

@@ -104,7 +104,17 @@ module MilkTea
       def emit_struct_equality_helpers
         struct_decls_by_linkage = (emitted_aggregate_structs + collect_generic_struct_decls).each_with_object({}) { |decl, map| map[decl.linkage_name] = decl }
         struct_equality_types
-          .filter_map { |type| type.is_a?(Types::VariantArmPayload) ? type : struct_decls_by_linkage[named_type_c_name(type)] }
+          .filter_map do |type|
+            if type.is_a?(Types::VariantArmPayload)
+              type
+            elsif struct_decls_by_linkage.key?(named_type_c_name(type))
+              struct_decls_by_linkage[named_type_c_name(type)]
+            elsif type.is_a?(Types::Struct)
+              # External structs (raw ABI bindings) are not lowered into
+              # @program.structs, but their field layout is still known.
+              type
+            end
+          end
           .flat_map { |decl_or_type| emit_struct_equality_helper(decl_or_type) }
       end
 
@@ -112,11 +122,14 @@ module MilkTea
         if struct_decl_or_type.is_a?(IR::StructDecl)
           outer_c = struct_decl_or_type.linkage_name
           fields = struct_decl_or_type.fields
-        else
+        elsif struct_decl_or_type.is_a?(Types::VariantArmPayload)
           payload = struct_decl_or_type
           outer_c = named_type_c_name(payload)
           arm_fields = payload.variant_type.arm(payload.arm_name) || {}
           fields = arm_fields.map { |name, field_type| IR::Field.new(name:, type: field_type) }
+        else
+          outer_c = named_type_c_name(struct_decl_or_type)
+          fields = struct_decl_or_type.fields.map { |name, field_type| IR::Field.new(name:, type: field_type) }
         end
 
         lines = ["static bool mt_struct_eq_#{outer_c}(struct #{outer_c} left, struct #{outer_c} right) {"]

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

@@ -266,6 +266,10 @@ module MilkTea
         simd_types = []
         visited = {}
 
+        all_emitted_top_level_values.each do |value|
+          collect_simd_type(value.type, simd_types, visited)
+        end
+
         emitted_functions.each do |function|
           collect_simd_type(function.return_type, simd_types, visited)
           function.params.each do |param|
@@ -280,6 +284,16 @@ module MilkTea
           end
         end
 
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_simd_type(field.type, simd_types, visited)
+          end
+        end
+
+        each_variant_arm_field_type do |field_type|
+          collect_simd_type(field_type, simd_types, visited)
+        end
+
         simd_types.uniq
       end
 
@@ -299,9 +313,32 @@ module MilkTea
         return unless type
         return if visited[type]
 
-        if type.is_a?(Types::Simd)
+        visited[type] = true
+
+        case type
+        when Types::Simd
           simd_types << type
-          visited[type] = true
+        when Types::Nullable
+          collect_simd_type(type.base, simd_types, visited)
+        when Types::GenericInstance
+          type.arguments.each do |argument|
+            collect_simd_type(argument, simd_types, visited) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+        when Types::Function
+          type.params.each do |param|
+            collect_simd_type(param.type, simd_types, visited)
+          end
+          collect_simd_type(type.return_type, simd_types, visited)
+        when Types::Struct, Types::Union
+          type.fields.each_value do |field_type|
+            collect_simd_type(field_type, simd_types, visited)
+          end
+        when Types::Variant
+          type.arm_names.each do |arm_name|
+            type.arm(arm_name).each_value do |field_type|
+              collect_simd_type(field_type, simd_types, visited)
+            end
+          end
         end
       end
 

data/lib/milk_tea/core/compile_time.rb

@@ -78,6 +78,10 @@ module MilkTea
           nil
         when AST::ExpressionList
           expression.elements.filter_map { |element| evaluate(element) }
+        when AST::RangeExpr
+          start_val = evaluate(expression.start_expr)
+          end_val = evaluate(expression.end_expr)
+          start_val.is_a?(Integer) && end_val.is_a?(Integer) ? (start_val...end_val).to_a : nil
         when AST::IntegerLiteral, AST::FloatLiteral, AST::BooleanLiteral
           expression.value
         when AST::StringLiteral
@@ -184,6 +188,8 @@ module MilkTea
         right = evaluate(expression.right)
 
         case expression.operator
+        when ".."
+          left.is_a?(Integer) && right.is_a?(Integer) ? (left...right).to_a : nil
         when "=="
           CompileTime.equality_result(left, right)
         when "!="
@@ -243,35 +249,41 @@ module MilkTea
         result = nil
 
         statements.each do |statement|
-          case statement
-          when AST::LocalDecl
-            result = evaluate_local_decl(statement, scopes:)
-          when AST::ReturnStmt
-            value = statement.value ? evaluate_expression(statement.value, scopes:) : nil
-            raise ReturnValue.new(value)
-          when AST::WhileStmt
-            result = evaluate_while(statement, scopes:)
-          when AST::ForStmt
-            result = evaluate_for(statement, scopes:)
-          when AST::Assignment
-            result = evaluate_assignment(statement, scopes:)
-          when AST::IfStmt
-            result = evaluate_if(statement, scopes:)
-          when AST::ExpressionStmt
-            evaluate_expression(statement.expression, scopes:)
-          when AST::PassStmt, AST::BreakStmt, AST::ContinueStmt
-            # no-op at compile time
-          when AST::EmitStmt
-            # evaluated during lowering
-            result = nil
-          else
-            result = nil
-          end
+          result = evaluate_statement(statement, scopes:)
         end
 
         result
       end
 
+      def evaluate_statement(statement, scopes:)
+        case statement
+        when AST::LocalDecl
+          evaluate_local_decl(statement, scopes:)
+        when AST::ReturnStmt
+          value = statement.value ? evaluate_expression(statement.value, scopes:) : nil
+          raise ReturnValue.new(value)
+        when AST::WhileStmt
+          evaluate_while(statement, scopes:)
+        when AST::ForStmt
+          evaluate_for(statement, scopes:)
+        when AST::MatchStmt
+          evaluate_match(statement, scopes:)
+        when AST::Assignment
+          evaluate_assignment(statement, scopes:)
+        when AST::IfStmt
+          evaluate_if(statement, scopes:)
+        when AST::ExpressionStmt
+          evaluate_expression(statement.expression, scopes:)
+        when AST::PassStmt, AST::BreakStmt, AST::ContinueStmt
+          # no-op at compile time
+        when AST::EmitStmt
+          # emitted declarations are collected during lowering
+          nil
+        else
+          nil
+        end
+      end
+
       def evaluate_expression(expression, scopes:)
         case expression
         when AST::Identifier
@@ -304,11 +316,34 @@ module MilkTea
         value = evaluate_expression(assignment.value, scopes:)
         case assignment.target
         when AST::Identifier
+          if assignment.operator != "="
+            current = @variables[assignment.target.name]
+            value = apply_compile_time_binary(assignment.operator.chomp("="), current, value)
+          end
           @variables[assignment.target.name] = value
         end
         value
       end
 
+      def apply_compile_time_binary(operator, left, right)
+        case operator
+        when "+" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left + right : nil
+        when "-" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left - right : nil
+        when "*" then left.is_a?(Numeric) && right.is_a?(Numeric) ? left * right : nil
+        when "/" then left.is_a?(Numeric) && right.is_a?(Numeric) && !zero_numeric?(right) ? left / right : nil
+        when "%" then left.is_a?(Integer) && right.is_a?(Integer) && !right.zero? ? left % right : nil
+        when "&" then left.is_a?(Integer) && right.is_a?(Integer) ? left & right : nil
+        when "|" then left.is_a?(Integer) && right.is_a?(Integer) ? left | right : nil
+        when "^" then left.is_a?(Integer) && right.is_a?(Integer) ? left ^ right : nil
+        when "<<" then left.is_a?(Integer) && right.is_a?(Integer) ? left << right : nil
+        when ">>" then left.is_a?(Integer) && right.is_a?(Integer) ? left >> right : nil
+        end
+      end
+
+      def zero_numeric?(value)
+        (value.is_a?(Integer) && value.zero?) || (value.is_a?(Float) && value.zero?)
+      end
+
       def evaluate_while(statement, scopes:)
         result = nil
         iterations = 0
@@ -319,17 +354,7 @@ module MilkTea
           break unless condition
           break unless CompileTime.boolean_value?(condition)
 
-          statement.body.each do |body_stmt|
-            case body_stmt
-            when AST::ReturnStmt
-              value = body_stmt.value ? evaluate_expression(body_stmt.value, scopes:) : nil
-              raise ReturnValue.new(value)
-            when AST::Assignment
-              evaluate_assignment(body_stmt, scopes:)
-            when AST::ExpressionStmt
-              evaluate_expression(body_stmt.expression, scopes:)
-            end
-          end
+          statement.body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
           iterations += 1
         end
 
@@ -347,21 +372,7 @@ module MilkTea
 
         iterable.each do |element|
           @variables[loop_var_name] = element
-          statement.body.each do |body_stmt|
-            case body_stmt
-            when AST::ReturnStmt
-              value = body_stmt.value ? evaluate_expression(body_stmt.value, scopes:) : nil
-              raise ReturnValue.new(value)
-            when AST::Assignment
-              evaluate_assignment(body_stmt, scopes:)
-            when AST::ExpressionStmt
-              evaluate_expression(body_stmt.expression, scopes:)
-            when AST::IfStmt
-              result = evaluate_if(body_stmt, scopes:)
-            when AST::WhileStmt
-              result = evaluate_while(body_stmt, scopes:)
-            end
-          end
+          statement.body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
         end
 
         result
@@ -371,32 +382,27 @@ module MilkTea
         statement.branches.each do |branch|
           condition = evaluate_expression(branch.condition, scopes:)
           if CompileTime.boolean_value?(condition) && condition
-            branch.body.each do |body_stmt|
-              case body_stmt
-              when AST::ReturnStmt
-                value = body_stmt.value ? evaluate_expression(body_stmt.value, scopes:) : nil
-                raise ReturnValue.new(value)
-              when AST::Assignment
-                evaluate_assignment(body_stmt, scopes:)
-              when AST::ExpressionStmt
-                evaluate_expression(body_stmt.expression, scopes:)
-              end
-            end
+            branch.body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
             return condition
           end
         end
 
         if statement.else_body
-          statement.else_body.each do |body_stmt|
-            case body_stmt
-            when AST::ReturnStmt
-              value = body_stmt.value ? evaluate_expression(body_stmt.value, scopes:) : nil
-              raise ReturnValue.new(value)
-            when AST::Assignment
-              evaluate_assignment(body_stmt, scopes:)
-            when AST::ExpressionStmt
-              evaluate_expression(body_stmt.expression, scopes:)
-            end
+          statement.else_body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
+        end
+
+        nil
+      end
+
+      def evaluate_match(statement, scopes:)
+        scrutinee = evaluate_expression(statement.expression, scopes:)
+        return nil unless scrutinee
+
+        statement.arms.each do |arm|
+          wildcard = arm.pattern.is_a?(AST::Identifier) && arm.pattern.name == "_"
+          if wildcard || CompileTime.equality_result(scrutinee, evaluate_expression(arm.pattern, scopes:)) == true
+            arm.body.each { |body_stmt| evaluate_statement(body_stmt, scopes:) }
+            return scrutinee
           end
         end
 
@@ -506,7 +512,7 @@ module MilkTea
       end
 
       def self.core_member_handles(type)
-        type.members.map { |name, value| Types::MemberHandle.new(nil, name, value) }
+        type.members.map { |name| Types::MemberHandle.new(nil, name, type.member_value(name)) }
       end
 
       def self.core_evaluate_type_returning(

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

@@ -186,6 +186,7 @@ module MilkTea
             mutable: false,
             pointer: false,
             const_value: element,
+            substitute_const_value: true,
           )
           emit_stmts, other_stmts = statement.body.partition { |s| s.is_a?(AST::EmitStmt) }
           emit_stmts.each do |emit_stmt|
@@ -486,13 +487,11 @@ module MilkTea
           expected_type: return_type,
           contextual_int_to_float: contextual_int_to_float_target?(return_type),
         ) : nil
-        if prepared_cleanups.any? && cstr_trackable_type?(return_type)
-          raise LoweringError.new("formatted string temporaries cannot be returned as borrowed text; use std.fmt.format(f\"...\") when ownership must escape",
-            line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
-        end
-
         prepared_cleanup_list = prepared_cleanups.flat_map(&:itself)
-        if prepared_cleanup_list.any? && return_type.is_a?(Types::Struct) && struct_contains_string_field?(return_type)
+        if prepared_cleanup_list.any? && (cstr_trackable_type?(return_type) ||
+                                          (return_type.is_a?(Types::Struct) && struct_contains_string_field?(return_type)))
+          # A dynamic f-string temp owns its heap buffer; returning it transfers
+          # ownership to the caller, so the format release must not run.
           prepared_cleanup_list = prepared_cleanup_list.reject { |stmt| stmt.is_a?(IR::ExpressionStmt) && stmt.expression.is_a?(IR::Call) && stmt.expression.callee == "mt_format_str_release" }
         end
         cleanup = prepared_cleanup_list + cleanup_statements(local_defers, active_defers)
@@ -793,7 +792,7 @@ module MilkTea
             else_body: nil,
           )
         end
-        local_defers.concat(prepared_cleanups)
+        local_defers.concat(reject_format_releases_for_assignment(prepared_cleanups, storage_type))
         if contains_proc_storage_type?(storage_type)
           local_value = IR::Name.new(name: linkage_name, type: storage_type, pointer: false)
           local_defers << lower_proc_nullable_release_statements(local_value, storage_type)

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

@@ -23,6 +23,7 @@ module MilkTea
         expanded_declarations.grep(AST::ConstDecl).filter_map do |decl|
           type = @ctx.values.fetch(decl.name).type
           const_value = @ctx.values.fetch(decl.name).const_value
+          ensure_registered_storage_type_types(type)
 
           next if type == Types::BUILTIN_TYPE_META_TYPE
 
@@ -35,7 +36,7 @@ module MilkTea
               value = lower_const_value_literal(type, const_value)
             end
           elsif decl.block_body || decl.value.is_a?(AST::ExpressionList)
-            raise LoweringError.new("constant #{decl.name} has no compile-time value", line: decl.line, column: decl.column)
+            raise LoweringError.new("constant #{decl.name} has no compile-time value", line: decl.line, column: decl.column, path: @ctx.current_analysis_path)
           else
             value = lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)
             if (decl.value.is_a?(AST::Call) || decl.value.is_a?(AST::Specialization)) && static_initializer_ir_has_call?(value)
@@ -78,6 +79,43 @@ module MilkTea
         end
       end
 
+      ## Register C struct typedefs for every tuple type reachable from a
+      ## module-storage type (consts and globals).  `ensure_tuple_struct` is
+      ## normally called while lowering tuple *expressions*, so a tuple that
+      ## only appears in static storage never gets its `mt_tuple_...` typedef
+      ## emitted; the C compiler then fails with "unknown type name".
+      def ensure_registered_storage_type_types(type, seen = {})
+        return if type.nil? || seen[type]
+
+        seen[type] = true
+        if type.is_a?(Types::Tuple)
+          ensure_tuple_struct(type)
+          type.element_types.each { |element_type| ensure_registered_storage_type_types(element_type, seen) }
+        end
+
+        case type
+        when Types::Nullable
+          ensure_registered_storage_type_types(type.base, seen)
+        when Types::Span
+          ensure_registered_storage_type_types(type.element_type, seen)
+        when Types::Task
+          ensure_registered_storage_type_types(type.result_type, seen)
+        when Types::GenericInstance, Types::StructInstance, Types::VariantInstance
+          type.arguments.each do |argument|
+            ensure_registered_storage_type_types(argument, seen) unless argument.is_a?(Types::LiteralTypeArg)
+          end
+        end
+
+        if type.respond_to?(:fields) && type.fields
+          type.fields.each_value { |field_type| ensure_registered_storage_type_types(field_type, seen) }
+        end
+        if type.respond_to?(:arms)
+          type.arms.each_value do |arm_fields|
+            arm_fields.each_value { |field_type| ensure_registered_storage_type_types(field_type, seen) }
+          end
+        end
+      end
+
       def lower_const_value_literal(type, const_value)
         case const_value
         when Integer
@@ -130,6 +168,7 @@ module MilkTea
           next unless decl.is_a?(AST::VarDecl) || decl.is_a?(AST::EventDecl)
 
           type = @ctx.values.fetch(decl.name).type
+          ensure_registered_storage_type_types(type)
           ensure_event_runtime(type) if type.is_a?(Types::Event)
           value = if decl.is_a?(AST::VarDecl) && decl.value
             lower_static_storage_initializer(decl.value, env: empty_env, expected_type: type)

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

@@ -643,6 +643,8 @@ module MilkTea
               end
             end
 
+            written_scalar_captures = captures.select { |c| written_names.include?(c.name) && !array_capture_names.include?(c.name) }
+
             @artifacts.synthetic_structs << IR::StructDecl.new(
               name: cap_struct_c_name, linkage_name: cap_struct_c_name,
               fields: cap_fields, packed: false, alignment: nil,
@@ -674,6 +676,14 @@ module MilkTea
 
             rewritten_body = array_capture_names.empty? ? block_body : rewrite_pfor_array_captures(block_body, array_capture_names)
             worker_body.concat(rewritten_body)
+
+            written_scalar_captures.each do |c|
+              worker_body << IR::Assignment.new(
+                target: IR::Member.new(receiver: cap_name_ir, member: c.name, type: c.type),
+                operator: "=",
+                value: IR::Name.new(name: c.name, type: c.type, pointer: false),
+              )
+            end
           end
 
           @artifacts.synthetic_functions << IR::Function.new(
@@ -715,7 +725,7 @@ module MilkTea
                         )
                       end
 
-          { worker_c_name:, cap_local_name:, cap_struct_type:, cap_init:, capture_names: Set.new(captures.map(&:name)), written_names:, captureless: }
+          { worker_c_name:, cap_local_name:, cap_struct_type:, cap_init:, capture_names: Set.new(captures.map(&:name)), written_names:, written_scalar_captures: captureless ? [] : written_scalar_captures, captureless: }
         end
 
         validate_pfor_write_conflicts!(block_infos)
@@ -768,6 +778,20 @@ module MilkTea
           type: void_type,
         ))
 
+        block_infos.each do |info|
+          info[:written_scalar_captures].each do |c|
+            call_site << IR::Assignment.new(
+              target: IR::Name.new(name: c.name, type: c.type, pointer: false),
+              operator: "=",
+              value: IR::Member.new(
+                receiver: IR::Name.new(name: info[:cap_local_name], type: info[:cap_struct_type], pointer: false),
+                member: c.name,
+                type: c.type,
+              ),
+            )
+          end
+        end
+
         IR::BlockStmt.new(body: call_site)
       end
 

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

@@ -745,7 +745,7 @@ module MilkTea
           end
             return function_type_for_name(expression.name) if @ctx.functions.key?(expression.name)
 
-            raise LoweringError.new("unknown identifier #{expression.name}", line: expression.line, column: expression.column)
+            raise LoweringError.new("unknown identifier #{expression.name}", line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
         when AST::MemberAccess
           if (type_expr = resolve_type_expression(expression.receiver))
             member_type = resolve_type_member(type_expr, expression.member)
@@ -784,7 +784,7 @@ module MilkTea
           end
 
           return receiver_type.field(expression.member) if receiver_type.respond_to?(:field)
-          raise LoweringError.new("unknown member #{expression.member}", line: expression.line, column: expression.column)
+          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:)
           index_type = infer_expression_type(expression.index, env:)
@@ -1677,7 +1677,15 @@ module MilkTea
             evaluate_attribute_arg_call(expression.arguments, env:)
           else
             callee_name = expression.callee.callee.is_a?(AST::Identifier) ? expression.callee.callee.name : nil
-            if callee_name
+            if callee_name == "array"
+              values = []
+              expression.arguments.each do |argument|
+                val = compile_time_const_value(argument.value, env:)
+                return nil unless val
+                values << val
+              end
+              values
+            elsif callee_name
               func = @ctx.functions[callee_name]
               if func&.ast&.respond_to?(:const) && func.ast.const
                 evaluate_const_function_body_lower(func, expression.arguments)

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

@@ -459,8 +459,8 @@ module MilkTea
         end
       end
 
-      def local_binding(type:, linkage_name:, mutable:, pointer:, storage_type: nil, projection: nil, cstr_backed: false, cstr_list_backed: false, const_value: nil)
-        { type:, storage_type: storage_type || type, linkage_name:, mutable:, pointer:, projection:, cstr_backed:, cstr_list_backed:, const_value: }
+      def local_binding(type:, linkage_name:, mutable:, pointer:, storage_type: nil, projection: nil, cstr_backed: false, cstr_list_backed: false, const_value: nil, substitute_const_value: false)
+        { type:, storage_type: storage_type || type, linkage_name:, mutable:, pointer:, projection:, cstr_backed:, cstr_list_backed:, const_value:, substitute_const_value: }
       end
 
       def callable_type?(type)
@@ -904,6 +904,10 @@ module MilkTea
         visible_type = binding[:type]
         projection = binding[:projection]
 
+        if binding[:substitute_const_value] && !binding[:const_value].nil?
+          return lower_const_value_literal(visible_type, binding[:const_value])
+        end
+
         if projection == :result_success_value
           local_ref = IR::Name.new(name: binding[:linkage_name], type: storage_type, pointer: binding[:pointer])
           return variant_binding_projection_expression(local_ref, storage_type, "success", "value", visible_type)

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

@@ -297,7 +297,7 @@ module MilkTea
         expression = nil
         arms = []
         expression = parse_expression
-        arms = parse_match_arms(arms)
+        arms = normalize_mixed_match_arms(parse_match_arms(arms))
         if arms.first&.is_a?(AST::MatchExprArm)
           expr = AST::MatchExpr.new(expression:, arms:, line:, column: token.column, length: token.lexeme.length)
           AST::ExpressionStmt.new(expression: expr, line:)
@@ -311,12 +311,13 @@ module MilkTea
         recovered_arms = synchronize_to_match_arm_boundary
         target_line = line
         if recovered_arms
+          combined_arms = normalize_mixed_match_arms(arms + recovered_arms)
           stmt =
-            if recovered_arms.first&.is_a?(AST::MatchExprArm)
-              expr = AST::MatchExpr.new(expression: expression || recovery_error_expr(e), arms: arms + recovered_arms, line: target_line, column: token.column, length: token.lexeme.length)
+            if combined_arms.first&.is_a?(AST::MatchExprArm)
+              expr = AST::MatchExpr.new(expression: expression || recovery_error_expr(e), arms: combined_arms, line: target_line, column: token.column, length: token.lexeme.length)
               AST::ExpressionStmt.new(expression: expr, line: target_line)
             else
-              AST::MatchStmt.new(expression: expression || recovery_error_expr(e), arms: arms + recovered_arms, line: target_line, column: token.column, length: token.lexeme.length)
+              AST::MatchStmt.new(expression: expression || recovery_error_expr(e), arms: combined_arms, line: target_line, column: token.column, length: token.lexeme.length)
             end
           return stmt
         end
@@ -335,6 +336,33 @@ module MilkTea
         arms
       end
 
+      ## A statement match may mix inline value arms (`pattern: expr`) with
+      ## block arms.  The inline form is a single expression statement, so when
+      ## any arm is a block the inline arms are rewritten to block arms with a
+      ## single expression-statement body.  This keeps MatchStmt arms
+      ## homogeneous (all MatchArm) and MatchExpr arms homogeneous (all
+      ## MatchExprArm); the sema / control-flow / lowering consumers rely on
+      ## that invariant.
+      def normalize_mixed_match_arms(arms)
+        return arms unless arms.any? { |arm| arm.is_a?(AST::MatchExprArm) } && arms.any? { |arm| arm.is_a?(AST::MatchArm) }
+
+        arms.map do |arm|
+          if arm.is_a?(AST::MatchExprArm)
+            AST::MatchArm.new(
+              pattern: arm.pattern,
+              binding_name: arm.binding_name,
+              binding_line: arm.binding_line,
+              binding_column: arm.binding_column,
+              body: [AST::ExpressionStmt.new(expression: arm.value, line: arm.line)],
+              line: arm.line,
+              column: arm.column,
+            )
+          else
+            arm
+          end
+        end
+      end
+
       def parse_match_arm_body(arms = [])
         skip_newlines
         until check(:dedent) || eof?
@@ -652,7 +680,7 @@ module MilkTea
         token = previous
         line = token.line
         discriminant = parse_expression
-        branches = parse_match_arms([])
+        branches = normalize_mixed_match_arms(parse_match_arms([]))
         else_body = if check(:else)
           if check_next(:newline) || check_next(:indent)
             parse_else_branch_body
@@ -734,14 +762,14 @@ module MilkTea
         line = token.line
         arms = []
         expression = parse_expression
-        arms = parse_match_arms(arms)
+        arms = normalize_mixed_match_arms(parse_match_arms(arms))
         AST::MatchStmt.new(expression:, arms:, inline: true, line:, column: token.column, length: token.lexeme.length)
       rescue ParseError => e
         raise unless @recovery_errors
 
         @recovery_errors << e
         recovered_arms = synchronize_to_match_arm_boundary
-        return AST::MatchStmt.new(expression: expression || recovery_error_expr(e), arms: arms + recovered_arms, inline: true, line:, column: token.column, length: token.lexeme.length) if recovered_arms
+        return AST::MatchStmt.new(expression: expression || recovery_error_expr(e), arms: normalize_mixed_match_arms(arms + recovered_arms), inline: true, line:, column: token.column, length: token.lexeme.length) if recovered_arms
 
         recovery_error_stmt(e)
       end

data/lib/milk_tea/core/pretty_printer/ir_formatter.rb

@@ -211,7 +211,8 @@ module MilkTea
         when IR::NullableSpanIndex
           "nullable_span_index<#{expression.receiver_type}>(#{render_expression(expression.receiver)}, #{render_expression(expression.index)})"
         when IR::Call
-          wrap("#{expression.callee}(#{expression.arguments.map { |argument| render_expression(argument) }.join(', ')})", parent_precedence, POSTFIX_PRECEDENCE)
+          callee_text = expression.callee.is_a?(String) ? expression.callee : render_expression(expression.callee)
+          wrap("#{callee_text}(#{expression.arguments.map { |argument| render_expression(argument) }.join(', ')})", parent_precedence, POSTFIX_PRECEDENCE)
         when IR::Unary
           operand = render_expression(expression.operand, UNARY_PRECEDENCE)
           text = expression.operator == "not" ? "not #{operand}" : "#{expression.operator}#{operand}"
@@ -258,6 +259,8 @@ module MilkTea
           end
         when IR::ArrayLiteral
           "#{expression.type}(#{expression.elements.map { |element| render_expression(element) }.join(', ')})"
+        when IR::SimdLaneWith
+          "#{render_expression(expression.src)}.with(#{render_expression(expression.index)}, #{render_expression(expression.value)})"
         when IR::Assignment
           "#{render_expression(expression.target)} #{expression.operator} #{render_expression(expression.value)}"
         else

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

@@ -101,11 +101,21 @@ module MilkTea
 
       def find_method_by_receiver_name(module_binding, receiver_type, name)
         module_binding.methods.each do |key, methods|
-          return methods[name] if key.is_a?(receiver_type.class) && key.name == receiver_type.name && methods.key?(name)
+          next unless key.is_a?(receiver_type.class)
+          next unless key.name == receiver_type.name
+          next unless same_type_module?(key, receiver_type)
+          return methods[name] if methods.key?(name)
         end
         nil
       end
 
+      def same_type_module?(type_a, type_b)
+        module_a = receiver_type_module_name(type_a)
+        module_b = receiver_type_module_name(type_b)
+        return true if module_a.nil? || module_b.nil?
+        module_a == module_b
+      end
+
     def reachable_module_binding_for_type(receiver_type)
       module_name = receiver_type_module_name(receiver_type)
       return nil unless module_name
@@ -709,7 +719,7 @@ module MilkTea
 
       def sized_layout_type?(type)
         case type
-        when Types::Primitive, Types::Struct, Types::StructInstance, Types::Union, Types::Enum, Types::Flags, Types::Variant, Types::Span, Types::StringView, Types::Task, Types::Event, Types::Subscription
+        when Types::Primitive, Types::Struct, Types::StructInstance, Types::Union, Types::Enum, Types::Flags, Types::Variant, Types::Tuple, Types::Span, Types::StringView, Types::Task, Types::Event, Types::Subscription
           true
         when Types::Nullable
           true

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

@@ -173,7 +173,7 @@ module MilkTea
 
           if (type_ref = type_ref_from_specialization(callee))
             specialized_type = resolve_type_ref(type_ref)
-            return if specialized_type.is_a?(Types::Struct) || result_type?(specialized_type)
+            return if specialized_type.is_a?(Types::Struct) || task_type?(specialized_type) || specialized_type.is_a?(Types::Vector) || specialized_type.is_a?(Types::Matrix) || specialized_type.is_a?(Types::Quaternion) || specialized_type.is_a?(Types::Simd)
           end
         end
 

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

@@ -846,7 +846,10 @@ module MilkTea
         return false unless else_body
         text << else_body
 
-        text.strip.length > 120
+        # The inline form would start at the `if` keyword's column, so the real
+        # line width includes the surrounding block's indentation.
+        indent = statement.branches.first.column.to_i - 1
+        (indent + text.strip.length) > 120
       end
 
       def source_line_from(line, column)

data/std/box2d.mt

@@ -111,9 +111,9 @@ public const B2_PI: float = c.B2_PI
 public const B2_MAX_POLYGON_VERTICES: int = c.B2_MAX_POLYGON_VERTICES
 public const B2_DEFAULT_CATEGORY_BITS: int = c.B2_DEFAULT_CATEGORY_BITS
 
-public foreign function set_allocator(alloc_fcn: ptr[AllocFcn], free_fcn: ptr[FreeFcn]) -> void = c.b2SetAllocator
+public foreign function set_allocator(alloc_fcn: AllocFcn, free_fcn: FreeFcn) -> void = c.b2SetAllocator
 public foreign function get_byte_count() -> int = c.b2GetByteCount
-public foreign function set_assert_fcn(assert_fcn: ptr[AssertFcn]) -> void = c.b2SetAssertFcn
+public foreign function set_assert_fcn(assert_fcn: AssertFcn) -> void = c.b2SetAssertFcn
 public foreign function get_version() -> Version = c.b2GetVersion
 public foreign function internal_assert_fcn(condition: str as cstr, file_name: str as cstr, line_number: int) -> int = c.b2InternalAssertFcn
 public foreign function get_ticks() -> ulong = c.b2GetTicks
@@ -188,9 +188,9 @@ public foreign function dynamic_tree_move_proxy(tree: ptr[DynamicTree], proxy_id
 public foreign function dynamic_tree_enlarge_proxy(tree: ptr[DynamicTree], proxy_id: int, aabb: AABB) -> void = c.b2DynamicTree_EnlargeProxy
 public foreign function dynamic_tree_set_category_bits(tree: ptr[DynamicTree], proxy_id: int, category_bits: ptr_uint) -> void = c.b2DynamicTree_SetCategoryBits
 public foreign function dynamic_tree_get_category_bits(tree: ptr[DynamicTree], proxy_id: int) -> ulong = c.b2DynamicTree_GetCategoryBits
-public foreign function dynamic_tree_query(tree: const_ptr[DynamicTree], aabb: AABB, mask_bits: ptr_uint, callback: ptr[TreeQueryCallbackFcn], context: ptr[void]) -> TreeStats = c.b2DynamicTree_Query
-public foreign function dynamic_tree_ray_cast(tree: const_ptr[DynamicTree], input: const_ptr[RayCastInput], mask_bits: ptr_uint, callback: ptr[TreeRayCastCallbackFcn], context: ptr[void]) -> TreeStats = c.b2DynamicTree_RayCast
-public foreign function dynamic_tree_shape_cast(tree: const_ptr[DynamicTree], input: const_ptr[ShapeCastInput], mask_bits: ptr_uint, callback: ptr[TreeShapeCastCallbackFcn], context: ptr[void]) -> TreeStats = c.b2DynamicTree_ShapeCast
+public foreign function dynamic_tree_query(tree: const_ptr[DynamicTree], aabb: AABB, mask_bits: ptr_uint, callback: TreeQueryCallbackFcn, context: ptr[void]) -> TreeStats = c.b2DynamicTree_Query
+public foreign function dynamic_tree_ray_cast(tree: const_ptr[DynamicTree], input: const_ptr[RayCastInput], mask_bits: ptr_uint, callback: TreeRayCastCallbackFcn, context: ptr[void]) -> TreeStats = c.b2DynamicTree_RayCast
+public foreign function dynamic_tree_shape_cast(tree: const_ptr[DynamicTree], input: const_ptr[ShapeCastInput], mask_bits: ptr_uint, callback: TreeShapeCastCallbackFcn, context: ptr[void]) -> TreeStats = c.b2DynamicTree_ShapeCast
 public foreign function dynamic_tree_get_height(tree: const_ptr[DynamicTree]) -> int = c.b2DynamicTree_GetHeight
 public foreign function dynamic_tree_get_area_ratio(tree: const_ptr[DynamicTree]) -> float = c.b2DynamicTree_GetAreaRatio
 public foreign function dynamic_tree_get_root_bounds(tree: const_ptr[DynamicTree]) -> AABB = c.b2DynamicTree_GetRootBounds
@@ -228,13 +228,13 @@ public foreign function world_draw(world_id: WorldId, inout draw: DebugDraw) ->
 public foreign function world_get_body_events(world_id: WorldId) -> BodyEvents = c.b2World_GetBodyEvents
 public foreign function world_get_sensor_events(world_id: WorldId) -> SensorEvents = c.b2World_GetSensorEvents
 public foreign function world_get_contact_events(world_id: WorldId) -> ContactEvents = c.b2World_GetContactEvents
-public foreign function world_overlap_aabb(world_id: WorldId, aabb: AABB, filter: QueryFilter, fcn: ptr[OverlapResultFcn], context: ptr[void]) -> TreeStats = c.b2World_OverlapAABB
-public foreign function world_overlap_shape(world_id: WorldId, proxy: const_ptr[ShapeProxy], filter: QueryFilter, fcn: ptr[OverlapResultFcn], context: ptr[void]) -> TreeStats = c.b2World_OverlapShape
-public foreign function world_cast_ray(world_id: WorldId, origin: Vec2, translation: Vec2, filter: QueryFilter, fcn: ptr[CastResultFcn], context: ptr[void]) -> TreeStats = c.b2World_CastRay
+public foreign function world_overlap_aabb(world_id: WorldId, aabb: AABB, filter: QueryFilter, fcn: OverlapResultFcn, context: ptr[void]) -> TreeStats = c.b2World_OverlapAABB
+public foreign function world_overlap_shape(world_id: WorldId, proxy: const_ptr[ShapeProxy], filter: QueryFilter, fcn: OverlapResultFcn, context: ptr[void]) -> TreeStats = c.b2World_OverlapShape
+public foreign function world_cast_ray(world_id: WorldId, origin: Vec2, translation: Vec2, filter: QueryFilter, fcn: CastResultFcn, context: ptr[void]) -> TreeStats = c.b2World_CastRay
 public foreign function world_cast_ray_closest(world_id: WorldId, origin: Vec2, translation: Vec2, filter: QueryFilter) -> RayResult = c.b2World_CastRayClosest
-public foreign function world_cast_shape(world_id: WorldId, proxy: const_ptr[ShapeProxy], translation: Vec2, filter: QueryFilter, fcn: ptr[CastResultFcn], context: ptr[void]) -> TreeStats = c.b2World_CastShape
+public foreign function world_cast_shape(world_id: WorldId, proxy: const_ptr[ShapeProxy], translation: Vec2, filter: QueryFilter, fcn: CastResultFcn, context: ptr[void]) -> TreeStats = c.b2World_CastShape
 public foreign function world_cast_mover(world_id: WorldId, mover: const_ptr[Capsule], translation: Vec2, filter: QueryFilter) -> float = c.b2World_CastMover
-public foreign function world_collide_mover(world_id: WorldId, mover: const_ptr[Capsule], filter: QueryFilter, fcn: ptr[PlaneResultFcn], context: ptr[void]) -> void = c.b2World_CollideMover
+public foreign function world_collide_mover(world_id: WorldId, mover: const_ptr[Capsule], filter: QueryFilter, fcn: PlaneResultFcn, context: ptr[void]) -> void = c.b2World_CollideMover
 public foreign function world_enable_sleeping(world_id: WorldId, flag: bool) -> void = c.b2World_EnableSleeping
 public foreign function world_is_sleeping_enabled(world_id: WorldId) -> bool = c.b2World_IsSleepingEnabled
 public foreign function world_enable_continuous(world_id: WorldId, flag: bool) -> void = c.b2World_EnableContinuous
@@ -243,8 +243,8 @@ public foreign function world_set_restitution_threshold(world_id: WorldId, value
 public foreign function world_get_restitution_threshold(world_id: WorldId) -> float = c.b2World_GetRestitutionThreshold
 public foreign function world_set_hit_event_threshold(world_id: WorldId, value: float) -> void = c.b2World_SetHitEventThreshold
 public foreign function world_get_hit_event_threshold(world_id: WorldId) -> float = c.b2World_GetHitEventThreshold
-public foreign function world_set_custom_filter_callback(world_id: WorldId, fcn: ptr[CustomFilterFcn], context: ptr[void]) -> void = c.b2World_SetCustomFilterCallback
-public foreign function world_set_pre_solve_callback(world_id: WorldId, fcn: ptr[PreSolveFcn], context: ptr[void]) -> void = c.b2World_SetPreSolveCallback
+public foreign function world_set_custom_filter_callback(world_id: WorldId, fcn: CustomFilterFcn, context: ptr[void]) -> void = c.b2World_SetCustomFilterCallback
+public foreign function world_set_pre_solve_callback(world_id: WorldId, fcn: PreSolveFcn, context: ptr[void]) -> void = c.b2World_SetPreSolveCallback
 public foreign function world_set_gravity(world_id: WorldId, gravity: Vec2) -> void = c.b2World_SetGravity
 public foreign function world_get_gravity(world_id: WorldId) -> Vec2 = c.b2World_GetGravity
 public foreign function world_explode(world_id: WorldId, in explosion_def: ExplosionDef) -> void = c.b2World_Explode
@@ -258,8 +258,8 @@ public foreign function world_get_profile(world_id: WorldId) -> Profile = c.b2Wo
 public foreign function world_get_counters(world_id: WorldId) -> Counters = c.b2World_GetCounters
 public foreign function world_set_user_data(world_id: WorldId, user_data: ptr[void]) -> void = c.b2World_SetUserData
 public foreign function world_get_user_data(world_id: WorldId) -> ptr[void] = c.b2World_GetUserData
-public foreign function world_set_friction_callback(world_id: WorldId, callback: ptr[FrictionCallback]) -> void = c.b2World_SetFrictionCallback
-public foreign function world_set_restitution_callback(world_id: WorldId, callback: ptr[RestitutionCallback]) -> void = c.b2World_SetRestitutionCallback
+public foreign function world_set_friction_callback(world_id: WorldId, callback: FrictionCallback) -> void = c.b2World_SetFrictionCallback
+public foreign function world_set_restitution_callback(world_id: WorldId, callback: RestitutionCallback) -> void = c.b2World_SetRestitutionCallback
 public foreign function world_dump_memory_stats(world_id: WorldId) -> void = c.b2World_DumpMemoryStats
 public foreign function world_rebuild_static_tree(world_id: WorldId) -> void = c.b2World_RebuildStaticTree
 public foreign function world_enable_speculative(world_id: WorldId, flag: bool) -> void = c.b2World_EnableSpeculative

data/std/c/box2d.mt

@@ -10,9 +10,9 @@ type b2AllocFcn = fn(arg0: uint, arg1: int) -> ptr[void]
 type b2FreeFcn = fn(arg0: ptr[void]) -> void
 type b2AssertFcn = fn(arg0: cstr, arg1: cstr, arg2: int) -> int
 
-external function b2SetAllocator(allocFcn: ptr[b2AllocFcn], freeFcn: ptr[b2FreeFcn]) -> void
+external function b2SetAllocator(allocFcn: b2AllocFcn, freeFcn: b2FreeFcn) -> void
 external function b2GetByteCount() -> int
-external function b2SetAssertFcn(assertFcn: ptr[b2AssertFcn]) -> void
+external function b2SetAssertFcn(assertFcn: b2AssertFcn) -> void
 
 struct b2Version:
     major: int
@@ -313,15 +313,15 @@ external function b2DynamicTree_GetCategoryBits(tree: ptr[b2DynamicTree], proxyI
 
 type b2TreeQueryCallbackFcn = fn(arg0: int, arg1: ulong, arg2: ptr[void]) -> bool
 
-external function b2DynamicTree_Query(tree: const_ptr[b2DynamicTree], aabb: b2AABB, maskBits: ptr_uint, callback: ptr[b2TreeQueryCallbackFcn], context: ptr[void]) -> b2TreeStats
+external function b2DynamicTree_Query(tree: const_ptr[b2DynamicTree], aabb: b2AABB, maskBits: ptr_uint, callback: b2TreeQueryCallbackFcn, context: ptr[void]) -> b2TreeStats
 
 type b2TreeRayCastCallbackFcn = fn(arg0: const_ptr[b2RayCastInput], arg1: int, arg2: ulong, arg3: ptr[void]) -> float
 
-external function b2DynamicTree_RayCast(tree: const_ptr[b2DynamicTree], input: const_ptr[b2RayCastInput], maskBits: ptr_uint, callback: ptr[b2TreeRayCastCallbackFcn], context: ptr[void]) -> b2TreeStats
+external function b2DynamicTree_RayCast(tree: const_ptr[b2DynamicTree], input: const_ptr[b2RayCastInput], maskBits: ptr_uint, callback: b2TreeRayCastCallbackFcn, context: ptr[void]) -> b2TreeStats
 
 type b2TreeShapeCastCallbackFcn = fn(arg0: const_ptr[b2ShapeCastInput], arg1: int, arg2: ulong, arg3: ptr[void]) -> float
 
-external function b2DynamicTree_ShapeCast(tree: const_ptr[b2DynamicTree], input: const_ptr[b2ShapeCastInput], maskBits: ptr_uint, callback: ptr[b2TreeShapeCastCallbackFcn], context: ptr[void]) -> b2TreeStats
+external function b2DynamicTree_ShapeCast(tree: const_ptr[b2DynamicTree], input: const_ptr[b2ShapeCastInput], maskBits: ptr_uint, callback: b2TreeShapeCastCallbackFcn, context: ptr[void]) -> b2TreeStats
 external function b2DynamicTree_GetHeight(tree: const_ptr[b2DynamicTree]) -> int
 external function b2DynamicTree_GetAreaRatio(tree: const_ptr[b2DynamicTree]) -> float
 external function b2DynamicTree_GetRootBounds(tree: const_ptr[b2DynamicTree]) -> b2AABB
@@ -382,7 +382,7 @@ const b2_nullChainId: b2ChainId = b2ChainId(index1 = 0, world0 = 0, generation =
 const b2_nullJointId: b2JointId = b2JointId(index1 = 0, world0 = 0, generation = 0)
 
 type b2TaskCallback = fn(arg0: int, arg1: int, arg2: uint, arg3: ptr[void]) -> void
-type b2EnqueueTaskCallback = fn(arg0: ptr[b2TaskCallback], arg1: int, arg2: int, arg3: ptr[void], arg4: ptr[void]) -> ptr[void]
+type b2EnqueueTaskCallback = fn(arg0: b2TaskCallback, arg1: int, arg2: int, arg3: ptr[void], arg4: ptr[void]) -> ptr[void]
 type b2FinishTaskCallback = fn(arg0: ptr[void], arg1: ptr[void]) -> void
 type b2FrictionCallback = fn(arg0: float, arg1: int, arg2: float, arg3: int) -> float
 type b2RestitutionCallback = fn(arg0: float, arg1: int, arg2: float, arg3: int) -> float
@@ -404,13 +404,13 @@ struct b2WorldDef:
     contactDampingRatio: float
     maxContactPushSpeed: float
     maximumLinearSpeed: float
-    frictionCallback: ptr[b2FrictionCallback]
-    restitutionCallback: ptr[b2RestitutionCallback]
+    frictionCallback: b2FrictionCallback
+    restitutionCallback: b2RestitutionCallback
     enableSleep: bool
     enableContinuous: bool
     workerCount: int
-    enqueueTask: ptr[b2EnqueueTaskCallback]
-    finishTask: ptr[b2FinishTaskCallback]
+    enqueueTask: b2EnqueueTaskCallback
+    finishTask: b2FinishTaskCallback
     userTaskContext: ptr[void]
     userData: ptr[void]
     internalValue: int
@@ -942,13 +942,13 @@ external function b2World_Draw(worldId: b2WorldId, draw: ptr[b2DebugDraw]) -> vo
 external function b2World_GetBodyEvents(worldId: b2WorldId) -> b2BodyEvents
 external function b2World_GetSensorEvents(worldId: b2WorldId) -> b2SensorEvents
 external function b2World_GetContactEvents(worldId: b2WorldId) -> b2ContactEvents
-external function b2World_OverlapAABB(worldId: b2WorldId, aabb: b2AABB, filter: b2QueryFilter, fcn: ptr[b2OverlapResultFcn], context: ptr[void]) -> b2TreeStats
-external function b2World_OverlapShape(worldId: b2WorldId, proxy: const_ptr[b2ShapeProxy], filter: b2QueryFilter, fcn: ptr[b2OverlapResultFcn], context: ptr[void]) -> b2TreeStats
-external function b2World_CastRay(worldId: b2WorldId, origin: b2Vec2, translation: b2Vec2, filter: b2QueryFilter, fcn: ptr[b2CastResultFcn], context: ptr[void]) -> b2TreeStats
+external function b2World_OverlapAABB(worldId: b2WorldId, aabb: b2AABB, filter: b2QueryFilter, fcn: b2OverlapResultFcn, context: ptr[void]) -> b2TreeStats
+external function b2World_OverlapShape(worldId: b2WorldId, proxy: const_ptr[b2ShapeProxy], filter: b2QueryFilter, fcn: b2OverlapResultFcn, context: ptr[void]) -> b2TreeStats
+external function b2World_CastRay(worldId: b2WorldId, origin: b2Vec2, translation: b2Vec2, filter: b2QueryFilter, fcn: b2CastResultFcn, context: ptr[void]) -> b2TreeStats
 external function b2World_CastRayClosest(worldId: b2WorldId, origin: b2Vec2, translation: b2Vec2, filter: b2QueryFilter) -> b2RayResult
-external function b2World_CastShape(worldId: b2WorldId, proxy: const_ptr[b2ShapeProxy], translation: b2Vec2, filter: b2QueryFilter, fcn: ptr[b2CastResultFcn], context: ptr[void]) -> b2TreeStats
+external function b2World_CastShape(worldId: b2WorldId, proxy: const_ptr[b2ShapeProxy], translation: b2Vec2, filter: b2QueryFilter, fcn: b2CastResultFcn, context: ptr[void]) -> b2TreeStats
 external function b2World_CastMover(worldId: b2WorldId, mover: const_ptr[b2Capsule], translation: b2Vec2, filter: b2QueryFilter) -> float
-external function b2World_CollideMover(worldId: b2WorldId, mover: const_ptr[b2Capsule], filter: b2QueryFilter, fcn: ptr[b2PlaneResultFcn], context: ptr[void]) -> void
+external function b2World_CollideMover(worldId: b2WorldId, mover: const_ptr[b2Capsule], filter: b2QueryFilter, fcn: b2PlaneResultFcn, context: ptr[void]) -> void
 external function b2World_EnableSleeping(worldId: b2WorldId, flag: bool) -> void
 external function b2World_IsSleepingEnabled(worldId: b2WorldId) -> bool
 external function b2World_EnableContinuous(worldId: b2WorldId, flag: bool) -> void
@@ -957,8 +957,8 @@ external function b2World_SetRestitutionThreshold(worldId: b2WorldId, value: flo
 external function b2World_GetRestitutionThreshold(worldId: b2WorldId) -> float
 external function b2World_SetHitEventThreshold(worldId: b2WorldId, value: float) -> void
 external function b2World_GetHitEventThreshold(worldId: b2WorldId) -> float
-external function b2World_SetCustomFilterCallback(worldId: b2WorldId, fcn: ptr[b2CustomFilterFcn], context: ptr[void]) -> void
-external function b2World_SetPreSolveCallback(worldId: b2WorldId, fcn: ptr[b2PreSolveFcn], context: ptr[void]) -> void
+external function b2World_SetCustomFilterCallback(worldId: b2WorldId, fcn: b2CustomFilterFcn, context: ptr[void]) -> void
+external function b2World_SetPreSolveCallback(worldId: b2WorldId, fcn: b2PreSolveFcn, context: ptr[void]) -> void
 external function b2World_SetGravity(worldId: b2WorldId, gravity: b2Vec2) -> void
 external function b2World_GetGravity(worldId: b2WorldId) -> b2Vec2
 external function b2World_Explode(worldId: b2WorldId, explosionDef: const_ptr[b2ExplosionDef]) -> void
@@ -972,8 +972,8 @@ external function b2World_GetProfile(worldId: b2WorldId) -> b2Profile
 external function b2World_GetCounters(worldId: b2WorldId) -> b2Counters
 external function b2World_SetUserData(worldId: b2WorldId, userData: ptr[void]) -> void
 external function b2World_GetUserData(worldId: b2WorldId) -> ptr[void]
-external function b2World_SetFrictionCallback(worldId: b2WorldId, callback: ptr[b2FrictionCallback]) -> void
-external function b2World_SetRestitutionCallback(worldId: b2WorldId, callback: ptr[b2RestitutionCallback]) -> void
+external function b2World_SetFrictionCallback(worldId: b2WorldId, callback: b2FrictionCallback) -> void
+external function b2World_SetRestitutionCallback(worldId: b2WorldId, callback: b2RestitutionCallback) -> void
 external function b2World_DumpMemoryStats(worldId: b2WorldId) -> void
 external function b2World_RebuildStaticTree(worldId: b2WorldId) -> void
 external function b2World_EnableSpeculative(worldId: b2WorldId, flag: bool) -> void

metadata

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