mt-lang 0.3.41 → 0.3.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91b5015b218da9925b56895b551063fca825ca776fc336fe898ef17e332aae4e
-  data.tar.gz: 46e4a2da80edfb7c64fc847ee10844c9f5d36572df35105ab6ed51e2455d347a
+  metadata.gz: 927d840392dcd8afb43392ab7ef3f0b620ff267a13107c1f539ad17596364c6c
+  data.tar.gz: f9f09a4989def57fbb058b3cc1ceeea62a23d1bfcec0c6bfe030c58e4ea26e8e
 SHA512:
-  metadata.gz: 0c1dcedaf98ef374c9dd21cded75f8512c755a63e4a3a155e494d9edf098b2d53da3b258edab5d63066a2a9eaa3c2a3883aa69241608509085caf398c1edecc1
-  data.tar.gz: a427c7ad0f2475b7dc5cccadcb6cc143ab195f906b7b9b13407a7e754043fd8550495c7dc750f5f27c92e2eca13477d9f6697650bddd515403526812b1dac06b
+  metadata.gz: a7d0a57ff106227cc3e59d3ac1b425ad8cc0deecf4f0f9016f09984074cd624f43ddc7e178935c4af31a472cdd79eff6275c18a410030d678c0e1a0567666343
+  data.tar.gz: 53edd11a322c1145dbab6d63209dd321e720a22c0f269b08f84be31638fac77f7bb092aa5920611cb12603905eb2260612f49e325d0644ebc35bb95295b134c1

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.41"
+  VERSION = "0.3.42"
 
   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

@@ -137,7 +137,7 @@ module MilkTea
 
         collect_checked_array_index_types.any? || collect_checked_span_index_types.any? ||
           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]) }
       end
 
       def uses_mt_fatal_str_helper?

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

@@ -51,6 +51,7 @@ module MilkTea
           "",
           "static mt_str mt_str_concat(mt_str a, mt_str b) {",
           "#{INDENT}uintptr_t total = a.len + b.len;",
+          "#{INDENT}if (total > MT_STR_CONCAT_BUF_SIZE) mt_fatal(\"str concatenation exceeds the scratch buffer budget\");",
           "#{INDENT}if (mt_str_concat_offset + total > MT_STR_CONCAT_BUF_SIZE) {",
           "#{INDENT * 2}mt_str_concat_offset = 0;",
           "#{INDENT}}",
@@ -297,6 +298,9 @@ module MilkTea
           "#{INDENT}for (int t = 0; t < nworkers; t++) {",
           "#{INDENT * 2}uv_thread_join(&threads[t]);",
           "#{INDENT}}",
+          "#{INDENT}for (int t = nworkers + 1; t < count; t++) {",
+          "#{INDENT * 2}items[t].work(items[t].data);",
+          "#{INDENT}}",
           "}",
         ]
       end
@@ -590,11 +594,11 @@ module MilkTea
 
       def emit_checked_array_index_helper(type)
         helper_name = checked_array_index_helper_name(type)
-        params = [c_declaration(type, '(*array)'), c_declaration(Types::Registry.primitive('ptr_uint'), 'index')].join(', ')
+        params = [c_declaration(pointer_to(array_element_type(type)), 'array'), c_declaration(Types::Registry.primitive('ptr_uint'), 'index')].join(', ')
         [
           "static inline #{c_function_declaration(pointer_to(array_element_type(type)), helper_name, params)} {",
           "#{INDENT}if (index >= #{array_length(type)}) mt_fatal(\"array index out of bounds\");",
-          "#{INDENT}return &(*array)[index];",
+          "#{INDENT}return &array[index];",
           "}",
         ]
       end
@@ -612,11 +616,11 @@ module MilkTea
 
       def emit_nullable_array_index_helper(type)
         helper_name = nullable_array_index_helper_name(type)
-        params = [c_declaration(type, '(*array)'), c_declaration(Types::Registry.primitive('ptr_uint'), 'index')].join(', ')
+        params = [c_declaration(pointer_to(array_element_type(type)), 'array'), c_declaration(Types::Registry.primitive('ptr_uint'), 'index')].join(', ')
         [
           "static inline #{c_function_declaration(pointer_to(array_element_type(type)), helper_name, params)} {",
           "#{INDENT}if (index >= #{array_length(type)}) return NULL;",
-          "#{INDENT}return &(*array)[index];",
+          "#{INDENT}return &array[index];",
           "}",
         ]
       end

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

@@ -495,7 +495,7 @@ module MilkTea
       def emit_checked_index_pointer(expression)
         case expression
         when IR::CheckedIndex
-          "#{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)})"
         when IR::CheckedSpanIndex
           "#{checked_span_index_helper_name(expression.receiver_type)}(#{emit_expression(expression.receiver)}, #{emit_expression(expression.index)})"
         else

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

@@ -223,6 +223,26 @@ module MilkTea
         soa_types = []
         visited = {}
 
+        all_emitted_top_level_values.each do |value|
+          collect_soa_type(value.type, soa_types, visited)
+        end
+
+        @program.structs.each do |struct_decl|
+          struct_decl.fields.each do |field|
+            collect_soa_type(field.type, soa_types, visited)
+          end
+        end
+
+        @program.unions.each do |union_decl|
+          union_decl.fields.each do |field|
+            collect_soa_type(field.type, soa_types, visited)
+          end
+        end
+
+        each_variant_arm_field_type do |field_type|
+          collect_soa_type(field_type, soa_types, visited)
+        end
+
         emitted_functions.each do |function|
           collect_soa_type(function.return_type, soa_types, visited)
           function.params.each do |param|
@@ -231,10 +251,9 @@ module MilkTea
           collect_soa_from_statements(function.body, soa_types, visited)
         end
 
-        @program.structs.each do |struct_decl|
-          struct_decl.fields.each do |field|
-            collect_soa_type(field.type, soa_types, visited)
-          end
+        @program.static_asserts.each do |statement|
+          collect_soa_type_in_expression(statement.condition, soa_types, visited)
+          collect_soa_type_in_expression(statement.message, soa_types, visited)
         end
 
         soa_types.uniq

data/lib/milk_tea/core/lowering/async/async_lowering.rb

@@ -636,13 +636,9 @@ module MilkTea
                 active_defers: active_defers + local_defers,
                 loop_flow: nested_loop_flow(loop_flow, local_defers),
               )
+              storage_ref = IR::Name.new(name: linkage_name, type: storage_type, pointer: false)
               lowered << IR::IfStmt.new(
-                condition: IR::Binary.new(
-                  operator: "==",
-                  left: IR::Name.new(name: linkage_name, type: storage_type, pointer: false),
-                  right: IR::NullLiteral.new(type: storage_type),
-                  type: @ctx.types.fetch("bool"),
-                ),
+                condition: let_else_failure_condition(storage_ref, storage_type),
                 then_body: else_body,
                 else_body: nil,
               )

data/lib/milk_tea/core/lowering/async/frame_builder.rb

@@ -421,7 +421,8 @@ module MilkTea
         body = [async_frame_cast_declaration(frame_type, async_info)]
 
         not_ready_expr = IR::Unary.new(operator: "not", operand: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")), type: @ctx.types.fetch("bool"))
-        not_ready_return = [IR::ReturnStmt.new(value: nil)]
+        frame_free_stmt = IR::ExpressionStmt.new(expression: IR::Call.new(callee: "mt_async_free", arguments: [raw_frame_expr], type: @ctx.types.fetch("void")))
+        not_ready_return = [frame_free_stmt, IR::ReturnStmt.new(value: nil)]
 
         if async_info[:await_fields].any?
           await_release_stmts = []
@@ -589,11 +590,17 @@ module MilkTea
         )
         body << IR::ExpressionStmt.new(expression: ready_assign)
 
-        waiter_frame_expr = async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr])
+        waiter_frame_field = async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr])
         wake_stmts = [
+          IR::LocalDecl.new(
+            name: "waiter_frame",
+            linkage_name: "__mt_waiter_frame",
+            type: async_info[:void_ptr],
+            value: waiter_frame_field,
+          ),
           IR::ExpressionStmt.new(
             expression: IR::Assignment.new(
-              target: async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr]),
+              target: waiter_frame_field,
               operator: "=",
               value: IR::NullLiteral.new(type: async_info[:void_ptr]),
             ),
@@ -601,13 +608,13 @@ module MilkTea
           IR::ExpressionStmt.new(
             expression: IR::Call.new(
               callee: IR::Name.new(name: async_frame_field_c_name("waiter"), type: async_info[:wake_type], pointer: false),
-              arguments: [waiter_frame_expr],
+              arguments: [IR::Name.new(name: "__mt_waiter_frame", type: async_info[:void_ptr], pointer: false)],
               type: @ctx.types.fetch("void"),
             ),
           ),
         ]
         body << IR::IfStmt.new(
-          condition: waiter_frame_expr,
+          condition: waiter_frame_field,
           then_body: wake_stmts,
           else_body: nil,
         )

data/lib/milk_tea/core/lowering/async/normalization.rb

@@ -364,6 +364,17 @@ module MilkTea
         end
       end
 
+      # Emits a type-name prefix that the semantic re-check of generated proc
+      # roots can actually resolve: bare names for prelude and current-module
+      # types, the qualified module path otherwise.
+      def ast_type_ref_base_parts(type)
+        return [type.name] if type.module_name.nil?
+        return [type.name] if type.module_name == @ctx.module_name
+        return [type.name] if %w[std.option std.result].include?(type.module_name)
+
+        type.module_name.split(".") + [type.name]
+      end
+
       def ast_type_ref_for(type)
         case type
         when Types::Primitive
@@ -392,9 +403,20 @@ module MilkTea
         when Types::TypeVar
           AST::TypeRef.new(name: AST::QualifiedName.new(parts: [type.name]), arguments: [], nullable: false)
         when Types::StructInstance
-          base_parts = type.module_name ? type.module_name.split(".") + [type.name] : [type.name]
           AST::TypeRef.new(
-            name: AST::QualifiedName.new(parts: base_parts),
+            name: AST::QualifiedName.new(parts: ast_type_ref_base_parts(type)),
+            arguments: type.arguments.map do |argument|
+              if argument.is_a?(Types::LiteralTypeArg)
+                AST::TypeArgument.new(value: AST::IntegerLiteral.new(lexeme: argument.value.to_s, value: argument.value))
+              else
+                AST::TypeArgument.new(value: ast_type_ref_for(argument))
+              end
+            end,
+            nullable: false,
+          )
+        when Types::VariantInstance
+          AST::TypeRef.new(
+            name: AST::QualifiedName.new(parts: ast_type_ref_base_parts(type)),
             arguments: type.arguments.map do |argument|
               if argument.is_a?(Types::LiteralTypeArg)
                 AST::TypeArgument.new(value: AST::IntegerLiteral.new(lexeme: argument.value.to_s, value: argument.value))
@@ -404,9 +426,8 @@ module MilkTea
             end,
             nullable: false,
           )
-        when Types::Struct, Types::Union, Types::Opaque, Types::Enum, Types::Flags
-          parts = type.module_name ? type.module_name.split(".") + [type.name] : [type.name]
-          AST::TypeRef.new(name: AST::QualifiedName.new(parts: parts), arguments: [], nullable: false)
+        when Types::Struct, Types::Union, Types::Opaque, Types::Enum, Types::Flags, Types::Variant
+          AST::TypeRef.new(name: AST::QualifiedName.new(parts: ast_type_ref_base_parts(type)), arguments: [], nullable: false)
         when Types::Function
           AST::FunctionType.new(
             params: type.params.each_with_index.map { |param, i| AST::Param.new(name: param.name || "p#{i}", type: ast_type_ref_for(param.type)) },

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

@@ -248,7 +248,13 @@ module MilkTea
             raise_sema_error("unsupported expression #{expression.class.name}")
           end
 
-          @resolved_expr_types[@ctx.ast.node_ids[expression.object_id]] = type
+          # Specialized generic-instance bodies share the same AST nodes across
+          # substitutions, so a node-id keyed cache cannot be populated there:
+          # the last-checked instance would overwrite every other instance's
+          # types and leak wrong types to lowering, which reads this cache.
+          # Regular functions carry an empty (but non-nil) substitution hash, so
+          # only a non-empty hash identifies an instance body.
+          @resolved_expr_types[@ctx.ast.node_ids[expression.object_id]] = type unless @current_type_substitutions&.any?
           type
         end
       end
@@ -961,7 +967,7 @@ module MilkTea
         callable_kind = resolution.kind
         callable = resolution.value
         receiver = resolution.receiver
-        @resolved_call_kinds[@ctx.ast.node_ids[expression.callee.object_id]] = callable_kind
+        @resolved_call_kinds[@ctx.ast.node_ids[expression.callee.object_id]] = callable_kind unless @current_type_substitutions&.any?
 
         case callable_kind
         when :function

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

@@ -695,7 +695,9 @@ module MilkTea
         offset = CompileTime::Layout.offset_of(type, binding.const_value.field_name)
         return unless offset
 
-        @const_values[@ctx.ast.node_ids[expression.object_id]] = offset
+        # Same node-id key collision as resolved_expr_types: instance bodies
+        # share AST nodes across substitutions, so never cache their values.
+        @const_values[@ctx.ast.node_ids[expression.object_id]] = offset unless @current_type_substitutions&.any?
       end
 
       def infer_offsetof_type(type_ref, field_name, scopes: nil)

data/lib/milk_tea/tooling/docs_app.rb

@@ -18,7 +18,7 @@ module MilkTea
       "Files & I/O" => %w[fs path stdio],
       "System" => %w[ctype errno process time c],
       "Network & HTTP" => %w[net http uri cookie curl],
-      "Game & Graphics" => %w[raylib box2d flecs enet cgltf cjson],
+      "Game & Graphics" => %w[raylib box2d box3d flecs enet cgltf cjson],
       "Algorithms & AI" => %w[fsm behavior_tree goap],
       "Database & Matching" => %w[sqlite3 pcre2],
       "Utilities" => %w[cli terminal span spatial asset_pack],