mt-lang 0.3.8 → 0.3.10

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

@@ -2,1412 +2,1411 @@
 
 module MilkTea
   module LowererAsync
-    private
-      def lower_contained_task_release_statements(value_expr, type)
-        return [] unless contains_task_type?(type)
-
-        void_type = @ctx.types.fetch("void")
-
-        case type
-        when Types::Task
-          task_frame_expr = IR::Member.new(receiver: value_expr, member: "frame", type: type.field("frame"))
-          release_call = IR::ExpressionStmt.new(
-            expression: IR::Call.new(
-              callee: IR::Member.new(receiver: value_expr, member: "release", type: type.field("release")),
-              arguments: [task_frame_expr],
-              type: void_type,
-            ),
-          )
-          [IR::IfStmt.new(condition: task_frame_expr, then_body: [release_call], else_body: nil)]
-
-        when Types::Struct, Types::StructInstance, Types::Union, Types::GenericStructDefinition, Types::VariantArmPayload
-          statements = []
-          type.fields.each do |field_name, field_type|
-            next unless contains_task_type?(field_type)
-
-            field_expr = IR::Member.new(receiver: value_expr, member: field_name, type: field_type)
-            statements.concat(lower_contained_task_release_statements(field_expr, field_type))
-          end
-          statements
-
-        when Types::VariantInstance
-          if type.definition.name == "Option" && type.arguments.any? { |a| contains_task_type?(a) }
-            lower_opt_task_value_release_statements(value_expr, type.arguments.first)
-          else
-            []
-          end
-
-        when Types::Variant, Types::GenericVariantDefinition
-          statements = []
-          type.arms.each do |arm_name, arm_fields|
-            arm_fields.each do |field_name, field_type|
-              next unless contains_task_type?(field_type)
-              data_expr = IR::Member.new(receiver: value_expr, member: "data", type: nil)
-              arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: nil)
-              field_expr = IR::Member.new(receiver: arm_expr, member: field_name, type: field_type)
-              statements.concat(lower_contained_task_release_statements(field_expr, field_type))
-            end
-          end
-          statements
+    def lower_contained_task_release_statements(value_expr, type)
+      return [] unless contains_task_type?(type)
+
+      void_type = @ctx.types.fetch("void")
+
+      case type
+      when Types::Task
+        task_frame_expr = IR::Member.new(receiver: value_expr, member: "frame", type: type.field("frame"))
+        release_call = IR::ExpressionStmt.new(
+          expression: IR::Call.new(
+            callee: IR::Member.new(receiver: value_expr, member: "release", type: type.field("release")),
+            arguments: [task_frame_expr],
+            type: void_type,
+          ),
+        )
+        [IR::IfStmt.new(condition: task_frame_expr, then_body: [release_call], else_body: nil)]
 
-        when Types::GenericInstance
-          if type.name == "Option" && type.arguments.any? { |a| contains_task_type?(a) }
-            lower_opt_task_value_release_statements(value_expr, type.arguments.first)
-          else
-            []
-          end
+      when Types::Struct, Types::StructInstance, Types::Union, Types::GenericStructDefinition, Types::VariantArmPayload
+        statements = []
+        type.fields.each do |field_name, field_type|
+          next unless contains_task_type?(field_type)
 
-        when Types::Nullable
-          lower_contained_task_release_statements(value_expr, type.base)
+          field_expr = IR::Member.new(receiver: value_expr, member: field_name, type: field_type)
+          statements.concat(lower_contained_task_release_statements(field_expr, field_type))
+        end
+        statements
 
+      when Types::VariantInstance
+        if type.definition.name == "Option" && type.arguments.any? { |a| contains_task_type?(a) }
+          lower_opt_task_value_release_statements(value_expr, type.arguments.first)
         else
           []
         end
-      end
 
-      def lower_opt_task_value_release_statements(value_expr, task_type)
-        int_type = @ctx.types.fetch("int")
-        kind_expr = IR::Member.new(receiver: value_expr, member: "kind", type: int_type)
-        some_check = IR::Binary.new(
-          operator: "==",
-          left: kind_expr,
-          right: IR::IntegerLiteral.new(value: 0, type: int_type),
-          type: @ctx.types.fetch("bool"),
-        )
-        data_expr = IR::Member.new(receiver: value_expr, member: "data", type: nil)
-        some_payload_expr = IR::Member.new(receiver: data_expr, member: "some", type: nil)
-        task_value_expr = IR::Member.new(receiver: some_payload_expr, member: "value", type: task_type)
-        release_body = lower_contained_task_release_statements(task_value_expr, task_type)
-        none_assignment = IR::Assignment.new(
-          target: kind_expr,
-          operator: "=",
-          value: IR::IntegerLiteral.new(value: 1, type: int_type),
-        )
-        then_body = release_body + [none_assignment]
-        [IR::IfStmt.new(condition: some_check, then_body:, else_body: nil)]
-      end
-
-      def lower_async_local_decl_statement(statement, field_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: [], loop_flow: nil)
-        lowered = []
-        type = field_info[:type]
-        storage_type = field_info[:storage_type]
-        target = async_frame_field_expression(frame_expr, field_info[:field_name], storage_type)
-        prepared_setup = []
-        prepared_value = statement.value
-
-        if statement.value
-          cleanup_start = (env[:prepared_expression_cleanups] ||= []).length
-          prepared_setup, prepared_value = prepare_expression_for_inline_lowering(
-            statement.value,
-            env:,
-            expected_type: storage_type,
-            allow_root_statement_foreign: true,
-          )
-          cleanup_count = (env[:prepared_expression_cleanups] || []).length - cleanup_start
-          if cleanup_count.positive?
-            async_info[:format_str_fields][field_info[:field_name]] = storage_type
-            env[:prepared_expression_cleanups].slice!(cleanup_start, cleanup_count)
+      when Types::Variant, Types::GenericVariantDefinition
+        statements = []
+        type.arms.each do |arm_name, arm_fields|
+          arm_fields.each do |field_name, field_type|
+            next unless contains_task_type?(field_type)
+            data_expr = IR::Member.new(receiver: value_expr, member: "data", type: nil)
+            arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: nil)
+            field_expr = IR::Member.new(receiver: arm_expr, member: field_name, type: field_type)
+            statements.concat(lower_contained_task_release_statements(field_expr, field_type))
           end
-          lowered.concat(prepared_setup)
         end
+        statements
 
-        if prepared_value && (foreign_call = foreign_call_info(prepared_value, env))
-          setup, value, call_type, release_assignments, cleanup_statements = lower_foreign_call_components(
-            foreign_call,
-            env:,
-            expected_type: storage_type,
-            statement_position: false,
-          )
-          lowered.concat(setup)
-          raise LoweringError.new("foreign call used to initialize #{statement.name} must return a value", line: 0, column: 0, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
-          raise LoweringError.new("consuming foreign calls must return void", line: 0, column: 0, path: @ctx.current_analysis_path) unless release_assignments.empty?
-
-          lowered << IR::Assignment.new(target:, operator: "=", value:)
-          lowered.concat(cleanup_statements)
+      when Types::GenericInstance
+        if type.name == "Option" && type.arguments.any? { |a| contains_task_type?(a) }
+          lower_opt_task_value_release_statements(value_expr, type.arguments.first)
         else
-          value = if prepared_value
-                    lower_contextual_expression(
-                      prepared_value,
-                      env:,
-                      expected_type: storage_type,
-                      contextual_int_to_float: statement.type && contextual_int_to_float_target?(type),
-                    )
-                  else
-                    IR::ZeroInit.new(type: storage_type)
-                  end
-          lowered << IR::Assignment.new(target:, operator: "=", value:)
+          []
         end
 
-        if statement.else_body
-          else_env = duplicate_env(env)
-          if statement.else_binding
-            current_actual_scope(else_env[:scopes])[statement.else_binding.name] = local_binding(
-              type: let_else_error_type(storage_type),
-              storage_type:,
-              linkage_name: async_frame_field_c_name(field_info[:field_name]),
-              mutable: false,
-              pointer: false,
-              projection: :result_failure_error,
-            )
-          end
-          else_body = lower_async_body(
-            statement.else_body,
-            env: else_env,
-            frame_expr:,
-            raw_frame_expr:,
-            resume_linkage_name:,
-            async_info:,
-            active_defers:,
-            loop_flow:,
-          )
-          lowered << IR::IfStmt.new(
-            condition: let_else_failure_condition(target, storage_type),
-            then_body: else_body,
-            else_body: nil,
-          )
-        end
+      when Types::Nullable
+        lower_contained_task_release_statements(value_expr, type.base)
 
-        lowered
+      else
+        []
       end
-      # Lowers a list of statements that contain no `await` anywhere, but live
-      # inside an async resume function. Return statements are lowered as async
-      # completions. All other control flow is lowered recursively.
-      def statements_contain_await?(statements, async_info)
-        statements.any? do |s|
-          case s
-          when AST::LocalDecl
-            async_info[:await_fields].key?(s.value&.object_id) || async_expression_contains_await?(s.value) || (s.else_body && statements_contain_await?(s.else_body, async_info))
-          when AST::Assignment
-            async_info[:await_fields].key?(s.value&.object_id) || async_expression_contains_await?(s.target) || async_expression_contains_await?(s.value)
-          when AST::ExpressionStmt
-            async_info[:await_fields].key?(s.expression&.object_id) || async_expression_contains_await?(s.expression)
-          when AST::ReturnStmt
-            async_info[:await_fields].key?(s.value&.object_id) || async_expression_contains_await?(s.value)
-          when AST::IfStmt
-            s.branches.any? { |b| statements_contain_await?(b.body, async_info) } ||
-              (s.else_body && statements_contain_await?(s.else_body, async_info))
-          when AST::WhileStmt
-            statements_contain_await?(s.body, async_info)
-          when AST::ForStmt
-            statements_contain_await?(s.body, async_info)
-          when AST::MatchStmt
-            s.arms.any? { |arm| statements_contain_await?(arm.body, async_info) }
-          when AST::UnsafeStmt
-            statements_contain_await?(s.body, async_info)
-          when AST::DeferStmt
-            (s.body && statements_contain_await?(s.body, async_info)) || (s.expression && async_expression_contains_await?(s.expression))
-          else
-            false
-          end
+    end
+
+    def lower_opt_task_value_release_statements(value_expr, task_type)
+      int_type = @ctx.types.fetch("int")
+      kind_expr = IR::Member.new(receiver: value_expr, member: "kind", type: int_type)
+      some_check = IR::Binary.new(
+        operator: "==",
+        left: kind_expr,
+        right: IR::IntegerLiteral.new(value: 0, type: int_type),
+        type: @ctx.types.fetch("bool"),
+      )
+      data_expr = IR::Member.new(receiver: value_expr, member: "data", type: nil)
+      some_payload_expr = IR::Member.new(receiver: data_expr, member: "some", type: nil)
+      task_value_expr = IR::Member.new(receiver: some_payload_expr, member: "value", type: task_type)
+      release_body = lower_contained_task_release_statements(task_value_expr, task_type)
+      none_assignment = IR::Assignment.new(
+        target: kind_expr,
+        operator: "=",
+        value: IR::IntegerLiteral.new(value: 1, type: int_type),
+      )
+      then_body = release_body + [none_assignment]
+      [IR::IfStmt.new(condition: some_check, then_body:, else_body: nil)]
+    end
+
+    def lower_async_local_decl_statement(statement, field_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: [], loop_flow: nil)
+      lowered = []
+      type = field_info[:type]
+      storage_type = field_info[:storage_type]
+      target = async_frame_field_expression(frame_expr, field_info[:field_name], storage_type)
+      prepared_setup = []
+      prepared_value = statement.value
+
+      if statement.value
+        cleanup_start = (env[:prepared_expression_cleanups] ||= []).length
+        prepared_setup, prepared_value = prepare_expression_for_inline_lowering(
+          statement.value,
+          env:,
+          expected_type: storage_type,
+          allow_root_statement_foreign: true,
+        )
+        cleanup_count = (env[:prepared_expression_cleanups] || []).length - cleanup_start
+        if cleanup_count.positive?
+          async_info[:format_str_fields][field_info[:field_name]] = storage_type
+          env[:prepared_expression_cleanups].slice!(cleanup_start, cleanup_count)
         end
+        lowered.concat(prepared_setup)
       end
 
-      def lower_async_body(body, env:, frame_expr:, raw_frame_expr:, async_info:, resume_linkage_name: nil, active_defers: [], loop_flow: nil)
-        if statements_contain_await?(body, async_info)
-          lower_async_cf_statements(body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
-        else
-          lower_async_non_await_statements(body, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers:, loop_flow:)
-        end
+      if prepared_value && (foreign_call = foreign_call_info(prepared_value, env))
+        setup, value, call_type, release_assignments, cleanup_statements = lower_foreign_call_components(
+          foreign_call,
+          env:,
+          expected_type: storage_type,
+          statement_position: false,
+        )
+        lowered.concat(setup)
+        raise LoweringError.new("foreign call used to initialize #{statement.name} must return a value", line: 0, column: 0, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
+        raise LoweringError.new("consuming foreign calls must return void", line: 0, column: 0, path: @ctx.current_analysis_path) unless release_assignments.empty?
+
+        lowered << IR::Assignment.new(target:, operator: "=", value:)
+        lowered.concat(cleanup_statements)
+      else
+        value = if prepared_value
+                  lower_contextual_expression(
+                    prepared_value,
+                    env:,
+                    expected_type: storage_type,
+                    contextual_int_to_float: statement.type && contextual_int_to_float_target?(type),
+                  )
+                else
+                  IR::ZeroInit.new(type: storage_type)
+                end
+        lowered << IR::Assignment.new(target:, operator: "=", value:)
       end
 
-      def build_async_while_with_condition_setup(condition_setup, condition, body, break_label)
-        if condition_setup.empty?
-          stmts = [IR::WhileStmt.new(condition:, body:)]
-          stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
-          return stmts
+      if statement.else_body
+        else_env = duplicate_env(env)
+        if statement.else_binding
+          current_actual_scope(else_env[:scopes])[statement.else_binding.name] = local_binding(
+            type: let_else_error_type(storage_type),
+            storage_type:,
+            linkage_name: async_frame_field_c_name(field_info[:field_name]),
+            mutable: false,
+            pointer: false,
+            projection: :result_failure_error,
+          )
         end
-
-        loop_body = [
-          *condition_setup,
-          IR::IfStmt.new(
-            condition: IR::Unary.new(operator: "not", operand: condition, type: @ctx.types.fetch("bool")),
-            then_body: [loop_exit_statement(loop_exit_break(break_label), local_defers: [], outer_defers: [])],
-            else_body: nil,
-          ),
-          *body,
-        ]
-        stmts = [IR::WhileStmt.new(condition: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")), body: loop_body)]
-        stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(loop_body, break_label)
-        stmts
-      end
-
-      # Lower a list of statements that MAY contain await expressions inside nested control flow.
-      # CPS-via-goto: labels placed inside if/while/match bodies, reachable from top-level switch dispatch.
-      def lower_async_cf_statements(statements, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: [], loop_flow: nil)
-        lowered = []
-        local_defers = []
-        env[:return_context] = async_return_context(
-          return_type: async_info[:result_type],
-          active_defers:,
-          local_defers:,
+        else_body = lower_async_body(
+          statement.else_body,
+          env: else_env,
           frame_expr:,
           raw_frame_expr:,
+          resume_linkage_name:,
           async_info:,
+          active_defers:,
+          loop_flow:,
+        )
+        lowered << IR::IfStmt.new(
+          condition: let_else_failure_condition(target, storage_type),
+          then_body: else_body,
+          else_body: nil,
         )
+      end
 
-        statements.each do |statement|
-          case statement
-          when AST::LocalDecl
-            field_info = async_info[:local_fields].fetch(async_local_decl_field_key(statement))
-            await_info = async_info[:await_fields][statement.value&.object_id]
-            if await_info
-              lowered.concat(lower_async_await_statement(statement, field_info:, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
-            else
-              lowered.concat(lower_async_local_decl_statement(statement, field_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
-            end
-            async_bind_local!(env, statement.name, field_info) if bind_let_else_local?(statement)
-          when AST::Assignment
-            await_info = async_info[:await_fields][statement.value&.object_id]
-            if await_info
-              lowered.concat(lower_async_await_statement(statement, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:))
-            else
-              lowered.concat(lower_async_assignment_statement(statement, env:))
-            end
-          when AST::ExpressionStmt
-            await_info = async_info[:await_fields][statement.expression&.object_id]
-            if await_info
-              lowered.concat(lower_async_await_statement(statement, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:))
-            else
-              lowered.concat(lower_async_expression_statement(statement, env:))
-            end
-          when AST::ReturnStmt
-            cleanup = lower_async_cleanup_entries(local_defers, active_defers, frame_expr:, raw_frame_expr:, async_info:)
-            await_info = async_info[:await_fields][statement.value&.object_id]
-            if await_info
-              lowered.concat(lower_async_await_statement(statement, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, cleanup:))
-            else
-              lowered.concat(lower_async_return_statement(statement, env:, frame_expr:, raw_frame_expr:, async_info:, cleanup:))
-            end
-          when AST::IfStmt
-            lowered.concat(lower_async_cf_if_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
-          when AST::WhileStmt
-            lowered.concat(lower_async_cf_while_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
-          when AST::ForStmt
-            lowered.concat(lower_async_cf_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers))
-          when AST::MatchStmt
-            lowered.concat(lower_async_cf_match_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
-          when AST::UnsafeStmt
-            lowered.concat(lower_async_cf_statements(statement.body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
-          when AST::DeferStmt
-            local_defers << lower_async_defer_cleanup(statement, env:, async_info:)
-          when AST::PassStmt
-            nil
-          when AST::BreakStmt
-            if loop_flow
-              lowered.concat(lower_async_loop_exit(loop_flow[:break_target], local_defers, loop_flow[:break_defers], frame_expr:, raw_frame_expr:, async_info:))
-            else
-              lowered << IR::BreakStmt.new
-            end
-          when AST::ContinueStmt
-            if loop_flow
-              lowered.concat(lower_async_loop_exit(loop_flow[:continue_target], local_defers, loop_flow[:continue_defers], frame_expr:, raw_frame_expr:, async_info:))
-            else
-              lowered << IR::ContinueStmt.new
-            end
-          when AST::StaticAssert
-            lowered.concat(lower_static_assert(statement))
-          else
-            raise LoweringError.new("unsupported async cf statement #{statement.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
-          end
+      lowered
+    end
+    # Lowers a list of statements that contain no `await` anywhere, but live
+    # inside an async resume function. Return statements are lowered as async
+    # completions. All other control flow is lowered recursively.
+    def statements_contain_await?(statements, async_info)
+      statements.any? do |s|
+        case s
+        when AST::LocalDecl
+          async_info[:await_fields].key?(s.value&.object_id) || async_expression_contains_await?(s.value) || (s.else_body && statements_contain_await?(s.else_body, async_info))
+        when AST::Assignment
+          async_info[:await_fields].key?(s.value&.object_id) || async_expression_contains_await?(s.target) || async_expression_contains_await?(s.value)
+        when AST::ExpressionStmt
+          async_info[:await_fields].key?(s.expression&.object_id) || async_expression_contains_await?(s.expression)
+        when AST::ReturnStmt
+          async_info[:await_fields].key?(s.value&.object_id) || async_expression_contains_await?(s.value)
+        when AST::IfStmt
+          s.branches.any? { |b| statements_contain_await?(b.body, async_info) } ||
+            (s.else_body && statements_contain_await?(s.else_body, async_info))
+        when AST::WhileStmt
+          statements_contain_await?(s.body, async_info)
+        when AST::ForStmt
+          statements_contain_await?(s.body, async_info)
+        when AST::MatchStmt
+          s.arms.any? { |arm| statements_contain_await?(arm.body, async_info) }
+        when AST::UnsafeStmt
+          statements_contain_await?(s.body, async_info)
+        when AST::DeferStmt
+          (s.body && statements_contain_await?(s.body, async_info)) || (s.expression && async_expression_contains_await?(s.expression))
+        else
+          false
         end
+      end
+    end
 
-        unless cfg_block_always_terminates?(statements)
-          lowered.concat(lower_async_cleanup_entries(local_defers, [], frame_expr:, raw_frame_expr:, async_info:))
-        end
-        lowered
+    def lower_async_body(body, env:, frame_expr:, raw_frame_expr:, async_info:, resume_linkage_name: nil, active_defers: [], loop_flow: nil)
+      if statements_contain_await?(body, async_info)
+        lower_async_cf_statements(body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
+      else
+        lower_async_non_await_statements(body, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers:, loop_flow:)
       end
+    end
 
-      def lower_async_cf_if_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
-        branch_entries = statement.branches.map do |branch|
-          condition_setup, prepared_cond = prepare_expression_for_inline_lowering(branch.condition, env:)
-          condition = lower_contextual_expression(prepared_cond, env:, expected_type: @ctx.types.fetch("bool"))
-          body = lower_async_body(branch.body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
-          { condition_setup:, condition:, body: }
-        end
+    def build_async_while_with_condition_setup(condition_setup, condition, body, break_label)
+      if condition_setup.empty?
+        stmts = [IR::WhileStmt.new(condition:, body:)]
+        stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
+        return stmts
+      end
 
-        else_body = if statement.else_body
-          lower_async_body(statement.else_body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
+      loop_body = [
+        *condition_setup,
+        IR::IfStmt.new(
+          condition: IR::Unary.new(operator: "not", operand: condition, type: @ctx.types.fetch("bool")),
+          then_body: [loop_exit_statement(loop_exit_break(break_label), local_defers: [], outer_defers: [])],
+          else_body: nil,
+        ),
+        *body,
+      ]
+      stmts = [IR::WhileStmt.new(condition: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")), body: loop_body)]
+      stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(loop_body, break_label)
+      stmts
+    end
+
+    # Lower a list of statements that MAY contain await expressions inside nested control flow.
+    # CPS-via-goto: labels placed inside if/while/match bodies, reachable from top-level switch dispatch.
+    def lower_async_cf_statements(statements, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: [], loop_flow: nil)
+      lowered = []
+      local_defers = []
+      env[:return_context] = async_return_context(
+        return_type: async_info[:result_type],
+        active_defers:,
+        local_defers:,
+        frame_expr:,
+        raw_frame_expr:,
+        async_info:,
+      )
+
+      statements.each do |statement|
+        case statement
+        when AST::LocalDecl
+          field_info = async_info[:local_fields].fetch(async_local_decl_field_key(statement))
+          await_info = async_info[:await_fields][statement.value&.object_id]
+          if await_info
+            lowered.concat(lower_async_await_statement(statement, field_info:, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
+          else
+            lowered.concat(lower_async_local_decl_statement(statement, field_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
+          end
+          async_bind_local!(env, statement.name, field_info) if bind_let_else_local?(statement)
+        when AST::Assignment
+          await_info = async_info[:await_fields][statement.value&.object_id]
+          if await_info
+            lowered.concat(lower_async_await_statement(statement, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:))
+          else
+            lowered.concat(lower_async_assignment_statement(statement, env:))
+          end
+        when AST::ExpressionStmt
+          await_info = async_info[:await_fields][statement.expression&.object_id]
+          if await_info
+            lowered.concat(lower_async_await_statement(statement, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:))
+          else
+            lowered.concat(lower_async_expression_statement(statement, env:))
+          end
+        when AST::ReturnStmt
+          cleanup = lower_async_cleanup_entries(local_defers, active_defers, frame_expr:, raw_frame_expr:, async_info:)
+          await_info = async_info[:await_fields][statement.value&.object_id]
+          if await_info
+            lowered.concat(lower_async_await_statement(statement, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, cleanup:))
+          else
+            lowered.concat(lower_async_return_statement(statement, env:, frame_expr:, raw_frame_expr:, async_info:, cleanup:))
+          end
+        when AST::IfStmt
+          lowered.concat(lower_async_cf_if_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
+        when AST::WhileStmt
+          lowered.concat(lower_async_cf_while_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
+        when AST::ForStmt
+          lowered.concat(lower_async_cf_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers))
+        when AST::MatchStmt
+          lowered.concat(lower_async_cf_match_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
+        when AST::UnsafeStmt
+          lowered.concat(lower_async_cf_statements(statement.body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)))
+        when AST::DeferStmt
+          local_defers << lower_async_defer_cleanup(statement, env:, async_info:)
+        when AST::PassStmt
+          nil
+        when AST::BreakStmt
+          if loop_flow
+            lowered.concat(lower_async_loop_exit(loop_flow[:break_target], local_defers, loop_flow[:break_defers], frame_expr:, raw_frame_expr:, async_info:))
+          else
+            lowered << IR::BreakStmt.new
+          end
+        when AST::ContinueStmt
+          if loop_flow
+            lowered.concat(lower_async_loop_exit(loop_flow[:continue_target], local_defers, loop_flow[:continue_defers], frame_expr:, raw_frame_expr:, async_info:))
+          else
+            lowered << IR::ContinueStmt.new
+          end
+        when AST::StaticAssert
+          lowered.concat(lower_static_assert(statement))
+        else
+          raise LoweringError.new("unsupported async cf statement #{statement.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
+      end
 
-        nested_else = else_body
-        branch_entries.reverse_each do |entry|
-          nested_else = [
-            *entry[:condition_setup],
-            IR::IfStmt.new(condition: entry[:condition], then_body: entry[:body], else_body: nested_else),
-          ]
-        end
-        nested_else || []
+      unless cfg_block_always_terminates?(statements)
+        lowered.concat(lower_async_cleanup_entries(local_defers, [], frame_expr:, raw_frame_expr:, async_info:))
       end
+      lowered
+    end
 
-      def lower_async_cf_while_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
-        continue_label = fresh_c_temp_name(env, "loop_continue")
-        break_label = fresh_c_temp_name(env, "loop_break")
-        condition_setup, prepared_cond = prepare_expression_for_inline_lowering(statement.condition, env:)
+    def lower_async_cf_if_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
+      branch_entries = statement.branches.map do |branch|
+        condition_setup, prepared_cond = prepare_expression_for_inline_lowering(branch.condition, env:)
         condition = lower_contextual_expression(prepared_cond, env:, expected_type: @ctx.types.fetch("bool"))
-        inner_loop_flow = loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label))
-        body = lower_async_body(statement.body, env: duplicate_env(env), frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: inner_loop_flow)
-        body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
-
-        build_async_while_with_condition_setup(condition_setup, condition, body, break_label)
+        body = lower_async_body(branch.body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
+        { condition_setup:, condition:, body: }
       end
 
-      def lower_async_cf_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
-        return lower_async_cf_parallel_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:) if statement.parallel?
+      else_body = if statement.else_body
+        lower_async_body(statement.else_body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
+      end
 
-        if range_iterable?(statement.iterable)
-          lower_async_cf_range_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
-        else
-          lower_async_cf_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
-        end
+      nested_else = else_body
+      branch_entries.reverse_each do |entry|
+        nested_else = [
+          *entry[:condition_setup],
+          IR::IfStmt.new(condition: entry[:condition], then_body: entry[:body], else_body: nested_else),
+        ]
+      end
+      nested_else || []
+    end
+
+    def lower_async_cf_while_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
+      continue_label = fresh_c_temp_name(env, "loop_continue")
+      break_label = fresh_c_temp_name(env, "loop_break")
+      condition_setup, prepared_cond = prepare_expression_for_inline_lowering(statement.condition, env:)
+      condition = lower_contextual_expression(prepared_cond, env:, expected_type: @ctx.types.fetch("bool"))
+      inner_loop_flow = loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label))
+      body = lower_async_body(statement.body, env: duplicate_env(env), frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: inner_loop_flow)
+      body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
+
+      build_async_while_with_condition_setup(condition_setup, condition, body, break_label)
+    end
+
+    def lower_async_cf_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
+      return lower_async_cf_parallel_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:) if statement.parallel?
+
+      if range_iterable?(statement.iterable)
+        lower_async_cf_range_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
+      else
+        lower_async_cf_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
       end
+    end
+
+    def lower_range_call(iterable, env:)
+      loop_type = infer_range_loop_type(iterable, env:)
+      start_expr_ast = range_start_of(iterable)
+      stop_expr_ast = range_end_of(iterable)
+      start_ir = lower_expression(start_expr_ast, env:, expected_type: loop_type)
+      stop_ir = lower_expression(stop_expr_ast, env:, expected_type: loop_type)
+      [start_ir, stop_ir, false]
+    end
+
+    def lower_async_cf_range_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
+      loop_var_name = statement.name
+      loop_var_type = infer_range_loop_type(statement.iterable, env:)
+      loop_var_field = async_info[:local_fields].fetch(loop_var_name)
+      loop_var_expr = async_frame_field_expression(frame_expr, loop_var_field[:field_name], loop_var_type)
+      continue_label = fresh_c_temp_name(env, "loop_continue")
+      break_label = fresh_c_temp_name(env, "loop_break")
+
+      start_expr, stop_expr, inclusive = lower_range_call(statement.iterable, env:)
+
+      # Store stop value in frame too so it survives suspension
+      stop_field_name = "#{loop_var_field[:field_name]}_stop"
+      async_info[:local_fields][stop_field_name] ||= { field_name: stop_field_name, type: loop_var_type, mutable: true }
+      stop_field_expr = async_frame_field_expression(frame_expr, stop_field_name, loop_var_type)
+
+      inner_env = duplicate_env(env)
+      inner_env[:scopes].last[loop_var_name] = local_binding(
+        type: loop_var_type,
+        linkage_name: async_frame_field_c_name(loop_var_field[:field_name]),
+        mutable: true, pointer: false
+      )
+      inner_loop_flow = loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label))
+
+      body = lower_async_body(statement.body, env: inner_env, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: inner_loop_flow)
+      body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
+
+      cmp_op = inclusive ? "<=" : "<"
+      stmts = [
+        IR::Assignment.new(target: loop_var_expr, operator: "=", value: start_expr),
+        IR::Assignment.new(target: stop_field_expr, operator: "=", value: stop_expr),
+        IR::WhileStmt.new(
+          condition: IR::Binary.new(operator: cmp_op, left: loop_var_expr, right: stop_field_expr, type: @ctx.types.fetch("bool")),
+          body: body + [IR::Assignment.new(target: loop_var_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: loop_var_type))],
+        ),
+      ]
+      stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
+      stmts
+    end
+
+    def lower_async_cf_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
+      iterable_type = infer_expression_type(statement.iterable, env:)
+      element_type = collection_loop_type(iterable_type)
+      raise LoweringError.new("for loop expects start..stop, array[T, N], or span[T], got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
+
+      iterable_setup, prepared_iterable = prepare_expression_for_inline_lowering(statement.iterable, env:, expected_type: iterable_type)
+      continue_label = fresh_c_temp_name(env, "loop_continue")
+      break_label = fresh_c_temp_name(env, "loop_break")
+      iterable_field = async_info[:local_fields].fetch(async_collection_iterable_field_key(statement))
+      index_field = async_info[:local_fields].fetch(async_collection_index_field_key(statement))
+      iterable_ref = async_frame_field_expression(frame_expr, iterable_field[:field_name], iterable_type)
+      index_ref = async_frame_field_expression(frame_expr, index_field[:field_name], @ctx.types.fetch("ptr_uint"))
+
+      # Loop variable stored in frame so it survives suspension
+      loop_var_field = async_info[:local_fields].fetch(statement.name)
+      loop_var_expr = async_frame_field_expression(frame_expr, loop_var_field[:field_name], element_type)
+
+      item_value = if array_type?(iterable_type)
+                      IR::Index.new(receiver: iterable_ref, index: index_ref, type: element_type)
+                    else
+                      data_ref = IR::Member.new(receiver: iterable_ref, member: "data", type: pointer_to(element_type))
+                      IR::Index.new(receiver: data_ref, index: index_ref, type: element_type)
+                    end
+      stop_value = if array_type?(iterable_type)
+                      IR::IntegerLiteral.new(value: array_length(iterable_type), type: @ctx.types.fetch("ptr_uint"))
+                    else
+                      IR::Member.new(receiver: iterable_ref, member: "len", type: @ctx.types.fetch("ptr_uint"))
+                    end
+
+      inner_env = duplicate_env(env)
+      inner_env[:scopes].last[statement.name] = local_binding(
+        type: element_type, linkage_name: async_frame_field_c_name(loop_var_field[:field_name]), mutable: true, pointer: false
+      )
+      inner_loop_flow = loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label))
+
+      assign_item = IR::Assignment.new(target: loop_var_expr, operator: "=", value: item_value)
+      body_stmts = lower_async_body(statement.body, env: inner_env, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: inner_loop_flow)
+      body_stmts << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body_stmts, continue_label)
+
+      stmts = [
+        *iterable_setup,
+        IR::Assignment.new(target: iterable_ref, operator: "=", value: lower_expression(prepared_iterable, env:, expected_type: iterable_type)),
+        IR::Assignment.new(target: index_ref, operator: "=", value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
+        IR::WhileStmt.new(
+          condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
+          body: [assign_item] + body_stmts + [
+            IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+          ],
+        ),
+      ]
+      stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body_stmts, break_label)
+      stmts
+    end
+
+    def lower_async_cf_parallel_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
+      infos = statement.bindings.each_with_index.map do |binding, index|
+        iterable = statement.iterables[index]
+        iterable_type = infer_expression_type(iterable, env:)
+        element_type = collection_loop_type(iterable_type)
+        raise LoweringError.new("parallel for loops expect arrays or spans for each iterable, got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
 
-      def lower_range_call(iterable, env:)
-        loop_type = infer_range_loop_type(iterable, env:)
-        start_expr_ast = range_start_of(iterable)
-        stop_expr_ast = range_end_of(iterable)
-        start_ir = lower_expression(start_expr_ast, env:, expected_type: loop_type)
-        stop_ir = lower_expression(stop_expr_ast, env:, expected_type: loop_type)
-        [start_ir, stop_ir, false]
+        {
+          binding:,
+          iterable:,
+          iterable_type:,
+          element_type:,
+          binding_type: collection_loop_binding_type(iterable_type, element_type) || element_type,
+          iterable_field: async_info[:local_fields].fetch(async_collection_iterable_field_key(statement, index)),
+        }
       end
 
-      def lower_async_cf_range_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
-        loop_var_name = statement.name
-        loop_var_type = infer_range_loop_type(statement.iterable, env:)
-        loop_var_field = async_info[:local_fields].fetch(loop_var_name)
-        loop_var_expr = async_frame_field_expression(frame_expr, loop_var_field[:field_name], loop_var_type)
-        continue_label = fresh_c_temp_name(env, "loop_continue")
-        break_label = fresh_c_temp_name(env, "loop_break")
-
-        start_expr, stop_expr, inclusive = lower_range_call(statement.iterable, env:)
-
-        # Store stop value in frame too so it survives suspension
-        stop_field_name = "#{loop_var_field[:field_name]}_stop"
-        async_info[:local_fields][stop_field_name] ||= { field_name: stop_field_name, type: loop_var_type, mutable: true }
-        stop_field_expr = async_frame_field_expression(frame_expr, stop_field_name, loop_var_type)
-
-        inner_env = duplicate_env(env)
-        inner_env[:scopes].last[loop_var_name] = local_binding(
-          type: loop_var_type,
-          linkage_name: async_frame_field_c_name(loop_var_field[:field_name]),
-          mutable: true, pointer: false
-        )
-        inner_loop_flow = loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label))
-
-        body = lower_async_body(statement.body, env: inner_env, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: inner_loop_flow)
-        body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
-
-        cmp_op = inclusive ? "<=" : "<"
-        stmts = [
-          IR::Assignment.new(target: loop_var_expr, operator: "=", value: start_expr),
-          IR::Assignment.new(target: stop_field_expr, operator: "=", value: stop_expr),
-          IR::WhileStmt.new(
-            condition: IR::Binary.new(operator: cmp_op, left: loop_var_expr, right: stop_field_expr, type: @ctx.types.fetch("bool")),
-            body: body + [IR::Assignment.new(target: loop_var_expr, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: loop_var_type))],
-          ),
-        ]
-        stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
-        stmts
+      iterable_entries = infos.map do |info|
+        setup, prepared_iterable = prepare_expression_for_inline_lowering(info[:iterable], env:, expected_type: info[:iterable_type])
+        info.merge(setup:, prepared_iterable:)
       end
 
-      def lower_async_cf_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
-        iterable_type = infer_expression_type(statement.iterable, env:)
-        element_type = collection_loop_type(iterable_type)
-        raise LoweringError.new("for loop expects start..stop, array[T, N], or span[T], got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
-
-        iterable_setup, prepared_iterable = prepare_expression_for_inline_lowering(statement.iterable, env:, expected_type: iterable_type)
-        continue_label = fresh_c_temp_name(env, "loop_continue")
-        break_label = fresh_c_temp_name(env, "loop_break")
-        iterable_field = async_info[:local_fields].fetch(async_collection_iterable_field_key(statement))
-        index_field = async_info[:local_fields].fetch(async_collection_index_field_key(statement))
-        iterable_ref = async_frame_field_expression(frame_expr, iterable_field[:field_name], iterable_type)
-        index_ref = async_frame_field_expression(frame_expr, index_field[:field_name], @ctx.types.fetch("ptr_uint"))
-
-        # Loop variable stored in frame so it survives suspension
-        loop_var_field = async_info[:local_fields].fetch(statement.name)
-        loop_var_expr = async_frame_field_expression(frame_expr, loop_var_field[:field_name], element_type)
-
-        item_value = if array_type?(iterable_type)
-                       IR::Index.new(receiver: iterable_ref, index: index_ref, type: element_type)
-                     else
-                       data_ref = IR::Member.new(receiver: iterable_ref, member: "data", type: pointer_to(element_type))
-                       IR::Index.new(receiver: data_ref, index: index_ref, type: element_type)
-                     end
-        stop_value = if array_type?(iterable_type)
-                       IR::IntegerLiteral.new(value: array_length(iterable_type), type: @ctx.types.fetch("ptr_uint"))
-                     else
-                       IR::Member.new(receiver: iterable_ref, member: "len", type: @ctx.types.fetch("ptr_uint"))
-                     end
-
-        inner_env = duplicate_env(env)
-        inner_env[:scopes].last[statement.name] = local_binding(
-          type: element_type, linkage_name: async_frame_field_c_name(loop_var_field[:field_name]), mutable: true, pointer: false
+      continue_label = fresh_c_temp_name(env, "loop_continue")
+      break_label = fresh_c_temp_name(env, "loop_break")
+      index_field = async_info[:local_fields].fetch(async_collection_index_field_key(statement))
+      index_ref = async_frame_field_expression(frame_expr, index_field[:field_name], @ctx.types.fetch("ptr_uint"))
+      iterable_refs = iterable_entries.map do |entry|
+        async_frame_field_expression(frame_expr, entry[:iterable_field][:field_name], entry[:iterable_type])
+      end
+      stop_value = collection_loop_stop_value(iterable_refs.first, iterable_entries.first[:iterable_type])
+
+      inner_env = duplicate_env(env)
+      assign_items = iterable_entries.map.with_index do |entry, index|
+        item_value = collection_loop_item_value(iterable_refs[index], entry[:iterable_type], index_ref, entry[:element_type])
+        loop_item_value = if ref_type?(entry[:binding_type])
+                            IR::AddressOf.new(expression: item_value, type: entry[:binding_type])
+                          else
+                            item_value
+                          end
+        binding_field = async_info[:local_fields].fetch(entry[:binding].name)
+        binding_target = async_frame_field_expression(frame_expr, binding_field[:field_name], entry[:binding_type])
+        inner_env[:scopes].last[entry[:binding].name] = local_binding(
+          type: entry[:binding_type],
+          linkage_name: async_frame_field_c_name(binding_field[:field_name]),
+          mutable: true,
+          pointer: false,
         )
-        inner_loop_flow = loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label))
-
-        assign_item = IR::Assignment.new(target: loop_var_expr, operator: "=", value: item_value)
-        body_stmts = lower_async_body(statement.body, env: inner_env, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: inner_loop_flow)
-        body_stmts << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body_stmts, continue_label)
-
-        stmts = [
-          *iterable_setup,
-          IR::Assignment.new(target: iterable_ref, operator: "=", value: lower_expression(prepared_iterable, env:, expected_type: iterable_type)),
-          IR::Assignment.new(target: index_ref, operator: "=", value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
-          IR::WhileStmt.new(
-            condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
-            body: [assign_item] + body_stmts + [
-              IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-            ],
-          ),
-        ]
-        stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body_stmts, break_label)
-        stmts
+        IR::Assignment.new(target: binding_target, operator: "=", value: loop_item_value)
       end
+      inner_loop_flow = loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label))
+      body_stmts = lower_async_body(statement.body, env: inner_env, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: inner_loop_flow)
+      body_stmts << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body_stmts, continue_label)
 
-      def lower_async_cf_parallel_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:)
-        infos = statement.bindings.each_with_index.map do |binding, index|
-          iterable = statement.iterables[index]
-          iterable_type = infer_expression_type(iterable, env:)
-          element_type = collection_loop_type(iterable_type)
-          raise LoweringError.new("parallel for loops expect arrays or spans for each iterable, got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
-
-          {
-            binding:,
-            iterable:,
-            iterable_type:,
-            element_type:,
-            binding_type: collection_loop_binding_type(iterable_type, element_type) || element_type,
-            iterable_field: async_info[:local_fields].fetch(async_collection_iterable_field_key(statement, index)),
-          }
-        end
-
-        iterable_entries = infos.map do |info|
-          setup, prepared_iterable = prepare_expression_for_inline_lowering(info[:iterable], env:, expected_type: info[:iterable_type])
-          info.merge(setup:, prepared_iterable:)
-        end
-
-        continue_label = fresh_c_temp_name(env, "loop_continue")
-        break_label = fresh_c_temp_name(env, "loop_break")
-        index_field = async_info[:local_fields].fetch(async_collection_index_field_key(statement))
-        index_ref = async_frame_field_expression(frame_expr, index_field[:field_name], @ctx.types.fetch("ptr_uint"))
-        iterable_refs = iterable_entries.map do |entry|
-          async_frame_field_expression(frame_expr, entry[:iterable_field][:field_name], entry[:iterable_type])
-        end
-        stop_value = collection_loop_stop_value(iterable_refs.first, iterable_entries.first[:iterable_type])
-
-        inner_env = duplicate_env(env)
-        assign_items = iterable_entries.map.with_index do |entry, index|
-          item_value = collection_loop_item_value(iterable_refs[index], entry[:iterable_type], index_ref, entry[:element_type])
-          loop_item_value = if ref_type?(entry[:binding_type])
-                              IR::AddressOf.new(expression: item_value, type: entry[:binding_type])
-                            else
-                              item_value
-                            end
-          binding_field = async_info[:local_fields].fetch(entry[:binding].name)
-          binding_target = async_frame_field_expression(frame_expr, binding_field[:field_name], entry[:binding_type])
-          inner_env[:scopes].last[entry[:binding].name] = local_binding(
-            type: entry[:binding_type],
-            linkage_name: async_frame_field_c_name(binding_field[:field_name]),
-            mutable: true,
-            pointer: false,
-          )
-          IR::Assignment.new(target: binding_target, operator: "=", value: loop_item_value)
-        end
-        inner_loop_flow = loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label))
-        body_stmts = lower_async_body(statement.body, env: inner_env, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: inner_loop_flow)
-        body_stmts << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body_stmts, continue_label)
-
-        length_checks = iterable_entries.drop(1).each_with_index.map do |entry, offset|
-          IR::IfStmt.new(
-            condition: IR::Binary.new(
-              operator: "!=",
-              left: collection_loop_stop_value(iterable_refs[offset + 1], entry[:iterable_type]),
-              right: stop_value,
-              type: @ctx.types.fetch("bool"),
-            ),
-            then_body: [lower_fatal_statement("parallel for iterables must have matching lengths", env:)],
-            else_body: nil,
-          )
-        end
-
-        stmts = [
-          *iterable_entries.flat_map { |entry| entry[:setup] },
-          *iterable_entries.each_with_index.map do |entry, index|
-            IR::Assignment.new(
-              target: iterable_refs[index],
-              operator: "=",
-              value: lower_expression(entry[:prepared_iterable], env:, expected_type: entry[:iterable_type]),
-            )
-          end,
-          *length_checks,
-          IR::Assignment.new(target: index_ref, operator: "=", value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
-          IR::WhileStmt.new(
-            condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
-            body: assign_items + body_stmts + [
-              IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-            ],
+      length_checks = iterable_entries.drop(1).each_with_index.map do |entry, offset|
+        IR::IfStmt.new(
+          condition: IR::Binary.new(
+            operator: "!=",
+            left: collection_loop_stop_value(iterable_refs[offset + 1], entry[:iterable_type]),
+            right: stop_value,
+            type: @ctx.types.fetch("bool"),
           ),
-        ]
-        stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body_stmts, break_label)
-        stmts
+          then_body: [lower_fatal_statement("parallel for iterables must have matching lengths", env:)],
+          else_body: nil,
+        )
       end
 
-      def lower_async_cf_match_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
-        expr_setup, prepared_expr = prepare_expression_for_inline_lowering(statement.expression, env:)
-        match_expr = lower_contextual_expression(prepared_expr, env:, expected_type: nil)
-        match_type = infer_expression_type(statement.expression, env:)
-        arm_loop_flow = switch_loop_flow(loop_flow, [])
-
-        if match_type.is_a?(Types::Variant)
-          if statement.arms.any? { |arm| arm.binding_name && !wildcard_arm_pattern?(arm.pattern) } &&
-             !duplicable_foreign_argument_expression?(match_expr)
-            scrutinee_linkage_name = fresh_c_temp_name(env, "match_value")
-            expr_setup << IR::LocalDecl.new(name: scrutinee_linkage_name, linkage_name: scrutinee_linkage_name, type: match_type, value: match_expr)
-            match_expr = IR::Name.new(name: scrutinee_linkage_name, type: match_type, pointer: false)
-          end
-
-          kind_type = @ctx.types.fetch("int")
-          kind_expr = IR::Member.new(receiver: match_expr, member: "kind", type: kind_type)
-          cases = statement.arms.map do |arm|
-            arm_env, binding_decl = async_variant_match_arm_binding(arm, match_expr, match_type, env:, frame_expr:, local_fields: async_info[:local_fields])
-            arm_body = lower_async_body(arm.body, env: arm_env, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: arm_loop_flow)
-            body = [binding_decl, *arm_body].compact + [IR::BreakStmt.new]
-            if wildcard_arm_pattern?(arm.pattern)
-              IR::SwitchDefaultCase.new(body: body)
-            else
-              arm_name = variant_match_arm_name_from_pattern(arm.pattern)
-              IR::SwitchCase.new(value: IR::Name.new(name: enum_member_c_name(match_type, "kind_#{arm_name}"), type: kind_type, pointer: false), body: body)
-            end
-          end
-
-          return expr_setup + [IR::SwitchStmt.new(expression: kind_expr, cases:, exhaustive: true)]
+      stmts = [
+        *iterable_entries.flat_map { |entry| entry[:setup] },
+        *iterable_entries.each_with_index.map do |entry, index|
+          IR::Assignment.new(
+            target: iterable_refs[index],
+            operator: "=",
+            value: lower_expression(entry[:prepared_iterable], env:, expected_type: entry[:iterable_type]),
+          )
+        end,
+        *length_checks,
+        IR::Assignment.new(target: index_ref, operator: "=", value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
+        IR::WhileStmt.new(
+          condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
+          body: assign_items + body_stmts + [
+            IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+          ],
+        ),
+      ]
+      stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body_stmts, break_label)
+      stmts
+    end
+
+    def lower_async_cf_match_stmt(statement, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow:)
+      expr_setup, prepared_expr = prepare_expression_for_inline_lowering(statement.expression, env:)
+      match_expr = lower_contextual_expression(prepared_expr, env:, expected_type: nil)
+      match_type = infer_expression_type(statement.expression, env:)
+      arm_loop_flow = switch_loop_flow(loop_flow, [])
+
+      if match_type.is_a?(Types::Variant)
+        if statement.arms.any? { |arm| arm.binding_name && !wildcard_arm_pattern?(arm.pattern) } &&
+            !duplicable_foreign_argument_expression?(match_expr)
+          scrutinee_linkage_name = fresh_c_temp_name(env, "match_value")
+          expr_setup << IR::LocalDecl.new(name: scrutinee_linkage_name, linkage_name: scrutinee_linkage_name, type: match_type, value: match_expr)
+          match_expr = IR::Name.new(name: scrutinee_linkage_name, type: match_type, pointer: false)
         end
 
+        kind_type = @ctx.types.fetch("int")
+        kind_expr = IR::Member.new(receiver: match_expr, member: "kind", type: kind_type)
         cases = statement.arms.map do |arm|
-          arm_body = lower_async_body(arm.body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: arm_loop_flow)
+          arm_env, binding_decl = async_variant_match_arm_binding(arm, match_expr, match_type, env:, frame_expr:, local_fields: async_info[:local_fields])
+          arm_body = lower_async_body(arm.body, env: arm_env, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: arm_loop_flow)
+          body = [binding_decl, *arm_body].compact + [IR::BreakStmt.new]
           if wildcard_arm_pattern?(arm.pattern)
-            IR::SwitchDefaultCase.new(body: arm_body + [IR::BreakStmt.new])
+            IR::SwitchDefaultCase.new(body: body)
           else
-            IR::SwitchCase.new(value: lower_expression(arm.pattern, env:, expected_type: match_type), body: arm_body + [IR::BreakStmt.new])
+            arm_name = variant_match_arm_name_from_pattern(arm.pattern)
+            IR::SwitchCase.new(value: IR::Name.new(name: enum_member_c_name(match_type, "kind_#{arm_name}"), type: kind_type, pointer: false), body: body)
           end
         end
 
-        expr_setup + [IR::SwitchStmt.new(expression: match_expr, cases:, exhaustive: true)]
+        return expr_setup + [IR::SwitchStmt.new(expression: kind_expr, cases:, exhaustive: true)]
       end
-      def lower_async_non_await_statements(statements, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [], loop_flow: nil)
-        local_env = duplicate_env(env)
-        lowered = []
-        local_defers = []
-        local_env[:return_context] = async_return_context(
-          return_type: async_info[:result_type],
-          active_defers:,
-          local_defers:,
-          frame_expr:,
-          raw_frame_expr:,
-          async_info:,
-        )
 
-        statements.each do |statement|
-          case statement
-          when AST::LocalDecl
-            else_env = duplicate_env(local_env) if statement.else_body
-            type, storage_type = async_local_decl_types(statement, env: local_env)
-            linkage_name = c_local_name(statement.name)
-            if statement.value
-              prepared_setup, prepared_value = prepare_expression_for_inline_lowering(
-                statement.value, env: local_env, expected_type: storage_type, allow_root_statement_foreign: true
-              )
-              lowered.concat(prepared_setup)
-              value = lower_contextual_expression(
-                prepared_value, env: local_env, expected_type: storage_type,
-                contextual_int_to_float: statement.type && contextual_int_to_float_target?(type)
-              )
-            else
-              value = IR::ZeroInit.new(type: storage_type)
+      cases = statement.arms.map do |arm|
+        arm_body = lower_async_body(arm.body, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, active_defers:, loop_flow: arm_loop_flow)
+        if wildcard_arm_pattern?(arm.pattern)
+          IR::SwitchDefaultCase.new(body: arm_body + [IR::BreakStmt.new])
+        else
+          IR::SwitchCase.new(value: lower_expression(arm.pattern, env:, expected_type: match_type), body: arm_body + [IR::BreakStmt.new])
+        end
+      end
+
+      expr_setup + [IR::SwitchStmt.new(expression: match_expr, cases:, exhaustive: true)]
+    end
+    def lower_async_non_await_statements(statements, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [], loop_flow: nil)
+      local_env = duplicate_env(env)
+      lowered = []
+      local_defers = []
+      local_env[:return_context] = async_return_context(
+        return_type: async_info[:result_type],
+        active_defers:,
+        local_defers:,
+        frame_expr:,
+        raw_frame_expr:,
+        async_info:,
+      )
+
+      statements.each do |statement|
+        case statement
+        when AST::LocalDecl
+          else_env = duplicate_env(local_env) if statement.else_body
+          type, storage_type = async_local_decl_types(statement, env: local_env)
+          linkage_name = c_local_name(statement.name)
+          if statement.value
+            prepared_setup, prepared_value = prepare_expression_for_inline_lowering(
+              statement.value, env: local_env, expected_type: storage_type, allow_root_statement_foreign: true
+            )
+            lowered.concat(prepared_setup)
+            value = lower_contextual_expression(
+              prepared_value, env: local_env, expected_type: storage_type,
+              contextual_int_to_float: statement.type && contextual_int_to_float_target?(type)
+            )
+          else
+            value = IR::ZeroInit.new(type: storage_type)
+          end
+          lowered << IR::LocalDecl.new(name: statement.name, linkage_name:, type: storage_type, value:)
+          current_actual_scope(local_env[:scopes])[statement.name] = local_binding(type:, storage_type:, linkage_name:, mutable: statement.kind == :var, pointer: false)
+          if statement.else_body
+            else_body = lower_async_non_await_statements(
+              statement.else_body,
+              env: else_env,
+              frame_expr:,
+              raw_frame_expr:,
+              async_info:,
+              active_defers: active_defers + local_defers,
+              loop_flow: nested_loop_flow(loop_flow, local_defers),
+            )
+            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"),
+              ),
+              then_body: else_body,
+              else_body: nil,
+            )
+          end
+        when AST::Assignment
+          lowered.concat(lower_async_assignment_statement(statement, env: local_env))
+        when AST::ExpressionStmt
+          lowered.concat(lower_async_expression_statement(statement, env: local_env))
+        when AST::ReturnStmt
+          lowered.concat(lower_async_return_statement(statement, env: local_env, frame_expr:, raw_frame_expr:, async_info:, cleanup: lower_async_cleanup_entries(local_defers, active_defers, frame_expr:, raw_frame_expr:, async_info:)))
+        when AST::IfStmt
+          branch_entries = statement.branches.map do |branch|
+            condition_setup, prepared_cond = prepare_expression_for_inline_lowering(
+              branch.condition, env: local_env, expected_type: @ctx.types.fetch("bool")
+            )
+            then_body = lower_async_non_await_statements(
+              branch.body, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)
+            )
+            [condition_setup, lower_expression(prepared_cond, env: local_env, expected_type: @ctx.types.fetch("bool")), then_body]
+          end
+          else_body = statement.else_body ? lower_async_non_await_statements(
+            statement.else_body, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)
+          ) : nil
+          nested = else_body || []
+          branch_entries.reverse_each do |cond_setup, cond, then_body|
+            nested = [*cond_setup, IR::IfStmt.new(condition: cond, then_body:, else_body: nested.empty? ? nil : nested)]
+          end
+          lowered.concat(nested)
+        when AST::MatchStmt
+          scrutinee_type = infer_expression_type(statement.expression, env: local_env)
+          expr_setup, prepared_expr = prepare_expression_for_inline_lowering(
+            statement.expression, env: local_env, expected_type: scrutinee_type
+          )
+          lowered.concat(expr_setup)
+          expr = lower_expression(prepared_expr, env: local_env, expected_type: scrutinee_type)
+          arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+          if scrutinee_type.is_a?(Types::Variant)
+            if statement.arms.any? { |arm| arm.binding_name && !wildcard_arm_pattern?(arm.pattern) } &&
+                !duplicable_foreign_argument_expression?(expr)
+              scrutinee_linkage_name = fresh_c_temp_name(local_env, "match_value")
+              lowered << IR::LocalDecl.new(name: scrutinee_linkage_name, linkage_name: scrutinee_linkage_name, type: scrutinee_type, value: expr)
+              expr = IR::Name.new(name: scrutinee_linkage_name, type: scrutinee_type, pointer: false)
             end
-            lowered << IR::LocalDecl.new(name: statement.name, linkage_name:, type: storage_type, value:)
-            current_actual_scope(local_env[:scopes])[statement.name] = local_binding(type:, storage_type:, linkage_name:, mutable: statement.kind == :var, pointer: false)
-            if statement.else_body
-              else_body = lower_async_non_await_statements(
-                statement.else_body,
-                env: else_env,
-                frame_expr:,
-                raw_frame_expr:,
-                async_info:,
-                active_defers: active_defers + local_defers,
-                loop_flow: nested_loop_flow(loop_flow, local_defers),
-              )
-              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"),
-                ),
-                then_body: else_body,
-                else_body: nil,
+
+            kind_type = @ctx.types.fetch("int")
+            kind_expr = IR::Member.new(receiver: expr, member: "kind", type: kind_type)
+            cases = statement.arms.map do |arm|
+              arm_env, binding_decl = async_variant_match_arm_binding(arm, expr, scrutinee_type, env: local_env)
+              arm_body = lower_async_non_await_statements(
+                arm.body, env: arm_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: arm_loop_flow
               )
+              body = [binding_decl, *arm_body].compact
+              if wildcard_arm_pattern?(arm.pattern)
+                IR::SwitchDefaultCase.new(body: body)
+              else
+                arm_name = variant_match_arm_name_from_pattern(arm.pattern)
+                IR::SwitchCase.new(value: IR::Name.new(name: enum_member_c_name(scrutinee_type, "kind_#{arm_name}"), type: kind_type, pointer: false), body: body)
+              end
             end
-          when AST::Assignment
-            lowered.concat(lower_async_assignment_statement(statement, env: local_env))
-          when AST::ExpressionStmt
-            lowered.concat(lower_async_expression_statement(statement, env: local_env))
-          when AST::ReturnStmt
-            lowered.concat(lower_async_return_statement(statement, env: local_env, frame_expr:, raw_frame_expr:, async_info:, cleanup: lower_async_cleanup_entries(local_defers, active_defers, frame_expr:, raw_frame_expr:, async_info:)))
-          when AST::IfStmt
-            branch_entries = statement.branches.map do |branch|
-              condition_setup, prepared_cond = prepare_expression_for_inline_lowering(
-                branch.condition, env: local_env, expected_type: @ctx.types.fetch("bool")
-              )
-              then_body = lower_async_non_await_statements(
-                branch.body, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)
+            lowered << IR::SwitchStmt.new(expression: kind_expr, cases:, exhaustive: true)
+          else
+            cases = statement.arms.map do |arm|
+              arm_body = lower_async_non_await_statements(
+                arm.body, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: arm_loop_flow
               )
-              [condition_setup, lower_expression(prepared_cond, env: local_env, expected_type: @ctx.types.fetch("bool")), then_body]
-            end
-            else_body = statement.else_body ? lower_async_non_await_statements(
-              statement.else_body, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)
-            ) : nil
-            nested = else_body || []
-            branch_entries.reverse_each do |cond_setup, cond, then_body|
-              nested = [*cond_setup, IR::IfStmt.new(condition: cond, then_body:, else_body: nested.empty? ? nil : nested)]
-            end
-            lowered.concat(nested)
-          when AST::MatchStmt
-            scrutinee_type = infer_expression_type(statement.expression, env: local_env)
-            expr_setup, prepared_expr = prepare_expression_for_inline_lowering(
-              statement.expression, env: local_env, expected_type: scrutinee_type
-            )
-            lowered.concat(expr_setup)
-            expr = lower_expression(prepared_expr, env: local_env, expected_type: scrutinee_type)
-            arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
-            if scrutinee_type.is_a?(Types::Variant)
-              if statement.arms.any? { |arm| arm.binding_name && !wildcard_arm_pattern?(arm.pattern) } &&
-                 !duplicable_foreign_argument_expression?(expr)
-                scrutinee_linkage_name = fresh_c_temp_name(local_env, "match_value")
-                lowered << IR::LocalDecl.new(name: scrutinee_linkage_name, linkage_name: scrutinee_linkage_name, type: scrutinee_type, value: expr)
-                expr = IR::Name.new(name: scrutinee_linkage_name, type: scrutinee_type, pointer: false)
+              if wildcard_arm_pattern?(arm.pattern)
+                IR::SwitchDefaultCase.new(body: arm_body)
+              else
+                value = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
+                IR::SwitchCase.new(value:, body: arm_body)
               end
-
-              kind_type = @ctx.types.fetch("int")
-              kind_expr = IR::Member.new(receiver: expr, member: "kind", type: kind_type)
-              cases = statement.arms.map do |arm|
-                arm_env, binding_decl = async_variant_match_arm_binding(arm, expr, scrutinee_type, env: local_env)
-                arm_body = lower_async_non_await_statements(
-                  arm.body, env: arm_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: arm_loop_flow
-                )
-                body = [binding_decl, *arm_body].compact
-                if wildcard_arm_pattern?(arm.pattern)
-                  IR::SwitchDefaultCase.new(body: body)
-                else
-                  arm_name = variant_match_arm_name_from_pattern(arm.pattern)
-                  IR::SwitchCase.new(value: IR::Name.new(name: enum_member_c_name(scrutinee_type, "kind_#{arm_name}"), type: kind_type, pointer: false), body: body)
-                end
-              end
-              lowered << IR::SwitchStmt.new(expression: kind_expr, cases:, exhaustive: true)
-            else
-              cases = statement.arms.map do |arm|
-                arm_body = lower_async_non_await_statements(
-                  arm.body, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: arm_loop_flow
-                )
-                if wildcard_arm_pattern?(arm.pattern)
-                  IR::SwitchDefaultCase.new(body: arm_body)
-                else
-                  value = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
-                  IR::SwitchCase.new(value:, body: arm_body)
-                end
-              end
-              lowered << IR::SwitchStmt.new(expression: expr, cases:, exhaustive: true)
-            end
-          when AST::WhileStmt
-            lowered << lower_async_while_stmt(statement, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers)
-          when AST::ForStmt
-            lowered << lower_async_for_stmt(statement, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers)
-          when AST::DeferStmt
-            local_defers << lower_async_defer_cleanup(statement, env: local_env, async_info:)
-          when AST::PassStmt
-            nil
-          when AST::BreakStmt
-            if loop_flow
-              lowered.concat(lower_async_loop_exit(loop_flow[:break_target], local_defers, loop_flow[:break_defers], frame_expr:, raw_frame_expr:, async_info:))
-            else
-              lowered << IR::BreakStmt.new
-            end
-          when AST::ContinueStmt
-            if loop_flow
-              lowered.concat(lower_async_loop_exit(loop_flow[:continue_target], local_defers, loop_flow[:continue_defers], frame_expr:, raw_frame_expr:, async_info:))
-            else
-              lowered << IR::ContinueStmt.new
             end
-          when AST::UnsafeStmt
-            lowered.concat(lower_async_non_await_statements(
-              statement.body, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)
-            ))
-          when AST::StaticAssert
-            lowered << lower_static_assert(statement, env: local_env)
+            lowered << IR::SwitchStmt.new(expression: expr, cases:, exhaustive: true)
+          end
+        when AST::WhileStmt
+          lowered << lower_async_while_stmt(statement, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers)
+        when AST::ForStmt
+          lowered << lower_async_for_stmt(statement, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers)
+        when AST::DeferStmt
+          local_defers << lower_async_defer_cleanup(statement, env: local_env, async_info:)
+        when AST::PassStmt
+          nil
+        when AST::BreakStmt
+          if loop_flow
+            lowered.concat(lower_async_loop_exit(loop_flow[:break_target], local_defers, loop_flow[:break_defers], frame_expr:, raw_frame_expr:, async_info:))
           else
-            raise LoweringError.new("unsupported async non-await statement #{statement.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
+            lowered << IR::BreakStmt.new
           end
+        when AST::ContinueStmt
+          if loop_flow
+            lowered.concat(lower_async_loop_exit(loop_flow[:continue_target], local_defers, loop_flow[:continue_defers], frame_expr:, raw_frame_expr:, async_info:))
+          else
+            lowered << IR::ContinueStmt.new
+          end
+        when AST::UnsafeStmt
+          lowered.concat(lower_async_non_await_statements(
+            statement.body, env: local_env, frame_expr:, raw_frame_expr:, async_info:, active_defers: active_defers + local_defers, loop_flow: nested_loop_flow(loop_flow, local_defers)
+          ))
+        when AST::StaticAssert
+          lowered << lower_static_assert(statement, env: local_env)
+        else
+          raise LoweringError.new("unsupported async non-await statement #{statement.class.name}", line: 0, column: 0, path: @ctx.current_analysis_path)
         end
-
-        unless cfg_block_always_terminates?(statements)
-          lowered.concat(lower_async_cleanup_entries(local_defers, [], frame_expr:, raw_frame_expr:, async_info:))
-        end
-        lowered
       end
 
-      def lower_async_while_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
-        continue_label = fresh_c_temp_name(env, "loop_continue")
-        break_label = fresh_c_temp_name(env, "loop_break")
-        condition_setup, prepared_cond = prepare_expression_for_inline_lowering(
-          statement.condition, env:, expected_type: @ctx.types.fetch("bool")
-        )
-        body = lower_async_non_await_statements(
-          statement.body,
-          env: duplicate_env(env),
-          frame_expr:,
-          raw_frame_expr:,
-          async_info:,
-          active_defers:,
-          loop_flow: loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label)),
-        )
-        body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
-        cond = lower_expression(prepared_cond, env:, expected_type: @ctx.types.fetch("bool"))
-
-        stmts = build_async_while_with_condition_setup(condition_setup, cond, body, break_label)
-        IR::BlockStmt.new(body: stmts)
+      unless cfg_block_always_terminates?(statements)
+        lowered.concat(lower_async_cleanup_entries(local_defers, [], frame_expr:, raw_frame_expr:, async_info:))
       end
+      lowered
+    end
+
+    def lower_async_while_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
+      continue_label = fresh_c_temp_name(env, "loop_continue")
+      break_label = fresh_c_temp_name(env, "loop_break")
+      condition_setup, prepared_cond = prepare_expression_for_inline_lowering(
+        statement.condition, env:, expected_type: @ctx.types.fetch("bool")
+      )
+      body = lower_async_non_await_statements(
+        statement.body,
+        env: duplicate_env(env),
+        frame_expr:,
+        raw_frame_expr:,
+        async_info:,
+        active_defers:,
+        loop_flow: loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label)),
+      )
+      body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
+      cond = lower_expression(prepared_cond, env:, expected_type: @ctx.types.fetch("bool"))
+
+      stmts = build_async_while_with_condition_setup(condition_setup, cond, body, break_label)
+      IR::BlockStmt.new(body: stmts)
+    end
+
+    def lower_async_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
+      return lower_async_parallel_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers:) if statement.parallel?
+
+      return lower_async_range_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers:) if range_iterable?(statement.iterable)
+
+      lower_async_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers:)
+    end
+
+    def lower_async_range_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
+      loop_type = infer_range_loop_type(statement.iterable, env:)
+      start_expr = range_start_of(statement.iterable)
+      stop_expr = range_end_of(statement.iterable)
+      start_setup, prepared_start = prepare_expression_for_inline_lowering(start_expr, env:, expected_type: loop_type)
+      stop_setup, prepared_stop = prepare_expression_for_inline_lowering(stop_expr, env:, expected_type: loop_type)
+      index_linkage_name = c_local_name(statement.name)
+      stop_linkage_name = fresh_c_temp_name(env, "for_stop")
+      continue_label = fresh_c_temp_name(env, "loop_continue")
+      break_label = fresh_c_temp_name(env, "loop_break")
+      index_ref = IR::Name.new(name: index_linkage_name, type: loop_type, pointer: false)
+      inline_stop = stop_setup.empty? && compile_time_numeric_const_expression?(prepared_stop)
+      stop_value = if inline_stop
+                      lower_expression(prepared_stop, env:, expected_type: loop_type)
+                    else
+                      IR::Name.new(name: stop_linkage_name, type: loop_type, pointer: false)
+                    end
+
+      while_env = duplicate_env(env)
+      current_actual_scope(while_env[:scopes])[statement.name] = local_binding(
+        type: loop_type, linkage_name: index_linkage_name, mutable: false, pointer: false
+      )
+      body = lower_async_non_await_statements(
+        statement.body,
+        env: while_env,
+        frame_expr:,
+        raw_frame_expr:,
+        async_info:,
+        active_defers:,
+        loop_flow: loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label)),
+      )
+      body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
+
+      for_statement = IR::ForStmt.new(
+        init: IR::LocalDecl.new(name: statement.name, linkage_name: index_linkage_name, type: loop_type, value: lower_expression(prepared_start, env:, expected_type: loop_type)),
+        condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
+        post: IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: loop_type)),
+        body:,
+      )
+
+      stmts = [
+        *start_setup,
+        *stop_setup,
+        *(inline_stop ? [] : [IR::LocalDecl.new(name: stop_linkage_name, linkage_name: stop_linkage_name, type: loop_type, value: lower_expression(prepared_stop, env:, expected_type: loop_type))]),
+        for_statement,
+      ]
+      stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
+      IR::BlockStmt.new(body: stmts)
+    end
+
+    def lower_async_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
+      iterable_type = infer_expression_type(statement.iterable, env:)
+      element_type = collection_loop_type(iterable_type)
+      raise LoweringError.new("for loop expects start..stop, array[T, N], or span[T], got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
+
+      iterable_setup, prepared_iterable = prepare_expression_for_inline_lowering(statement.iterable, env:, expected_type: iterable_type)
+      iterable_linkage_name = fresh_c_temp_name(env, "for_items")
+      index_linkage_name = fresh_c_temp_name(env, "for_index")
+      continue_label = fresh_c_temp_name(env, "loop_continue")
+      break_label = fresh_c_temp_name(env, "loop_break")
+      iterable_ref = IR::Name.new(name: iterable_linkage_name, type: iterable_type, pointer: false)
+      index_ref = IR::Name.new(name: index_linkage_name, type: @ctx.types.fetch("ptr_uint"), pointer: false)
+
+      item_value = if array_type?(iterable_type)
+                      IR::Index.new(receiver: iterable_ref, index: index_ref, type: element_type)
+                    else
+                      data_ref = IR::Member.new(receiver: iterable_ref, member: "data", type: pointer_to(element_type))
+                      IR::Index.new(receiver: data_ref, index: index_ref, type: element_type)
+                    end
+      stop_value = if array_type?(iterable_type)
+                      IR::IntegerLiteral.new(value: array_length(iterable_type), type: @ctx.types.fetch("ptr_uint"))
+                    else
+                      IR::Member.new(receiver: iterable_ref, member: "len", type: @ctx.types.fetch("ptr_uint"))
+                    end
+
+      while_env = duplicate_env(env)
+      current_actual_scope(while_env[:scopes])[statement.name] = local_binding(
+        type: element_type, linkage_name: c_local_name(statement.name), mutable: false, pointer: false
+      )
+      body = [IR::LocalDecl.new(name: statement.name, linkage_name: c_local_name(statement.name), type: element_type, value: item_value)]
+      body.concat(lower_async_non_await_statements(
+        statement.body,
+        env: while_env,
+        frame_expr:,
+        raw_frame_expr:,
+        async_info:,
+        active_defers:,
+        loop_flow: loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label)),
+      ))
+      body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
+
+      for_statement = IR::ForStmt.new(
+        init: IR::LocalDecl.new(name: index_linkage_name, linkage_name: index_linkage_name, type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
+        condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
+        post: IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+        body:,
+      )
+
+      stmts = [
+        *iterable_setup,
+        IR::LocalDecl.new(name: iterable_linkage_name, linkage_name: iterable_linkage_name, type: iterable_type, value: lower_expression(prepared_iterable, env:, expected_type: iterable_type)),
+        for_statement,
+      ]
+      stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
+      IR::BlockStmt.new(body: stmts)
+    end
+
+    def lower_async_parallel_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
+      infos = statement.bindings.each_with_index.map do |binding, index|
+        iterable = statement.iterables[index]
+        iterable_type = infer_expression_type(iterable, env:)
+        element_type = collection_loop_type(iterable_type)
+        raise LoweringError.new("parallel for loops expect arrays or spans for each iterable, got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
 
-      def lower_async_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
-        return lower_async_parallel_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers:) if statement.parallel?
-
-        return lower_async_range_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers:) if range_iterable?(statement.iterable)
-
-        lower_async_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers:)
+        {
+          binding:,
+          iterable:,
+          iterable_type:,
+          element_type:,
+          binding_type: collection_loop_binding_type(iterable_type, element_type) || element_type,
+        }
       end
 
-      def lower_async_range_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
-        loop_type = infer_range_loop_type(statement.iterable, env:)
-        start_expr = range_start_of(statement.iterable)
-        stop_expr = range_end_of(statement.iterable)
-        start_setup, prepared_start = prepare_expression_for_inline_lowering(start_expr, env:, expected_type: loop_type)
-        stop_setup, prepared_stop = prepare_expression_for_inline_lowering(stop_expr, env:, expected_type: loop_type)
-        index_linkage_name = c_local_name(statement.name)
-        stop_linkage_name = fresh_c_temp_name(env, "for_stop")
-        continue_label = fresh_c_temp_name(env, "loop_continue")
-        break_label = fresh_c_temp_name(env, "loop_break")
-        index_ref = IR::Name.new(name: index_linkage_name, type: loop_type, pointer: false)
-        inline_stop = stop_setup.empty? && compile_time_numeric_const_expression?(prepared_stop)
-        stop_value = if inline_stop
-                       lower_expression(prepared_stop, env:, expected_type: loop_type)
-                     else
-                       IR::Name.new(name: stop_linkage_name, type: loop_type, pointer: false)
-                     end
-
-        while_env = duplicate_env(env)
-        current_actual_scope(while_env[:scopes])[statement.name] = local_binding(
-          type: loop_type, linkage_name: index_linkage_name, mutable: false, pointer: false
-        )
-        body = lower_async_non_await_statements(
-          statement.body,
-          env: while_env,
-          frame_expr:,
-          raw_frame_expr:,
-          async_info:,
-          active_defers:,
-          loop_flow: loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label)),
+      iterable_entries = infos.map do |info|
+        setup, prepared_iterable = prepare_expression_for_inline_lowering(info[:iterable], env:, expected_type: info[:iterable_type])
+        linkage_name = fresh_c_temp_name(env, "for_items")
+        info.merge(
+          setup:,
+          prepared_iterable:,
+          iterable_linkage_name: linkage_name,
+          iterable_ref: IR::Name.new(name: linkage_name, type: info[:iterable_type], pointer: false),
         )
-        body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
-
-        for_statement = IR::ForStmt.new(
-          init: IR::LocalDecl.new(name: statement.name, linkage_name: index_linkage_name, type: loop_type, value: lower_expression(prepared_start, env:, expected_type: loop_type)),
-          condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
-          post: IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: loop_type)),
-          body:,
-        )
-
-        stmts = [
-          *start_setup,
-          *stop_setup,
-          *(inline_stop ? [] : [IR::LocalDecl.new(name: stop_linkage_name, linkage_name: stop_linkage_name, type: loop_type, value: lower_expression(prepared_stop, env:, expected_type: loop_type))]),
-          for_statement,
-        ]
-        stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
-        IR::BlockStmt.new(body: stmts)
       end
 
-      def lower_async_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
-        iterable_type = infer_expression_type(statement.iterable, env:)
-        element_type = collection_loop_type(iterable_type)
-        raise LoweringError.new("for loop expects start..stop, array[T, N], or span[T], got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
-
-        iterable_setup, prepared_iterable = prepare_expression_for_inline_lowering(statement.iterable, env:, expected_type: iterable_type)
-        iterable_linkage_name = fresh_c_temp_name(env, "for_items")
-        index_linkage_name = fresh_c_temp_name(env, "for_index")
-        continue_label = fresh_c_temp_name(env, "loop_continue")
-        break_label = fresh_c_temp_name(env, "loop_break")
-        iterable_ref = IR::Name.new(name: iterable_linkage_name, type: iterable_type, pointer: false)
-        index_ref = IR::Name.new(name: index_linkage_name, type: @ctx.types.fetch("ptr_uint"), pointer: false)
-
-        item_value = if array_type?(iterable_type)
-                       IR::Index.new(receiver: iterable_ref, index: index_ref, type: element_type)
-                     else
-                       data_ref = IR::Member.new(receiver: iterable_ref, member: "data", type: pointer_to(element_type))
-                       IR::Index.new(receiver: data_ref, index: index_ref, type: element_type)
-                     end
-        stop_value = if array_type?(iterable_type)
-                       IR::IntegerLiteral.new(value: array_length(iterable_type), type: @ctx.types.fetch("ptr_uint"))
-                     else
-                       IR::Member.new(receiver: iterable_ref, member: "len", type: @ctx.types.fetch("ptr_uint"))
-                     end
-
-        while_env = duplicate_env(env)
-        current_actual_scope(while_env[:scopes])[statement.name] = local_binding(
-          type: element_type, linkage_name: c_local_name(statement.name), mutable: false, pointer: false
+      index_linkage_name = fresh_c_temp_name(env, "for_index")
+      continue_label = fresh_c_temp_name(env, "loop_continue")
+      break_label = fresh_c_temp_name(env, "loop_break")
+      index_ref = IR::Name.new(name: index_linkage_name, type: @ctx.types.fetch("ptr_uint"), pointer: false)
+      stop_value = collection_loop_stop_value(iterable_entries.first[:iterable_ref], iterable_entries.first[:iterable_type])
+
+      while_env = duplicate_env(env)
+      body = iterable_entries.map do |entry|
+        item_value = collection_loop_item_value(entry[:iterable_ref], entry[:iterable_type], index_ref, entry[:element_type])
+        loop_item_value = if ref_type?(entry[:binding_type])
+                            IR::AddressOf.new(expression: item_value, type: entry[:binding_type])
+                          else
+                            item_value
+                          end
+        binding = entry[:binding]
+        current_actual_scope(while_env[:scopes])[binding.name] = local_binding(type: entry[:binding_type], linkage_name: c_local_name(binding.name), mutable: false, pointer: false)
+        IR::LocalDecl.new(name: binding.name, linkage_name: c_local_name(binding.name), type: entry[:binding_type], value: loop_item_value)
+      end
+      body.concat(lower_async_non_await_statements(
+        statement.body,
+        env: while_env,
+        frame_expr:,
+        raw_frame_expr:,
+        async_info:,
+        active_defers:,
+        loop_flow: loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label)),
+      ))
+      body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
+
+      length_checks = iterable_entries.drop(1).map do |entry|
+        IR::IfStmt.new(
+          condition: IR::Binary.new(
+            operator: "!=",
+            left: collection_loop_stop_value(entry[:iterable_ref], entry[:iterable_type]),
+            right: stop_value,
+            type: @ctx.types.fetch("bool"),
+          ),
+          then_body: [lower_fatal_statement("parallel for iterables must have matching lengths", env:)],
+          else_body: nil,
         )
-        body = [IR::LocalDecl.new(name: statement.name, linkage_name: c_local_name(statement.name), type: element_type, value: item_value)]
-        body.concat(lower_async_non_await_statements(
-          statement.body,
-          env: while_env,
-          frame_expr:,
-          raw_frame_expr:,
-          async_info:,
-          active_defers:,
-          loop_flow: loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label)),
-        ))
-        body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
+      end
 
-        for_statement = IR::ForStmt.new(
-          init: IR::LocalDecl.new(name: index_linkage_name, linkage_name: index_linkage_name, type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
-          condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
-          post: IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-          body:,
+      for_statement = IR::ForStmt.new(
+        init: IR::LocalDecl.new(name: index_linkage_name, linkage_name: index_linkage_name, type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
+        condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
+        post: IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
+        body:,
+      )
+
+      stmts = [
+        *iterable_entries.flat_map { |entry| entry[:setup] },
+        *iterable_entries.map do |entry|
+          IR::LocalDecl.new(name: entry[:iterable_linkage_name], linkage_name: entry[:iterable_linkage_name], type: entry[:iterable_type], value: lower_expression(entry[:prepared_iterable], env:, expected_type: entry[:iterable_type]))
+        end,
+        *length_checks,
+        for_statement,
+      ]
+      stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
+      IR::BlockStmt.new(body: stmts)
+    end
+
+    def lower_async_assignment_statement(statement, env:)
+      lowered = []
+      target = lower_assignment_target(statement.target, env:)
+      prepared_setup, prepared_value = prepare_expression_for_inline_lowering(
+        statement.value,
+        env:,
+        expected_type: target.type,
+        allow_root_statement_foreign: true,
+      )
+      lowered.concat(prepared_setup)
+
+      if (foreign_call = foreign_call_info(prepared_value, env))
+        setup, value, call_type, release_assignments, cleanup_statements = lower_foreign_call_components(
+          foreign_call,
+          env:,
+          expected_type: target.type,
+          statement_position: false,
         )
+        lowered.concat(setup)
+        raise LoweringError.new("foreign call used in assignment must return a value", line: 0, column: 0, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
+        raise LoweringError.new("consuming foreign calls must return void", line: 0, column: 0, path: @ctx.current_analysis_path) unless release_assignments.empty?
 
-        stmts = [
-          *iterable_setup,
-          IR::LocalDecl.new(name: iterable_linkage_name, linkage_name: iterable_linkage_name, type: iterable_type, value: lower_expression(prepared_iterable, env:, expected_type: iterable_type)),
-          for_statement,
-        ]
-        stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
-        IR::BlockStmt.new(body: stmts)
+        lowered << IR::Assignment.new(target:, operator: statement.operator, value:)
+        lowered.concat(cleanup_statements)
+        update_cstr_metadata_for_assignment!(statement, prepared_value, env)
+        return lowered
       end
 
-      def lower_async_parallel_collection_for_stmt(statement, env:, frame_expr:, raw_frame_expr:, async_info:, active_defers: [])
-        infos = statement.bindings.each_with_index.map do |binding, index|
-          iterable = statement.iterables[index]
-          iterable_type = infer_expression_type(iterable, env:)
-          element_type = collection_loop_type(iterable_type)
-          raise LoweringError.new("parallel for loops expect arrays or spans for each iterable, got #{iterable_type}", line: 0, column: 0, path: @ctx.current_analysis_path) unless element_type
-
-          {
-            binding:,
-            iterable:,
-            iterable_type:,
-            element_type:,
-            binding_type: collection_loop_binding_type(iterable_type, element_type) || element_type,
-          }
-        end
-
-        iterable_entries = infos.map do |info|
-          setup, prepared_iterable = prepare_expression_for_inline_lowering(info[:iterable], env:, expected_type: info[:iterable_type])
-          linkage_name = fresh_c_temp_name(env, "for_items")
-          info.merge(
-            setup:,
-            prepared_iterable:,
-            iterable_linkage_name: linkage_name,
-            iterable_ref: IR::Name.new(name: linkage_name, type: info[:iterable_type], pointer: false),
-          )
-        end
-
-        index_linkage_name = fresh_c_temp_name(env, "for_index")
-        continue_label = fresh_c_temp_name(env, "loop_continue")
-        break_label = fresh_c_temp_name(env, "loop_break")
-        index_ref = IR::Name.new(name: index_linkage_name, type: @ctx.types.fetch("ptr_uint"), pointer: false)
-        stop_value = collection_loop_stop_value(iterable_entries.first[:iterable_ref], iterable_entries.first[:iterable_type])
-
-        while_env = duplicate_env(env)
-        body = iterable_entries.map do |entry|
-          item_value = collection_loop_item_value(entry[:iterable_ref], entry[:iterable_type], index_ref, entry[:element_type])
-          loop_item_value = if ref_type?(entry[:binding_type])
-                              IR::AddressOf.new(expression: item_value, type: entry[:binding_type])
-                            else
-                              item_value
-                            end
-          binding = entry[:binding]
-          current_actual_scope(while_env[:scopes])[binding.name] = local_binding(type: entry[:binding_type], linkage_name: c_local_name(binding.name), mutable: false, pointer: false)
-          IR::LocalDecl.new(name: binding.name, linkage_name: c_local_name(binding.name), type: entry[:binding_type], value: loop_item_value)
-        end
-        body.concat(lower_async_non_await_statements(
-          statement.body,
-          env: while_env,
-          frame_expr:,
-          raw_frame_expr:,
-          async_info:,
-          active_defers:,
-          loop_flow: loop_flow(break_target: loop_exit_break(break_label), continue_target: loop_exit_continue(continue_label)),
-        ))
-        body << IR::LabelStmt.new(name: continue_label) if contains_label_target?(body, continue_label)
-
-        length_checks = iterable_entries.drop(1).map do |entry|
-          IR::IfStmt.new(
-            condition: IR::Binary.new(
-              operator: "!=",
-              left: collection_loop_stop_value(entry[:iterable_ref], entry[:iterable_type]),
-              right: stop_value,
-              type: @ctx.types.fetch("bool"),
-            ),
-            then_body: [lower_fatal_statement("parallel for iterables must have matching lengths", env:)],
-            else_body: nil,
-          )
-        end
-
-        for_statement = IR::ForStmt.new(
-          init: IR::LocalDecl.new(name: index_linkage_name, linkage_name: index_linkage_name, type: @ctx.types.fetch("ptr_uint"), value: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint"))),
-          condition: IR::Binary.new(operator: "<", left: index_ref, right: stop_value, type: @ctx.types.fetch("bool")),
-          post: IR::Assignment.new(target: index_ref, operator: "+=", value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint"))),
-          body:,
+      value = if statement.operator == "="
+                lower_contextual_expression(
+                  prepared_value,
+                  env:,
+                  expected_type: target.type,
+                  external_numeric: external_numeric_assignment_target?(statement.target, env:),
+                  contextual_int_to_float: contextual_int_to_float_target?(target.type),
+                )
+              elsif ["+=", "-=", "*=", "/="].include?(statement.operator)
+                lower_contextual_expression(
+                  prepared_value,
+                  env:,
+                  expected_type: target.type,
+                  contextual_int_to_float: contextual_int_to_float_target?(target.type),
+                )
+              else
+                lower_expression(prepared_value, env:, expected_type: target.type)
+              end
+      update_cstr_metadata_for_assignment!(statement, prepared_value, env)
+      operator = statement.operator
+      if ["+=", "-=", "*=", "/="].include?(operator) &&
+          (target.type.is_a?(Types::Vector) || target.type.is_a?(Types::Matrix) || target.type.is_a?(Types::Quaternion))
+        binary_op = operator[0...-1]
+        expanded = lower_vector_binary_op(binary_op, target, target.type, value, value.type, target.type)
+        value = expanded || IR::Binary.new(operator: binary_op, left: target, right: value, type: target.type)
+        operator = "="
+      end
+      if operator == "=" && contains_proc_storage_type?(target.type)
+        rhs_name = fresh_c_temp_name(env, "proc_assign")
+        lowered << IR::LocalDecl.new(name: rhs_name, linkage_name: rhs_name, type: target.type, value:)
+        rhs = IR::Name.new(name: rhs_name, type: target.type, pointer: false)
+        lowered.concat(lower_proc_selective_retain_statements(rhs, statement.value, target.type))
+        lowered.concat(lower_proc_contained_guarded_release_statements(target, target.type))
+        lowered << IR::Assignment.new(target:, operator: "=", value: rhs)
+      else
+        lowered << IR::Assignment.new(target:, operator:, value:)
+      end
+      lowered
+    end
+
+    def lower_async_expression_statement(statement, env:)
+      lowered = []
+      expression_expected_type = if statement.expression.is_a?(AST::UnaryOp) && statement.expression.operator == "?"
+                                    nil
+                                  else
+                                    infer_expression_type(statement.expression, env:)
+                                  end
+      prepared_setup, prepared_expression = prepare_expression_for_inline_lowering(
+        statement.expression,
+        env:,
+        expected_type: expression_expected_type,
+        allow_root_statement_foreign: true,
+        allow_void_propagation: true,
+      )
+      lowered.concat(prepared_setup)
+
+      if prepared_expression && (foreign_call = foreign_call_info(prepared_expression, env))
+        setup, = lower_foreign_call_statement(
+          foreign_call,
+          env:,
+          expected_type: foreign_call[:binding].type.return_type,
+          statement_position: true,
+          discard_result: true,
         )
-
-        stmts = [
-          *iterable_entries.flat_map { |entry| entry[:setup] },
-          *iterable_entries.map do |entry|
-            IR::LocalDecl.new(name: entry[:iterable_linkage_name], linkage_name: entry[:iterable_linkage_name], type: entry[:iterable_type], value: lower_expression(entry[:prepared_iterable], env:, expected_type: entry[:iterable_type]))
-          end,
-          *length_checks,
-          for_statement,
-        ]
-        stmts << IR::LabelStmt.new(name: break_label) if contains_label_target?(body, break_label)
-        IR::BlockStmt.new(body: stmts)
+        lowered.concat(setup)
+      elsif prepared_expression
+        lowered << IR::ExpressionStmt.new(expression: lower_expression(prepared_expression, env:), line: statement.line, path: @ctx.current_analysis_path)
       end
 
-      def lower_async_assignment_statement(statement, env:)
-        lowered = []
-        target = lower_assignment_target(statement.target, env:)
+      lowered
+    end
+    def lower_async_return_statement(statement, env:, frame_expr:, raw_frame_expr:, async_info:, cleanup: [])
+      lowered = []
+      value = nil
+      prepared_setup = []
+      prepared_value = statement.value
+
+      if statement.value
         prepared_setup, prepared_value = prepare_expression_for_inline_lowering(
           statement.value,
           env:,
-          expected_type: target.type,
+          expected_type: async_info[:result_type],
           allow_root_statement_foreign: true,
         )
         lowered.concat(prepared_setup)
-
-        if (foreign_call = foreign_call_info(prepared_value, env))
-          setup, value, call_type, release_assignments, cleanup_statements = lower_foreign_call_components(
-            foreign_call,
-            env:,
-            expected_type: target.type,
-            statement_position: false,
-          )
-          lowered.concat(setup)
-          raise LoweringError.new("foreign call used in assignment must return a value", line: 0, column: 0, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
-          raise LoweringError.new("consuming foreign calls must return void", line: 0, column: 0, path: @ctx.current_analysis_path) unless release_assignments.empty?
-
-          lowered << IR::Assignment.new(target:, operator: statement.operator, value:)
-          lowered.concat(cleanup_statements)
-          update_cstr_metadata_for_assignment!(statement, prepared_value, env)
-          return lowered
-        end
-
-        value = if statement.operator == "="
-                  lower_contextual_expression(
-                    prepared_value,
-                    env:,
-                    expected_type: target.type,
-                    external_numeric: external_numeric_assignment_target?(statement.target, env:),
-                    contextual_int_to_float: contextual_int_to_float_target?(target.type),
-                  )
-                elsif ["+=", "-=", "*=", "/="].include?(statement.operator)
-                  lower_contextual_expression(
-                    prepared_value,
-                    env:,
-                    expected_type: target.type,
-                    contextual_int_to_float: contextual_int_to_float_target?(target.type),
-                  )
-                else
-                  lower_expression(prepared_value, env:, expected_type: target.type)
-                end
-        update_cstr_metadata_for_assignment!(statement, prepared_value, env)
-        operator = statement.operator
-        if ["+=", "-=", "*=", "/="].include?(operator) &&
-           (target.type.is_a?(Types::Vector) || target.type.is_a?(Types::Matrix) || target.type.is_a?(Types::Quaternion))
-          binary_op = operator[0...-1]
-          expanded = lower_vector_binary_op(binary_op, target, target.type, value, value.type, target.type)
-          value = expanded || IR::Binary.new(operator: binary_op, left: target, right: value, type: target.type)
-          operator = "="
-        end
-        if operator == "=" && contains_proc_storage_type?(target.type)
-          rhs_name = fresh_c_temp_name(env, "proc_assign")
-          lowered << IR::LocalDecl.new(name: rhs_name, linkage_name: rhs_name, type: target.type, value:)
-          rhs = IR::Name.new(name: rhs_name, type: target.type, pointer: false)
-          lowered.concat(lower_proc_selective_retain_statements(rhs, statement.value, target.type))
-          lowered.concat(lower_proc_contained_guarded_release_statements(target, target.type))
-          lowered << IR::Assignment.new(target:, operator: "=", value: rhs)
-        else
-          lowered << IR::Assignment.new(target:, operator:, value:)
-        end
-        lowered
       end
 
-      def lower_async_expression_statement(statement, env:)
-        lowered = []
-        expression_expected_type = if statement.expression.is_a?(AST::UnaryOp) && statement.expression.operator == "?"
-                                     nil
-                                   else
-                                     infer_expression_type(statement.expression, env:)
-                                   end
-        prepared_setup, prepared_expression = prepare_expression_for_inline_lowering(
-          statement.expression,
+      if prepared_value && (foreign_call = foreign_call_info(prepared_value, env))
+        setup, value = lower_foreign_call_statement(foreign_call, env:, expected_type: async_info[:result_type], statement_position: false)
+        lowered.concat(setup)
+      elsif prepared_value
+        value = lower_contextual_expression(
+          prepared_value,
           env:,
-          expected_type: expression_expected_type,
-          allow_root_statement_foreign: true,
-          allow_void_propagation: true,
+          expected_type: async_info[:result_type],
+          contextual_int_to_float: contextual_int_to_float_target?(async_info[:result_type]),
         )
-        lowered.concat(prepared_setup)
-
-        if prepared_expression && (foreign_call = foreign_call_info(prepared_expression, env))
-          setup, = lower_foreign_call_statement(
-            foreign_call,
-            env:,
-            expected_type: foreign_call[:binding].type.return_type,
-            statement_position: true,
-            discard_result: true,
-          )
-          lowered.concat(setup)
-        elsif prepared_expression
-          lowered << IR::ExpressionStmt.new(expression: lower_expression(prepared_expression, env:), line: statement.line, source_path: @ctx.current_analysis_path)
-        end
+      end
 
-        lowered
+      if async_info[:result_type] != @ctx.types.fetch("void") && value && cleanup.any? && !cleanup_safe_return_expression?(prepared_value)
+        lowered << IR::Assignment.new(
+          target: async_frame_field_expression(frame_expr, "result", async_info[:result_type]),
+          operator: "=",
+          value: value,
+        )
+        lowered.concat(cleanup)
+        lowered.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value: nil, result_already_stored: true))
+      else
+        lowered.concat(cleanup)
+        lowered.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value:))
+      end
+      lowered
+    end
+
+    def lower_async_await_statement(statement, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, field_info: nil, cleanup: [], active_defers: [], loop_flow: nil)
+      lowered = []
+      await_expression = case statement
+                          when AST::LocalDecl then statement.value
+                          when AST::Assignment then statement.value
+                          when AST::ExpressionStmt then statement.expression
+                          when AST::ReturnStmt then statement.value
+                          end
+      prepared_setup, prepared_task = prepare_expression_for_inline_lowering(
+        await_expression.expression,
+        env:,
+        expected_type: await_info[:task_type],
+      )
+      lowered.concat(prepared_setup)
+      raise LoweringError.new("await does not support foreign task expressions", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_call_info(prepared_task, env)
+
+      task_expr = async_frame_field_expression(frame_expr, await_info[:field_name], await_info[:task_type])
+      task_frame_expr = async_task_frame_expression(task_expr, await_info[:task_type])
+      ready_call = async_task_call(task_expr, await_info[:task_type], "ready", [task_frame_expr], @ctx.types.fetch("bool"))
+      set_waiter_call = async_task_call(
+        task_expr,
+        await_info[:task_type],
+        "set_waiter",
+        [
+          task_frame_expr,
+          raw_frame_expr,
+          IR::Name.new(name: resume_linkage_name, type: async_info[:wake_type], pointer: false),
+        ],
+        @ctx.types.fetch("void"),
+      )
+      take_result_call = async_task_call(task_expr, await_info[:task_type], "take_result", [task_frame_expr], await_info[:result_type])
+      release_call = async_task_call(task_expr, await_info[:task_type], "release", [task_frame_expr], @ctx.types.fetch("void"))
+
+      unless await_info[:reuse_existing_storage]
+        lowered << IR::Assignment.new(
+          target: task_expr,
+          operator: "=",
+          value: lower_contextual_expression(prepared_task, env:, expected_type: await_info[:task_type]),
+        )
       end
-      def lower_async_return_statement(statement, env:, frame_expr:, raw_frame_expr:, async_info:, cleanup: [])
-        lowered = []
-        value = nil
-        prepared_setup = []
-        prepared_value = statement.value
-
-        if statement.value
-          prepared_setup, prepared_value = prepare_expression_for_inline_lowering(
-            statement.value,
-            env:,
-            expected_type: async_info[:result_type],
-            allow_root_statement_foreign: true,
+      lowered << IR::IfStmt.new(
+        condition: IR::Unary.new(operator: "not", operand: ready_call, type: @ctx.types.fetch("bool")),
+        then_body: [
+          IR::Assignment.new(
+            target: async_frame_field_expression(frame_expr, "state", @ctx.types.fetch("int")),
+            operator: "=",
+            value: IR::IntegerLiteral.new(value: await_info[:state], type: @ctx.types.fetch("int")),
+          ),
+          IR::ExpressionStmt.new(expression: set_waiter_call),
+          IR::ReturnStmt.new(value: nil),
+        ],
+        else_body: nil,
+      )
+      lowered << IR::LabelStmt.new(name: async_state_label(resume_linkage_name, await_info[:state]))
+
+      case statement
+      when AST::LocalDecl
+        storage_type = field_info[:storage_type]
+        target = async_frame_field_expression(frame_expr, field_info[:field_name], storage_type)
+        lowered << IR::Assignment.new(target:, operator: "=", value: take_result_call)
+        lowered << IR::ExpressionStmt.new(expression: release_call)
+        if statement.else_body
+          else_env = duplicate_env(env)
+          if statement.else_binding
+            current_actual_scope(else_env[:scopes])[statement.else_binding.name] = local_binding(
+              type: let_else_error_type(storage_type),
+              storage_type:,
+              linkage_name: async_frame_field_c_name(field_info[:field_name]),
+              mutable: false,
+              pointer: false,
+              projection: :result_failure_error,
+            )
+          end
+          else_body = lower_async_body(
+            statement.else_body,
+            env: else_env,
+            frame_expr:,
+            raw_frame_expr:,
+            resume_linkage_name:,
+            async_info:,
+            active_defers:,
+            loop_flow:,
           )
-          lowered.concat(prepared_setup)
-        end
-
-        if prepared_value && (foreign_call = foreign_call_info(prepared_value, env))
-          setup, value = lower_foreign_call_statement(foreign_call, env:, expected_type: async_info[:result_type], statement_position: false)
-          lowered.concat(setup)
-        elsif prepared_value
-          value = lower_contextual_expression(
-            prepared_value,
-            env:,
-            expected_type: async_info[:result_type],
-            contextual_int_to_float: contextual_int_to_float_target?(async_info[:result_type]),
+          lowered << IR::IfStmt.new(
+            condition: let_else_failure_condition(target, storage_type),
+            then_body: else_body,
+            else_body: nil,
           )
         end
-
-        if async_info[:result_type] != @ctx.types.fetch("void") && value && cleanup.any? && !cleanup_safe_return_expression?(prepared_value)
-          lowered << IR::Assignment.new(
-            target: async_frame_field_expression(frame_expr, "result", async_info[:result_type]),
-            operator: "=",
-            value: value,
-          )
+      when AST::Assignment
+        lowered << IR::Assignment.new(target: lower_assignment_target(statement.target, env:), operator: statement.operator, value: take_result_call)
+        lowered << IR::ExpressionStmt.new(expression: release_call)
+      when AST::ExpressionStmt
+        lowered << IR::ExpressionStmt.new(expression: take_result_call)
+        lowered << IR::ExpressionStmt.new(expression: release_call)
+      when AST::ReturnStmt
+        if await_info[:result_type] == @ctx.types.fetch("void")
+          lowered << IR::ExpressionStmt.new(expression: take_result_call)
+          lowered << IR::ExpressionStmt.new(expression: release_call)
           lowered.concat(cleanup)
           lowered.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value: nil, result_already_stored: true))
         else
-          lowered.concat(cleanup)
-          lowered.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value:))
-        end
-        lowered
-      end
-
-      def lower_async_await_statement(statement, await_info:, env:, frame_expr:, raw_frame_expr:, resume_linkage_name:, async_info:, field_info: nil, cleanup: [], active_defers: [], loop_flow: nil)
-        lowered = []
-        await_expression = case statement
-                           when AST::LocalDecl then statement.value
-                           when AST::Assignment then statement.value
-                           when AST::ExpressionStmt then statement.expression
-                           when AST::ReturnStmt then statement.value
-                           end
-        prepared_setup, prepared_task = prepare_expression_for_inline_lowering(
-          await_expression.expression,
-          env:,
-          expected_type: await_info[:task_type],
-        )
-        lowered.concat(prepared_setup)
-        raise LoweringError.new("await does not support foreign task expressions", line: 0, column: 0, path: @ctx.current_analysis_path) if foreign_call_info(prepared_task, env)
-
-        task_expr = async_frame_field_expression(frame_expr, await_info[:field_name], await_info[:task_type])
-        task_frame_expr = async_task_frame_expression(task_expr, await_info[:task_type])
-        ready_call = async_task_call(task_expr, await_info[:task_type], "ready", [task_frame_expr], @ctx.types.fetch("bool"))
-        set_waiter_call = async_task_call(
-          task_expr,
-          await_info[:task_type],
-          "set_waiter",
-          [
-            task_frame_expr,
-            raw_frame_expr,
-            IR::Name.new(name: resume_linkage_name, type: async_info[:wake_type], pointer: false),
-          ],
-          @ctx.types.fetch("void"),
-        )
-        take_result_call = async_task_call(task_expr, await_info[:task_type], "take_result", [task_frame_expr], await_info[:result_type])
-        release_call = async_task_call(task_expr, await_info[:task_type], "release", [task_frame_expr], @ctx.types.fetch("void"))
-
-        unless await_info[:reuse_existing_storage]
           lowered << IR::Assignment.new(
-            target: task_expr,
+            target: async_frame_field_expression(frame_expr, "result", async_info[:result_type]),
             operator: "=",
-            value: lower_contextual_expression(prepared_task, env:, expected_type: await_info[:task_type]),
+            value: take_result_call,
           )
-        end
-        lowered << IR::IfStmt.new(
-          condition: IR::Unary.new(operator: "not", operand: ready_call, type: @ctx.types.fetch("bool")),
-          then_body: [
-            IR::Assignment.new(
-              target: async_frame_field_expression(frame_expr, "state", @ctx.types.fetch("int")),
-              operator: "=",
-              value: IR::IntegerLiteral.new(value: await_info[:state], type: @ctx.types.fetch("int")),
-            ),
-            IR::ExpressionStmt.new(expression: set_waiter_call),
-            IR::ReturnStmt.new(value: nil),
-          ],
-          else_body: nil,
-        )
-        lowered << IR::LabelStmt.new(name: async_state_label(resume_linkage_name, await_info[:state]))
-
-        case statement
-        when AST::LocalDecl
-          storage_type = field_info[:storage_type]
-          target = async_frame_field_expression(frame_expr, field_info[:field_name], storage_type)
-          lowered << IR::Assignment.new(target:, operator: "=", value: take_result_call)
-          lowered << IR::ExpressionStmt.new(expression: release_call)
-          if statement.else_body
-            else_env = duplicate_env(env)
-            if statement.else_binding
-              current_actual_scope(else_env[:scopes])[statement.else_binding.name] = local_binding(
-                type: let_else_error_type(storage_type),
-                storage_type:,
-                linkage_name: async_frame_field_c_name(field_info[:field_name]),
-                mutable: false,
-                pointer: false,
-                projection: :result_failure_error,
-              )
-            end
-            else_body = lower_async_body(
-              statement.else_body,
-              env: else_env,
-              frame_expr:,
-              raw_frame_expr:,
-              resume_linkage_name:,
-              async_info:,
-              active_defers:,
-              loop_flow:,
-            )
-            lowered << IR::IfStmt.new(
-              condition: let_else_failure_condition(target, storage_type),
-              then_body: else_body,
-              else_body: nil,
-            )
-          end
-        when AST::Assignment
-          lowered << IR::Assignment.new(target: lower_assignment_target(statement.target, env:), operator: statement.operator, value: take_result_call)
-          lowered << IR::ExpressionStmt.new(expression: release_call)
-        when AST::ExpressionStmt
-          lowered << IR::ExpressionStmt.new(expression: take_result_call)
           lowered << IR::ExpressionStmt.new(expression: release_call)
-        when AST::ReturnStmt
-          if await_info[:result_type] == @ctx.types.fetch("void")
-            lowered << IR::ExpressionStmt.new(expression: take_result_call)
-            lowered << IR::ExpressionStmt.new(expression: release_call)
-            lowered.concat(cleanup)
-            lowered.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value: nil, result_already_stored: true))
-          else
-            lowered << IR::Assignment.new(
-              target: async_frame_field_expression(frame_expr, "result", async_info[:result_type]),
-              operator: "=",
-              value: take_result_call,
-            )
-            lowered << IR::ExpressionStmt.new(expression: release_call)
-            lowered.concat(cleanup)
-            lowered.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value: nil, result_already_stored: true))
-          end
+          lowered.concat(cleanup)
+          lowered.concat(async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value: nil, result_already_stored: true))
         end
-
-        lowered
       end
 
-      def lower_async_defer_cleanup(statement, env:, async_info:)
-        body = if statement.body
-                 statement.body
-               elsif statement.expression
-                 [AST::ExpressionStmt.new(expression: statement.expression, line: statement.line)]
-               else
-                 []
-               end
+      lowered
+    end
 
-        { body:, env: snapshot_env(env) }
-      end
+    def lower_async_defer_cleanup(statement, env:, async_info:)
+      body = if statement.body
+                statement.body
+              elsif statement.expression
+                [AST::ExpressionStmt.new(expression: statement.expression, line: statement.line)]
+              else
+                []
+              end
 
-      def lower_async_cleanup_entries(local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)
-        cleanup_entries = local_defers.reverse + outer_defers.reverse
-        cleanup_entries.flat_map do |cleanup_entry|
-          next [] if cleanup_entry[:body].empty?
+      { body:, env: snapshot_env(env) }
+    end
 
-          cleanup_env = duplicate_env(cleanup_entry[:env])
-          lower_async_body(
-            cleanup_entry[:body],
-            env: cleanup_env,
-            frame_expr:,
-            raw_frame_expr:,
-            resume_linkage_name: async_info.fetch(:resume_linkage_name),
-            async_info:,
-            active_defers: [],
-            loop_flow: nil,
-          )
-        end
-      end
+    def lower_async_cleanup_entries(local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)
+      cleanup_entries = local_defers.reverse + outer_defers.reverse
+      cleanup_entries.flat_map do |cleanup_entry|
+        next [] if cleanup_entry[:body].empty?
 
-      def async_return_context(return_type:, active_defers:, local_defers:, frame_expr:, raw_frame_expr:, async_info:, allow_return: true)
-        {
-          return_type:,
-          active_defers:,
-          local_defers:,
-          allow_return:,
+        cleanup_env = duplicate_env(cleanup_entry[:env])
+        lower_async_body(
+          cleanup_entry[:body],
+          env: cleanup_env,
           frame_expr:,
           raw_frame_expr:,
+          resume_linkage_name: async_info.fetch(:resume_linkage_name),
           async_info:,
-        }
+          active_defers: [],
+          loop_flow: nil,
+        )
       end
-
-      def async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value:, result_already_stored: false)
-        lowered = []
-
-        if async_info[:result_type] != @ctx.types.fetch("void") && !result_already_stored
-          lowered << IR::Assignment.new(
-            target: async_frame_field_expression(frame_expr, "result", async_info[:result_type]),
-            operator: "=",
-            value: value,
-          )
-        end
-
+    end
+
+    def async_return_context(return_type:, active_defers:, local_defers:, frame_expr:, raw_frame_expr:, async_info:, allow_return: true)
+      {
+        return_type:,
+        active_defers:,
+        local_defers:,
+        allow_return:,
+        frame_expr:,
+        raw_frame_expr:,
+        async_info:,
+      }
+    end
+
+    def async_complete_statements(frame_expr:, raw_frame_expr:, async_info:, value:, result_already_stored: false)
+      lowered = []
+
+      if async_info[:result_type] != @ctx.types.fetch("void") && !result_already_stored
         lowered << IR::Assignment.new(
-          target: async_frame_field_expression(frame_expr, "ready", @ctx.types.fetch("bool")),
+          target: async_frame_field_expression(frame_expr, "result", async_info[:result_type]),
           operator: "=",
-          value: IR::BooleanLiteral.new(value: true, type: @ctx.types.fetch("bool")),
+          value: value,
         )
+      end
 
-        waiter_frame_field = async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr])
-        lowered << IR::IfStmt.new(
-          condition: IR::Binary.new(
-            operator: "!=",
-            left: waiter_frame_field,
-            right: IR::NullLiteral.new(type: async_info[:void_ptr]),
-            type: @ctx.types.fetch("bool"),
+      lowered << 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")),
+      )
+
+      waiter_frame_field = async_frame_field_expression(frame_expr, "waiter_frame", async_info[:void_ptr])
+      lowered << IR::IfStmt.new(
+        condition: IR::Binary.new(
+          operator: "!=",
+          left: waiter_frame_field,
+          right: IR::NullLiteral.new(type: async_info[:void_ptr]),
+          type: @ctx.types.fetch("bool"),
+        ),
+        then_body: [
+          IR::LocalDecl.new(
+            name: "waiter_frame",
+            linkage_name: "__mt_waiter_frame",
+            type: async_info[:void_ptr],
+            value: waiter_frame_field,
           ),
-          then_body: [
-            IR::LocalDecl.new(
-              name: "waiter_frame",
-              linkage_name: "__mt_waiter_frame",
-              type: async_info[:void_ptr],
-              value: waiter_frame_field,
-            ),
-            IR::Assignment.new(
-              target: waiter_frame_field,
-              operator: "=",
-              value: IR::NullLiteral.new(type: async_info[:void_ptr]),
-            ),
-            IR::ExpressionStmt.new(
-              expression: IR::Call.new(
-                callee: async_frame_field_expression(frame_expr, "waiter", async_info[:wake_type]),
-                arguments: [IR::Name.new(name: "__mt_waiter_frame", type: async_info[:void_ptr], pointer: false)],
-                type: @ctx.types.fetch("void"),
-              ),
+          IR::Assignment.new(
+            target: waiter_frame_field,
+            operator: "=",
+            value: IR::NullLiteral.new(type: async_info[:void_ptr]),
+          ),
+          IR::ExpressionStmt.new(
+            expression: IR::Call.new(
+              callee: async_frame_field_expression(frame_expr, "waiter", async_info[:wake_type]),
+              arguments: [IR::Name.new(name: "__mt_waiter_frame", type: async_info[:void_ptr], pointer: false)],
+              type: @ctx.types.fetch("void"),
             ),
-            IR::ReturnStmt.new(value: nil),
-          ],
-          else_body: nil,
-        )
-        lowered << IR::ReturnStmt.new(value: nil)
-        lowered
-      end
-
-      def async_variant_match_arm_binding(arm, scrutinee_expr, scrutinee_type, env:, frame_expr: nil, local_fields: nil)
-        arm_env = duplicate_env(env)
-        binding_decl = nil
-
-        if arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
-          arm_name = variant_match_arm_name_from_pattern(arm.pattern)
-          if arm_name && scrutinee_type.has_payload?(arm_name)
-            fields = scrutinee_type.arm(arm_name)
-            payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
-
-            field_key = async_match_binding_field_key(arm)
-            field_info = local_fields&.fetch(field_key, nil)
-            if field_info && frame_expr
-              target = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:storage_type])
-              binding_c = async_frame_field_c_name(field_info[:field_name])
-              arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: binding_c, mutable: false, pointer: false)
-              data_expr = IR::Member.new(receiver: scrutinee_expr, member: "data", type: nil)
-              arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
-              binding_decl = IR::Assignment.new(target:, operator: "=", value: arm_expr)
-            else
-              data_expr = IR::Member.new(receiver: scrutinee_expr, member: "data", type: nil)
-              arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
-              binding_c = c_local_name(arm.binding_name)
-              arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: binding_c, mutable: false, pointer: false)
-              binding_decl = IR::LocalDecl.new(name: arm.binding_name, linkage_name: binding_c, type: payload_type, value: arm_expr)
-            end
+          ),
+          IR::ReturnStmt.new(value: nil),
+        ],
+        else_body: nil,
+      )
+      lowered << IR::ReturnStmt.new(value: nil)
+      lowered
+    end
+
+    def async_variant_match_arm_binding(arm, scrutinee_expr, scrutinee_type, env:, frame_expr: nil, local_fields: nil)
+      arm_env = duplicate_env(env)
+      binding_decl = nil
+
+      if arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
+        arm_name = variant_match_arm_name_from_pattern(arm.pattern)
+        if arm_name && scrutinee_type.has_payload?(arm_name)
+          fields = scrutinee_type.arm(arm_name)
+          payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
+
+          field_key = async_match_binding_field_key(arm)
+          field_info = local_fields&.fetch(field_key, nil)
+          if field_info && frame_expr
+            target = async_frame_field_expression(frame_expr, field_info[:field_name], field_info[:storage_type])
+            binding_c = async_frame_field_c_name(field_info[:field_name])
+            arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: binding_c, mutable: false, pointer: false)
+            data_expr = IR::Member.new(receiver: scrutinee_expr, member: "data", type: nil)
+            arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
+            binding_decl = IR::Assignment.new(target:, operator: "=", value: arm_expr)
+          else
+            data_expr = IR::Member.new(receiver: scrutinee_expr, member: "data", type: nil)
+            arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
+            binding_c = c_local_name(arm.binding_name)
+            arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: binding_c, mutable: false, pointer: false)
+            binding_decl = IR::LocalDecl.new(name: arm.binding_name, linkage_name: binding_c, type: payload_type, value: arm_expr)
           end
         end
-
-        [arm_env, binding_decl]
       end
 
-      def bind_async_variant_match_arm_env!(arm_env, scrutinee_type, arm)
-        return unless scrutinee_type.is_a?(Types::Variant)
-        return unless arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
+      [arm_env, binding_decl]
+    end
 
-        arm_name = variant_match_arm_name_from_pattern(arm.pattern)
-        return unless arm_name && scrutinee_type.has_payload?(arm_name)
+    def bind_async_variant_match_arm_env!(arm_env, scrutinee_type, arm)
+      return unless scrutinee_type.is_a?(Types::Variant)
+      return unless arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
 
-        fields = scrutinee_type.arm(arm_name)
-        payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
-        arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: c_local_name(arm.binding_name), mutable: true, pointer: false)
-      end
+      arm_name = variant_match_arm_name_from_pattern(arm.pattern)
+      return unless arm_name && scrutinee_type.has_payload?(arm_name)
 
-      def lower_async_loop_exit(target, local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)
-        cleanup = lower_async_cleanup_entries(local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)
-        if cleanup.empty?
-          [loop_exit_statement(target, local_defers:, outer_defers:)]
-        else
-          label = target[:label]
-          raise LoweringError.new("structured loop exits with cleanup are unsupported", line: 0, column: 0, path: @ctx.current_analysis_path) unless label
+      fields = scrutinee_type.arm(arm_name)
+      payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
+      arm_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: c_local_name(arm.binding_name), mutable: true, pointer: false)
+    end
 
-          cleanup + [IR::GotoStmt.new(label:)]
-        end
+    def lower_async_loop_exit(target, local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)
+      cleanup = lower_async_cleanup_entries(local_defers, outer_defers, frame_expr:, raw_frame_expr:, async_info:)
+      if cleanup.empty?
+        [loop_exit_statement(target, local_defers:, outer_defers:)]
+      else
+        label = target[:label]
+        raise LoweringError.new("structured loop exits with cleanup are unsupported", line: 0, column: 0, path: @ctx.current_analysis_path) unless label
+
+        cleanup + [IR::GotoStmt.new(label:)]
       end
+    end
 
-      def async_local_decl_field_key(statement)
-        return "__discard_#{statement.line}" if statement.name == "_"
+    def async_local_decl_field_key(statement)
+      return "__discard_#{statement.line}" if statement.name == "_"
 
-        statement.name
-      end
+      statement.name
+    end
 
-      def async_local_decl_field_name(statement)
-        return "local_discard_#{statement.line}" if statement.name == "_"
+    def async_local_decl_field_name(statement)
+      return "local_discard_#{statement.line}" if statement.name == "_"
 
-        "local_#{statement.name}"
-      end
+      "local_#{statement.name}"
+    end
 
-      def async_match_binding_field_key(arm)
-        @async_binding_counter ||= 0
-        @async_binding_counter += 1
-        "match_binding_#{@async_binding_counter}"
-      end
+    def async_match_binding_field_key(arm)
+      @async_binding_counter ||= 0
+      @async_binding_counter += 1
+      "match_binding_#{@async_binding_counter}"
+    end
 
-      def async_match_binding_field_name(arm)
-        "local_match_binding_#{@async_binding_counter}"
-      end
+    def async_match_binding_field_name(arm)
+      "local_match_binding_#{@async_binding_counter}"
+    end
   end
 end