mt-lang 0.3.8 → 0.3.10

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

@@ -2,715 +2,712 @@
 
 module MilkTea
   module LowererAsync
-    private
-
-
-      def build_async_main_entrypoint(binding, _constructor_c_name, async_info)
-        task_type = async_info[:task_type]
-        signature = root_main_entrypoint_signature(binding)
-        raise LoweringError.new("async main entrypoint requires a supported signature",
-          line: 0, column: 0, path: @ctx.current_analysis_path) unless signature
-
-        params, setup_statements, call_arguments, cleanup_statements = build_root_main_entrypoint_bridge(signature)
-        body = []
-        env = empty_env
-
-        root_proc_name = "__mt_async_main_root"
-        result_name = "__mt_result"
-
-        body.concat(setup_statements)
-        argument_names = binding.type.params.each_index.map { |index| "__mt_async_main_arg_#{index + 1}" }
-        binding.type.params.each_with_index do |param, index|
-          name = argument_names.fetch(index)
-          env[:scopes].last[name] = local_binding(type: param.type, linkage_name: name, mutable: false, pointer: false)
-          body << IR::LocalDecl.new(
-            name: name,
-            linkage_name: name,
-            type: param.type,
-            value: call_arguments.fetch(index),
-          )
-        end
-
-        proc_expression = AST::ProcExpr.new(
-          params: [],
-          return_type: ast_type_ref_for(task_type),
-          body: [
-            AST::ReturnStmt.new(
-              value: AST::Call.new(
-                callee: AST::Identifier.new(name: binding.name),
-                arguments: argument_names.map { |name| AST::Argument.new(name: nil, value: AST::Identifier.new(name: name)) },
-              ),
-            ),
-          ],
-        )
-        root_proc_type = Types::Registry.proc(params: [], return_type: task_type)
-        proc_setup, proc_value = lower_proc_expression_for_local(proc_expression, env:, local_name: root_proc_name, proc_type: root_proc_type)
-        body.concat(proc_setup)
+    def build_async_main_entrypoint(binding, _constructor_c_name, async_info)
+      task_type = async_info[:task_type]
+      signature = root_main_entrypoint_signature(binding)
+      raise LoweringError.new("async main entrypoint requires a supported signature",
+        line: 0, column: 0, path: @ctx.current_analysis_path) unless signature
+
+      params, setup_statements, call_arguments, cleanup_statements = build_root_main_entrypoint_bridge(signature)
+      body = []
+      env = empty_env
+
+      root_proc_name = "__mt_async_main_root"
+      result_name = "__mt_result"
+
+      body.concat(setup_statements)
+      argument_names = binding.type.params.each_index.map { |index| "__mt_async_main_arg_#{index + 1}" }
+      binding.type.params.each_with_index do |param, index|
+        name = argument_names.fetch(index)
+        env[:scopes].last[name] = local_binding(type: param.type, linkage_name: name, mutable: false, pointer: false)
         body << IR::LocalDecl.new(
-          name: root_proc_name,
-          linkage_name: root_proc_name,
-          type: root_proc_type,
-          value: proc_value,
-        )
-
-        root_proc_expr = IR::Name.new(name: root_proc_name, type: root_proc_type, pointer: false)
-
-        if async_info[:result_type] == @ctx.types.fetch("int")
-          wait_callee = async_main_runtime_callee_name("wait", type_arguments: [async_info[:result_type]])
-          body << IR::LocalDecl.new(
-            name: result_name,
-            linkage_name: result_name,
-            type: @ctx.types.fetch("int"),
-            value: IR::Call.new(
-              callee: wait_callee,
-              arguments: [root_proc_expr],
-              type: @ctx.types.fetch("int"),
-            ),
-          )
-        else
-          run_callee = async_main_runtime_callee_name("run")
-          body << IR::ExpressionStmt.new(
-            expression: IR::Call.new(
-              callee: run_callee,
-              arguments: [root_proc_expr],
-              type: @ctx.types.fetch("void"),
-            ),
-          )
-        end
-
-        body << IR::ExpressionStmt.new(
-          expression: lower_proc_release_expression(root_proc_expr, root_proc_type),
-        )
-        body.concat(cleanup_statements)
-        body << IR::ReturnStmt.new(
-          value: async_info[:result_type] == @ctx.types.fetch("int") ? IR::Name.new(name: result_name, type: @ctx.types.fetch("int"), pointer: false) : IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("int")),
+          name: name,
+          linkage_name: name,
+          type: param.type,
+          value: call_arguments.fetch(index),
         )
-
-        IR::Function.new(
-          name: binding.name,
-          linkage_name: "main",
-          params:,
-          return_type: @ctx.types.fetch("int"),
-          body: body,
-          entry_point: true,
-        )
-      end
-
-      def async_main_runtime_callee_name(function_name, type_arguments: [])
-        binding = analysis_for_module("std.async").functions.fetch(function_name)
-        binding = binding.owner.send(:instantiate_function_binding, binding, type_arguments) if type_arguments.any?
-        function_binding_c_name(binding, module_name: binding.owner.module_name)
       end
 
-      def build_root_main_entrypoint(binding)
-        return nil if binding.async
-
-        signature = root_main_entrypoint_signature(binding)
-        return nil unless signature
-
-        params, setup_statements, call_arguments, cleanup_statements = build_root_main_entrypoint_bridge(signature)
-        return_type = binding.body_return_type
-        body = []
-        call = IR::Call.new(
-          callee: function_binding_c_name(binding, module_name: @ctx.module_name),
-          arguments: call_arguments,
-          type: return_type,
-        )
-
-        body.concat(setup_statements)
-        if return_type == @ctx.types.fetch("void")
-          body << IR::ExpressionStmt.new(expression: call)
-          body.concat(cleanup_statements)
-          body << IR::ReturnStmt.new(value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("int")))
-        elsif cleanup_statements.empty?
-          body << IR::ReturnStmt.new(value: call)
-        else
-          result_name = "__mt_result"
-          body << IR::LocalDecl.new(
-            name: result_name,
-            linkage_name: result_name,
-            type: @ctx.types.fetch("int"),
-            value: call,
-          )
-          body.concat(cleanup_statements)
-          body << IR::ReturnStmt.new(value: IR::Name.new(name: result_name, type: @ctx.types.fetch("int"), pointer: false))
-        end
-
-        IR::Function.new(
-          name: binding.name,
-          linkage_name: "main",
-          params:,
-          return_type: @ctx.types.fetch("int"),
-          body:,
-          entry_point: true,
-        )
-      end
-
-      def build_root_main_entrypoint_bridge(signature)
-        argc_type = @ctx.types.fetch("int")
-        raw_argv_type = pointer_to(pointer_to(@ctx.types.fetch("char")))
-        argc_name = "argc"
-        argv_name = "argv"
-
-        case signature[:kind]
-        when :none
-          [[], [], [], []]
-        when :raw_char_ptr_ptr
-          argc_expr = IR::Name.new(name: argc_name, type: argc_type, pointer: false)
-          argv_expr = IR::Name.new(name: argv_name, type: raw_argv_type, pointer: false)
-          [
-            [
-              IR::Param.new(name: argc_name, linkage_name: argc_name, type: argc_type, pointer: false),
-              IR::Param.new(name: argv_name, linkage_name: argv_name, type: raw_argv_type, pointer: false),
-            ],
-            [],
-            [argc_expr, argv_expr],
-            [],
-          ]
-        when :raw_cstr_ptr
-          argc_expr = IR::Name.new(name: argc_name, type: argc_type, pointer: false)
-          argv_expr = IR::Cast.new(
-            target_type: signature[:argv_type],
-            expression: IR::Name.new(name: argv_name, type: raw_argv_type, pointer: false),
-            type: signature[:argv_type],
-          )
-          [
-            [
-              IR::Param.new(name: argc_name, linkage_name: argc_name, type: argc_type, pointer: false),
-              IR::Param.new(name: argv_name, linkage_name: argv_name, type: raw_argv_type, pointer: false),
-            ],
-            [],
-            [argc_expr, argv_expr],
-            [],
-          ]
-        when :span_str
-          items_type = pointer_to(@ctx.types.fetch("str"))
-          items_name = "__mt_args_items"
-          args_name = "__mt_args"
-          items_expr = IR::Name.new(name: items_name, type: items_type, pointer: false)
-          args_expr = IR::Name.new(name: args_name, type: signature[:args_type], pointer: false)
-          argc_expr = IR::Name.new(name: argc_name, type: argc_type, pointer: false)
-          argv_expr = IR::Name.new(name: argv_name, type: raw_argv_type, pointer: false)
-
-          setup = [
-            IR::LocalDecl.new(
-              name: items_name,
-              linkage_name: items_name,
-              type: items_type,
-              value: IR::NullLiteral.new(type: items_type),
-            ),
-            IR::LocalDecl.new(
-              name: args_name,
-              linkage_name: args_name,
-              type: signature[:args_type],
-              value: IR::Call.new(
-                callee: "mt_entry_argv_to_span_str",
-                arguments: [
-                  argc_expr,
-                  argv_expr,
-                  IR::AddressOf.new(expression: items_expr, type: pointer_to(items_type)),
-                ],
-                type: signature[:args_type],
-              ),
+      proc_expression = AST::ProcExpr.new(
+        params: [],
+        return_type: ast_type_ref_for(task_type),
+        body: [
+          AST::ReturnStmt.new(
+            value: AST::Call.new(
+              callee: AST::Identifier.new(name: binding.name),
+              arguments: argument_names.map { |name| AST::Argument.new(name: nil, value: AST::Identifier.new(name: name)) },
             ),
-          ]
-          cleanup = [
-            IR::ExpressionStmt.new(
-              expression: IR::Call.new(callee: "mt_free_entry_argv_strs", arguments: [items_expr], type: @ctx.types.fetch("void")),
-            ),
-          ]
-
-          [
-            [
-              IR::Param.new(name: argc_name, linkage_name: argc_name, type: argc_type, pointer: false),
-              IR::Param.new(name: argv_name, linkage_name: argv_name, type: raw_argv_type, pointer: false),
-            ],
-            setup,
-            [args_expr],
-            cleanup,
-          ]
-        else
-          raise LoweringError.new("unsupported root main entrypoint bridge #{signature[:kind]}",
-            line: 0, column: 0, path: @ctx.current_analysis_path)
-        end
-      end
-
-      def root_main_entrypoint_signature(binding)
-        return nil unless @ctx.analysis == @program.root_analysis
-        return nil unless binding.type.receiver_type.nil?
-        return nil unless binding.name == "main"
-        return nil unless binding.type_arguments.empty?
-
-        return_type = binding.body_return_type
-        return nil unless return_type == @ctx.types.fetch("int") || return_type == @ctx.types.fetch("void")
-
-        params = binding.type.params
-        return { kind: :none } if params.empty?
-
-        if params.length == 1 && params.first.type.is_a?(Types::Span) && params.first.type.element_type == @ctx.types.fetch("str")
-          return { kind: :span_str, args_type: params.first.type }
-        end
-
-        return nil unless params.length == 2
-        return nil unless params[0].type == @ctx.types.fetch("int")
-
-        argv_type = params[1].type
-        return { kind: :raw_cstr_ptr, argv_type: } if argv_type == pointer_to(@ctx.types.fetch("cstr"))
-        return { kind: :raw_char_ptr_ptr, argv_type: } if argv_type == pointer_to(pointer_to(@ctx.types.fetch("char")))
-
-        nil
-      end
-
-
-      def build_async_constructor_function(binding, decl, frame_type, constructor_linkage_name, resume_linkage_name, ready_linkage_name, set_waiter_linkage_name, release_linkage_name, take_result_linkage_name, cancel_linkage_name, async_info)
-        params = []
-        body = []
-        frame_pointer_type = pointer_to(frame_type)
-        frame_expr = IR::Name.new(name: async_frame_local_name, type: frame_pointer_type, pointer: false)
-        raw_frame_expr = IR::Cast.new(target_type: async_info[:void_ptr], expression: frame_expr, type: async_info[:void_ptr])
-
+          ),
+        ],
+      )
+      root_proc_type = Types::Registry.proc(params: [], return_type: task_type)
+      proc_setup, proc_value = lower_proc_expression_for_local(proc_expression, env:, local_name: root_proc_name, proc_type: root_proc_type)
+      body.concat(proc_setup)
+      body << IR::LocalDecl.new(
+        name: root_proc_name,
+        linkage_name: root_proc_name,
+        type: root_proc_type,
+        value: proc_value,
+      )
+
+      root_proc_expr = IR::Name.new(name: root_proc_name, type: root_proc_type, pointer: false)
+
+      if async_info[:result_type] == @ctx.types.fetch("int")
+        wait_callee = async_main_runtime_callee_name("wait", type_arguments: [async_info[:result_type]])
         body << IR::LocalDecl.new(
-          name: async_frame_local_name,
-          linkage_name: async_frame_local_name,
-          type: frame_pointer_type,
-          value: IR::Cast.new(
-            target_type: frame_pointer_type,
-            expression: IR::Call.new(
-              callee: "mt_async_alloc",
-              arguments: [IR::SizeofExpr.new(target_type: frame_type, type: @ctx.types.fetch("ptr_uint"))],
-              type: async_info[:void_ptr],
-            ),
-            type: frame_pointer_type,
+          name: result_name,
+          linkage_name: result_name,
+          type: @ctx.types.fetch("int"),
+          value: IR::Call.new(
+            callee: wait_callee,
+            arguments: [root_proc_expr],
+            type: @ctx.types.fetch("int"),
           ),
         )
-
-        binding.body_params.each do |param_binding|
-          field_info = async_info[:param_fields].fetch(param_binding.name)
-          field_type = field_info[:type]
-          param_type = field_info[:param_type]
-          linkage_name = c_local_name(param_binding.name)
-          input_linkage_name = array_type?(param_type) && !field_info[:pointer] ? "#{linkage_name}_input" : linkage_name
-          params << IR::Param.new(name: param_binding.name, linkage_name: input_linkage_name, type: param_type, pointer: field_info[:pointer])
-          frame_field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_type)
-          body << IR::Assignment.new(
-            target: frame_field_expr,
-            operator: "=",
-            value: IR::Name.new(name: input_linkage_name, type: param_type, pointer: field_info[:pointer]),
-          )
-          # Retain proc-containing params: the frame outlives the constructor call stack,
-          # so we must increment the env refcount so the caller releasing their copy is safe.
-          if !field_info[:pointer] && contains_proc_storage_type?(param_type)
-            body.concat(lower_proc_contained_retain_statements(frame_field_expr, param_type))
-          end
-        end
-
+      else
+        run_callee = async_main_runtime_callee_name("run")
         body << IR::ExpressionStmt.new(
-          expression: IR::Call.new(callee: resume_linkage_name, arguments: [raw_frame_expr], type: @ctx.types.fetch("void")),
-        )
-        body << IR::ReturnStmt.new(
-          value: IR::AggregateLiteral.new(
-            type: async_info[:task_type],
-            fields: [
-              IR::AggregateField.new(name: "frame", value: raw_frame_expr),
-              IR::AggregateField.new(name: "ready", value: IR::Name.new(name: ready_linkage_name, type: async_info[:task_type].field("ready"), pointer: false)),
-              IR::AggregateField.new(name: "set_waiter", value: IR::Name.new(name: set_waiter_linkage_name, type: async_info[:task_type].field("set_waiter"), pointer: false)),
-              IR::AggregateField.new(name: "release", value: IR::Name.new(name: release_linkage_name, type: async_info[:task_type].field("release"), pointer: false)),
-              IR::AggregateField.new(name: "take_result", value: IR::Name.new(name: take_result_linkage_name, type: async_info[:task_type].field("take_result"), pointer: false)),
-              IR::AggregateField.new(name: "cancel", value: IR::Name.new(name: cancel_linkage_name, type: async_info[:task_type].field("cancel"), pointer: false)),
-            ],
+          expression: IR::Call.new(
+            callee: run_callee,
+            arguments: [root_proc_expr],
+            type: @ctx.types.fetch("void"),
           ),
         )
-
-        IR::Function.new(
-          name: decl.name,
-          linkage_name: constructor_linkage_name,
-          params:,
-          return_type: async_info[:task_type],
-          body:,
-          entry_point: false,
-          method_receiver_param: !binding.type.receiver_type.nil?,
-        )
       end
 
-      def build_async_resume_function(binding, statements, frame_type, resume_linkage_name, async_info)
-        async_info = async_info.merge(resume_linkage_name:)
-        frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
-        raw_frame_expr = IR::Name.new(name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)
-        body = [async_frame_cast_declaration(frame_type, async_info)]
-
-        env = async_resume_env_for(async_info)
-        if async_info[:await_fields].empty?
-          body.concat(lower_async_non_await_statements(statements, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: []))
-        else
-          cases = (0..async_info[:await_fields].length).map do |state|
-            IR::SwitchCase.new(
-              value: IR::IntegerLiteral.new(value: state, type: @ctx.types.fetch("int")),
-              body: [IR::GotoStmt.new(label: async_state_label(resume_linkage_name, state))],
-            )
-          end
-          body << IR::SwitchStmt.new(expression: async_frame_field_expression(frame_expr, "state", @ctx.types.fetch("int")), cases:)
-          body << IR::ReturnStmt.new(value: nil)
-          body << IR::LabelStmt.new(name: async_state_label(resume_linkage_name, 0))
-          body.concat(lower_async_cf_statements(statements, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: []))
-        end
-
-        if async_info[:result_type] == @ctx.types.fetch("void") && !cfg_block_always_terminates?(statements)
-          body.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value: nil, result_already_stored: true))
-        end
-
-        IR::Function.new(
-          name: "#{binding.name}__resume",
-          linkage_name: resume_linkage_name,
-          params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
-          return_type: @ctx.types.fetch("void"),
-          body:,
-          entry_point: false,
+      body << IR::ExpressionStmt.new(
+        expression: lower_proc_release_expression(root_proc_expr, root_proc_type),
+      )
+      body.concat(cleanup_statements)
+      body << IR::ReturnStmt.new(
+        value: async_info[:result_type] == @ctx.types.fetch("int") ? IR::Name.new(name: result_name, type: @ctx.types.fetch("int"), pointer: false) : IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("int")),
+      )
+
+      IR::Function.new(
+        name: binding.name,
+        linkage_name: "main",
+        params:,
+        return_type: @ctx.types.fetch("int"),
+        body: body,
+        entry_point: true,
+      )
+    end
+
+    def async_main_runtime_callee_name(function_name, type_arguments: [])
+      binding = analysis_for_module("std.async").functions.fetch(function_name)
+      binding = binding.owner.instantiate_function_binding(binding, type_arguments) if type_arguments.any?
+      function_binding_c_name(binding, module_name: binding.owner.module_name)
+    end
+
+    def build_root_main_entrypoint(binding)
+      return nil if binding.async
+
+      signature = root_main_entrypoint_signature(binding)
+      return nil unless signature
+
+      params, setup_statements, call_arguments, cleanup_statements = build_root_main_entrypoint_bridge(signature)
+      return_type = binding.body_return_type
+      body = []
+      call = IR::Call.new(
+        callee: function_binding_c_name(binding, module_name: @ctx.module_name),
+        arguments: call_arguments,
+        type: return_type,
+      )
+
+      body.concat(setup_statements)
+      if return_type == @ctx.types.fetch("void")
+        body << IR::ExpressionStmt.new(expression: call)
+        body.concat(cleanup_statements)
+        body << IR::ReturnStmt.new(value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("int")))
+      elsif cleanup_statements.empty?
+        body << IR::ReturnStmt.new(value: call)
+      else
+        result_name = "__mt_result"
+        body << IR::LocalDecl.new(
+          name: result_name,
+          linkage_name: result_name,
+          type: @ctx.types.fetch("int"),
+          value: call,
         )
+        body.concat(cleanup_statements)
+        body << IR::ReturnStmt.new(value: IR::Name.new(name: result_name, type: @ctx.types.fetch("int"), pointer: false))
       end
 
-      def build_async_ready_function(frame_type, ready_linkage_name, async_info)
-        frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
-
-        IR::Function.new(
-          name: "#{ready_linkage_name}_fn",
-          linkage_name: ready_linkage_name,
-          params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
-          return_type: @ctx.types.fetch("bool"),
-          body: [
-            async_frame_cast_declaration(frame_type, async_info),
-            IR::ReturnStmt.new(value: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool"))),
+      IR::Function.new(
+        name: binding.name,
+        linkage_name: "main",
+        params:,
+        return_type: @ctx.types.fetch("int"),
+        body:,
+        entry_point: true,
+      )
+    end
+
+    def build_root_main_entrypoint_bridge(signature)
+      argc_type = @ctx.types.fetch("int")
+      raw_argv_type = pointer_to(pointer_to(@ctx.types.fetch("char")))
+      argc_name = "argc"
+      argv_name = "argv"
+
+      case signature[:kind]
+      when :none
+        [[], [], [], []]
+      when :raw_char_ptr_ptr
+        argc_expr = IR::Name.new(name: argc_name, type: argc_type, pointer: false)
+        argv_expr = IR::Name.new(name: argv_name, type: raw_argv_type, pointer: false)
+        [
+          [
+            IR::Param.new(name: argc_name, linkage_name: argc_name, type: argc_type, pointer: false),
+            IR::Param.new(name: argv_name, linkage_name: argv_name, type: raw_argv_type, pointer: false),
           ],
-          entry_point: false,
+          [],
+          [argc_expr, argv_expr],
+          [],
+        ]
+      when :raw_cstr_ptr
+        argc_expr = IR::Name.new(name: argc_name, type: argc_type, pointer: false)
+        argv_expr = IR::Cast.new(
+          target_type: signature[:argv_type],
+          expression: IR::Name.new(name: argv_name, type: raw_argv_type, pointer: false),
+          type: signature[:argv_type],
         )
-      end
-
-      def build_async_set_waiter_function(frame_type, set_waiter_linkage_name, async_info)
-        frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
-        waiter_frame_expr = IR::Name.new(name: "waiter_frame", type: async_info[:void_ptr], pointer: false)
-        waiter_expr = IR::Name.new(name: "waiter", type: async_info[:wake_type], pointer: false)
-
-        IR::Function.new(
-          name: "#{set_waiter_linkage_name}_fn",
-          linkage_name: set_waiter_linkage_name,
-          params: [
-            IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false),
-            IR::Param.new(name: "waiter_frame", linkage_name: "waiter_frame", type: async_info[:void_ptr], pointer: false),
-            IR::Param.new(name: "waiter", linkage_name: "waiter", type: async_info[:wake_type], pointer: false),
+        [
+          [
+            IR::Param.new(name: argc_name, linkage_name: argc_name, type: argc_type, pointer: false),
+            IR::Param.new(name: argv_name, linkage_name: argv_name, type: raw_argv_type, pointer: false),
           ],
-          return_type: @ctx.types.fetch("void"),
-          body: [
-            async_frame_cast_declaration(frame_type, async_info),
-            IR::IfStmt.new(
-              condition: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")),
-              then_body: [
-                IR::ExpressionStmt.new(expression: IR::Call.new(callee: waiter_expr, arguments: [waiter_frame_expr], type: @ctx.types.fetch("void"))),
-                IR::ReturnStmt.new(value: nil),
+          [],
+          [argc_expr, argv_expr],
+          [],
+        ]
+      when :span_str
+        items_type = pointer_to(@ctx.types.fetch("str"))
+        items_name = "__mt_args_items"
+        args_name = "__mt_args"
+        items_expr = IR::Name.new(name: items_name, type: items_type, pointer: false)
+        args_expr = IR::Name.new(name: args_name, type: signature[:args_type], pointer: false)
+        argc_expr = IR::Name.new(name: argc_name, type: argc_type, pointer: false)
+        argv_expr = IR::Name.new(name: argv_name, type: raw_argv_type, pointer: false)
+
+        setup = [
+          IR::LocalDecl.new(
+            name: items_name,
+            linkage_name: items_name,
+            type: items_type,
+            value: IR::NullLiteral.new(type: items_type),
+          ),
+          IR::LocalDecl.new(
+            name: args_name,
+            linkage_name: args_name,
+            type: signature[:args_type],
+            value: IR::Call.new(
+              callee: "mt_entry_argv_to_span_str",
+              arguments: [
+                argc_expr,
+                argv_expr,
+                IR::AddressOf.new(expression: items_expr, type: pointer_to(items_type)),
               ],
-              else_body: nil,
+              type: signature[:args_type],
             ),
-            IR::Assignment.new(target: async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr]), operator: "=", value: waiter_frame_expr),
-            IR::Assignment.new(target: async_frame_field_expression(frame_expr, "waiter", async_info[:wake_type]), operator: "=", value: waiter_expr),
-            IR::ReturnStmt.new(value: nil),
+          ),
+        ]
+        cleanup = [
+          IR::ExpressionStmt.new(
+            expression: IR::Call.new(callee: "mt_free_entry_argv_strs", arguments: [items_expr], type: @ctx.types.fetch("void")),
+          ),
+        ]
+
+        [
+          [
+            IR::Param.new(name: argc_name, linkage_name: argc_name, type: argc_type, pointer: false),
+            IR::Param.new(name: argv_name, linkage_name: argv_name, type: raw_argv_type, pointer: false),
           ],
-          entry_point: false,
-        )
+          setup,
+          [args_expr],
+          cleanup,
+        ]
+      else
+        raise LoweringError.new("unsupported root main entrypoint bridge #{signature[:kind]}",
+          line: 0, column: 0, path: @ctx.current_analysis_path)
       end
+    end
 
-      def build_async_release_function(frame_type, release_linkage_name, async_info)
-        frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
-        raw_frame_expr = IR::Name.new(name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)
-
-        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)]
-
-        if async_info[:await_fields].any?
-          await_release_stmts = []
-          async_info[:await_fields].each_value do |field_info|
-            task_field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:task_type])
-            task_frame_expr = async_task_frame_expression(task_field_expr, field_info[:task_type])
-            release_call = IR::ExpressionStmt.new(
-              expression: async_task_call(task_field_expr, field_info[:task_type], "release", [task_frame_expr], @ctx.types.fetch("void")),
-            )
-            await_release_stmts << IR::IfStmt.new(
-              condition: task_frame_expr,
-              then_body: [release_call],
-              else_body: nil,
-            )
-          end
-          body << IR::IfStmt.new(
-            condition: not_ready_expr,
-            then_body: await_release_stmts + not_ready_return,
-            else_body: nil,
-          )
-        else
-          body << IR::IfStmt.new(
-            condition: not_ready_expr,
-            then_body: not_ready_return,
-            else_body: nil,
-          )
-        end
-
-        # Release proc-containing params (always initialized by constructor, but null-guard is safe).
-        async_info[:param_fields].each_value do |field_info|
-          next if field_info[:pointer]
-          next unless contains_proc_storage_type?(field_info[:type])
+    def root_main_entrypoint_signature(binding)
+      return nil unless @ctx.analysis == @program.root_analysis
+      return nil unless binding.type.receiver_type.nil?
+      return nil unless binding.name == "main"
+      return nil unless binding.type_arguments.empty?
 
-          field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:type])
-          body.concat(lower_async_frame_proc_release_statements(field_expr, field_info[:type]))
-        end
+      return_type = binding.body_return_type
+      return nil unless return_type == @ctx.types.fetch("int") || return_type == @ctx.types.fetch("void")
 
-        # Release proc-containing locals (may not be initialized if function returned early via branch,
-        # so always null-guard via invoke pointer check on each proc).
-        async_info[:local_fields].each_value do |field_info|
-          next unless contains_proc_storage_type?(field_info[:storage_type])
+      params = binding.type.params
+      return { kind: :none } if params.empty?
 
-          field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:storage_type])
-          body.concat(lower_async_frame_proc_release_statements(field_expr, field_info[:storage_type]))
-        end
+      if params.length == 1 && params.first.type.is_a?(Types::Span) && params.first.type.element_type == @ctx.types.fetch("str")
+        return { kind: :span_str, args_type: params.first.type }
+      end
 
-        (async_info[:format_str_fields] || {}).each_key do |field_name|
-          field_expr = async_frame_field_expression(frame_expr, field_name, @ctx.types.fetch("str"))
-          body << IR::ExpressionStmt.new(
-            expression: IR::Call.new(
-              callee: "mt_format_str_release",
-              arguments: [field_expr],
-              type: @ctx.types.fetch("void"),
-            ),
-          )
+      return nil unless params.length == 2
+      return nil unless params[0].type == @ctx.types.fetch("int")
+
+      argv_type = params[1].type
+      return { kind: :raw_cstr_ptr, argv_type: } if argv_type == pointer_to(@ctx.types.fetch("cstr"))
+      return { kind: :raw_char_ptr_ptr, argv_type: } if argv_type == pointer_to(pointer_to(@ctx.types.fetch("char")))
+
+      nil
+    end
+
+
+    def build_async_constructor_function(binding, decl, frame_type, constructor_linkage_name, resume_linkage_name, ready_linkage_name, set_waiter_linkage_name, release_linkage_name, take_result_linkage_name, cancel_linkage_name, async_info)
+      params = []
+      body = []
+      frame_pointer_type = pointer_to(frame_type)
+      frame_expr = IR::Name.new(name: async_frame_local_name, type: frame_pointer_type, pointer: false)
+      raw_frame_expr = IR::Cast.new(target_type: async_info[:void_ptr], expression: frame_expr, type: async_info[:void_ptr])
+
+      body << IR::LocalDecl.new(
+        name: async_frame_local_name,
+        linkage_name: async_frame_local_name,
+        type: frame_pointer_type,
+        value: IR::Cast.new(
+          target_type: frame_pointer_type,
+          expression: IR::Call.new(
+            callee: "mt_async_alloc",
+            arguments: [IR::SizeofExpr.new(target_type: frame_type, type: @ctx.types.fetch("ptr_uint"))],
+            type: async_info[:void_ptr],
+          ),
+          type: frame_pointer_type,
+        ),
+      )
+
+      binding.body_params.each do |param_binding|
+        field_info = async_info[:param_fields].fetch(param_binding.name)
+        field_type = field_info[:type]
+        param_type = field_info[:param_type]
+        linkage_name = c_local_name(param_binding.name)
+        input_linkage_name = array_type?(param_type) && !field_info[:pointer] ? "#{linkage_name}_input" : linkage_name
+        params << IR::Param.new(name: param_binding.name, linkage_name: input_linkage_name, type: param_type, pointer: field_info[:pointer])
+        frame_field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_type)
+        body << IR::Assignment.new(
+          target: frame_field_expr,
+          operator: "=",
+          value: IR::Name.new(name: input_linkage_name, type: param_type, pointer: field_info[:pointer]),
+        )
+        # Retain proc-containing params: the frame outlives the constructor call stack,
+        # so we must increment the env refcount so the caller releasing their copy is safe.
+        if !field_info[:pointer] && contains_proc_storage_type?(param_type)
+          body.concat(lower_proc_contained_retain_statements(frame_field_expr, param_type))
         end
+      end
 
-        async_info[:param_fields].each_value do |field_info|
-          next unless field_info[:pointer]
-
-          param_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:type])
-          body << IR::ExpressionStmt.new(
-            expression: IR::Call.new(callee: "mt_async_free", arguments: [param_expr], type: @ctx.types.fetch("void")),
+      body << IR::ExpressionStmt.new(
+        expression: IR::Call.new(callee: resume_linkage_name, arguments: [raw_frame_expr], type: @ctx.types.fetch("void")),
+      )
+      body << IR::ReturnStmt.new(
+        value: IR::AggregateLiteral.new(
+          type: async_info[:task_type],
+          fields: [
+            IR::AggregateField.new(name: "frame", value: raw_frame_expr),
+            IR::AggregateField.new(name: "ready", value: IR::Name.new(name: ready_linkage_name, type: async_info[:task_type].field("ready"), pointer: false)),
+            IR::AggregateField.new(name: "set_waiter", value: IR::Name.new(name: set_waiter_linkage_name, type: async_info[:task_type].field("set_waiter"), pointer: false)),
+            IR::AggregateField.new(name: "release", value: IR::Name.new(name: release_linkage_name, type: async_info[:task_type].field("release"), pointer: false)),
+            IR::AggregateField.new(name: "take_result", value: IR::Name.new(name: take_result_linkage_name, type: async_info[:task_type].field("take_result"), pointer: false)),
+            IR::AggregateField.new(name: "cancel", value: IR::Name.new(name: cancel_linkage_name, type: async_info[:task_type].field("cancel"), pointer: false)),
+          ],
+        ),
+      )
+
+      IR::Function.new(
+        name: decl.name,
+        linkage_name: constructor_linkage_name,
+        params:,
+        return_type: async_info[:task_type],
+        body:,
+        entry_point: false,
+        method_receiver_param: !binding.type.receiver_type.nil?,
+      )
+    end
+
+    def build_async_resume_function(binding, statements, frame_type, resume_linkage_name, async_info)
+      async_info = async_info.merge(resume_linkage_name:)
+      frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
+      raw_frame_expr = IR::Name.new(name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)
+      body = [async_frame_cast_declaration(frame_type, async_info)]
+
+      env = async_resume_env_for(async_info)
+      if async_info[:await_fields].empty?
+        body.concat(lower_async_non_await_statements(statements, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: []))
+      else
+        cases = (0..async_info[:await_fields].length).map do |state|
+          IR::SwitchCase.new(
+            value: IR::IntegerLiteral.new(value: state, type: @ctx.types.fetch("int")),
+            body: [IR::GotoStmt.new(label: async_state_label(resume_linkage_name, state))],
           )
         end
-
-        body << IR::ExpressionStmt.new(expression: IR::Call.new(callee: "mt_async_free", arguments: [raw_frame_expr], type: @ctx.types.fetch("void")))
+        body << IR::SwitchStmt.new(expression: async_frame_field_expression(frame_expr, "state", @ctx.types.fetch("int")), cases:)
         body << IR::ReturnStmt.new(value: nil)
+        body << IR::LabelStmt.new(name: async_state_label(resume_linkage_name, 0))
+        body.concat(lower_async_cf_statements(statements, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: []))
+      end
 
-        IR::Function.new(
-          name: "#{release_linkage_name}_fn",
-          linkage_name: release_linkage_name,
-          params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
-          return_type: @ctx.types.fetch("void"),
-          body:,
-          entry_point: false,
-        )
+      if async_info[:result_type] == @ctx.types.fetch("void") && !cfg_block_always_terminates?(statements)
+        body.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value: nil, result_already_stored: true))
       end
 
-      def build_async_cancel_function(frame_type, cancel_linkage_name, async_info)
-        frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
+      IR::Function.new(
+        name: "#{binding.name}__resume",
+        linkage_name: resume_linkage_name,
+        params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
+        return_type: @ctx.types.fetch("void"),
+        body:,
+        entry_point: false,
+      )
+    end
+
+    def build_async_ready_function(frame_type, ready_linkage_name, async_info)
+      frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
+
+      IR::Function.new(
+        name: "#{ready_linkage_name}_fn",
+        linkage_name: ready_linkage_name,
+        params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
+        return_type: @ctx.types.fetch("bool"),
+        body: [
+          async_frame_cast_declaration(frame_type, async_info),
+          IR::ReturnStmt.new(value: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool"))),
+        ],
+        entry_point: false,
+      )
+    end
+
+    def build_async_set_waiter_function(frame_type, set_waiter_linkage_name, async_info)
+      frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
+      waiter_frame_expr = IR::Name.new(name: "waiter_frame", type: async_info[:void_ptr], pointer: false)
+      waiter_expr = IR::Name.new(name: "waiter", type: async_info[:wake_type], pointer: false)
+
+      IR::Function.new(
+        name: "#{set_waiter_linkage_name}_fn",
+        linkage_name: set_waiter_linkage_name,
+        params: [
+          IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false),
+          IR::Param.new(name: "waiter_frame", linkage_name: "waiter_frame", type: async_info[:void_ptr], pointer: false),
+          IR::Param.new(name: "waiter", linkage_name: "waiter", type: async_info[:wake_type], pointer: false),
+        ],
+        return_type: @ctx.types.fetch("void"),
+        body: [
+          async_frame_cast_declaration(frame_type, async_info),
+          IR::IfStmt.new(
+            condition: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")),
+            then_body: [
+              IR::ExpressionStmt.new(expression: IR::Call.new(callee: waiter_expr, arguments: [waiter_frame_expr], type: @ctx.types.fetch("void"))),
+              IR::ReturnStmt.new(value: nil),
+            ],
+            else_body: nil,
+          ),
+          IR::Assignment.new(target: async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr]), operator: "=", value: waiter_frame_expr),
+          IR::Assignment.new(target: async_frame_field_expression(frame_expr, "waiter", async_info[:wake_type]), operator: "=", value: waiter_expr),
+          IR::ReturnStmt.new(value: nil),
+        ],
+        entry_point: false,
+      )
+    end
 
-        body = [async_frame_cast_declaration(frame_type, async_info)]
+    def build_async_release_function(frame_type, release_linkage_name, async_info)
+      frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
+      raw_frame_expr = IR::Name.new(name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)
 
-        ready_expr = async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool"))
-        if_ready_return = IR::IfStmt.new(
-          condition: ready_expr,
-          then_body: [IR::ReturnStmt.new(value: nil)],
-          else_body: nil,
-        )
-        body << if_ready_return
+      body = [async_frame_cast_declaration(frame_type, async_info)]
 
-        cancelled_assign = IR::Assignment.new(
-          target: async_frame_field_expression(frame_expr, "cancelled", @ctx.types.fetch("bool")),
-          operator: "=",
-          value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")),
-        )
-        body << IR::ExpressionStmt.new(expression: cancelled_assign)
+      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)]
 
-        cancel_stmts = []
+      if async_info[:await_fields].any?
+        await_release_stmts = []
         async_info[:await_fields].each_value do |field_info|
           task_field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:task_type])
           task_frame_expr = async_task_frame_expression(task_field_expr, field_info[:task_type])
-          cancel_call = IR::ExpressionStmt.new(
-            expression: async_task_call(task_field_expr, field_info[:task_type], "cancel", [task_frame_expr], @ctx.types.fetch("void")),
-          )
           release_call = IR::ExpressionStmt.new(
             expression: async_task_call(task_field_expr, field_info[:task_type], "release", [task_frame_expr], @ctx.types.fetch("void")),
           )
-          cancel_member_expr = IR::Member.new(receiver: task_field_expr, member: "cancel", type: async_info[:task_type].field("cancel"))
-          cancel_stmts << IR::IfStmt.new(
+          await_release_stmts << IR::IfStmt.new(
             condition: task_frame_expr,
-            then_body: [
-              IR::IfStmt.new(
-                condition: cancel_member_expr,
-                then_body: [cancel_call],
-                else_body: nil,
-              ),
-              release_call,
-            ],
+            then_body: [release_call],
             else_body: nil,
           )
         end
-        body.concat(cancel_stmts) if cancel_stmts.any?
-
-        async_info[:param_fields].each_value do |field_info|
-          next if field_info[:pointer]
-          next unless contains_proc_storage_type?(field_info[:type])
-
-          field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:type])
-          body.concat(lower_async_frame_proc_release_statements(field_expr, field_info[:type]))
-        end
-
-        async_info[:local_fields].each_value do |field_info|
-          next unless contains_proc_storage_type?(field_info[:storage_type])
-
-          field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:storage_type])
-          body.concat(lower_async_frame_proc_release_statements(field_expr, field_info[:storage_type]))
-        end
-
-        (async_info[:format_str_fields] || {}).each_key do |field_name|
-          field_expr = async_frame_field_expression(frame_expr, field_name, @ctx.types.fetch("str"))
-          body << IR::ExpressionStmt.new(
-            expression: IR::Call.new(
-              callee: "mt_format_str_release",
-              arguments: [field_expr],
-              type: @ctx.types.fetch("void"),
-            ),
-          )
-        end
-
-        async_info[:param_fields].each_value do |field_info|
-          next unless field_info[:pointer]
-
-          param_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:type])
-          body << IR::ExpressionStmt.new(
-            expression: IR::Call.new(callee: "mt_async_free", arguments: [param_expr], type: @ctx.types.fetch("void")),
-          )
-        end
-
-        ready_assign = IR::Assignment.new(
-          target: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")),
-          operator: "=",
-          value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")),
+        body << IR::IfStmt.new(
+          condition: not_ready_expr,
+          then_body: await_release_stmts + not_ready_return,
+          else_body: nil,
         )
-        body << IR::ExpressionStmt.new(expression: ready_assign)
-
-        waiter_frame_expr = async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr])
-        wake_stmts = [
-          IR::ExpressionStmt.new(
-            expression: IR::Assignment.new(
-              target: async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr]),
-              operator: "=",
-              value: IR::NullLiteral.new(type: async_info[:void_ptr]),
-            ),
-          ),
-          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],
-              type: @ctx.types.fetch("void"),
-            ),
-          ),
-        ]
+      else
         body << IR::IfStmt.new(
-          condition: waiter_frame_expr,
-          then_body: wake_stmts,
+          condition: not_ready_expr,
+          then_body: not_ready_return,
           else_body: nil,
         )
+      end
 
-        body << IR::ReturnStmt.new(value: nil)
+      # Release proc-containing params (always initialized by constructor, but null-guard is safe).
+      async_info[:param_fields].each_value do |field_info|
+        next if field_info[:pointer]
+        next unless contains_proc_storage_type?(field_info[:type])
 
-        IR::Function.new(
-          name: "#{cancel_linkage_name}_fn",
-          linkage_name: cancel_linkage_name,
-          params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
-          return_type: @ctx.types.fetch("void"),
-          body:,
-          entry_point: false,
-        )
+        field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:type])
+        body.concat(lower_async_frame_proc_release_statements(field_expr, field_info[:type]))
       end
 
-      def build_async_take_result_function(frame_type, take_result_linkage_name, async_info)
-        frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
-        body = if async_info[:result_type] == @ctx.types.fetch("void")
-                 [IR::ReturnStmt.new(value: nil)]
-               else
-                 [async_frame_cast_declaration(frame_type, async_info),
-                  IR::ReturnStmt.new(value: async_frame_field_expression(frame_expr, "result", async_info[:result_type]))]
-               end
-
-        IR::Function.new(
-          name: "#{take_result_linkage_name}_fn",
-          linkage_name: take_result_linkage_name,
-          params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
-          return_type: async_info[:result_type],
-          body:,
-          entry_point: false,
-        )
-      end
+      # Release proc-containing locals (may not be initialized if function returned early via branch,
+      # so always null-guard via invoke pointer check on each proc).
+      async_info[:local_fields].each_value do |field_info|
+        next unless contains_proc_storage_type?(field_info[:storage_type])
 
-      def async_resume_env_for(async_info)
-        env = empty_env
-        async_info[:param_fields].each do |name, field_info|
-          env[:scopes].last[name] = local_binding(
-            type: field_info[:pointer] ? pointee_type(field_info[:type]) : field_info[:type],
-            linkage_name: async_frame_field_c_name(field_info[:field_name]),
-            mutable: field_info[:mutable],
-            pointer: field_info[:pointer],
-          )
-        end
-        env
+        field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:storage_type])
+        body.concat(lower_async_frame_proc_release_statements(field_expr, field_info[:storage_type]))
       end
 
-      def async_bind_local!(env, name, field_info)
-        current_actual_scope(env[:scopes])[name] = local_binding(
-          type: field_info[:type],
-          storage_type: field_info[:storage_type],
-          linkage_name: async_frame_field_c_name(field_info[:field_name]),
-          mutable: field_info[:mutable],
-          pointer: false,
+      (async_info[:format_str_fields] || {}).each_key do |field_name|
+        field_expr = async_frame_field_expression(frame_expr, field_name, @ctx.types.fetch("str"))
+        body << IR::ExpressionStmt.new(
+          expression: IR::Call.new(
+            callee: "mt_format_str_release",
+            arguments: [field_expr],
+            type: @ctx.types.fetch("void"),
+          ),
         )
       end
 
-      def async_frame_cast_declaration(frame_type, async_info)
-        IR::LocalDecl.new(
-          name: async_frame_local_name,
-          linkage_name: async_frame_local_name,
-          type: pointer_to(frame_type),
-          value: IR::Cast.new(
-            target_type: pointer_to(frame_type),
-            expression: IR::Name.new(name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false),
-            type: pointer_to(frame_type),
-          ),
+      async_info[:param_fields].each_value do |field_info|
+        next unless field_info[:pointer]
+
+        param_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:type])
+        body << IR::ExpressionStmt.new(
+          expression: IR::Call.new(callee: "mt_async_free", arguments: [param_expr], type: @ctx.types.fetch("void")),
         )
       end
 
-      def async_frame_local_name
-        "__mt_frame"
+      body << IR::ExpressionStmt.new(expression: IR::Call.new(callee: "mt_async_free", arguments: [raw_frame_expr], type: @ctx.types.fetch("void")))
+      body << IR::ReturnStmt.new(value: nil)
+
+      IR::Function.new(
+        name: "#{release_linkage_name}_fn",
+        linkage_name: release_linkage_name,
+        params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
+        return_type: @ctx.types.fetch("void"),
+        body:,
+        entry_point: false,
+      )
+    end
+
+    def build_async_cancel_function(frame_type, cancel_linkage_name, async_info)
+      frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
+
+      body = [async_frame_cast_declaration(frame_type, async_info)]
+
+      ready_expr = async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool"))
+      if_ready_return = IR::IfStmt.new(
+        condition: ready_expr,
+        then_body: [IR::ReturnStmt.new(value: nil)],
+        else_body: nil,
+      )
+      body << if_ready_return
+
+      cancelled_assign = IR::Assignment.new(
+        target: async_frame_field_expression(frame_expr, "cancelled", @ctx.types.fetch("bool")),
+        operator: "=",
+        value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")),
+      )
+      body << IR::ExpressionStmt.new(expression: cancelled_assign)
+
+      cancel_stmts = []
+      async_info[:await_fields].each_value do |field_info|
+        task_field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:task_type])
+        task_frame_expr = async_task_frame_expression(task_field_expr, field_info[:task_type])
+        cancel_call = IR::ExpressionStmt.new(
+          expression: async_task_call(task_field_expr, field_info[:task_type], "cancel", [task_frame_expr], @ctx.types.fetch("void")),
+        )
+        release_call = IR::ExpressionStmt.new(
+          expression: async_task_call(task_field_expr, field_info[:task_type], "release", [task_frame_expr], @ctx.types.fetch("void")),
+        )
+        cancel_member_expr = IR::Member.new(receiver: task_field_expr, member: "cancel", type: async_info[:task_type].field("cancel"))
+        cancel_stmts << IR::IfStmt.new(
+          condition: task_frame_expr,
+          then_body: [
+            IR::IfStmt.new(
+              condition: cancel_member_expr,
+              then_body: [cancel_call],
+              else_body: nil,
+            ),
+            release_call,
+          ],
+          else_body: nil,
+        )
       end
+      body.concat(cancel_stmts) if cancel_stmts.any?
 
-      def async_frame_raw_name
-        "__mt_frame_raw"
-      end
+      async_info[:param_fields].each_value do |field_info|
+        next if field_info[:pointer]
+        next unless contains_proc_storage_type?(field_info[:type])
 
-      def async_frame_field_c_name(field_name)
-        "#{async_frame_local_name}->#{field_name}"
+        field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:type])
+        body.concat(lower_async_frame_proc_release_statements(field_expr, field_info[:type]))
       end
 
-      def async_state_label(resume_linkage_name, state)
-        "#{resume_linkage_name}_state_#{state}"
+      async_info[:local_fields].each_value do |field_info|
+        next unless contains_proc_storage_type?(field_info[:storage_type])
+
+        field_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:storage_type])
+        body.concat(lower_async_frame_proc_release_statements(field_expr, field_info[:storage_type]))
       end
 
-      def async_frame_field_expression(frame_expr, field_name, field_type)
-        IR::Member.new(receiver: frame_expr, member: field_name, type: field_type)
+      (async_info[:format_str_fields] || {}).each_key do |field_name|
+        field_expr = async_frame_field_expression(frame_expr, field_name, @ctx.types.fetch("str"))
+        body << IR::ExpressionStmt.new(
+          expression: IR::Call.new(
+            callee: "mt_format_str_release",
+            arguments: [field_expr],
+            type: @ctx.types.fetch("void"),
+          ),
+        )
       end
 
-      def async_task_frame_expression(task_expr, task_type)
-        IR::Member.new(receiver: task_expr, member: "frame", type: task_type.field("frame"))
+      async_info[:param_fields].each_value do |field_info|
+        next unless field_info[:pointer]
+
+        param_expr = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:type])
+        body << IR::ExpressionStmt.new(
+          expression: IR::Call.new(callee: "mt_async_free", arguments: [param_expr], type: @ctx.types.fetch("void")),
+        )
       end
 
-      def async_task_call(task_expr, task_type, member, arguments, return_type)
-        IR::Call.new(
-          callee: IR::Member.new(receiver: task_expr, member:, type: task_type.field(member)),
-          arguments:,
-          type: return_type,
+      ready_assign = IR::Assignment.new(
+        target: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")),
+        operator: "=",
+        value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")),
+      )
+      body << IR::ExpressionStmt.new(expression: ready_assign)
+
+      waiter_frame_expr = async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr])
+      wake_stmts = [
+        IR::ExpressionStmt.new(
+          expression: IR::Assignment.new(
+            target: async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr]),
+            operator: "=",
+            value: IR::NullLiteral.new(type: async_info[:void_ptr]),
+          ),
+        ),
+        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],
+            type: @ctx.types.fetch("void"),
+          ),
+        ),
+      ]
+      body << IR::IfStmt.new(
+        condition: waiter_frame_expr,
+        then_body: wake_stmts,
+        else_body: nil,
+      )
+
+      body << IR::ReturnStmt.new(value: nil)
+
+      IR::Function.new(
+        name: "#{cancel_linkage_name}_fn",
+        linkage_name: cancel_linkage_name,
+        params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
+        return_type: @ctx.types.fetch("void"),
+        body:,
+        entry_point: false,
+      )
+    end
+
+    def build_async_take_result_function(frame_type, take_result_linkage_name, async_info)
+      frame_expr = IR::Name.new(name: async_frame_local_name, type: pointer_to(frame_type), pointer: false)
+      body = if async_info[:result_type] == @ctx.types.fetch("void")
+                [IR::ReturnStmt.new(value: nil)]
+              else
+                [async_frame_cast_declaration(frame_type, async_info),
+                IR::ReturnStmt.new(value: async_frame_field_expression(frame_expr, "result", async_info[:result_type]))]
+              end
+
+      IR::Function.new(
+        name: "#{take_result_linkage_name}_fn",
+        linkage_name: take_result_linkage_name,
+        params: [IR::Param.new(name: "frame", linkage_name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false)],
+        return_type: async_info[:result_type],
+        body:,
+        entry_point: false,
+      )
+    end
+
+    def async_resume_env_for(async_info)
+      env = empty_env
+      async_info[:param_fields].each do |name, field_info|
+        env[:scopes].last[name] = local_binding(
+          type: field_info[:pointer] ? pointee_type(field_info[:type]) : field_info[:type],
+          linkage_name: async_frame_field_c_name(field_info[:field_name]),
+          mutable: field_info[:mutable],
+          pointer: field_info[:pointer],
         )
       end
+      env
+    end
+
+    def async_bind_local!(env, name, field_info)
+      current_actual_scope(env[:scopes])[name] = local_binding(
+        type: field_info[:type],
+        storage_type: field_info[:storage_type],
+        linkage_name: async_frame_field_c_name(field_info[:field_name]),
+        mutable: field_info[:mutable],
+        pointer: false,
+      )
+    end
+
+    def async_frame_cast_declaration(frame_type, async_info)
+      IR::LocalDecl.new(
+        name: async_frame_local_name,
+        linkage_name: async_frame_local_name,
+        type: pointer_to(frame_type),
+        value: IR::Cast.new(
+          target_type: pointer_to(frame_type),
+          expression: IR::Name.new(name: async_frame_raw_name, type: async_info[:void_ptr], pointer: false),
+          type: pointer_to(frame_type),
+        ),
+      )
+    end
+
+    def async_frame_local_name
+      "__mt_frame"
+    end
+
+    def async_frame_raw_name
+      "__mt_frame_raw"
+    end
+
+    def async_frame_field_c_name(field_name)
+      "#{async_frame_local_name}->#{field_name}"
+    end
+
+    def async_state_label(resume_linkage_name, state)
+      "#{resume_linkage_name}_state_#{state}"
+    end
+
+    def async_frame_field_expression(frame_expr, field_name, field_type)
+      IR::Member.new(receiver: frame_expr, member: field_name, type: field_type)
+    end
+
+    def async_task_frame_expression(task_expr, task_type)
+      IR::Member.new(receiver: task_expr, member: "frame", type: task_type.field("frame"))
+    end
+
+    def async_task_call(task_expr, task_type, member, arguments, return_type)
+      IR::Call.new(
+        callee: IR::Member.new(receiver: task_expr, member:, type: task_type.field(member)),
+        arguments:,
+        type: return_type,
+      )
+    end
   end
 end