mt-lang 0.4.23 → 0.4.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21ef46a88a5b23f5191412808ad2dfd353d68cead76553908ae5d13c0c773673
-  data.tar.gz: 60cf1b226bb63cb9392d6c54c11c9aead667203d9d103811681aaa43b28c9596
+  metadata.gz: f4c65f190209c5486b52d39b2ac868b2e2c076ad3ec01206151df16675319cf9
+  data.tar.gz: 28bb0127501319fb64f0da085409bb8658b6fd9cd41d8c18c0ac2175608f93dd
 SHA512:
-  metadata.gz: a9721db3d74e88c837e15a10657041010b1ff2aba40fee78ebf5c2862375d38121fcb3e3a57a328d3155314a39ba9fb7345b262fc7c99cc12bad41a98d70bc4c
-  data.tar.gz: 4bf9aaa1e0b8a9ba9e5878ab9eece9266e9c386144309abc14f0c47ddc0111dc9de6796f38052e2a956386c159fe9e7c8a0833068e0d084707c133f8e893b9e5
+  metadata.gz: '098dc1e2c0303bbf39dcd4402d7f21482c682f83b904799c1c85a9a73207b4c8443c0a98bdee192db9d17a0bf33ec4a96ad31c03a733f28c57880b7601c91d42'
+  data.tar.gz: ce0f5ba1ae8e8c6f958ab4cd5e2d0e89c522a9f814d8e5e31a1e8b8b849faafe437caaab098bd3a4d59755cdbf4f12c23d521810e9892c6e039acf27176b7d10

data/.ruby-version

@@ -1 +1 @@
-4.0.3
+4.0.6

data/Gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-ruby "4.0.3"
+ruby "4.0.6"
 
 gem "rake", "~> 13.4"
 gem "rexml", "~> 3.4"

data/Gemfile.lock

@@ -5,7 +5,7 @@ GEM
     drb (2.2.3)
     fiddle (1.1.8)
     logger (1.7.0)
-    minitest (6.0.4)
+    minitest (6.0.6)
       drb (~> 2.0)
       prism (~> 1.5)
     minitest-coverage (1.0.0.b3)
@@ -15,7 +15,7 @@ GEM
     puma (6.6.1)
       nio4r (~> 2.0)
     racc (1.8.1)
-    rack (3.2.6)
+    rack (3.2.7)
     rack-protection (4.2.1)
       base64 (>= 0.1.0)
       logger (>= 1.6.0)
@@ -34,7 +34,7 @@ GEM
       rack-protection (= 4.2.1)
       rack-session (>= 2.0.0, < 3)
       tilt (~> 2.0)
-    tilt (2.7.0)
+    tilt (2.9.0)
     tomlrb (2.0.4)
 
 PLATFORMS
@@ -58,25 +58,25 @@ CHECKSUMS
   drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
   fiddle (1.1.8) sha256=7fa8ee3627271497f3add5503acdbc3f40b32f610fc1cf49634f083ef3f32eee
   logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
-  minitest (6.0.4) sha256=df1304664589d40f46089247fdc451f866b0ce0d7cae1457a15fc1eb7d48dca1
+  minitest (6.0.6) sha256=153ea36d1d987a62942382b61075745042a2b3123b1cd48f4c3675af9cc7d6f1
   minitest-coverage (1.0.0.b3) sha256=27c8b6b8df1259325dd206baa2b143c594f8a88b7dfd97fd8d3389a0e8a6ad26
   mustermann (3.1.1) sha256=4c6170c7234d5499c345562ba7c7dfe73e1754286dcc1abb053064d66a127198
   nio4r (2.7.5) sha256=6c90168e48fb5f8e768419c93abb94ba2b892a1d0602cb06eef16d8b7df1dca1
   prism (1.9.0) sha256=7b530c6a9f92c24300014919c9dcbc055bf4cdf51ec30aed099b06cd6674ef85
   puma (6.6.1) sha256=b9b56e4a4ea75d1bfa6d9e1972ee2c9f43d0883f011826d914e8e37b3694ea1e
   racc (1.8.1) sha256=4a7f6929691dbec8b5209a0b373bc2614882b55fc5d2e447a21aaa691303d62f
-  rack (3.2.6) sha256=5ed78e1f73b2e25679bec7d45ee2d4483cc4146eb1be0264fc4d94cb5ef212c2
+  rack (3.2.7) sha256=93e13e1c24f93556671d85d2d79fa228c3485815c50d7e2f265b5330c6528fb7
   rack-protection (4.2.1) sha256=cf6e2842df8c55f5e4d1a4be015e603e19e9bc3a7178bae58949ccbb58558bac
   rack-session (2.1.2) sha256=595434f8c0c3473ae7d7ac56ecda6cc6dfd9d37c0b2b5255330aa1576967ffe8
   rackup (2.3.1) sha256=6c79c26753778e90983761d677a48937ee3192b3ffef6bc963c0950f94688868
   rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
   rexml (3.4.4) sha256=19e0a2c3425dfbf2d4fc1189747bdb2f849b6c5e74180401b15734bc97b5d142
   sinatra (4.2.1) sha256=b7aeb9b11d046b552972ade834f1f9be98b185fa8444480688e3627625377080
-  tilt (2.7.0) sha256=0d5b9ba69f6a36490c64b0eee9f6e9aad517e20dcc848800a06eb116f08c6ab3
+  tilt (2.9.0) sha256=da5735d0280bba96e9a91041bb14aee435ccad5c17b0fa519249ae543d9aa3a5
   tomlrb (2.0.4) sha256=262f77947ac3ac9b3366a0a5940ecd238300c553e2e14f22009e2afcd2181b99
 
 RUBY VERSION
-  ruby 4.0.3
+  ruby 4.0.6
 
 BUNDLED WITH
-  4.0.3
+  4.0.16

data/lib/milk_tea/base.rb

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

data/lib/milk_tea/core/control_flow/builder.rb

@@ -352,6 +352,12 @@ module MilkTea
           read_identifiers(expression.expression, names, reads_info)
         when AST::UnsafeExpr
           read_identifiers(expression.expression, names, reads_info)
+        when AST::PrefixCast
+          read_identifiers(expression.expression, names, reads_info)
+        when AST::DetachExpr
+          expression.body.each do |stmt|
+            read_identifiers(stmt.expression, names, reads_info) if stmt.is_a?(AST::ExpressionStmt)
+          end
         when AST::FormatString
           expression.parts.each do |part|
             read_identifiers(part.expression, names, reads_info) if part.is_a?(AST::FormatExprPart)
@@ -433,6 +439,12 @@ module MilkTea
           end
         when AST::UnsafeExpr
           write_targets_from_expression(expression.expression, line:, writes:, writes_info:)
+        when AST::PrefixCast
+          write_targets_from_expression(expression.expression, line:, writes:, writes_info:)
+        when AST::DetachExpr
+          expression.body.each do |stmt|
+            write_targets_from_expression(stmt.expression, line:, writes:, writes_info:) if stmt.is_a?(AST::ExpressionStmt)
+          end
         when AST::FormatString
           expression.parts.each do |part|
             write_targets_from_expression(part.expression, line:, writes:, writes_info:) if part.is_a?(AST::FormatExprPart)

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

@@ -10,11 +10,11 @@ module MilkTea
     POINTER_SIZE = Fiddle::SIZEOF_VOIDP
 
     def self.size_of(type)
-      size_and_alignment(type, {})&.first
+      size_and_alignment(type, nil)&.first
     end
 
     def self.alignment_of(type)
-      size_and_alignment(type, {})&.last
+      size_and_alignment(type, nil)&.last
     end
 
     def self.offset_of(type, field_name)
@@ -38,6 +38,14 @@ module MilkTea
       end
     end
 
+    # Computes [size, alignment] for a type.
+    #
+    # `stack` carries the aggregates on the current root-to-leaf path,
+    # pass-down only (never popped). A field whose type reaches any aggregate
+    # on that path participates in a storage cycle, and the C backend embeds
+    # exactly those fields as pointers (see
+    # CBackend#build_cyclic_aggregate_pairs and the cyclic field emission in
+    # type_declaration.rb), so layout sizes back-edge fields as raw pointers.
     def self.size_and_alignment(type, stack)
       case type
       when Types::Primitive
@@ -48,24 +56,24 @@ module MilkTea
         if type.is_a?(Types::Function) || layout_pointer_like_nullable_base?(type.base)
           [POINTER_SIZE, POINTER_SIZE]
         else
-          with_stack(type, stack) do
-            layout = struct_layout(nullable_opt_layout_fields(type.base), packed: false, alignment: nil, stack:)
+          with_stack(type, stack) do |next_stack|
+            layout = struct_layout(nullable_opt_layout_fields(type.base), packed: false, alignment: nil, stack: next_stack)
             [layout[:size], layout[:alignment]]
           end
         end
       when Types::StringView, Types::Span, Types::Task, Types::Struct, Types::StructInstance
-        with_stack(type, stack) do
-          layout = struct_layout(ordered_fields(type), packed: packed_layout?(type), alignment: explicit_alignment(type), stack:)
+        with_stack(type, stack) do |next_stack|
+          layout = struct_layout(ordered_fields(type), packed: packed_layout?(type), alignment: explicit_alignment(type), stack: next_stack)
           [layout[:size], layout[:alignment]]
         end
       when Types::Union
-        with_stack(type, stack) do
-          layout = union_layout(ordered_fields(type), packed: packed_layout?(type), alignment: explicit_alignment(type), stack:)
+        with_stack(type, stack) do |next_stack|
+          layout = union_layout(ordered_fields(type), packed: packed_layout?(type), alignment: explicit_alignment(type), stack: next_stack)
           [layout[:size], layout[:alignment]]
         end
       when Types::Variant, Types::VariantInstance
-        with_stack(type, stack) do
-          layout = variant_layout(type, stack:)
+        with_stack(type, stack) do |next_stack|
+          layout = variant_layout(type, stack: next_stack)
           [layout[:size], layout[:alignment]]
         end
       when Types::GenericInstance
@@ -128,8 +136,8 @@ module MilkTea
       when "str_buffer"
         return unless str_buffer_type?(type)
 
-        with_stack(type, stack) do
-          layout = struct_layout(str_buffer_fields(type), packed: false, alignment: nil, stack:)
+        with_stack(type, stack) do |next_stack|
+          layout = struct_layout(str_buffer_fields(type), packed: false, alignment: nil, stack: next_stack)
           [layout[:size], layout[:alignment]]
         end
       end
@@ -151,7 +159,7 @@ module MilkTea
 
     def self.struct_layout(fields, packed:, alignment:, stack:)
       field_infos = fields.map do |field_name, field_type|
-        field_layout = size_and_alignment(field_type, stack)
+        field_layout = field_size_and_alignment(field_type, stack)
         return nil unless field_layout
 
         [field_name, field_layout.first, field_layout.last]
@@ -162,7 +170,7 @@ module MilkTea
 
     def self.union_layout(fields, packed:, alignment:, stack:)
       field_infos = fields.map do |_field_name, field_type|
-        field_layout = size_and_alignment(field_type, stack)
+        field_layout = field_size_and_alignment(field_type, stack)
         return nil unless field_layout
 
         field_layout
@@ -171,6 +179,30 @@ module MilkTea
       union_layout_from_layouts(field_infos.map { |size, field_alignment| { size:, alignment: field_alignment } }, packed:, alignment:)
     end
 
+    # A field whose type reaches any aggregate on the current path is a
+    # storage-cycle back edge. The C backend emits such fields as pointers
+    # (element pointer for arrays), so they occupy pointer-size storage here.
+    def self.field_size_and_alignment(field_type, stack)
+      return [POINTER_SIZE, POINTER_SIZE] if cyclic_back_edge?(field_type, stack)
+
+      size_and_alignment(field_type, stack)
+    end
+
+    def self.cyclic_back_edge?(field_type, stack)
+      return false if stack.nil? || stack.empty?
+
+      aggregate_reaches_in_progress?(field_type, stack, {})
+    end
+
+    def self.aggregate_reaches_in_progress?(type, stack, visited)
+      return false if visited.key?(type.object_id)
+
+      visited[type.object_id] = true
+      return true if stack.key?(type)
+
+      reachability_children(type).any? { |child| aggregate_reaches_in_progress?(child, stack, visited) }
+    end
+
     def self.struct_layout_from_infos(field_infos, packed:, alignment:)
       offsets = {}
       offset = 0
@@ -253,13 +285,52 @@ module MilkTea
       remainder.zero? ? value : value + alignment - remainder
     end
 
+    # `stack` is the set of aggregates on the current path, pass-down only.
+    # A nil or empty stack means the caller is not inside an aggregate yet.
+    # Yields the extended stack; returns nil when `type` is already in progress
+    # (callers treat that as unreachable while mirroring backend semantics).
     def self.with_stack(type, stack)
-      return if stack[type]
+      next_stack = (stack || {}).dup
+      return nil if next_stack.key?(type)
+
+      next_stack[type] = true
+      yield(next_stack)
+    end
+
+    # Structural expansion used for back-edge detection. Mirrors the
+    # CBackend's `aggregate_type_dependencies` so pointer-broken cyclic
+    # fields agree with the emitted C struct layout.
+    def self.reachability_children(type)
+      case type
+      when Types::Nullable
+        [type.base]
+      when Types::GenericInstance
+        if pointer_type?(type)
+          []
+        elsif array_type?(type)
+          [array_element_type(type)]
+        else
+          []
+        end
+      when Types::Span
+        [type.element_type]
+      when Types::Struct, Types::StructInstance, Types::Union
+        type.fields.values
+      when Types::Variant, Types::VariantInstance
+        type.arm_names.flat_map { |name| type.arm(name).values }
+      when Types::VariantArmPayload
+        type.fields.values
+      else
+        []
+      end
+    end
+
+    def self.pointer_type?(type)
+      type.is_a?(Types::GenericInstance) && %w[ptr const_ptr own ref].include?(type.name)
+    end
 
-      stack[type] = true
-      yield
-    ensure
-      stack.delete(type)
+    def self.array_element_type(type)
+      type.arguments.first
     end
     end
   end

data/lib/milk_tea/tooling/cli/commands/std.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module MilkTea
+  class CLI
+    module CommandStd
+      def std_command
+        subcommand = @argv.shift
+
+        case subcommand
+        when "list"
+          std_list_command
+        when "show"
+          std_show_command
+        when nil
+          @err.puts("missing std subcommand (expected list or show)")
+          print_command_help("std", @err)
+          1
+        else
+          @err.puts("unknown std subcommand #{subcommand}")
+          print_command_help("std", @err)
+          1
+        end
+      end
+
+      def std_list_command
+        as_json = false
+        until @argv.empty?
+          option = @argv.shift
+          case option
+          when "--json"
+            as_json = true
+          else
+            @err.puts("unknown std list option #{option}")
+            return 1
+          end
+        end
+
+        entries = StdCatalog.entries
+        if as_json
+          @out.puts(JSON.generate(entries.map(&:to_h)))
+          return 0
+        end
+
+        print_std_list(entries)
+        0
+      end
+
+      def print_std_list(entries)
+        name_width = entries.map { |entry| entry.name.length }.max
+        description_width = entries.map { |entry| entry.description&.length.to_i }.max
+
+        StdCatalog::CATEGORY_ORDER.each do |category|
+          category_entries = entries.select { |entry| entry.category == category }
+          next if category_entries.empty?
+
+          @out.puts("#{category}:")
+          category_entries.each do |entry|
+            description = entry.description || "(no description)"
+            @out.puts("  #{entry.name.ljust(name_width)}  #{description.ljust(description_width)}  #{entry.path}")
+          end
+          @out.puts
+        end
+      end
+
+      def std_show_command
+        name = @argv.shift
+        unless name
+          @err.puts("missing module name")
+          print_command_help("std", @err)
+          return 1
+        end
+
+        path = StdCatalog.resolve(name)
+        unless path
+          @err.puts("std module not found: #{name}")
+          return 1
+        end
+
+        @out.write(File.read(path))
+        0
+      end
+    end
+  end
+end

data/lib/milk_tea/tooling/cli.rb

@@ -33,6 +33,7 @@ module MilkTea
       ["bindgen",     "Generate a binding module from a C header"],
       ["cache",       "Inspect and manage the build cache"],
       ["docs",        "Serve the local documentation site"],
+      ["std",         "List standard library modules and print their source"],
       ["snapshot",    "Render a highlighted HTML snapshot"],
       ["lsp",         "Start the Language Server Protocol server"],
       ["dap",         "Start the Debug Adapter Protocol server"],
@@ -127,6 +128,8 @@ module MilkTea
         cache_command
       when "docs"
         docs_command
+      when "std"
+        std_command
       when "snapshot"
         snapshot_command
       when "lsp"
@@ -164,6 +167,7 @@ module MilkTea
     require_relative "cli/commands/bindgen"
     require_relative "cli/commands/cache"
     require_relative "cli/commands/docs"
+    require_relative "cli/commands/std"
     require_relative "cli/commands/snapshot"
     require_relative "cli/commands/lsp"
     require_relative "cli/commands/dap"
@@ -187,6 +191,7 @@ module MilkTea
     include CommandBindgen
     include CommandCache
     include CommandDocs
+    include CommandStd
     include CommandSnapshot
     include CommandLsp
     include CommandDap
@@ -796,6 +801,24 @@ module MilkTea
             --open, -o            Open the docs in your default browser.
             --port, -p PORT       Listen on a specific port (default: random).
         HELP
+      "std"             => <<~HELP,
+        Usage: mtc std list [--json]
+               mtc std show MODULE
+
+          Inspect the Milk Tea standard library shipped in std/.
+
+          list    Print every hand-written standard library module with a short
+                  description and its path on disk, grouped by category.
+                  Generated binding modules (std/c/* and imported-binding
+                  wrappers such as raylib or zstd) are not listed.
+          show    Print the source of a module. Accepts dotted or slashed names
+                  (mem.arena, mem/arena) and resolves platform variants such as
+                  fs to the active platform file. Generated modules stay
+                  viewable here (for example c.cjson or raylib).
+
+          Options:
+            --json    Emit list output as JSON.
+        HELP
       "snapshot"        => <<~HELP,
         Usage: mtc snapshot INPUT.mt [OPTIONS]
 
@@ -891,6 +914,8 @@ module MilkTea
       io.puts("       mtc bindgen MODULE HEADER [-o OUTPUT] [--nullable-report PATH] [--link LIB] [--include HEADER] [--clang PATH] [--clang-arg ARG]")
       io.puts("       mtc cache purge|status")
       io.puts("       mtc docs [--open] [--port PORT]")
+      io.puts("       mtc std list [--json]")
+      io.puts("       mtc std show MODULE")
       io.puts("       mtc snapshot INPUT.mt [--theme PATH] [-o OUTPUT]")
       io.puts("       mtc lsp [--log-level LEVEL] [--stdio]")
       io.puts("       mtc dap [--backend KIND] [--adapter-path PATH]")

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

@@ -17,6 +17,7 @@ module MilkTea
         when "redundant-else"         then redundant_else_edits(lines, warning)
         when "redundant-return"       then redundant_return_edits(lines, warning)
         when "redundant-type-annotation" then redundant_type_annotation_edits(lines, warning)
+        when "redundant-unsafe"       then redundant_unsafe_edits(lines, warning)
         when "prefer-inline-methods"  then prefer_inline_methods_edits(lines, warning)
         when "unused-import"          then unused_import_edits(lines, warning)
         when "trailing-list-comma"    then trailing_list_comma_edits(lines, warning)
@@ -302,6 +303,105 @@ module MilkTea
         edits
       end
 
+      # ── redundant-unsafe ───────────────────────────────────────────────────
+      # Removes an `unsafe:` wrapper that contains no unsafe operations.
+      #
+      # Supported shapes:
+      #   <indent>unsafe:\n<deeper body>   (block statement; body is dedented)
+      #   ... unsafe: expr ...             (inline expression on a single line)
+      def self.redundant_unsafe_edits(lines, warning)
+        return [] unless warning.line
+
+        line_idx = warning.line - 1
+        line = lines[line_idx]
+        return [] unless line
+
+        unsafe_idx = line.index("unsafe:")
+        return [] unless unsafe_idx
+
+        keyword_end = unsafe_idx + "unsafe:".length
+        rest = line[keyword_end..]
+
+        if rest && !rest.strip.empty?
+          # Inline expression form: drop the keyword and the whitespace after
+          # it, but only when the remainder is balanced on this line.
+          remainder = rest.sub(/\A\s+/, "")
+          return [] if remainder.empty? || !balanced_line?(remainder)
+
+          return [FixEdit.new(
+            start_line: line_idx,
+            start_char: unsafe_idx,
+            end_line: line_idx,
+            end_char: keyword_end + (rest.length - remainder.length),
+            new_text: "",
+          )]
+        end
+
+        # Block statement form: `unsafe:` alone, body indented deeper.
+        indent = line[0...unsafe_idx]
+        return [] unless indent.match?(/\A *\z/)
+
+        body_start = line_idx + 1
+        body_indent = nil
+        last_body = nil
+        (body_start...lines.length).each do |i|
+          candidate = lines[i]
+          if candidate.nil? || candidate.strip.empty?
+            last_body = i
+            next
+          end
+
+          break unless candidate.start_with?(indent + " ")
+
+          body_indent ||= candidate[/\A */].length - indent.length
+          last_body = i
+        end
+
+        return [] if last_body.nil? || last_body < body_start
+        return [] if body_indent.nil? || body_indent <= 0
+        return [] unless (body_start..last_body).all? do |i|
+          l = lines[i]
+          l.nil? || l.strip.empty? || l.start_with?(indent + " " * body_indent)
+        end
+
+        replacement = (body_start..last_body).map do |i|
+          l = lines[i]
+          l.nil? || l.strip.empty? ? "" : l[body_indent..].to_s.chomp
+        end
+
+        if last_body + 1 <= lines.length - 1
+          # Consume through the first following line; apply_fix_edits re-emits
+          # it as the suffix of a multi-line replacement.
+          end_line = last_body + 1
+          end_char = 0
+        else
+          end_line = last_body
+          end_char = lines[last_body].to_s.length
+        end
+
+        [FixEdit.new(
+          start_line: line_idx,
+          start_char: 0,
+          end_line:,
+          end_char:,
+          new_text: replacement.join("\n") + "\n",
+        )]
+      end
+
+      def self.balanced_line?(text)
+        depth = 0
+        text.each_char do |char|
+          case char
+          when "(", "["
+            depth += 1
+          when ")", "]"
+            depth -= 1
+            return false if depth.negative?
+          end
+        end
+        depth.zero?
+      end
+
       def self.match_paren(line, open_pos)
         depth = 0
         (open_pos...line.length).each do |i|

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

@@ -258,10 +258,28 @@ module MilkTea
         case expr
         when AST::Call
           expr.arguments.any? do |arg|
-            next unless arg.is_a?(AST::Argument)
+            next false unless arg.is_a?(AST::Argument)
 
-            arg.value.is_a?(AST::Identifier) && arg.value.name == name ||
-              own_struct_field_transfer?(arg.value, name)
+            own_transfer_identifier?(arg.value, name)
+          end
+        when AST::PrefixCast
+          own_transfer_identifier?(expr.expression, name)
+        else
+          false
+        end
+      end
+
+      def own_transfer_identifier?(value, name)
+        case value
+        when AST::Identifier
+          value.name == name
+        when AST::PrefixCast
+          own_transfer_identifier?(value.expression, name)
+        when AST::Call
+          value.arguments.any? do |arg|
+            next false unless arg.is_a?(AST::Argument)
+
+            own_transfer_identifier?(arg.value, name)
           end
         else
           false
@@ -426,15 +444,29 @@ module MilkTea
         return false unless expr.is_a?(AST::Call)
 
         expr.arguments.any? do |arg|
-          next false unless arg.is_a?(AST::Argument) && arg.name
-
-          if arg.value.is_a?(AST::Identifier) && arg.value.name == name
-            true
-          elsif arg.value.is_a?(AST::Call)
-            _expr_contains_transfer?(arg.value, name)
-          else
-            false
+          named = arg.is_a?(AST::Argument) && !arg.name.nil?
+          argument_transfers?(arg.value, name, named)
+        end
+      end
+
+      # An identifier passed as a named argument transfers ownership (struct
+      # field initialization), even when wrapped in a pointer cast
+      # (e.g. handle_set_data(h, ptr[void]<-state)). Nested calls are walked
+      # so `queue.push(Foo(field = x))` recognizes the inner transfer.
+      def argument_transfers?(value, name, named)
+        case value
+        when AST::Identifier
+          named && value.name == name
+        when AST::PrefixCast
+          inner = value.expression
+          inner.is_a?(AST::Identifier) && inner.name == name
+        when AST::Call
+          value.arguments.any? do |arg|
+            nested_named = arg.is_a?(AST::Argument) && !arg.name.nil?
+            argument_transfers?(arg.value, name, nested_named)
           end
+        else
+          false
         end
       end
 
@@ -481,6 +513,9 @@ module MilkTea
         return if expr.nil?
 
         result << expr.callee.receiver.name if release_call_on_binding?(expr)
+        if expr.is_a?(AST::Call) && expr.callee.is_a?(AST::Identifier) && expr.callee.name.start_with?("release_")
+          result.merge(release_helper_binding_names(expr))
+        end
 
         case expr
         when AST::Call
@@ -496,6 +531,26 @@ module MilkTea
         end
       end
 
+      # std convention: `release_*` helper functions take ownership of the
+      # bindings handed to them via ref_of/ptr_of, e.g.
+      # `release_string_values(ref_of(values))`. Treat those bindings as
+      # released so the leak rule understands the cleanup-helper idiom.
+      def release_helper_binding_names(expr)
+        names = Set.new
+        expr.arguments.each do |arg|
+          value = arg.respond_to?(:value) ? arg.value : nil
+          next unless value.is_a?(AST::Call)
+          next unless value.callee.is_a?(AST::Identifier)
+          next unless %w[ref_of ptr_of].include?(value.callee.name)
+
+          value.arguments.each do |inner|
+            binding_name = inner.value
+            names << binding_name.name if binding_name.is_a?(AST::Identifier)
+          end
+        end
+        names
+      end
+
       def _any_stmt?(stmts, &pred)
         return false if stmts.nil?
 
@@ -620,6 +675,9 @@ module MilkTea
         return false unless expr
 
         return true if release_call_on_binding?(expr) && expr.callee.receiver.name == name
+        return true if expr.is_a?(AST::Call) && expr.callee.is_a?(AST::Identifier) &&
+                       expr.callee.name.start_with?("release_") &&
+                       release_helper_binding_names(expr).include?(name)
 
         case expr
         when AST::Call