mt-lang 0.3.24 → 0.3.26

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

@@ -5,208 +5,202 @@ require_relative "resolve"
 require_relative "utils"
 
 module MilkTea
-  module LowererScans
-    def collect_structs
-      @ctx.ast.declarations.each { |decl| collect_one_struct_decl(decl) }
-    end
-
-    def collect_one_struct_decl(decl)
-      case decl
-      when AST::WhenStmt
-        body = lower_when_chosen_body(decl)
-        body&.each { |nested| collect_one_struct_decl(nested) }
-      when AST::OpaqueDecl
-        @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
-      when AST::StructDecl
-        @ctx.struct_types[decl.name] = @ctx.types.fetch(decl.name)
-        collect_nested_structs(decl)
-      when AST::UnionDecl
-        @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
+  module Lowering
+    module Scans
+      def collect_structs
+        @ctx.ast.declarations.each { |decl| collect_one_struct_decl(decl) }
       end
-    end
 
-    def collect_struct_from_decl(decl)
-      collect_one_struct_decl(decl)
-    end
-
-    def lower_when_chosen_body(decl)
-      val = compile_time_const_value(decl.discriminant)
-      return nil if val.nil?
+      def collect_one_struct_decl(decl)
+        case decl
+        when AST::WhenStmt
+          body = lower_when_chosen_body(decl)
+          body&.each { |nested| collect_one_struct_decl(nested) }
+        when AST::OpaqueDecl
+          @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
+        when AST::StructDecl
+          @ctx.struct_types[decl.name] = @ctx.types.fetch(decl.name)
+          collect_nested_structs(decl)
+        when AST::UnionDecl
+          @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
+        end
+      end
 
-      chosen = decl.branches.find { |b| val == compile_time_const_value(b.pattern) }
-      chosen&.body || decl.else_body
-    end
+      def lower_when_chosen_body(decl)
+        val = compile_time_const_value(decl.discriminant)
+        return nil if val.nil?
 
-    def collect_nested_structs(parent_decl, parent_name: parent_decl.name)
-      parent_decl.nested_types.each do |nested|
-        qualified_name = "#{parent_name}.#{nested.name}"
-        @ctx.struct_types[qualified_name] = @ctx.types.fetch(qualified_name)
-        collect_nested_structs(nested, parent_name: qualified_name)
+        chosen = decl.branches.find { |b| val == compile_time_const_value(b.pattern) }
+        chosen&.body || decl.else_body
       end
-    end
-
-    def collect_includes
-      headers = ["<stdbool.h>", "<stdint.h>", "<string.h>"]
-      headers << "<stddef.h>" if program_uses_offsetof?
-      headers << "<stdio.h>" if program_uses_fatal?
 
-      each_raw_module_analysis do |analysis|
-        analysis.directives.grep(AST::IncludeDirective).each do |directive|
-          headers << normalized_include_header(directive.value)
+      def collect_nested_structs(parent_decl, parent_name: parent_decl.name)
+        parent_decl.nested_types.each do |nested|
+          qualified_name = "#{parent_name}.#{nested.name}"
+          @ctx.struct_types[qualified_name] = @ctx.types.fetch(qualified_name)
+          collect_nested_structs(nested, parent_name: qualified_name)
         end
       end
 
-      headers.uniq.map { |header| IR::Include.new(header:) }
-    end
+      def collect_includes
+        headers = ["<stdbool.h>", "<stdint.h>", "<string.h>"]
+        headers << "<stddef.h>" if program_uses_offsetof?
+        headers << "<stdio.h>" if program_uses_fatal?
 
-    def normalized_include_header(header_name)
-      return "<#{header_name}>" if standard_c_runtime_header?(header_name)
+        each_raw_module_analysis do |analysis|
+          analysis.directives.grep(AST::IncludeDirective).each do |directive|
+            headers << normalized_include_header(directive.value)
+          end
+        end
 
-      %("#{header_name}")
-    end
+        headers.uniq.map { |header| IR::Include.new(header:) }
+      end
 
-    def standard_c_runtime_header?(header_name)
-      %w[stdbool.h stdint.h stdlib.h string.h stddef.h stdio.h time.h].include?(header_name)
-    end
+      def normalized_include_header(header_name)
+        return "<#{header_name}>" if standard_c_runtime_header?(header_name)
 
-    def program_uses_fatal?
-      each_non_raw_module_analysis.any? do |analysis|
-        analysis_uses_fatal?(analysis)
+        %("#{header_name}")
       end
-    end
 
-    def program_uses_offsetof?
-      each_non_raw_module_analysis.any? do |analysis|
-        analysis_uses_offsetof?(analysis)
+      def standard_c_runtime_header?(header_name)
+        %w[stdbool.h stdint.h stdlib.h string.h stddef.h stdio.h time.h].include?(header_name)
       end
-    end
 
-    def analysis_uses_fatal?(analysis)
-      analysis.ast.declarations.any? do |decl|
-        case decl
-        when AST::FunctionDef
-          block_uses_fatal?(decl.body)
-        when AST::ExtendingBlock
-          decl.methods.any? { |method| block_uses_fatal?(method.body) }
-        else
-          false
+      def program_uses_fatal?
+        each_non_raw_module_analysis.any? do |analysis|
+          analysis_uses_fatal?(analysis)
         end
       end
-    end
 
-    def analysis_uses_offsetof?(analysis)
-      analysis.ast.declarations.any? do |decl|
-        case decl
-        when AST::FunctionDef
-          block_uses_offsetof?(decl.body)
-        when AST::ExtendingBlock
-          decl.methods.any? { |method| block_uses_offsetof?(method.body) }
-        else
-          false
+      def program_uses_offsetof?
+        each_non_raw_module_analysis.any? do |analysis|
+          analysis_uses_offsetof?(analysis)
         end
       end
-    end
 
-    def block_uses_fatal?(statements)
-      block_uses_expression_pattern?(statements) { |expression| fatal_expression?(expression) }
-    end
+      def analysis_uses_fatal?(analysis)
+        analysis.ast.declarations.any? do |decl|
+          case decl
+          when AST::FunctionDef
+            block_uses_fatal?(decl.body)
+          when AST::ExtendingBlock
+            decl.methods.any? { |method| block_uses_fatal?(method.body) }
+          else
+            false
+          end
+        end
+      end
 
-    def block_uses_offsetof?(statements)
-      block_uses_expression_pattern?(statements) { |expression| offsetof_expression?(expression) }
-    end
+      def analysis_uses_offsetof?(analysis)
+        analysis.ast.declarations.any? do |decl|
+          case decl
+          when AST::FunctionDef
+            block_uses_offsetof?(decl.body)
+          when AST::ExtendingBlock
+            decl.methods.any? { |method| block_uses_offsetof?(method.body) }
+          else
+            false
+          end
+        end
+      end
 
-    def block_uses_expression_pattern?(statements, &predicate)
-      statements.any? { |statement| statement_uses_expression_pattern?(statement, &predicate) }
-    end
+      def block_uses_fatal?(statements)
+        block_uses_expression_pattern?(statements) { |expression| fatal_expression?(expression) }
+      end
 
-    def statement_uses_expression_pattern?(statement, &predicate)
-      case statement
-      when AST::LocalDecl
-        expression_uses_pattern?(statement.value, &predicate)
-      when AST::Assignment
-        expression_uses_pattern?(statement.target, &predicate) || expression_uses_pattern?(statement.value, &predicate)
-      when AST::IfStmt
-        statement.branches.any? { |branch| expression_uses_pattern?(branch.condition, &predicate) || block_uses_expression_pattern?(branch.body, &predicate) } ||
-          (statement.else_body && block_uses_expression_pattern?(statement.else_body, &predicate))
-      when AST::MatchStmt
-        expression_uses_pattern?(statement.expression, &predicate) || statement.arms.any? { |arm| expression_uses_pattern?(arm.pattern, &predicate) || block_uses_expression_pattern?(arm.body, &predicate) }
-      when AST::StaticAssert
-        expression_uses_pattern?(statement.condition, &predicate) || expression_uses_pattern?(statement.message, &predicate)
-      when AST::ForStmt
-        statement.iterables.any? { |iterable| expression_uses_pattern?(iterable, &predicate) } || block_uses_expression_pattern?(statement.body, &predicate)
-      when AST::UnsafeStmt, AST::WhileStmt
-        expression = statement.is_a?(AST::WhileStmt) ? statement.condition : nil
-        (expression && expression_uses_pattern?(expression, &predicate)) || block_uses_expression_pattern?(statement.body, &predicate)
-      when AST::ReturnStmt
-        statement.value && expression_uses_pattern?(statement.value, &predicate)
-      when AST::ExpressionStmt
-        expression_uses_pattern?(statement.expression, &predicate)
-      when AST::DeferStmt
-        block_uses_expression_pattern?(statement.body, &predicate)
-      else
-        false
+      def block_uses_offsetof?(statements)
+        block_uses_expression_pattern?(statements) { |expression| offsetof_expression?(expression) }
       end
-    end
 
-    def fatal_expression?(expression)
-      expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier) && expression.callee.name == "fatal"
-    end
+      def block_uses_expression_pattern?(statements, &predicate)
+        statements.any? { |statement| statement_uses_expression_pattern?(statement, &predicate) }
+      end
 
-    def offsetof_expression?(expression)
-      expression.is_a?(AST::OffsetofExpr)
-    end
+      def statement_uses_expression_pattern?(statement, &predicate)
+        case statement
+        when AST::LocalDecl
+          expression_uses_pattern?(statement.value, &predicate)
+        when AST::Assignment
+          expression_uses_pattern?(statement.target, &predicate) || expression_uses_pattern?(statement.value, &predicate)
+        when AST::IfStmt
+          statement.branches.any? { |branch| expression_uses_pattern?(branch.condition, &predicate) || block_uses_expression_pattern?(branch.body, &predicate) } ||
+            (statement.else_body && block_uses_expression_pattern?(statement.else_body, &predicate))
+        when AST::MatchStmt
+          expression_uses_pattern?(statement.expression, &predicate) || statement.arms.any? { |arm| expression_uses_pattern?(arm.pattern, &predicate) || block_uses_expression_pattern?(arm.body, &predicate) }
+        when AST::StaticAssert
+          expression_uses_pattern?(statement.condition, &predicate) || expression_uses_pattern?(statement.message, &predicate)
+        when AST::ForStmt
+          statement.iterables.any? { |iterable| expression_uses_pattern?(iterable, &predicate) } || block_uses_expression_pattern?(statement.body, &predicate)
+        when AST::UnsafeStmt, AST::WhileStmt
+          expression = statement.is_a?(AST::WhileStmt) ? statement.condition : nil
+          (expression && expression_uses_pattern?(expression, &predicate)) || block_uses_expression_pattern?(statement.body, &predicate)
+        when AST::ReturnStmt
+          statement.value && expression_uses_pattern?(statement.value, &predicate)
+        when AST::ExpressionStmt
+          expression_uses_pattern?(statement.expression, &predicate)
+        when AST::DeferStmt
+          block_uses_expression_pattern?(statement.body, &predicate)
+        else
+          false
+        end
+      end
 
-    def expression_uses_pattern?(expression, &predicate)
-      return false unless expression
-      return true if predicate.call(expression)
-
-      case expression
-      when AST::AwaitExpr
-        expression_uses_pattern?(expression.expression, &predicate)
-      when AST::Call
-        expression_uses_pattern?(expression.callee, &predicate) || expression.arguments.any? { |argument| expression_uses_pattern?(argument.value, &predicate) }
-      when AST::BinaryOp
-        expression_uses_pattern?(expression.left, &predicate) || expression_uses_pattern?(expression.right, &predicate)
-      when AST::RangeExpr
-        expression_uses_pattern?(expression.start_expr, &predicate) || expression_uses_pattern?(expression.end_expr, &predicate)
-      when AST::IfExpr
-        expression_uses_pattern?(expression.condition, &predicate) || expression_uses_pattern?(expression.then_expression, &predicate) || expression_uses_pattern?(expression.else_expression, &predicate)
-      when AST::MatchExpr
-        expression_uses_pattern?(expression.expression, &predicate) || expression.arms.any? { |arm| expression_uses_pattern?(arm.pattern, &predicate) || expression_uses_pattern?(arm.value, &predicate) }
-      when AST::UnsafeExpr
-        expression_uses_pattern?(expression.expression, &predicate)
-      when AST::PrefixCast
-        expression_uses_pattern?(expression.expression, &predicate)
-      when AST::UnaryOp
-        expression_uses_pattern?(expression.operand, &predicate)
-      when AST::MemberAccess
-        expression_uses_pattern?(expression.receiver, &predicate)
-      when AST::IndexAccess
-        expression_uses_pattern?(expression.receiver, &predicate) || expression_uses_pattern?(expression.index, &predicate)
-      when AST::Specialization
-        expression_uses_pattern?(expression.callee, &predicate) || expression.arguments.any? { |argument| expression_uses_pattern?(argument.value, &predicate) }
-      else
-        false
+      def fatal_expression?(expression)
+        expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier) && expression.callee.name == "fatal"
       end
-    end
 
-    def prepare_analysis(analysis, path: nil)
-      @ctx.install(analysis)
-      @ctx.current_analysis_path = path
-      @ctx.module_prefix = module_c_prefix(@ctx.module_name)
-    end
+      def offsetof_expression?(expression)
+        expression.is_a?(AST::OffsetofExpr)
+      end
 
-    def sanitize_type_name_for_tuple(type)
-      type.to_s.gsub(/[^a-zA-Z0-9]/, "_").gsub(/_+/, "_").gsub(/^_|_$/, "")
-    end
+      def expression_uses_pattern?(expression, &predicate)
+        return false unless expression
+        return true if predicate.call(expression)
+
+        case expression
+        when AST::AwaitExpr
+          expression_uses_pattern?(expression.expression, &predicate)
+        when AST::Call
+          expression_uses_pattern?(expression.callee, &predicate) || expression.arguments.any? { |argument| expression_uses_pattern?(argument.value, &predicate) }
+        when AST::BinaryOp
+          expression_uses_pattern?(expression.left, &predicate) || expression_uses_pattern?(expression.right, &predicate)
+        when AST::RangeExpr
+          expression_uses_pattern?(expression.start_expr, &predicate) || expression_uses_pattern?(expression.end_expr, &predicate)
+        when AST::IfExpr
+          expression_uses_pattern?(expression.condition, &predicate) || expression_uses_pattern?(expression.then_expression, &predicate) || expression_uses_pattern?(expression.else_expression, &predicate)
+        when AST::MatchExpr
+          expression_uses_pattern?(expression.expression, &predicate) || expression.arms.any? { |arm| expression_uses_pattern?(arm.pattern, &predicate) || expression_uses_pattern?(arm.value, &predicate) }
+        when AST::UnsafeExpr
+          expression_uses_pattern?(expression.expression, &predicate)
+        when AST::PrefixCast
+          expression_uses_pattern?(expression.expression, &predicate)
+        when AST::UnaryOp
+          expression_uses_pattern?(expression.operand, &predicate)
+        when AST::MemberAccess
+          expression_uses_pattern?(expression.receiver, &predicate)
+        when AST::IndexAccess
+          expression_uses_pattern?(expression.receiver, &predicate) || expression_uses_pattern?(expression.index, &predicate)
+        when AST::Specialization
+          expression_uses_pattern?(expression.callee, &predicate) || expression.arguments.any? { |argument| expression_uses_pattern?(argument.value, &predicate) }
+        else
+          false
+        end
+      end
+
+      def prepare_analysis(analysis, path: nil)
+        @ctx.install(analysis)
+        @ctx.current_analysis_path = path
+        @ctx.module_prefix = module_c_prefix(@ctx.module_name)
+      end
 
-    def build_method_definitions
-      @program.analyses_by_path.values.each_with_object({}) do |analysis, definitions|
-        analysis.ast.declarations.grep(AST::ExtendingBlock).each do |extending_block|
-          receiver_type = resolve_extending_receiver_type(analysis, extending_block.type_name)
-          extending_block.methods.each do |method|
-            method_key = method.kind == :static ? "static:#{method.name}" : method.name
-            definitions[[receiver_type, method_key]] = [analysis, method]
+      def build_method_definitions
+        @program.analyses_by_path.values.each_with_object({}) do |analysis, definitions|
+          analysis.ast.declarations.grep(AST::ExtendingBlock).each do |extending_block|
+            receiver_type = resolve_extending_receiver_type(analysis, extending_block.type_name)
+            extending_block.methods.each do |method|
+              method_key = method.kind == :static ? "static:#{method.name}" : method.name
+              definitions[[receiver_type, method_key]] = [analysis, method]
+            end
           end
         end
       end

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

@@ -1,122 +1,124 @@
 # frozen_string_literal: true
 
 module MilkTea
-  module LowererStrBuffer
-    def str_buffer_method_kind(receiver_type, name)
-      return unless str_buffer_type?(receiver_type)
+  module Lowering
+    module StrBuffer
+      def str_buffer_method_kind(receiver_type, name)
+        return unless str_buffer_type?(receiver_type)
 
-      case name
-      when "clear"
-        :str_buffer_clear
-      when "assign"
-        :str_buffer_assign
-      when "append"
-        :str_buffer_append
-      when "assign_format"
-        :str_buffer_assign_format
-      when "append_format"
-        :str_buffer_append_format
-      when "len"
-        :str_buffer_len
-      when "capacity"
-        :str_buffer_capacity
-      when "as_str"
-        :str_buffer_as_str
-      when "as_cstr"
-        :str_buffer_as_cstr
+        case name
+        when "clear"
+          :str_buffer_clear
+        when "assign"
+          :str_buffer_assign
+        when "append"
+          :str_buffer_append
+        when "assign_format"
+          :str_buffer_assign_format
+        when "append_format"
+          :str_buffer_append_format
+        when "len"
+          :str_buffer_len
+        when "capacity"
+          :str_buffer_capacity
+        when "as_str"
+          :str_buffer_as_str
+        when "as_cstr"
+          :str_buffer_as_cstr
+        end
       end
-    end
 
-    def str_buffer_method_type(kind, receiver_type)
-      return_type, params = case kind
-                            when :str_buffer_clear
-                              [@ctx.types.fetch("void"), []]
-                            when :str_buffer_assign, :str_buffer_append, :str_buffer_assign_format, :str_buffer_append_format
-                              [@ctx.types.fetch("void"), [Types::Registry.parameter("value", @ctx.types.fetch("str"))]]
-                            when :str_buffer_len, :str_buffer_capacity
-                              [@ctx.types.fetch("ptr_uint"), []]
-                            when :str_buffer_as_str
-                              [@ctx.types.fetch("str"), []]
-                            when :str_buffer_as_cstr
-                              [@ctx.types.fetch("cstr"), []]
-                            else
-                              raise LoweringError.new("unsupported str_buffer method #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
-                            end
+      def str_buffer_method_type(kind, receiver_type)
+        return_type, params = case kind
+                              when :str_buffer_clear
+                                [@ctx.types.fetch("void"), []]
+                              when :str_buffer_assign, :str_buffer_append, :str_buffer_assign_format, :str_buffer_append_format
+                                [@ctx.types.fetch("void"), [Types::Registry.parameter("value", @ctx.types.fetch("str"))]]
+                              when :str_buffer_len, :str_buffer_capacity
+                                [@ctx.types.fetch("ptr_uint"), []]
+                              when :str_buffer_as_str
+                                [@ctx.types.fetch("str"), []]
+                              when :str_buffer_as_cstr
+                                [@ctx.types.fetch("cstr"), []]
+                              else
+                                raise LoweringError.new("unsupported str_buffer method #{kind}", line: 0, column: 0, path: @ctx.current_analysis_path)
+                              end
 
-      Types::Registry.function(
-        kind.to_s,
-        params:,
-        return_type:,
-        receiver_type:,
-        receiver_editable: %i[str_buffer_clear str_buffer_assign str_buffer_append str_buffer_assign_format str_buffer_append_format].include?(kind),
-        external: false,
-      )
-    end
+        Types::Registry.function(
+          kind.to_s,
+          params:,
+          return_type:,
+          receiver_type:,
+          receiver_editable: %i[str_buffer_clear str_buffer_assign str_buffer_append str_buffer_assign_format str_buffer_append_format].include?(kind),
+          external: false,
+        )
+      end
 
-    def lower_char_array_data_pointer(expression, env:)
-      lowered_receiver = lower_expression(expression, env:)
-      IR::AddressOf.new(
-        expression: IR::Index.new(
-          receiver: lowered_receiver,
-          index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
-          type: @ctx.types.fetch("char"),
-        ),
-        type: pointer_to(@ctx.types.fetch("char")),
-      )
-    end
+      def lower_char_array_data_pointer(expression, env:)
+        lowered_receiver = lower_expression(expression, env:)
+        IR::AddressOf.new(
+          expression: IR::Index.new(
+            receiver: lowered_receiver,
+            index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
+            type: @ctx.types.fetch("char"),
+          ),
+          type: pointer_to(@ctx.types.fetch("char")),
+        )
+      end
 
-    def lower_str_buffer_data_pointer(expression, env:)
-      lower_str_buffer_data_pointer_from_lowered(lower_expression(expression, env:))
-    end
+      def lower_str_buffer_data_pointer(expression, env:)
+        lower_str_buffer_data_pointer_from_lowered(lower_expression(expression, env:))
+      end
 
-    def lower_str_buffer_data_pointer_from_lowered(lowered_receiver)
-      IR::AddressOf.new(
-        expression: IR::Index.new(
-          receiver: IR::Member.new(
-            receiver: lowered_receiver,
-            member: "data",
-            type: Types::Registry.generic_instance(
-              "array",
-              [@ctx.types.fetch("char"), Types::LiteralTypeArg.new(str_buffer_storage_capacity(lowered_receiver.type))],
+      def lower_str_buffer_data_pointer_from_lowered(lowered_receiver)
+        IR::AddressOf.new(
+          expression: IR::Index.new(
+            receiver: IR::Member.new(
+              receiver: lowered_receiver,
+              member: "data",
+              type: Types::Registry.generic_instance(
+                "array",
+                [@ctx.types.fetch("char"), Types::LiteralTypeArg.new(str_buffer_storage_capacity(lowered_receiver.type))],
+              ),
             ),
+            index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
+            type: @ctx.types.fetch("char"),
           ),
-          index: IR::IntegerLiteral.new(value: 0, type: @ctx.types.fetch("ptr_uint")),
-          type: @ctx.types.fetch("char"),
-        ),
-        type: pointer_to(@ctx.types.fetch("char")),
-      )
-    end
+          type: pointer_to(@ctx.types.fetch("char")),
+        )
+      end
 
-    def lower_str_buffer_len_pointer(expression, env:)
-      lower_str_buffer_len_pointer_from_lowered(lower_expression(expression, env:))
-    end
+      def lower_str_buffer_len_pointer(expression, env:)
+        lower_str_buffer_len_pointer_from_lowered(lower_expression(expression, env:))
+      end
 
-    def lower_str_buffer_len_pointer_from_lowered(lowered_receiver)
-      IR::AddressOf.new(
-        expression: IR::Member.new(receiver: lowered_receiver, member: "len", type: @ctx.types.fetch("ptr_uint")),
-        type: pointer_to(@ctx.types.fetch("ptr_uint")),
-      )
-    end
+      def lower_str_buffer_len_pointer_from_lowered(lowered_receiver)
+        IR::AddressOf.new(
+          expression: IR::Member.new(receiver: lowered_receiver, member: "len", type: @ctx.types.fetch("ptr_uint")),
+          type: pointer_to(@ctx.types.fetch("ptr_uint")),
+        )
+      end
 
-    def lower_str_buffer_dirty_pointer(expression, env:)
-      lower_str_buffer_dirty_pointer_from_lowered(lower_expression(expression, env:))
-    end
+      def lower_str_buffer_dirty_pointer(expression, env:)
+        lower_str_buffer_dirty_pointer_from_lowered(lower_expression(expression, env:))
+      end
 
-    def lower_str_buffer_dirty_pointer_from_lowered(lowered_receiver)
-      IR::AddressOf.new(
-        expression: IR::Member.new(receiver: lowered_receiver, member: "dirty", type: @ctx.types.fetch("bool")),
-        type: pointer_to(@ctx.types.fetch("bool")),
-      )
-    end
+      def lower_str_buffer_dirty_pointer_from_lowered(lowered_receiver)
+        IR::AddressOf.new(
+          expression: IR::Member.new(receiver: lowered_receiver, member: "dirty", type: @ctx.types.fetch("bool")),
+          type: pointer_to(@ctx.types.fetch("bool")),
+        )
+      end
 
-    def str_buffer_args(receiver, env:)
-      receiver_type = infer_expression_type(receiver, env:)
-      [
-        lower_str_buffer_data_pointer(receiver, env:),
-        IR::IntegerLiteral.new(value: str_buffer_capacity(receiver_type), type: @ctx.types.fetch("ptr_uint")),
-        lower_str_buffer_len_pointer(receiver, env:),
-        lower_str_buffer_dirty_pointer(receiver, env:),
-      ]
+      def str_buffer_args(receiver, env:)
+        receiver_type = infer_expression_type(receiver, env:)
+        [
+          lower_str_buffer_data_pointer(receiver, env:),
+          IR::IntegerLiteral.new(value: str_buffer_capacity(receiver_type), type: @ctx.types.fetch("ptr_uint")),
+          lower_str_buffer_len_pointer(receiver, env:),
+          lower_str_buffer_dirty_pointer(receiver, env:),
+        ]
+      end
     end
   end
 end