mt-lang 0.3.23 → 0.3.25

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

@@ -10,1140 +10,1142 @@ require_relative "declarations"
 require_relative "calls"
 
 module MilkTea
-  module LowererBlock
-    def lower_block(statements, env:, active_defers:, return_type:, loop_flow:, allow_return: true)
-      local_env = duplicate_env(env)
-      lowered = []
-      local_defers = []
-      local_env[:return_context] = {
-        return_type:,
-        active_defers:,
-        local_defers:,
-        allow_return:,
-      }
-
-      statements.each do |statement|
-        case statement
-        when AST::DeferStmt
-          local_defers << lower_defer_cleanup_body(statement.body, env: local_env, return_type:)
-        when AST::UnsafeStmt
-          lower_block_unsafe_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-        when AST::LocalDecl
-          lower_block_local_decl_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-        when AST::Assignment
-          lower_block_assignment_stmt(statement, lowered:, local_defers:, local_env:)
-        when AST::IfStmt
-          lower_block_if_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-        when AST::MatchStmt
-          lower_block_match_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-        when AST::StaticAssert
-          lowered << lower_static_assert(statement, env: local_env)
-        when AST::ForStmt
-          if statement.inline
-            lowered.concat(lower_inline_for_stmt(statement, env: local_env, active_defers:, return_type:, allow_return:))
-          else
-            lowered << lower_for_stmt(statement, env: local_env, active_defers: active_defers + local_defers, return_type:, allow_return:)
-          end
-        when AST::ParallelBlockStmt
-          lowered << lower_parallel_block_stmt(statement, env: local_env, active_defers: active_defers + local_defers)
-        when AST::GatherStmt
-          lowered << lower_gather_stmt(statement, env: local_env)
-        when AST::WhileStmt
-          if statement.inline
-            lowered.concat(lower_inline_while_stmt(statement, env: local_env, active_defers:, return_type:, allow_return:))
+  module Lowering
+    module Block
+      def lower_block(statements, env:, active_defers:, return_type:, loop_flow:, allow_return: true)
+        local_env = duplicate_env(env)
+        lowered = []
+        local_defers = []
+        local_env[:return_context] = {
+          return_type:,
+          active_defers:,
+          local_defers:,
+          allow_return:,
+        }
+
+        statements.each do |statement|
+          case statement
+          when AST::DeferStmt
+            local_defers << lower_defer_cleanup_body(statement.body, env: local_env, return_type:)
+          when AST::UnsafeStmt
+            lower_unsafe_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+          when AST::LocalDecl
+            lower_local_decl_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+          when AST::Assignment
+            lower_assignment_stmt(statement, lowered:, local_defers:, local_env:)
+          when AST::IfStmt
+            lower_if_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+          when AST::MatchStmt
+            lower_match_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+          when AST::StaticAssert
+            lowered << lower_static_assert(statement, env: local_env)
+          when AST::ForStmt
+            if statement.inline
+              lowered.concat(lower_inline_for_stmt(statement, env: local_env, active_defers:, return_type:, allow_return:))
+            else
+              lowered << lower_for_stmt(statement, env: local_env, active_defers: active_defers + local_defers, return_type:, allow_return:)
+            end
+          when AST::ParallelBlockStmt
+            lowered << lower_parallel_block_stmt(statement, env: local_env, active_defers: active_defers + local_defers)
+          when AST::GatherStmt
+            lowered << lower_gather_stmt(statement, env: local_env)
+          when AST::WhileStmt
+            if statement.inline
+              lowered.concat(lower_inline_while_stmt(statement, env: local_env, active_defers:, return_type:, allow_return:))
+            else
+              lowered << lower_while_stmt(statement, env: local_env, active_defers: active_defers + local_defers, return_type:, allow_return:)
+            end
+          when AST::PassStmt
+            nil
+          when AST::BreakStmt
+            raise LoweringError.new("break must be inside a loop",
+              line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless loop_flow
+
+            lowered.concat(lower_loop_exit(loop_flow[:break_target], local_defers, loop_flow[:break_defers]))
+          when AST::ContinueStmt
+            raise LoweringError.new("continue must be inside a loop",
+              line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless loop_flow
+
+            lowered.concat(lower_loop_exit(loop_flow[:continue_target], local_defers, loop_flow[:continue_defers]))
+          when AST::ReturnStmt
+            lower_return_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, allow_return:)
+          when AST::ExpressionStmt
+            lower_expression_stmt(statement, lowered:, local_defers:, local_env:)
+          when AST::EmitStmt
+            lowered.concat(lower_emit_stmt(statement, env: local_env))
+          when AST::WhenStmt
+            lower_when_stmt(statement, lowered:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
           else
-            lowered << lower_while_stmt(statement, env: local_env, active_defers: active_defers + local_defers, return_type:, allow_return:)
+            raise LoweringError.new("unsupported statement #{statement.class.name}",
+              line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
           end
-        when AST::PassStmt
-          nil
-        when AST::BreakStmt
-          raise LoweringError.new("break must be inside a loop",
-            line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless loop_flow
-
-          lowered.concat(lower_loop_exit(loop_flow[:break_target], local_defers, loop_flow[:break_defers]))
-        when AST::ContinueStmt
-          raise LoweringError.new("continue must be inside a loop",
-            line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless loop_flow
-
-          lowered.concat(lower_loop_exit(loop_flow[:continue_target], local_defers, loop_flow[:continue_defers]))
-        when AST::ReturnStmt
-          lower_block_return_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, allow_return:)
-        when AST::ExpressionStmt
-          lower_block_expression_stmt(statement, lowered:, local_defers:, local_env:)
-        when AST::EmitStmt
-          lowered.concat(lower_emit_stmt(statement, env: local_env))
-        when AST::WhenStmt
-          lower_block_when_stmt(statement, lowered:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-        else
-          raise LoweringError.new("unsupported statement #{statement.class.name}",
-            line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
         end
-      end
 
-      unless terminating_ir_statement?(lowered.last)
-        lowered.concat(cleanup_statements(local_defers, []))
+        unless terminating_ir_statement?(lowered.last)
+          lowered.concat(cleanup_statements(local_defers, []))
+        end
+        lowered
       end
-      lowered
-    end
 
-    def lower_proc_expression_for_local(expression, env:, local_name:, proc_type:)
-      captures = proc_capture_entries(expression, env)
-      captures.each do |capture|
-        if ref_type?(capture[:type]) || contains_ref_type?(capture[:type])
-          raise LoweringError.new("proc capture #{capture[:name]} cannot use ref types",
-            line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
+      def lower_proc_expression_for_local(expression, env:, local_name:, proc_type:)
+        captures = proc_capture_entries(expression, env)
+        captures.each do |capture|
+          if ref_type?(capture[:type]) || contains_ref_type?(capture[:type])
+            raise LoweringError.new("proc capture #{capture[:name]} cannot use ref types",
+              line: expression.line, column: expression.column, path: @ctx.current_analysis_path)
+          end
         end
-      end
 
-      proc_id = fresh_proc_symbol
-      invoke_c_name = "#{@ctx.module_prefix}__proc_#{proc_id}__invoke"
-      release_linkage_name = "#{@ctx.module_prefix}__proc_#{proc_id}__release"
-      retain_c_name = "#{@ctx.module_prefix}__proc_#{proc_id}__retain"
-      env_struct_type = nil
-      setup = []
-
-      env_value = if captures.empty?
-        IR::NullLiteral.new(type: proc_env_pointer_type)
-      else
-        env_struct_type = Types::Struct.new("#{@ctx.module_prefix}__proc_#{proc_id}__env").define_fields(
-          { "__mt_ref_count" => @ctx.types.fetch("ptr_uint") }.merge(captures.each_with_object({}) { |capture, fields| fields[capture[:field_name]] = capture[:type] }),
-        )
-        @artifacts.synthetic_structs << IR::StructDecl.new(
-          name: env_struct_type.name,
-          linkage_name: env_struct_type.name,
-          fields: [IR::Field.new(name: "__mt_ref_count", type: @ctx.types.fetch("ptr_uint")), *captures.map { |capture| IR::Field.new(name: capture[:field_name], type: capture[:type]) }],
-          packed: false,
-          alignment: nil,
-        )
+        proc_id = fresh_proc_symbol
+        invoke_c_name = "#{@ctx.module_prefix}__proc_#{proc_id}__invoke"
+        release_linkage_name = "#{@ctx.module_prefix}__proc_#{proc_id}__release"
+        retain_c_name = "#{@ctx.module_prefix}__proc_#{proc_id}__retain"
+        env_struct_type = nil
+        setup = []
 
-        env_pointer_type = pointer_to(env_struct_type)
-        env_name = fresh_c_temp_name(env, "#{local_name}_env")
-        raw_allocation = IR::Call.new(
-          callee: "mt_async_alloc",
-          arguments: [IR::SizeofExpr.new(target_type: env_struct_type, type: @ctx.types.fetch("ptr_uint"))],
-          type: proc_env_pointer_type,
-        )
-        setup << IR::LocalDecl.new(
-          name: env_name,
-          linkage_name: env_name,
-          type: env_pointer_type,
-          value: IR::Cast.new(target_type: env_pointer_type, expression: raw_allocation, type: env_pointer_type),
-        )
-        env_pointer = IR::Name.new(name: env_name, type: env_pointer_type, pointer: false)
-        setup << IR::Assignment.new(
-          target: IR::Member.new(receiver: env_pointer, member: "__mt_ref_count", type: @ctx.types.fetch("ptr_uint")),
-          operator: "=",
-          value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint")),
-        )
-        captures.each do |capture|
+        env_value = if captures.empty?
+          IR::NullLiteral.new(type: proc_env_pointer_type)
+        else
+          env_struct_type = Types::Struct.new("#{@ctx.module_prefix}__proc_#{proc_id}__env").define_fields(
+            { "__mt_ref_count" => @ctx.types.fetch("ptr_uint") }.merge(captures.each_with_object({}) { |capture, fields| fields[capture[:field_name]] = capture[:type] }),
+          )
+          @artifacts.synthetic_structs << IR::StructDecl.new(
+            name: env_struct_type.name,
+            linkage_name: env_struct_type.name,
+            fields: [IR::Field.new(name: "__mt_ref_count", type: @ctx.types.fetch("ptr_uint")), *captures.map { |capture| IR::Field.new(name: capture[:field_name], type: capture[:type]) }],
+            packed: false,
+            alignment: nil,
+          )
+
+          env_pointer_type = pointer_to(env_struct_type)
+          env_name = fresh_c_temp_name(env, "#{local_name}_env")
+          raw_allocation = IR::Call.new(
+            callee: "mt_async_alloc",
+            arguments: [IR::SizeofExpr.new(target_type: env_struct_type, type: @ctx.types.fetch("ptr_uint"))],
+            type: proc_env_pointer_type,
+          )
+          setup << IR::LocalDecl.new(
+            name: env_name,
+            linkage_name: env_name,
+            type: env_pointer_type,
+            value: IR::Cast.new(target_type: env_pointer_type, expression: raw_allocation, type: env_pointer_type),
+          )
+          env_pointer = IR::Name.new(name: env_name, type: env_pointer_type, pointer: false)
           setup << IR::Assignment.new(
-            target: IR::Member.new(receiver: env_pointer, member: capture[:field_name], type: capture[:type]),
+            target: IR::Member.new(receiver: env_pointer, member: "__mt_ref_count", type: @ctx.types.fetch("ptr_uint")),
             operator: "=",
-            value: lower_expression(AST::Identifier.new(name: capture[:name]), env:, expected_type: capture[:type]),
+            value: IR::IntegerLiteral.new(value: 1, type: @ctx.types.fetch("ptr_uint")),
           )
-        end
-        captures.each do |capture|
-          next unless contains_proc_storage_type?(capture[:type])
+          captures.each do |capture|
+            setup << IR::Assignment.new(
+              target: IR::Member.new(receiver: env_pointer, member: capture[:field_name], type: capture[:type]),
+              operator: "=",
+              value: lower_expression(AST::Identifier.new(name: capture[:name]), env:, expected_type: capture[:type]),
+            )
+          end
+          captures.each do |capture|
+            next unless contains_proc_storage_type?(capture[:type])
 
-          member = IR::Member.new(receiver: env_pointer, member: capture[:field_name], type: capture[:type])
-          setup.concat(lower_proc_contained_retain_statements(member, capture[:type]))
+            member = IR::Member.new(receiver: env_pointer, member: capture[:field_name], type: capture[:type])
+            setup.concat(lower_proc_contained_retain_statements(member, capture[:type]))
+          end
+          IR::Cast.new(target_type: proc_env_pointer_type, expression: env_pointer, type: proc_env_pointer_type)
         end
-        IR::Cast.new(target_type: proc_env_pointer_type, expression: env_pointer, type: proc_env_pointer_type)
-      end
 
-      @artifacts.synthetic_functions << build_proc_invoke_function(expression, proc_type, captures, env_struct_type, invoke_c_name)
-      @artifacts.synthetic_functions << build_proc_release_function(release_linkage_name, env_struct_type)
-      @artifacts.synthetic_functions << build_proc_retain_function(retain_c_name, env_struct_type)
-
-      [
-        setup,
-        IR::AggregateLiteral.new(
-          type: proc_type,
-          fields: [
-            IR::AggregateField.new(name: "env", value: env_value),
-            IR::AggregateField.new(name: "invoke", value: IR::Name.new(name: invoke_c_name, type: proc_invoke_function_type(proc_type), pointer: false)),
-            IR::AggregateField.new(name: "release", value: IR::Name.new(name: release_linkage_name, type: proc_release_function_type, pointer: false)),
-            IR::AggregateField.new(name: "retain", value: IR::Name.new(name: retain_c_name, type: proc_retain_function_type, pointer: false)),
-          ],
-        ),
-      ]
-    end
+        @artifacts.synthetic_functions << build_proc_invoke_function(expression, proc_type, captures, env_struct_type, invoke_c_name)
+        @artifacts.synthetic_functions << build_proc_release_function(release_linkage_name, env_struct_type)
+        @artifacts.synthetic_functions << build_proc_retain_function(retain_c_name, env_struct_type)
+
+        [
+          setup,
+          IR::AggregateLiteral.new(
+            type: proc_type,
+            fields: [
+              IR::AggregateField.new(name: "env", value: env_value),
+              IR::AggregateField.new(name: "invoke", value: IR::Name.new(name: invoke_c_name, type: proc_invoke_function_type(proc_type), pointer: false)),
+              IR::AggregateField.new(name: "release", value: IR::Name.new(name: release_linkage_name, type: proc_release_function_type, pointer: false)),
+              IR::AggregateField.new(name: "retain", value: IR::Name.new(name: retain_c_name, type: proc_retain_function_type, pointer: false)),
+            ],
+          ),
+        ]
+      end
 
-    def lower_inline_for_stmt(statement, env:, active_defers:, return_type:, allow_return:)
-      iterable = compile_time_const_value(statement.iterables.first, env:)
-      return [] unless iterable.is_a?(Array) && !iterable.empty?
-
-      loop_var_name = statement.bindings.first.name
-      loop_var_type = inline_loop_element_type(iterable.first)
-      lowered = []
-
-      iterable.each do |element|
-        iter_env = duplicate_env(env)
-        current_actual_scope(iter_env[:scopes])[loop_var_name] = local_binding(
-          type: loop_var_type,
-          linkage_name: c_local_name(loop_var_name),
-          mutable: false,
-          pointer: false,
-          const_value: element,
-        )
-        emit_stmts, other_stmts = statement.body.partition { |s| s.is_a?(AST::EmitStmt) }
-        emit_stmts.each do |emit_stmt|
-          lowered.concat(lower_emit_stmt(emit_stmt, env: iter_env))
-        rescue LoweringError
-          # emit for compile-time-only constructs — skip
-        end
+      def lower_inline_for_stmt(statement, env:, active_defers:, return_type:, allow_return:)
+        iterable = compile_time_const_value(statement.iterables.first, env:)
+        return [] unless iterable.is_a?(Array) && !iterable.empty?
+
+        loop_var_name = statement.bindings.first.name
+        loop_var_type = inline_loop_element_type(iterable.first)
+        lowered = []
+
+        iterable.each do |element|
+          iter_env = duplicate_env(env)
+          current_actual_scope(iter_env[:scopes])[loop_var_name] = local_binding(
+            type: loop_var_type,
+            linkage_name: c_local_name(loop_var_name),
+            mutable: false,
+            pointer: false,
+            const_value: element,
+          )
+          emit_stmts, other_stmts = statement.body.partition { |s| s.is_a?(AST::EmitStmt) }
+          emit_stmts.each do |emit_stmt|
+            lowered.concat(lower_emit_stmt(emit_stmt, env: iter_env))
+          rescue LoweringError
+            # emit for compile-time-only constructs — skip
+          end
 
-        unless other_stmts.empty?
-          saved_type_env = @type_resolution_env
-          saved_bypass = @bypass_sema_type_cache
-          # Each unrolled iteration may bind the loop var to a different value
-          # (e.g. a field whose `.type` differs per field), so expression types
-          # must be re-inferred per iteration instead of reusing the single
-          # sema-cached type computed for the representative first element.
-          @type_resolution_env = iter_env
-          @bypass_sema_type_cache = true
-          begin
-            body = lower_block(other_stmts, env: iter_env, active_defers:, return_type:, loop_flow: nil, allow_return:)
-          ensure
-            @type_resolution_env = saved_type_env
-            @bypass_sema_type_cache = saved_bypass
+          unless other_stmts.empty?
+            saved_type_env = @type_resolution_env
+            saved_bypass = @bypass_sema_type_cache
+            # Each unrolled iteration may bind the loop var to a different value
+            # (e.g. a field whose `.type` differs per field), so expression types
+            # must be re-inferred per iteration instead of reusing the single
+            # sema-cached type computed for the representative first element.
+            @type_resolution_env = iter_env
+            @bypass_sema_type_cache = true
+            begin
+              body = lower_block(other_stmts, env: iter_env, active_defers:, return_type:, loop_flow: nil, allow_return:)
+            ensure
+              @type_resolution_env = saved_type_env
+              @bypass_sema_type_cache = saved_bypass
+            end
+            lowered << IR::BlockStmt.new(body:) unless body.empty?
           end
-          lowered << IR::BlockStmt.new(body:) unless body.empty?
         end
+
+        lowered
       end
 
-      lowered
-    end
+      def lower_inline_while_stmt(statement, env:, active_defers:, return_type:, allow_return:)
+        condition = compile_time_const_value(statement.condition, env:)
+        return [] unless condition
 
-    def lower_inline_while_stmt(statement, env:, active_defers:, return_type:, allow_return:)
-      condition = compile_time_const_value(statement.condition, env:)
-      return [] unless condition
+        iterations = 0
+        max_iterations = 10_000
+        lowered = []
 
-      iterations = 0
-      max_iterations = 10_000
-      lowered = []
+        while compile_time_const_value(statement.condition, env:) && iterations < max_iterations
+          body = lower_block(statement.body, env:, active_defers:, return_type:, loop_flow: nil, allow_return:)
+          lowered << IR::BlockStmt.new(body:) unless body.empty?
+          iterations += 1
+        end
 
-      while compile_time_const_value(statement.condition, env:) && iterations < max_iterations
-        body = lower_block(statement.body, env:, active_defers:, return_type:, loop_flow: nil, allow_return:)
-        lowered << IR::BlockStmt.new(body:) unless body.empty?
-        iterations += 1
+        lowered
       end
 
-      lowered
-    end
-
-    def lower_inline_if_stmt(statement, env:, active_defers:, return_type:, allow_return:)
-      chosen_branch = statement.branches.find do |branch|
-        ct_value = compile_time_const_value(branch.condition, env:)
-        ct_value == true
-      end
+      def lower_inline_if_stmt(statement, env:, active_defers:, return_type:, allow_return:)
+        chosen_branch = statement.branches.find do |branch|
+          ct_value = compile_time_const_value(branch.condition, env:)
+          ct_value == true
+        end
 
-      if chosen_branch
-        lower_block(chosen_branch.body, env:, active_defers:, return_type:, loop_flow: nil, allow_return:)
-      elsif statement.else_body
-        lower_block(statement.else_body, env:, active_defers:, return_type:, loop_flow: nil, allow_return:)
-      else
-        []
+        if chosen_branch
+          lower_block(chosen_branch.body, env:, active_defers:, return_type:, loop_flow: nil, allow_return:)
+        elsif statement.else_body
+          lower_block(statement.else_body, env:, active_defers:, return_type:, loop_flow: nil, allow_return:)
+        else
+          []
+        end
       end
-    end
-
-    def lower_inline_match_stmt(statement, env:, active_defers:, return_type:, allow_return:)
-      scrutinee = compile_time_const_value(statement.expression, env:)
-      return [] unless scrutinee
 
-      chosen_arm = statement.arms.find do |arm|
-        scrutinee == compile_time_const_value(arm.pattern, env:)
-      end
+      def lower_inline_match_stmt(statement, env:, active_defers:, return_type:, allow_return:)
+        scrutinee = compile_time_const_value(statement.expression, env:)
+        return [] unless scrutinee
 
-      return [] unless chosen_arm
+        chosen_arm = statement.arms.find do |arm|
+          scrutinee == compile_time_const_value(arm.pattern, env:)
+        end
 
-      lower_block(chosen_arm.body, env:, active_defers:, return_type:, loop_flow: nil, allow_return:)
-    end
+        return [] unless chosen_arm
 
-    def inline_loop_element_type(element)
-      if element.is_a?(Types::FieldHandle)
-        @ctx.types.fetch("field_handle")
-      elsif element.is_a?(Types::CallableHandle)
-        @ctx.types.fetch("callable_handle")
-      elsif element.is_a?(Types::AttributeHandle)
-        @ctx.types.fetch("attribute_handle")
-      elsif element.is_a?(Types::MemberHandle)
-        @ctx.types.fetch("member_handle")
-      elsif element.is_a?(Types::StructHandle)
-        @ctx.types.fetch("struct_handle")
-      else
-        @ctx.types.fetch("int")
+        lower_block(chosen_arm.body, env:, active_defers:, return_type:, loop_flow: nil, allow_return:)
       end
-    end
 
-    def lower_emit_stmt(statement, env:)
-      decl = statement.declaration
-      case decl
-      when AST::FunctionDef
-        lower_emitted_function(decl, env:)
-      when AST::StructDecl
-        lower_emitted_struct(decl)
-      when AST::ConstDecl
-        lower_emitted_const(decl, env:)
-      else
-        raise LoweringError.new("emit is not supported for #{decl.class.name}",
-          line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
+      def inline_loop_element_type(element)
+        if element.is_a?(Types::FieldHandle)
+          @ctx.types.fetch("field_handle")
+        elsif element.is_a?(Types::CallableHandle)
+          @ctx.types.fetch("callable_handle")
+        elsif element.is_a?(Types::AttributeHandle)
+          @ctx.types.fetch("attribute_handle")
+        elsif element.is_a?(Types::MemberHandle)
+          @ctx.types.fetch("member_handle")
+        elsif element.is_a?(Types::StructHandle)
+          @ctx.types.fetch("struct_handle")
+        else
+          @ctx.types.fetch("int")
+        end
       end
-    end
 
-    def lower_emitted_function(decl, env:)
-      params = []
-      param_setup = []
-      return_type = decl.return_type ? resolve_type_ref(decl.return_type) : @ctx.types.fetch("void")
-      linkage_name = "#{@ctx.module_prefix}#{decl.name}"
-
-      decl.params.each do |param|
-        param_type = param.type ? resolve_type_ref(param.type) : @ctx.types.fetch("int")
-        param_linkage_name = c_local_name(param.name)
-        params << IR::Param.new(name: param.name, linkage_name: param_linkage_name, type: param_type, pointer: false)
-        env[:scopes].last[param.name] = local_binding(type: param_type, linkage_name: param_linkage_name, mutable: false, pointer: false)
+      def lower_emit_stmt(statement, env:)
+        decl = statement.declaration
+        case decl
+        when AST::FunctionDef
+          lower_emitted_function(decl, env:)
+        when AST::StructDecl
+          lower_emitted_struct(decl)
+        when AST::ConstDecl
+          lower_emitted_const(decl, env:)
+        else
+          raise LoweringError.new("emit is not supported for #{decl.class.name}",
+            line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
+        end
       end
 
-      body = lower_block(decl.body, env:, active_defers: [], return_type:, loop_flow: nil, allow_return: true)
-      body = param_setup + body
-      func = IR::Function.new(name: decl.name, linkage_name:, params:, return_type:, body:, entry_point: false, method_receiver_param: false)
-      @artifacts.emitted_declarations << func
-      []
-    end
+      def lower_emitted_function(decl, env:)
+        params = []
+        param_setup = []
+        return_type = decl.return_type ? resolve_type_ref(decl.return_type) : @ctx.types.fetch("void")
+        linkage_name = "#{@ctx.module_prefix}#{decl.name}"
+
+        decl.params.each do |param|
+          param_type = param.type ? resolve_type_ref(param.type) : @ctx.types.fetch("int")
+          param_linkage_name = c_local_name(param.name)
+          params << IR::Param.new(name: param.name, linkage_name: param_linkage_name, type: param_type, pointer: false)
+          env[:scopes].last[param.name] = local_binding(type: param_type, linkage_name: param_linkage_name, mutable: false, pointer: false)
+        end
 
-    def lower_emitted_struct(decl)
-      fields = decl.fields.map do |field|
-        field_type = field.type ? resolve_type_ref(field.type) : @ctx.types.fetch("int")
-        IR::Field.new(name: field.name, type: field_type)
+        body = lower_block(decl.body, env:, active_defers: [], return_type:, loop_flow: nil, allow_return: true)
+        body = param_setup + body
+        func = IR::Function.new(name: decl.name, linkage_name:, params:, return_type:, body:, entry_point: false, method_receiver_param: false)
+        @artifacts.emitted_declarations << func
+        []
       end
-      linkage_name = "#{@ctx.module_prefix}#{decl.name}"
-      struct_decl = IR::StructDecl.new(name: decl.name, linkage_name:, fields:, packed: decl.respond_to?(:packed) ? decl.packed : false, alignment: nil)
-      @artifacts.emitted_declarations << struct_decl
-      []
-    end
 
-    def lower_destructure_decl(statement, env:, lowered:, local_defers:, active_defers:, return_type:, loop_flow:, allow_return:)
-      value_type = infer_expression_type(statement.value, env:)
-      setup, prepared_value, _cleanups = prepare_expression_with_cleanups(statement.value, env:, expected_type: value_type)
-      lowered.concat(setup)
-      value = lower_contextual_expression(prepared_value, env:, expected_type: value_type)
-
-      temp_name = fresh_c_temp_name(env, "destructure_val")
-      lowered << IR::LocalDecl.new(name: temp_name, linkage_name: temp_name, type: value_type, value:)
-
-      if statement.destructure_type_name
-        # Struct destructure: find fields by name in the struct type
-        destructure_type = value_type
-        fields = destructure_type.fields
-        statement.destructure_bindings.each do |name|
-          next if name == "_"
-          field_type = fields[name]
-          field_expr = IR::Member.new(receiver: IR::Name.new(name: temp_name, type: destructure_type, pointer: false), member: name, type: field_type)
-          decl_c_name = c_local_name(name)
-          lowered << IR::LocalDecl.new(name: decl_c_name, linkage_name: decl_c_name, type: field_type, value: field_expr)
-          env[:scopes].last[name] = local_binding(type: field_type, linkage_name: decl_c_name, mutable: false, pointer: false)
-        end
-      else
-        # Tuple destructure: index by position
-        statement.destructure_bindings.each_with_index do |name, index|
-          next if name == "_"
-          field_name = value_type.field_names[index]
-          field_type = value_type.element_types[index]
-          field_expr = IR::Member.new(receiver: IR::Name.new(name: temp_name, type: value_type, pointer: false), member: field_name, type: field_type)
-          decl_c_name = c_local_name(name)
-          lowered << IR::LocalDecl.new(name: decl_c_name, linkage_name: decl_c_name, type: field_type, value: field_expr)
-          env[:scopes].last[name] = local_binding(type: field_type, linkage_name: decl_c_name, mutable: false, pointer: false)
+      def lower_emitted_struct(decl)
+        fields = decl.fields.map do |field|
+          field_type = field.type ? resolve_type_ref(field.type) : @ctx.types.fetch("int")
+          IR::Field.new(name: field.name, type: field_type)
         end
+        linkage_name = "#{@ctx.module_prefix}#{decl.name}"
+        struct_decl = IR::StructDecl.new(name: decl.name, linkage_name:, fields:, packed: decl.respond_to?(:packed) ? decl.packed : false, alignment: nil)
+        @artifacts.emitted_declarations << struct_decl
+        []
       end
-    end
-
-    def lower_emitted_const(decl, env:)
-      value = lower_static_storage_initializer(decl.value, env:, expected_type: decl.type ? resolve_type_ref(decl.type) : nil)
-      type = decl.type ? resolve_type_ref(decl.type) : infer_expression_type(decl.value, env:)
-      linkage_name = value_c_name(decl.name)
-      constant = IR::Constant.new(name: decl.name, linkage_name:, type:, value:, line: decl.line, path: @ctx.current_analysis_path)
-      @artifacts.emitted_declarations << constant
-      []
-    end
 
-    def variant_self_referencing_field?(field_type, scrutinee_type)
-      return false unless field_type.is_a?(Types::Variant) || field_type.is_a?(Types::VariantInstance)
-      return false unless scrutinee_type.is_a?(Types::Variant) || scrutinee_type.is_a?(Types::VariantInstance)
-      field_type == scrutinee_type
-    end
+      def lower_destructure_decl(statement, env:, lowered:, local_defers:, active_defers:, return_type:, loop_flow:, allow_return:)
+        value_type = infer_expression_type(statement.value, env:)
+        setup, prepared_value, _cleanups = prepare_expression_with_cleanups(statement.value, env:, expected_type: value_type)
+        lowered.concat(setup)
+        value = lower_contextual_expression(prepared_value, env:, expected_type: value_type)
+
+        temp_name = fresh_c_temp_name(env, "destructure_val")
+        lowered << IR::LocalDecl.new(name: temp_name, linkage_name: temp_name, type: value_type, value:)
+
+        if statement.destructure_type_name
+          # Struct destructure: find fields by name in the struct type
+          destructure_type = value_type
+          fields = destructure_type.fields
+          statement.destructure_bindings.each do |name|
+            next if name == "_"
+            field_type = fields[name]
+            field_expr = IR::Member.new(receiver: IR::Name.new(name: temp_name, type: destructure_type, pointer: false), member: name, type: field_type)
+            decl_c_name = c_local_name(name)
+            lowered << IR::LocalDecl.new(name: decl_c_name, linkage_name: decl_c_name, type: field_type, value: field_expr)
+            env[:scopes].last[name] = local_binding(type: field_type, linkage_name: decl_c_name, mutable: false, pointer: false)
+          end
+        else
+          # Tuple destructure: index by position
+          statement.destructure_bindings.each_with_index do |name, index|
+            next if name == "_"
+            field_name = value_type.field_names[index]
+            field_type = value_type.element_types[index]
+            field_expr = IR::Member.new(receiver: IR::Name.new(name: temp_name, type: value_type, pointer: false), member: field_name, type: field_type)
+            decl_c_name = c_local_name(name)
+            lowered << IR::LocalDecl.new(name: decl_c_name, linkage_name: decl_c_name, type: field_type, value: field_expr)
+            env[:scopes].last[name] = local_binding(type: field_type, linkage_name: decl_c_name, mutable: false, pointer: false)
+          end
+        end
+      end
 
-    def dereference_if_self_ref(field_expr, field_type, scrutinee_type)
-      if variant_self_referencing_field?(field_type, scrutinee_type)
-        IR::Unary.new(operator: "*", operand: field_expr, type: field_type)
-      else
-        field_expr
+      def lower_emitted_const(decl, env:)
+        value = lower_static_storage_initializer(decl.value, env:, expected_type: decl.type ? resolve_type_ref(decl.type) : nil)
+        type = decl.type ? resolve_type_ref(decl.type) : infer_expression_type(decl.value, env:)
+        linkage_name = value_c_name(decl.name)
+        constant = IR::Constant.new(name: decl.name, linkage_name:, type:, value:, line: decl.line, path: @ctx.current_analysis_path)
+        @artifacts.emitted_declarations << constant
+        []
       end
-    end
 
-    def lower_block_unsafe_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      body = lower_block(
-        statement.body,
-        env: local_env,
-        active_defers: active_defers + local_defers,
-        return_type:,
-        loop_flow: nested_loop_flow(loop_flow, local_defers),
-        allow_return:,
-      )
-      lowered << IR::BlockStmt.new(body:)
-    end
+      def variant_self_referencing_field?(field_type, scrutinee_type)
+        return false unless field_type.is_a?(Types::Variant) || field_type.is_a?(Types::VariantInstance)
+        return false unless scrutinee_type.is_a?(Types::Variant) || scrutinee_type.is_a?(Types::VariantInstance)
+        field_type == scrutinee_type
+      end
 
-    def lower_block_when_stmt(statement, lowered:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      discriminant = compile_time_const_value(statement.discriminant)
-      chosen_branch = statement.branches.find do |branch|
-        discriminant == compile_time_const_value(branch.pattern)
+      def dereference_if_self_ref(field_expr, field_type, scrutinee_type)
+        if variant_self_referencing_field?(field_type, scrutinee_type)
+          IR::Unary.new(operator: "*", operand: field_expr, type: field_type)
+        else
+          field_expr
+        end
       end
 
-      if chosen_branch
-        lowered.concat(lower_block(
-          chosen_branch.body,
-          env: local_env,
-          active_defers:,
-          return_type:,
-          loop_flow:,
-          allow_return:,
-        ))
-      elsif statement.else_body
-        lowered.concat(lower_block(
-          statement.else_body,
+      def lower_unsafe_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        body = lower_block(
+          statement.body,
           env: local_env,
-          active_defers:,
+          active_defers: active_defers + local_defers,
           return_type:,
-          loop_flow:,
+          loop_flow: nested_loop_flow(loop_flow, local_defers),
           allow_return:,
-        ))
+        )
+        lowered << IR::BlockStmt.new(body:)
       end
-    end
 
-    def lower_block_expression_stmt(statement, lowered:, local_defers:, local_env:)
-      if (format_sink_statements = lower_explicit_format_sink_expression_statement(statement.expression, env: local_env, line: statement.line))
-        lowered.concat(format_sink_statements)
-        return
-      end
+      def lower_when_stmt(statement, lowered:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        discriminant = compile_time_const_value(statement.discriminant)
+        chosen_branch = statement.branches.find do |branch|
+          discriminant == compile_time_const_value(branch.pattern)
+        end
 
-      expression_expected_type = if statement.expression.is_a?(AST::UnaryOp) && statement.expression.operator == "?"
-        nil
-      else
-        infer_expression_type(statement.expression, env: local_env)
-      end
-      prepared_setup, prepared_expression, prepared_cleanups = prepare_expression_with_cleanups(
-        statement.expression,
-        env: local_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, local_env))
-        setup, _value = lower_foreign_call_statement(
-          foreign_call,
-          env: local_env,
-          expected_type: foreign_call[:binding].type.return_type,
-          statement_position: true,
-          discard_result: true,
-        )
-        lowered.concat(setup)
-        lowered.concat(prepared_cleanups.flat_map(&:itself))
-        local_env[:scopes] = scopes_with_refinements(local_env[:scopes], consuming_foreign_call_refinements(foreign_call, local_env))
-      elsif prepared_expression
-        lowered << IR::ExpressionStmt.new(expression: lower_expression(prepared_expression, env: local_env), line: statement.line, path: @ctx.current_analysis_path)
-        lowered.concat(prepared_cleanups.flat_map(&:itself))
-      else
-        lowered.concat(prepared_cleanups.flat_map(&:itself))
+        if chosen_branch
+          lowered.concat(lower_block(
+            chosen_branch.body,
+            env: local_env,
+            active_defers:,
+            return_type:,
+            loop_flow:,
+            allow_return:,
+          ))
+        elsif statement.else_body
+          lowered.concat(lower_block(
+            statement.else_body,
+            env: local_env,
+            active_defers:,
+            return_type:,
+            loop_flow:,
+            allow_return:,
+          ))
+        end
       end
-    end
 
-    def lower_block_return_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, allow_return:)
-      raise LoweringError.new("return is not allowed inside defer blocks",
-        line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless allow_return
+      def lower_expression_stmt(statement, lowered:, local_defers:, local_env:)
+        if (format_sink_statements = lower_explicit_format_sink_expression_statement(statement.expression, env: local_env, line: statement.line))
+          lowered.concat(format_sink_statements)
+          return
+        end
 
-      value = nil
-      prepared_setup = []
-      prepared_value = statement.value
-      prepared_cleanups = []
-      if statement.value
-        prepared_setup, prepared_value, prepared_cleanups = prepare_expression_with_cleanups(
-          statement.value,
+        expression_expected_type = if statement.expression.is_a?(AST::UnaryOp) && statement.expression.operator == "?"
+          nil
+        else
+          infer_expression_type(statement.expression, env: local_env)
+        end
+        prepared_setup, prepared_expression, prepared_cleanups = prepare_expression_with_cleanups(
+          statement.expression,
           env: local_env,
-          expected_type: return_type,
+          expected_type: expression_expected_type,
           allow_root_statement_foreign: true,
-          materialize_array_calls: !array_type?(return_type),
+          allow_void_propagation: true,
         )
         lowered.concat(prepared_setup)
-      end
-      if prepared_value && (foreign_call = foreign_call_info(prepared_value, local_env))
-        setup, value = lower_foreign_call_statement(foreign_call, env: local_env, expected_type: return_type, statement_position: false)
-        lowered.concat(setup)
-      end
-      value ||= prepared_value ? lower_contextual_expression(
-        prepared_value,
-        env: local_env,
-        expected_type: return_type,
-        contextual_int_to_float: contextual_int_to_float_target?(return_type),
-      ) : nil
-      if prepared_cleanups.any? && cstr_trackable_type?(return_type)
-        raise LoweringError.new("formatted string temporaries cannot be returned as borrowed text; use std.fmt.format(f\"...\") when ownership must escape",
-          line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
+        if prepared_expression && (foreign_call = foreign_call_info(prepared_expression, local_env))
+          setup, _value = lower_foreign_call_statement(
+            foreign_call,
+            env: local_env,
+            expected_type: foreign_call[:binding].type.return_type,
+            statement_position: true,
+            discard_result: true,
+          )
+          lowered.concat(setup)
+          lowered.concat(prepared_cleanups.flat_map(&:itself))
+          local_env[:scopes] = scopes_with_refinements(local_env[:scopes], consuming_foreign_call_refinements(foreign_call, local_env))
+        elsif prepared_expression
+          lowered << IR::ExpressionStmt.new(expression: lower_expression(prepared_expression, env: local_env), line: statement.line, path: @ctx.current_analysis_path)
+          lowered.concat(prepared_cleanups.flat_map(&:itself))
+        else
+          lowered.concat(prepared_cleanups.flat_map(&:itself))
+        end
       end
 
-      prepared_cleanup_list = prepared_cleanups.flat_map(&:itself)
-      if prepared_cleanup_list.any? && return_type.is_a?(Types::Struct) && struct_contains_string_field?(return_type)
-        prepared_cleanup_list = prepared_cleanup_list.reject { |stmt| stmt.is_a?(IR::ExpressionStmt) && stmt.expression.is_a?(IR::Call) && stmt.expression.callee == "mt_format_str_release" }
-      end
-      cleanup = prepared_cleanup_list + cleanup_statements(local_defers, active_defers)
-      needs_proc_retain = value && contains_proc_storage_type?(return_type) && !local_defers.empty? && !expression_contains_proc_expr?(prepared_value)
-      if value && (!cleanup.empty? && !cleanup_safe_return_expression?(prepared_value) || needs_proc_retain)
-        return_value_name = fresh_c_temp_name(local_env, "return_value")
-        lowered << IR::LocalDecl.new(name: return_value_name, linkage_name: return_value_name, type: return_type, value:)
-        value = IR::Name.new(name: return_value_name, type: return_type, pointer: false)
-      end
-      lowered.concat(lower_proc_contained_retain_statements(value, return_type)) if needs_proc_retain
-      lowered.concat(cleanup)
-      lowered << IR::ReturnStmt.new(value:, line: statement.line, path: @ctx.current_analysis_path)
-    end
+      def lower_return_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, allow_return:)
+        raise LoweringError.new("return is not allowed inside defer blocks",
+          line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless allow_return
+
+        value = nil
+        prepared_setup = []
+        prepared_value = statement.value
+        prepared_cleanups = []
+        if statement.value
+          prepared_setup, prepared_value, prepared_cleanups = prepare_expression_with_cleanups(
+            statement.value,
+            env: local_env,
+            expected_type: return_type,
+            allow_root_statement_foreign: true,
+            materialize_array_calls: !array_type?(return_type),
+          )
+          lowered.concat(prepared_setup)
+        end
+        if prepared_value && (foreign_call = foreign_call_info(prepared_value, local_env))
+          setup, value = lower_foreign_call_statement(foreign_call, env: local_env, expected_type: return_type, statement_position: false)
+          lowered.concat(setup)
+        end
+        value ||= prepared_value ? lower_contextual_expression(
+          prepared_value,
+          env: local_env,
+          expected_type: return_type,
+          contextual_int_to_float: contextual_int_to_float_target?(return_type),
+        ) : nil
+        if prepared_cleanups.any? && cstr_trackable_type?(return_type)
+          raise LoweringError.new("formatted string temporaries cannot be returned as borrowed text; use std.fmt.format(f\"...\") when ownership must escape",
+            line: statement.line, column: statement.column, path: @ctx.current_analysis_path)
+        end
 
-    def lower_block_assignment_stmt(statement, lowered:, local_defers:, local_env:)
-      if statement.operator == "=" &&
-         statement.target.is_a?(AST::IndexAccess) &&
-         statement.target.index.is_a?(AST::RangeExpr) &&
-         statement.value.is_a?(AST::ExpressionList)
-        lowered.concat(lower_range_index_assignment(statement, env: local_env))
-        return
+        prepared_cleanup_list = prepared_cleanups.flat_map(&:itself)
+        if prepared_cleanup_list.any? && return_type.is_a?(Types::Struct) && struct_contains_string_field?(return_type)
+          prepared_cleanup_list = prepared_cleanup_list.reject { |stmt| stmt.is_a?(IR::ExpressionStmt) && stmt.expression.is_a?(IR::Call) && stmt.expression.callee == "mt_format_str_release" }
+        end
+        cleanup = prepared_cleanup_list + cleanup_statements(local_defers, active_defers)
+        needs_proc_retain = value && contains_proc_storage_type?(return_type) && !local_defers.empty? && !expression_contains_proc_expr?(prepared_value)
+        if value && (!cleanup.empty? && !cleanup_safe_return_expression?(prepared_value) || needs_proc_retain)
+          return_value_name = fresh_c_temp_name(local_env, "return_value")
+          lowered << IR::LocalDecl.new(name: return_value_name, linkage_name: return_value_name, type: return_type, value:)
+          value = IR::Name.new(name: return_value_name, type: return_type, pointer: false)
+        end
+        lowered.concat(lower_proc_contained_retain_statements(value, return_type)) if needs_proc_retain
+        lowered.concat(cleanup)
+        lowered << IR::ReturnStmt.new(value:, line: statement.line, path: @ctx.current_analysis_path)
       end
-      target = lower_assignment_target(statement.target, env: local_env)
-      prepared_cleanups = []
-      prepared_setup, prepared_value, prepared_cleanups = prepare_expression_with_cleanups(
-        statement.value,
-        env: local_env,
-        expected_type: target.type,
-        allow_root_statement_foreign: true,
-        materialize_array_calls: !array_type?(target.type),
-      )
-      lowered.concat(prepared_setup)
-      if (foreign_call = foreign_call_info(prepared_value, local_env))
-        setup, value, call_type, release_assignments, cleanup_statements = lower_foreign_call_components(
-          foreign_call,
+
+      def lower_assignment_stmt(statement, lowered:, local_defers:, local_env:)
+        if statement.operator == "=" &&
+          statement.target.is_a?(AST::IndexAccess) &&
+          statement.target.index.is_a?(AST::RangeExpr) &&
+          statement.value.is_a?(AST::ExpressionList)
+          lowered.concat(lower_range_index_assignment(statement, env: local_env))
+          return
+        end
+        target = lower_assignment_target(statement.target, env: local_env)
+        prepared_cleanups = []
+        prepared_setup, prepared_value, prepared_cleanups = prepare_expression_with_cleanups(
+          statement.value,
           env: local_env,
           expected_type: target.type,
-          statement_position: false,
+          allow_root_statement_foreign: true,
+          materialize_array_calls: !array_type?(target.type),
         )
-        lowered.concat(setup)
-        raise LoweringError.new("foreign call used in assignment must return a value",
-          line: statement.line, column: statement.column, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
-        raise LoweringError.new("consuming foreign calls must return void",
-          line: statement.line, column: statement.column, 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, local_env)
-        local_defers.concat(suppress_format_releases_for_assignment(prepared_cleanups, target.type))
-        return
-      else
-        value = if statement.operator == "="
-          lower_contextual_expression(
-            prepared_value,
-            env: local_env,
-            expected_type: target.type,
-            external_numeric: external_numeric_assignment_target?(statement.target, env: local_env),
-            contextual_int_to_float: contextual_int_to_float_target?(target.type),
-          )
-        elsif ["+=", "-=", "*=", "/="].include?(statement.operator)
-          lower_contextual_expression(
-            prepared_value,
+        lowered.concat(prepared_setup)
+        if (foreign_call = foreign_call_info(prepared_value, local_env))
+          setup, value, call_type, release_assignments, cleanup_statements = lower_foreign_call_components(
+            foreign_call,
             env: local_env,
             expected_type: target.type,
-            contextual_int_to_float: contextual_int_to_float_target?(target.type),
+            statement_position: false,
           )
+          lowered.concat(setup)
+          raise LoweringError.new("foreign call used in assignment must return a value",
+            line: statement.line, column: statement.column, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
+          raise LoweringError.new("consuming foreign calls must return void",
+            line: statement.line, column: statement.column, 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, local_env)
+          local_defers.concat(reject_format_releases_for_assignment(prepared_cleanups, target.type))
+          return
         else
-          lower_expression(prepared_value, env: local_env, expected_type: target.type)
+          value = if statement.operator == "="
+            lower_contextual_expression(
+              prepared_value,
+              env: local_env,
+              expected_type: target.type,
+              external_numeric: external_numeric_assignment_target?(statement.target, env: local_env),
+              contextual_int_to_float: contextual_int_to_float_target?(target.type),
+            )
+          elsif ["+=", "-=", "*=", "/="].include?(statement.operator)
+            lower_contextual_expression(
+              prepared_value,
+              env: local_env,
+              expected_type: target.type,
+              contextual_int_to_float: contextual_int_to_float_target?(target.type),
+            )
+          else
+            lower_expression(prepared_value, env: local_env, expected_type: target.type)
+          end
+        end
+        if target.type.is_a?(Types::Nullable) && value && !value.type.is_a?(Types::Nullable) && !pointer_like_type?(target.type.base)
+          value = nullable_some_literal(target.type, value)
+        end
+        update_cstr_metadata_for_assignment!(statement, prepared_value, local_env)
+        local_defers.concat(reject_format_releases_for_assignment(prepared_cleanups, target.type))
+        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_operation(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(local_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_nullable_release_statements(target, target.type))
+          lowered << IR::Assignment.new(target:, operator: "=", value: rhs)
+        else
+          lowered << IR::Assignment.new(target:, operator:, value:)
         end
       end
-      if target.type.is_a?(Types::Nullable) && value && !value.type.is_a?(Types::Nullable) && !pointer_like_type?(target.type.base)
-        value = nullable_some_literal(target.type, value)
-      end
-      update_cstr_metadata_for_assignment!(statement, prepared_value, local_env)
-      local_defers.concat(suppress_format_releases_for_assignment(prepared_cleanups, target.type))
-      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(local_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
-    end
 
-    def lower_block_if_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      if statement.inline
-        lowered.concat(lower_inline_if_stmt(statement, env: local_env, active_defers:, return_type:, allow_return:))
-        return
-      end
+      def lower_if_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        if statement.inline
+          lowered.concat(lower_inline_if_stmt(statement, env: local_env, active_defers:, return_type:, allow_return:))
+          return
+        end
 
-      false_refinements = {}
-      branch_entries = []
+        false_refinements = {}
+        branch_entries = []
 
-      unless statement.branches.empty?
-        if @bypass_sema_type_cache
-          ct_cond = compile_time_const_value(statement.branches.first.condition, env: local_env)
-          if ct_cond == true
-            lowered.concat(lower_block(
-              statement.branches.first.body,
-              env: local_env,
-              active_defers: active_defers + local_defers,
-              return_type:,
-              loop_flow: nested_loop_flow(loop_flow, local_defers),
-              allow_return:,
-            ))
-            return
-          elsif ct_cond == false
-            if statement.else_body
+        unless statement.branches.empty?
+          if @bypass_sema_type_cache
+            ct_cond = compile_time_const_value(statement.branches.first.condition, env: local_env)
+            if ct_cond == true
               lowered.concat(lower_block(
-                statement.else_body,
+                statement.branches.first.body,
                 env: local_env,
                 active_defers: active_defers + local_defers,
                 return_type:,
                 loop_flow: nested_loop_flow(loop_flow, local_defers),
                 allow_return:,
               ))
+              return
+            elsif ct_cond == false
+              if statement.else_body
+                lowered.concat(lower_block(
+                  statement.else_body,
+                  env: local_env,
+                  active_defers: active_defers + local_defers,
+                  return_type:,
+                  loop_flow: nested_loop_flow(loop_flow, local_defers),
+                  allow_return:,
+                ))
+              end
+              return
             end
-            return
           end
         end
-      end
-
-      statement.branches.each do |branch|
-        branch_env = env_with_refinements(local_env, false_refinements)
-        condition_setup, prepared_condition, condition_cleanups = prepare_expression_with_cleanups(
-          branch.condition,
-          env: branch_env,
-          expected_type: @ctx.types.fetch("bool"),
-        )
-        true_refinements = merge_refinements(false_refinements, flow_refinements(branch.condition, truthy: true, env: branch_env))
-
-        branch_entries << [
-          condition_setup,
-          condition_cleanups,
-          lower_expression(prepared_condition, env: branch_env, expected_type: @ctx.types.fetch("bool")),
-          lower_block(
-            branch.body,
-            env: env_with_refinements(local_env, true_refinements),
-            active_defers: active_defers + local_defers,
-            return_type:,
-            loop_flow: nested_loop_flow(loop_flow, local_defers),
-            allow_return:,
-          ),
-        ]
-
-        false_refinements = merge_refinements(false_refinements, flow_refinements(branch.condition, truthy: false, env: branch_env))
-      end
-
-      nested_else_body = statement.else_body ? lower_block(
-        statement.else_body,
-        env: env_with_refinements(local_env, false_refinements),
-        active_defers: active_defers + local_defers,
-        return_type:,
-        loop_flow: nested_loop_flow(loop_flow, local_defers),
-        allow_return:,
-      ) : []
-
-      nested_if = nested_else_body
-      branch_entries.reverse_each do |condition_setup, condition_cleanups, condition, then_body|
-        condition_cleanup_statements = condition_cleanups.flat_map(&:itself)
-        nested_if = [
-          *condition_setup,
-          IR::IfStmt.new(
-            condition:,
-            then_body: condition_cleanup_statements + then_body,
-            else_body: condition_cleanup_statements + nested_if,
-          ),
-        ]
-      end
-      lowered.concat(nested_if)
-
-      merge_cstr_metadata_after_if_statement!(statement, local_env)
 
-      if statement.else_body.nil? && statement.branches.all? { |branch| cfg_block_always_terminates?(branch.body) }
-        local_env[:scopes] = scopes_with_refinements(local_env[:scopes], false_refinements)
-      end
-    end
-
-    def lower_block_local_decl_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      if statement.destructure_bindings
-        lower_destructure_decl(statement, env: local_env, lowered:, local_defers:, active_defers:, return_type:, loop_flow:, allow_return:)
-        return
-      end
+        statement.branches.each do |branch|
+          branch_env = env_with_refinements(local_env, false_refinements)
+          condition_setup, prepared_condition, condition_cleanups = prepare_expression_with_cleanups(
+            branch.condition,
+            env: branch_env,
+            expected_type: @ctx.types.fetch("bool"),
+          )
+          true_refinements = merge_refinements(false_refinements, flow_refinements(branch.condition, truthy: true, env: branch_env))
+
+          branch_entries << [
+            condition_setup,
+            condition_cleanups,
+            lower_expression(prepared_condition, env: branch_env, expected_type: @ctx.types.fetch("bool")),
+            lower_block(
+              branch.body,
+              env: env_with_refinements(local_env, true_refinements),
+              active_defers: active_defers + local_defers,
+              return_type:,
+              loop_flow: nested_loop_flow(loop_flow, local_defers),
+              allow_return:,
+            ),
+          ]
 
-      storage_type = if statement.else_body
-        infer_expression_type(statement.value, env: local_env)
-      elsif statement.type
-        resolve_type_ref(statement.type)
-      else
-        infer_expression_type(statement.value, env: local_env)
-      end
-      type = if statement.else_body
-        statement.type ? resolve_type_ref(statement.type) : let_else_success_type(storage_type)
-      else
-        storage_type
-      end
-      linkage_name = let_else_storage_c_name(statement, local_env)
-      decl_name = bind_let_else_local?(statement) ? statement.name : linkage_name
-      prepared_setup = []
-      prepared_value = statement.value
-      prepared_cleanups = []
-      emitted_decl = false
-      if statement.value
-        local_env[:current_local_name] = linkage_name
-        prepared_setup, prepared_value, prepared_cleanups = prepare_expression_with_cleanups(
-          statement.value,
-          env: local_env,
-          expected_type: storage_type,
-          allow_root_statement_foreign: true,
-          materialize_array_calls: !array_type?(storage_type),
-        )
-        lowered.concat(prepared_setup)
-      end
-      if prepared_value && (foreign_call = foreign_call_info(prepared_value, local_env))
-        setup, value, call_type, release_assignments, cleanup_statements = lower_foreign_call_components(
-          foreign_call,
-          env: local_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: statement.line, column: statement.column, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
-        raise LoweringError.new("consuming foreign calls must return void",
-          line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless release_assignments.empty?
-
-        lowered << IR::LocalDecl.new(name: decl_name, linkage_name:, type: storage_type, value:, line: statement.line, path: @ctx.current_analysis_path)
-        lowered.concat(cleanup_statements)
-        emitted_decl = true
-      elsif prepared_value.is_a?(AST::ProcExpr)
-        setup, value = lower_proc_expression_for_local(prepared_value, env: local_env, local_name: statement.name, proc_type: storage_type)
-        lowered.concat(setup)
-      elsif prepared_value
-        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
-      if value && storage_type.is_a?(Types::Nullable) && !value.type.is_a?(Types::Nullable) && !pointer_like_type?(storage_type.base)
-        value = nullable_some_literal(storage_type, value)
-      end
-      if bind_let_else_local?(statement)
-        current_actual_scope(local_env[:scopes])[statement.name] = local_binding(
-          type:,
-          storage_type:,
-          linkage_name:,
-          mutable: statement.kind == :var,
-          pointer: false,
-          projection: statement.else_body ? let_else_binding_projection(storage_type) : nil,
-          cstr_backed: cstr_backed_storage_value?(storage_type, prepared_value, local_env),
-          cstr_list_backed: cstr_list_backed_storage_value?(storage_type, prepared_value, local_env),
-          const_value: statement.else_body ? nil : statement.kind == :let && prepared_value ? compile_time_const_value(prepared_value, env: local_env) : nil,
-        )
-      end
-      lowered << IR::LocalDecl.new(name: decl_name, linkage_name:, type: storage_type, value:, line: statement.line, path: @ctx.current_analysis_path) unless emitted_decl
-      if statement.else_body
-        else_env = if statement.else_binding
-          duplicate_env(local_env).tap do |env_with_error|
-            current_actual_scope(env_with_error[:scopes])[statement.else_binding.name] = local_binding(
-              type: let_else_error_type(storage_type),
-              storage_type:,
-              linkage_name:,
-              mutable: false,
-              pointer: false,
-              projection: :result_failure_error,
-            )
-          end
-        else
-          local_env
+          false_refinements = merge_refinements(false_refinements, flow_refinements(branch.condition, truthy: false, env: branch_env))
         end
-        else_body = lower_block(
+
+        nested_else_body = statement.else_body ? lower_block(
           statement.else_body,
-          env: else_env,
-          active_defers: active_defers + local_defers + prepared_cleanups,
+          env: env_with_refinements(local_env, false_refinements),
+          active_defers: active_defers + local_defers,
           return_type:,
           loop_flow: nested_loop_flow(loop_flow, local_defers),
           allow_return:,
-        )
-        local_ref = IR::Name.new(name: linkage_name, type: storage_type, pointer: false)
-        lowered << IR::IfStmt.new(
-          condition: let_else_failure_condition(local_ref, storage_type),
-          then_body: else_body,
-          else_body: nil,
-        )
-      end
-      local_defers.concat(prepared_cleanups)
-      if contains_proc_storage_type?(storage_type)
-        local_value = IR::Name.new(name: linkage_name, type: storage_type, pointer: false)
-        local_defers << lower_proc_contained_guarded_release_statements(local_value, storage_type)
-        if statement.value && !expression_contains_proc_expr?(statement.value)
-          lowered.concat(lower_proc_contained_retain_statements(local_value, storage_type))
+        ) : []
+
+        nested_if = nested_else_body
+        branch_entries.reverse_each do |condition_setup, condition_cleanups, condition, then_body|
+          condition_cleanup_statements = condition_cleanups.flat_map(&:itself)
+          nested_if = [
+            *condition_setup,
+            IR::IfStmt.new(
+              condition:,
+              then_body: condition_cleanup_statements + then_body,
+              else_body: condition_cleanup_statements + nested_if,
+            ),
+          ]
         end
-      end
-    end
+        lowered.concat(nested_if)
 
-    def lower_block_match_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      if statement.inline
-        lowered.concat(lower_inline_match_stmt(statement, env: local_env, active_defers:, return_type:, allow_return:))
-        return
-      end
-      scrutinee_type = infer_expression_type(statement.expression, env: local_env)
-      expression_setup, prepared_expression, expression_cleanups = prepare_expression_with_cleanups(
-        statement.expression,
-        env: local_env,
-        expected_type: scrutinee_type,
-      )
-      lowered.concat(expression_setup)
-      expression = lower_expression(prepared_expression, env: local_env, expected_type: scrutinee_type)
-
-      if scrutinee_type.is_a?(Types::Variant) &&
-         statement.arms.any? { |arm| arm.binding_name && !wildcard_arm_pattern?(arm.pattern) } &&
-         !duplicable_foreign_argument_expression?(expression)
-        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: expression)
-        expression = IR::Name.new(name: scrutinee_linkage_name, type: scrutinee_type, pointer: false)
+        merge_cstr_metadata_after_if_statement!(statement, local_env)
+
+        if statement.else_body.nil? && statement.branches.all? { |branch| cfg_block_always_terminates?(branch.body) }
+          local_env[:scopes] = scopes_with_refinements(local_env[:scopes], false_refinements)
+        end
       end
 
-      if scrutinee_type.is_a?(Types::Variant)
-        if statement.arms.any? { |arm| arm.pattern.is_a?(AST::Call) }
-          lower_block_variant_struct_pattern_match(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+      def lower_local_decl_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        if statement.destructure_bindings
+          lower_destructure_decl(statement, env: local_env, lowered:, local_defers:, active_defers:, return_type:, loop_flow:, allow_return:)
+          return
+        end
+
+        storage_type = if statement.else_body
+          infer_expression_type(statement.value, env: local_env)
+        elsif statement.type
+          resolve_type_ref(statement.type)
         else
-          kind_type = @ctx.types.fetch("int")
-          kind_expr = IR::Member.new(receiver: expression, member: "kind", type: kind_type)
-          arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
-          cases = statement.arms.map do |arm|
-            arm_local_env = duplicate_env(local_env)
-            binding_decl = 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)
-                data_expr = IR::Member.new(receiver: expression, 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_local_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: binding_c, mutable: true, pointer: false)
-                IR::LocalDecl.new(name: arm.binding_name, linkage_name: binding_c, type: payload_type, value: arm_expr)
-              end
-            end
-            body = lower_block(
-              arm.body,
-              env: arm_local_env,
-              active_defers: active_defers + local_defers,
-              return_type:,
-              loop_flow: arm_loop_flow,
-              allow_return:,
-            )
-            body = [binding_decl, *body].compact if binding_decl
-            if wildcard_arm_pattern?(arm.pattern)
-              IR::SwitchDefaultCase.new(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:)
-            end
-          end
-          lowered << IR::SwitchStmt.new(expression: kind_expr, cases:, exhaustive: true)
+          infer_expression_type(statement.value, env: local_env)
         end
-      elsif scrutinee_type.is_a?(Types::StringView)
-        lower_block_string_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      elsif scrutinee_type.is_a?(Types::Tuple)
-        lower_block_tuple_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      else
-        has_range_arms = statement.arms.any? { |arm| arm.pattern.is_a?(AST::RangeExpr) }
-
-        if has_range_arms
-          lower_block_range_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        type = if statement.else_body
+          statement.type ? resolve_type_ref(statement.type) : let_else_success_type(storage_type)
         else
-          arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
-          cases = statement.arms.map do |arm|
-            body = lower_block(
-              arm.body,
-              env: local_env,
-              active_defers: active_defers + local_defers,
-              return_type:,
-              loop_flow: arm_loop_flow,
-              allow_return:,
-            )
-            if wildcard_arm_pattern?(arm.pattern)
-              IR::SwitchDefaultCase.new(body:)
-            else
-              value = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
-              IR::SwitchCase.new(value:, body:)
+          storage_type
+        end
+        linkage_name = let_else_storage_c_name(statement, local_env)
+        decl_name = bind_let_else_local?(statement) ? statement.name : linkage_name
+        prepared_setup = []
+        prepared_value = statement.value
+        prepared_cleanups = []
+        emitted_decl = false
+        if statement.value
+          local_env[:current_local_name] = linkage_name
+          prepared_setup, prepared_value, prepared_cleanups = prepare_expression_with_cleanups(
+            statement.value,
+            env: local_env,
+            expected_type: storage_type,
+            allow_root_statement_foreign: true,
+            materialize_array_calls: !array_type?(storage_type),
+          )
+          lowered.concat(prepared_setup)
+        end
+        if prepared_value && (foreign_call = foreign_call_info(prepared_value, local_env))
+          setup, value, call_type, release_assignments, cleanup_statements = lower_foreign_call_components(
+            foreign_call,
+            env: local_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: statement.line, column: statement.column, path: @ctx.current_analysis_path) if call_type == @ctx.types.fetch("void")
+          raise LoweringError.new("consuming foreign calls must return void",
+            line: statement.line, column: statement.column, path: @ctx.current_analysis_path) unless release_assignments.empty?
+
+          lowered << IR::LocalDecl.new(name: decl_name, linkage_name:, type: storage_type, value:, line: statement.line, path: @ctx.current_analysis_path)
+          lowered.concat(cleanup_statements)
+          emitted_decl = true
+        elsif prepared_value.is_a?(AST::ProcExpr)
+          setup, value = lower_proc_expression_for_local(prepared_value, env: local_env, local_name: statement.name, proc_type: storage_type)
+          lowered.concat(setup)
+        elsif prepared_value
+          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
+        if value && storage_type.is_a?(Types::Nullable) && !value.type.is_a?(Types::Nullable) && !pointer_like_type?(storage_type.base)
+          value = nullable_some_literal(storage_type, value)
+        end
+        if bind_let_else_local?(statement)
+          current_actual_scope(local_env[:scopes])[statement.name] = local_binding(
+            type:,
+            storage_type:,
+            linkage_name:,
+            mutable: statement.kind == :var,
+            pointer: false,
+            projection: statement.else_body ? let_else_binding_projection(storage_type) : nil,
+            cstr_backed: cstr_backed_storage_value?(storage_type, prepared_value, local_env),
+            cstr_list_backed: cstr_list_backed_storage_value?(storage_type, prepared_value, local_env),
+            const_value: statement.else_body ? nil : statement.kind == :let && prepared_value ? compile_time_const_value(prepared_value, env: local_env) : nil,
+          )
+        end
+        lowered << IR::LocalDecl.new(name: decl_name, linkage_name:, type: storage_type, value:, line: statement.line, path: @ctx.current_analysis_path) unless emitted_decl
+        if statement.else_body
+          else_env = if statement.else_binding
+            duplicate_env(local_env).tap do |env_with_error|
+              current_actual_scope(env_with_error[:scopes])[statement.else_binding.name] = local_binding(
+                type: let_else_error_type(storage_type),
+                storage_type:,
+                linkage_name:,
+                mutable: false,
+                pointer: false,
+                projection: :result_failure_error,
+              )
             end
+          else
+            local_env
+          end
+          else_body = lower_block(
+            statement.else_body,
+            env: else_env,
+            active_defers: active_defers + local_defers + prepared_cleanups,
+            return_type:,
+            loop_flow: nested_loop_flow(loop_flow, local_defers),
+            allow_return:,
+          )
+          local_ref = IR::Name.new(name: linkage_name, type: storage_type, pointer: false)
+          lowered << IR::IfStmt.new(
+            condition: let_else_failure_condition(local_ref, storage_type),
+            then_body: else_body,
+            else_body: nil,
+          )
+        end
+        local_defers.concat(prepared_cleanups)
+        if contains_proc_storage_type?(storage_type)
+          local_value = IR::Name.new(name: linkage_name, type: storage_type, pointer: false)
+          local_defers << lower_proc_nullable_release_statements(local_value, storage_type)
+          if statement.value && !expression_contains_proc_expr?(statement.value)
+            lowered.concat(lower_proc_contained_retain_statements(local_value, storage_type))
           end
-          lowered << IR::SwitchStmt.new(expression:, cases:, exhaustive: true)
         end
       end
-      lowered.concat(expression_cleanups.flat_map(&:itself))
-    end
 
-    def lower_block_variant_struct_pattern_match(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      kind_type = @ctx.types.fetch("int")
-      arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
-      @match_label_counter ||= 0
-      @match_label_counter += 1
-      m = @match_label_counter
-      match_end_label = "__mt_match_#{m}_end"
-      arm_next_label = "__mt_match_#{m}_arm_next"
-
-      statement.arms.each_with_index do |arm, arm_index|
-        arm_local_env = duplicate_env(local_env)
-        arm_name = variant_match_arm_name_from_pattern(arm.pattern) unless wildcard_arm_pattern?(arm.pattern)
-
-        if arm_index > 0
-          lowered << IR::LabelStmt.new(name: "__mt_match_#{m}_arm_#{arm_index}")
+      def lower_match_stmt(statement, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        if statement.inline
+          lowered.concat(lower_inline_match_stmt(statement, env: local_env, active_defers:, return_type:, allow_return:))
+          return
+        end
+        scrutinee_type = infer_expression_type(statement.expression, env: local_env)
+        expression_setup, prepared_expression, expression_cleanups = prepare_expression_with_cleanups(
+          statement.expression,
+          env: local_env,
+          expected_type: scrutinee_type,
+        )
+        lowered.concat(expression_setup)
+        expression = lower_expression(prepared_expression, env: local_env, expected_type: scrutinee_type)
+
+        if scrutinee_type.is_a?(Types::Variant) &&
+          statement.arms.any? { |arm| arm.binding_name && !wildcard_arm_pattern?(arm.pattern) } &&
+          !duplicable_foreign_argument_expression?(expression)
+          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: expression)
+          expression = IR::Name.new(name: scrutinee_linkage_name, type: scrutinee_type, pointer: false)
         end
 
-        if arm_name && !wildcard_arm_pattern?(arm.pattern)
-          tag_value = IR::Name.new(name: enum_member_c_name(scrutinee_type, "kind_#{arm_name}"), type: kind_type, pointer: false)
-          tag_expr = IR::Member.new(receiver: expression, member: "kind", type: kind_type)
-          goto_label = if arm_index < statement.arms.length - 1
-            "__mt_match_#{m}_arm_#{arm_index + 1}"
+        if scrutinee_type.is_a?(Types::Variant)
+          if statement.arms.any? { |arm| arm.pattern.is_a?(AST::Call) }
+            lower_variant_struct_pattern_match(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
           else
-            arm_next_label
+            kind_type = @ctx.types.fetch("int")
+            kind_expr = IR::Member.new(receiver: expression, member: "kind", type: kind_type)
+            arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+            cases = statement.arms.map do |arm|
+              arm_local_env = duplicate_env(local_env)
+              binding_decl = 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)
+                  data_expr = IR::Member.new(receiver: expression, 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_local_env[:scopes].last[arm.binding_name] = local_binding(type: payload_type, linkage_name: binding_c, mutable: true, pointer: false)
+                  IR::LocalDecl.new(name: arm.binding_name, linkage_name: binding_c, type: payload_type, value: arm_expr)
+                end
+              end
+              body = lower_block(
+                arm.body,
+                env: arm_local_env,
+                active_defers: active_defers + local_defers,
+                return_type:,
+                loop_flow: arm_loop_flow,
+                allow_return:,
+              )
+              body = [binding_decl, *body].compact if binding_decl
+              if wildcard_arm_pattern?(arm.pattern)
+                IR::SwitchDefaultCase.new(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:)
+              end
+            end
+            lowered << IR::SwitchStmt.new(expression: kind_expr, cases:, exhaustive: true)
           end
-          tag_check = IR::Binary.new(operator: "!=", left: tag_expr, right: tag_value, type: @ctx.types.fetch("bool"))
-          lowered << IR::IfStmt.new(condition: tag_check, then_body: [IR::GotoStmt.new(label: goto_label)], else_body: [])
-        end
+        elsif scrutinee_type.is_a?(Types::StringView)
+          lower_string_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        elsif scrutinee_type.is_a?(Types::Tuple)
+          lower_tuple_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        else
+          has_range_arms = statement.arms.any? { |arm| arm.pattern.is_a?(AST::RangeExpr) }
 
-        if arm_name && !wildcard_arm_pattern?(arm.pattern) && scrutinee_type.has_payload?(arm_name)
-          fields = scrutinee_type.arm(arm_name)
-          payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
-          data_expr = IR::Member.new(receiver: expression, member: "data", type: nil)
-          arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
-          payload_c_name = fresh_c_temp_name(arm_local_env, "match_payload")
-          arm_local_env[:scopes].last["__mt_payload"] = local_binding(type: payload_type, linkage_name: payload_c_name, mutable: true, pointer: false)
-
-          arm_body_ir = []
-          arm_body_ir << IR::LocalDecl.new(name: payload_c_name, linkage_name: payload_c_name, type: payload_type, value: arm_expr)
-
-          nested_struct_fields = nil
-          nested_struct_c_name = nil
-          nested_struct_type = nil
-          if fields.size == 1 && fields.values.first.is_a?(Types::Struct)
-            native_field = fields.keys.first
-            has_native_reference = arm.pattern.arguments.any? do |arg|
-              next false if !arg.name && arg.value.is_a?(AST::Identifier) && arg.value.name == "_"
-
-              name = arg.name || (arg.value.is_a?(AST::Identifier) ? arg.value.name : nil)
-              name == native_field
-            end
-            unless has_native_reference
-              nested_struct_type = fields.values.first
-              nested_struct_fields = nested_struct_type.fields
-              single_field_name = fields.keys.first
-              nested_struct_c_name = fresh_c_temp_name(arm_local_env, "match_struct")
-              struct_expr = IR::Member.new(
-                receiver: IR::Name.new(name: payload_c_name, type: payload_type, pointer: false),
-                member: single_field_name,
-                type: nested_struct_type,
+          if has_range_arms
+            lower_range_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+          else
+            arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+            cases = statement.arms.map do |arm|
+              body = lower_block(
+                arm.body,
+                env: local_env,
+                active_defers: active_defers + local_defers,
+                return_type:,
+                loop_flow: arm_loop_flow,
+                allow_return:,
               )
-              arm_body_ir << IR::LocalDecl.new(name: nested_struct_c_name, linkage_name: nested_struct_c_name, type: nested_struct_type, value: struct_expr)
+              if wildcard_arm_pattern?(arm.pattern)
+                IR::SwitchDefaultCase.new(body:)
+              else
+                value = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
+                IR::SwitchCase.new(value:, body:)
+              end
             end
+            lowered << IR::SwitchStmt.new(expression:, cases:, exhaustive: true)
           end
+        end
+        lowered.concat(expression_cleanups.flat_map(&:itself))
+      end
 
-          if arm.pattern.is_a?(AST::Call) && !arm.pattern.arguments.empty?
-            pattern_fields = nested_struct_fields || fields
-            pattern_receiver_name = nested_struct_c_name || payload_c_name
-            pattern_receiver_type = nested_struct_type || payload_type
+      def lower_variant_struct_pattern_match(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        kind_type = @ctx.types.fetch("int")
+        arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+        @match_label_counter ||= 0
+        @match_label_counter += 1
+        m = @match_label_counter
+        match_end_label = "__mt_match_#{m}_end"
+        arm_next_label = "__mt_match_#{m}_arm_next"
+
+        statement.arms.each_with_index do |arm, arm_index|
+          arm_local_env = duplicate_env(local_env)
+          arm_name = variant_match_arm_name_from_pattern(arm.pattern) unless wildcard_arm_pattern?(arm.pattern)
+
+          if arm_index > 0
+            lowered << IR::LabelStmt.new(name: "__mt_match_#{m}_arm_#{arm_index}")
+          end
 
-            arm.pattern.arguments.each do |arg|
-              if !arg.name && arg.value.is_a?(AST::BinaryOp) && arg.value.left.is_a?(AST::Identifier)
-                field_name = arg.value.left.name
-                next unless pattern_fields.key?(field_name)
+          if arm_name && !wildcard_arm_pattern?(arm.pattern)
+            tag_value = IR::Name.new(name: enum_member_c_name(scrutinee_type, "kind_#{arm_name}"), type: kind_type, pointer: false)
+            tag_expr = IR::Member.new(receiver: expression, member: "kind", type: kind_type)
+            goto_label = if arm_index < statement.arms.length - 1
+              "__mt_match_#{m}_arm_#{arm_index + 1}"
+            else
+              arm_next_label
+            end
+            tag_check = IR::Binary.new(operator: "!=", left: tag_expr, right: tag_value, type: @ctx.types.fetch("bool"))
+            lowered << IR::IfStmt.new(condition: tag_check, then_body: [IR::GotoStmt.new(label: goto_label)], else_body: [])
+          end
 
-                field_type = pattern_fields[field_name]
-                field_expr = IR::Member.new(receiver: IR::Name.new(name: pattern_receiver_name, type: pattern_receiver_type, pointer: false), member: field_name, type: field_type)
-                field_expr = dereference_if_self_ref(field_expr, field_type, scrutinee_type)
-                rhs_expr = lower_expression(arg.value.right, env: arm_local_env, expected_type: field_type)
-                guard_condition = IR::Binary.new(operator: arg.value.operator, left: field_expr, right: rhs_expr, type: @ctx.types.fetch("bool"))
-                arm_body_ir << IR::IfStmt.new(condition: guard_condition, then_body: [], else_body: [IR::GotoStmt.new(label: goto_label)])
+          if arm_name && !wildcard_arm_pattern?(arm.pattern) && scrutinee_type.has_payload?(arm_name)
+            fields = scrutinee_type.arm(arm_name)
+            payload_type = Types::VariantArmPayload.new(scrutinee_type, arm_name, fields)
+            data_expr = IR::Member.new(receiver: expression, member: "data", type: nil)
+            arm_expr = IR::Member.new(receiver: data_expr, member: arm_name, type: payload_type)
+            payload_c_name = fresh_c_temp_name(arm_local_env, "match_payload")
+            arm_local_env[:scopes].last["__mt_payload"] = local_binding(type: payload_type, linkage_name: payload_c_name, mutable: true, pointer: false)
+
+            arm_body_ir = []
+            arm_body_ir << IR::LocalDecl.new(name: payload_c_name, linkage_name: payload_c_name, type: payload_type, value: arm_expr)
+
+            nested_struct_fields = nil
+            nested_struct_c_name = nil
+            nested_struct_type = nil
+            if fields.size == 1 && fields.values.first.is_a?(Types::Struct)
+              native_field = fields.keys.first
+              has_native_reference = arm.pattern.arguments.any? do |arg|
+                next false if !arg.name && arg.value.is_a?(AST::Identifier) && arg.value.name == "_"
+
+                name = arg.name || (arg.value.is_a?(AST::Identifier) ? arg.value.name : nil)
+                name == native_field
               end
+              unless has_native_reference
+                nested_struct_type = fields.values.first
+                nested_struct_fields = nested_struct_type.fields
+                single_field_name = fields.keys.first
+                nested_struct_c_name = fresh_c_temp_name(arm_local_env, "match_struct")
+                struct_expr = IR::Member.new(
+                  receiver: IR::Name.new(name: payload_c_name, type: payload_type, pointer: false),
+                  member: single_field_name,
+                  type: nested_struct_type,
+                )
+                arm_body_ir << IR::LocalDecl.new(name: nested_struct_c_name, linkage_name: nested_struct_c_name, type: nested_struct_type, value: struct_expr)
+              end
+            end
+
+            if arm.pattern.is_a?(AST::Call) && !arm.pattern.arguments.empty?
+              pattern_fields = nested_struct_fields || fields
+              pattern_receiver_name = nested_struct_c_name || payload_c_name
+              pattern_receiver_type = nested_struct_type || payload_type
+
+              arm.pattern.arguments.each do |arg|
+                if !arg.name && arg.value.is_a?(AST::BinaryOp) && arg.value.left.is_a?(AST::Identifier)
+                  field_name = arg.value.left.name
+                  next unless pattern_fields.key?(field_name)
+
+                  field_type = pattern_fields[field_name]
+                  field_expr = IR::Member.new(receiver: IR::Name.new(name: pattern_receiver_name, type: pattern_receiver_type, pointer: false), member: field_name, type: field_type)
+                  field_expr = dereference_if_self_ref(field_expr, field_type, scrutinee_type)
+                  rhs_expr = lower_expression(arg.value.right, env: arm_local_env, expected_type: field_type)
+                  guard_condition = IR::Binary.new(operator: arg.value.operator, left: field_expr, right: rhs_expr, type: @ctx.types.fetch("bool"))
+                  arm_body_ir << IR::IfStmt.new(condition: guard_condition, then_body: [], else_body: [IR::GotoStmt.new(label: goto_label)])
+                end
+
+                if arg.name
+                  field_name = arg.name
+                  next unless pattern_fields.key?(field_name)
+
+                  field_type = pattern_fields[field_name]
+                  field_expr = IR::Member.new(receiver: IR::Name.new(name: pattern_receiver_name, type: pattern_receiver_type, pointer: false), member: field_name, type: field_type)
+                  field_expr = dereference_if_self_ref(field_expr, field_type, scrutinee_type)
+                  value_expr = lower_expression(arg.value, env: arm_local_env, expected_type: field_type)
+                  eq_check = IR::Binary.new(operator: "!=", left: field_expr, right: value_expr, type: @ctx.types.fetch("bool"))
+                  arm_body_ir << IR::IfStmt.new(condition: eq_check, then_body: [IR::GotoStmt.new(label: goto_label)], else_body: [])
+                end
+              end
+
+              arm.pattern.arguments.each do |arg|
+                next if arg.name
+                next unless arg.value.is_a?(AST::Identifier)
+                next if arg.value.name == "_"
 
-              if arg.name
-                field_name = arg.name
+                field_name = arg.value.name
                 next unless pattern_fields.key?(field_name)
 
                 field_type = pattern_fields[field_name]
+                binding_c = c_local_name(field_name)
                 field_expr = IR::Member.new(receiver: IR::Name.new(name: pattern_receiver_name, type: pattern_receiver_type, pointer: false), member: field_name, type: field_type)
                 field_expr = dereference_if_self_ref(field_expr, field_type, scrutinee_type)
-                value_expr = lower_expression(arg.value, env: arm_local_env, expected_type: field_type)
-                eq_check = IR::Binary.new(operator: "!=", left: field_expr, right: value_expr, type: @ctx.types.fetch("bool"))
-                arm_body_ir << IR::IfStmt.new(condition: eq_check, then_body: [IR::GotoStmt.new(label: goto_label)], else_body: [])
+                arm_body_ir << IR::LocalDecl.new(name: binding_c, linkage_name: binding_c, type: field_type, value: field_expr)
+                arm_local_env[:scopes].last[field_name] = local_binding(type: field_type, linkage_name: binding_c, mutable: false, pointer: false)
               end
             end
 
-            arm.pattern.arguments.each do |arg|
-              next if arg.name
-              next unless arg.value.is_a?(AST::Identifier)
-              next if arg.value.name == "_"
+            if arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
+              binding_c = c_local_name(arm.binding_name)
+              if arm_name && scrutinee_type.has_payload?(arm_name)
+                payload_key = "__mt_payload"
+                if arm_local_env[:scopes].last.key?(payload_key)
+                  payload_binding = arm_local_env[:scopes].last[payload_key]
+                  arm_local_env[:scopes].last[arm.binding_name] = local_binding(type: payload_binding[:type], linkage_name: binding_c, mutable: true, pointer: false)
+                  payload_ref = IR::Name.new(name: payload_binding[:linkage_name], type: payload_binding[:type], pointer: false)
+                  arm_body_ir << IR::LocalDecl.new(name: arm.binding_name, linkage_name: binding_c, type: payload_binding[:type], value: payload_ref)
+                end
+              end
+            end
 
-              field_name = arg.value.name
-              next unless pattern_fields.key?(field_name)
+            body = lower_block(
+              arm.body,
+              env: arm_local_env,
+              active_defers: active_defers + local_defers,
+              return_type:,
+              loop_flow: arm_loop_flow,
+              allow_return:,
+            )
+            arm_body_ir.concat(body)
+            arm_body_ir << IR::GotoStmt.new(label: match_end_label)
 
-              field_type = pattern_fields[field_name]
-              binding_c = c_local_name(field_name)
-              field_expr = IR::Member.new(receiver: IR::Name.new(name: pattern_receiver_name, type: pattern_receiver_type, pointer: false), member: field_name, type: field_type)
-              field_expr = dereference_if_self_ref(field_expr, field_type, scrutinee_type)
-              arm_body_ir << IR::LocalDecl.new(name: binding_c, linkage_name: binding_c, type: field_type, value: field_expr)
-              arm_local_env[:scopes].last[field_name] = local_binding(type: field_type, linkage_name: binding_c, mutable: false, pointer: false)
-            end
+            lowered << IR::BlockStmt.new(body: arm_body_ir)
+          else
+            body = lower_block(
+              arm.body,
+              env: arm_local_env,
+              active_defers: active_defers + local_defers,
+              return_type:,
+              loop_flow: arm_loop_flow,
+              allow_return:,
+            )
+            lowered << IR::BlockStmt.new(body: body + [IR::GotoStmt.new(label: match_end_label)])
           end
+        end
 
-          if arm.binding_name && !wildcard_arm_pattern?(arm.pattern)
-            binding_c = c_local_name(arm.binding_name)
-            if arm_name && scrutinee_type.has_payload?(arm_name)
-              payload_key = "__mt_payload"
-              if arm_local_env[:scopes].last.key?(payload_key)
-                payload_binding = arm_local_env[:scopes].last[payload_key]
-                arm_local_env[:scopes].last[arm.binding_name] = local_binding(type: payload_binding[:type], linkage_name: binding_c, mutable: true, pointer: false)
-                payload_ref = IR::Name.new(name: payload_binding[:linkage_name], type: payload_binding[:type], pointer: false)
-                arm_body_ir << IR::LocalDecl.new(name: arm.binding_name, linkage_name: binding_c, type: payload_binding[:type], value: payload_ref)
-              end
-            end
-          end
+        lowered << IR::LabelStmt.new(name: arm_next_label)
+        lowered << IR::LabelStmt.new(name: match_end_label)
+      end
 
-          body = lower_block(
-            arm.body,
-            env: arm_local_env,
+      def lower_string_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+        bool_type = @ctx.types.fetch("bool")
+        non_wildcard = statement.arms.reject { |arm| wildcard_arm_pattern?(arm.pattern) }
+        wildcard = statement.arms.find { |arm| wildcard_arm_pattern?(arm.pattern) }
+        else_body = if wildcard
+          lower_block(
+            wildcard.body,
+            env: local_env,
             active_defers: active_defers + local_defers,
             return_type:,
             loop_flow: arm_loop_flow,
             allow_return:,
           )
-          arm_body_ir.concat(body)
-          arm_body_ir << IR::GotoStmt.new(label: match_end_label)
-
-          lowered << IR::BlockStmt.new(body: arm_body_ir)
         else
-          body = lower_block(
+          []
+        end
+        non_wildcard.reverse_each do |arm|
+          arm_body = lower_block(
             arm.body,
-            env: arm_local_env,
+            env: local_env,
             active_defers: active_defers + local_defers,
             return_type:,
             loop_flow: arm_loop_flow,
             allow_return:,
           )
-          lowered << IR::BlockStmt.new(body: body + [IR::GotoStmt.new(label: match_end_label)])
+          lit = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
+          cond = IR::Binary.new(operator: "==", left: expression, right: lit, type: bool_type)
+          else_body = [IR::IfStmt.new(condition: cond, then_body: arm_body, else_body:)]
         end
+        lowered.concat(else_body)
       end
 
-      lowered << IR::LabelStmt.new(name: arm_next_label)
-      lowered << IR::LabelStmt.new(name: match_end_label)
-    end
-
-    def lower_block_string_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
-      bool_type = @ctx.types.fetch("bool")
-      non_wildcard = statement.arms.reject { |arm| wildcard_arm_pattern?(arm.pattern) }
-      wildcard = statement.arms.find { |arm| wildcard_arm_pattern?(arm.pattern) }
-      else_body = if wildcard
-        lower_block(
-          wildcard.body,
-          env: local_env,
-          active_defers: active_defers + local_defers,
-          return_type:,
-          loop_flow: arm_loop_flow,
-          allow_return:,
-        )
-      else
-        []
-      end
-      non_wildcard.reverse_each do |arm|
-        arm_body = lower_block(
-          arm.body,
-          env: local_env,
-          active_defers: active_defers + local_defers,
-          return_type:,
-          loop_flow: arm_loop_flow,
-          allow_return:,
-        )
-        lit = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
-        cond = IR::Binary.new(operator: "==", left: expression, right: lit, type: bool_type)
-        else_body = [IR::IfStmt.new(condition: cond, then_body: arm_body, else_body:)]
-      end
-      lowered.concat(else_body)
-    end
-
-    def lower_block_tuple_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
-      bool_type = @ctx.types.fetch("bool")
-      non_wildcard = statement.arms.reject { |arm| wildcard_arm_pattern?(arm.pattern) }
-      wildcard = statement.arms.find { |arm| wildcard_arm_pattern?(arm.pattern) }
-      else_body = if wildcard
-        lower_block(
-          wildcard.body,
-          env: local_env,
-          active_defers: active_defers + local_defers,
-          return_type:,
-          loop_flow: arm_loop_flow,
-          allow_return:,
-        )
-      else
-        []
-      end
-      non_wildcard.reverse_each do |arm|
-        arm_body = lower_block(
-          arm.body,
-          env: local_env,
-          active_defers: active_defers + local_defers,
-          return_type:,
-          loop_flow: arm_loop_flow,
-          allow_return:,
-        )
-        cond = tuple_arm_condition(arm, expression, scrutinee_type, bool_type, env: local_env)
-        else_body = [IR::IfStmt.new(condition: cond, then_body: arm_body, else_body:)]
+      def lower_tuple_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+        bool_type = @ctx.types.fetch("bool")
+        non_wildcard = statement.arms.reject { |arm| wildcard_arm_pattern?(arm.pattern) }
+        wildcard = statement.arms.find { |arm| wildcard_arm_pattern?(arm.pattern) }
+        else_body = if wildcard
+          lower_block(
+            wildcard.body,
+            env: local_env,
+            active_defers: active_defers + local_defers,
+            return_type:,
+            loop_flow: arm_loop_flow,
+            allow_return:,
+          )
+        else
+          []
+        end
+        non_wildcard.reverse_each do |arm|
+          arm_body = lower_block(
+            arm.body,
+            env: local_env,
+            active_defers: active_defers + local_defers,
+            return_type:,
+            loop_flow: arm_loop_flow,
+            allow_return:,
+          )
+          cond = tuple_arm_condition(arm, expression, scrutinee_type, bool_type, env: local_env)
+          else_body = [IR::IfStmt.new(condition: cond, then_body: arm_body, else_body:)]
+        end
+        lowered.concat(else_body)
       end
-      lowered.concat(else_body)
-    end
 
-    def lower_block_range_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
-      arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
-      bool_type = @ctx.types.fetch("bool")
-      non_wildcard = statement.arms.reject { |arm| wildcard_arm_pattern?(arm.pattern) }
-      wildcard = statement.arms.find { |arm| wildcard_arm_pattern?(arm.pattern) }
-      else_body = if wildcard
-        lower_block(wildcard.body, env: local_env, active_defers: active_defers + local_defers, return_type:, loop_flow: arm_loop_flow, allow_return:)
-      else
-        []
-      end
-      non_wildcard.reverse_each do |arm|
-        arm_body = lower_block(
-          arm.body,
-          env: local_env,
-          active_defers: active_defers + local_defers,
-          return_type:,
-          loop_flow: arm_loop_flow,
-          allow_return:,
-        )
-        cond = if arm.pattern.is_a?(AST::RangeExpr)
-          lower_range_match_condition(arm.pattern, expression, bool_type, env: local_env)
+      def lower_range_match_stmt(statement, scrutinee_type:, expression:, lowered:, local_defers:, local_env:, active_defers:, return_type:, loop_flow:, allow_return:)
+        arm_loop_flow = switch_loop_flow(loop_flow, local_defers)
+        bool_type = @ctx.types.fetch("bool")
+        non_wildcard = statement.arms.reject { |arm| wildcard_arm_pattern?(arm.pattern) }
+        wildcard = statement.arms.find { |arm| wildcard_arm_pattern?(arm.pattern) }
+        else_body = if wildcard
+          lower_block(wildcard.body, env: local_env, active_defers: active_defers + local_defers, return_type:, loop_flow: arm_loop_flow, allow_return:)
         else
-          lit = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
-          IR::Binary.new(operator: "==", left: expression, right: lit, type: bool_type)
+          []
+        end
+        non_wildcard.reverse_each do |arm|
+          arm_body = lower_block(
+            arm.body,
+            env: local_env,
+            active_defers: active_defers + local_defers,
+            return_type:,
+            loop_flow: arm_loop_flow,
+            allow_return:,
+          )
+          cond = if arm.pattern.is_a?(AST::RangeExpr)
+            lower_range_match_condition(arm.pattern, expression, bool_type, env: local_env)
+          else
+            lit = lower_expression(arm.pattern, env: local_env, expected_type: scrutinee_type)
+            IR::Binary.new(operator: "==", left: expression, right: lit, type: bool_type)
+          end
+          else_body = [IR::IfStmt.new(condition: cond, then_body: arm_body, else_body:)]
         end
-        else_body = [IR::IfStmt.new(condition: cond, then_body: arm_body, else_body:)]
+        lowered.concat(else_body)
       end
-      lowered.concat(else_body)
     end
   end
 end