mt-lang 0.3.9 → 0.3.10

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

@@ -2,27 +2,12 @@
 
 module MilkTea
   module LowererScans
-    private
-
-      def collect_structs
-        @ctx.ast.declarations.each do |decl|
-          case decl
-          when AST::WhenStmt
-            body = lower_when_chosen_body(decl)
-            body&.each { |nested| collect_struct_from_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
-      end
-
-      def collect_struct_from_decl(decl)
+    def collect_structs
+      @ctx.ast.declarations.each do |decl|
         case decl
+        when AST::WhenStmt
+          body = lower_when_chosen_body(decl)
+          body&.each { |nested| collect_struct_from_decl(nested) }
         when AST::OpaqueDecl
           @ctx.opaque_types[decl.name] = @ctx.types.fetch(decl.name)
         when AST::StructDecl
@@ -30,191 +15,204 @@ module MilkTea
           collect_nested_structs(decl)
         when AST::UnionDecl
           @ctx.union_types[decl.name] = @ctx.types.fetch(decl.name)
-        when AST::WhenStmt
-          body = lower_when_chosen_body(decl)
-          body&.each { |nested| collect_struct_from_decl(nested) }
-        end
-      end
-
-      def lower_when_chosen_body(decl)
-        val = compile_time_const_value(decl.discriminant)
-        return nil if val.nil?
-
-        chosen = decl.branches.find { |b| val == compile_time_const_value(b.pattern) }
-        chosen&.body || decl.else_body
-      end
-
-      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
-
-      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)
-          end
         end
-
-        headers.uniq.map { |header| IR::Include.new(header:) }
-      end
-
-      def normalized_include_header(header_name)
-        return "<#{header_name}>" if standard_c_runtime_header?(header_name)
-
-        %("#{header_name}")
-      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 program_uses_fatal?
-        each_non_raw_module_analysis.any? do |analysis|
-          analysis_uses_fatal?(analysis)
+    end
+
+    def collect_struct_from_decl(decl)
+      case decl
+      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)
+      when AST::WhenStmt
+        body = lower_when_chosen_body(decl)
+        body&.each { |nested| collect_struct_from_decl(nested) }
+      end
+    end
+
+    def lower_when_chosen_body(decl)
+      val = compile_time_const_value(decl.discriminant)
+      return nil if val.nil?
+
+      chosen = decl.branches.find { |b| val == compile_time_const_value(b.pattern) }
+      chosen&.body || decl.else_body
+    end
+
+    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
+
+    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)
         end
       end
 
-      def program_uses_offsetof?
-        each_non_raw_module_analysis.any? do |analysis|
-          analysis_uses_offsetof?(analysis)
-        end
-      end
+      headers.uniq.map { |header| IR::Include.new(header:) }
+    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 normalized_include_header(header_name)
+      return "<#{header_name}>" if standard_c_runtime_header?(header_name)
 
-      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
+      %("#{header_name}")
+    end
 
-      def block_uses_fatal?(statements)
-        block_uses_expression_pattern?(statements) { |expression| fatal_expression?(expression) }
-      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 block_uses_offsetof?(statements)
-        block_uses_expression_pattern?(statements) { |expression| offsetof_expression?(expression) }
+    def program_uses_fatal?
+      each_non_raw_module_analysis.any? do |analysis|
+        analysis_uses_fatal?(analysis)
       end
+    end
 
-      def block_uses_expression_pattern?(statements, &predicate)
-        statements.any? { |statement| statement_uses_expression_pattern?(statement, &predicate) }
+    def program_uses_offsetof?
+      each_non_raw_module_analysis.any? do |analysis|
+        analysis_uses_offsetof?(analysis)
       end
+    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::DeferStmt, AST::ExpressionStmt
-          expression_uses_pattern?(statement.expression, &predicate)
+    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 fatal_expression?(expression)
-        expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier) && expression.callee.name == "fatal"
-      end
-
-      def offsetof_expression?(expression)
-        expression.is_a?(AST::OffsetofExpr)
-      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) }
+    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
-
-      def prepare_analysis(analysis, source_path: nil)
-        @ctx.install(analysis)
-        @ctx.current_analysis_path = source_path
-        @ctx.module_prefix = module_c_prefix(@ctx.module_name)
-      end
-
-      private def sanitize_type_name_for_tuple(type)
-        type.to_s.gsub(/[^a-zA-Z0-9]/, "_").gsub(/_+/, "_").gsub(/^_|_$/, "")
-      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]
-            end
+    end
+
+    def block_uses_fatal?(statements)
+      block_uses_expression_pattern?(statements) { |expression| fatal_expression?(expression) }
+    end
+
+    def block_uses_offsetof?(statements)
+      block_uses_expression_pattern?(statements) { |expression| offsetof_expression?(expression) }
+    end
+
+    def block_uses_expression_pattern?(statements, &predicate)
+      statements.any? { |statement| statement_uses_expression_pattern?(statement, &predicate) }
+    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::DeferStmt, AST::ExpressionStmt
+        expression_uses_pattern?(statement.expression, &predicate)
+      else
+        false
+      end
+    end
+
+    def fatal_expression?(expression)
+      expression.is_a?(AST::Call) && expression.callee.is_a?(AST::Identifier) && expression.callee.name == "fatal"
+    end
+
+    def offsetof_expression?(expression)
+      expression.is_a?(AST::OffsetofExpr)
+    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 sanitize_type_name_for_tuple(type)
+      type.to_s.gsub(/[^a-zA-Z0-9]/, "_").gsub(/_+/, "_").gsub(/^_|_$/, "")
+    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]
           end
         end
       end
+    end
   end
 end

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

@@ -2,124 +2,121 @@
 
 module MilkTea
   module LowererStrBuffer
-    private
+    def str_buffer_method_kind(receiver_type, name)
+      return unless str_buffer_type?(receiver_type)
 
-
-      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
-        end
+      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
 
-      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"),
           ),
-          type: pointer_to(@ctx.types.fetch("char")),
-        )
-      end
+          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_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:),
-        ]
-      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:),
+      ]
+    end
   end
 end