mt-lang 0.3.24 → 0.3.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b340d2440f6a9cd8241ce7eb2fe5eb25dcc5fa8fc2446dd7c3fa3dfeb71622c
-  data.tar.gz: 9f888a290e2277d691d1a794d39489d64e39241c936ef26fcf00a98ae7d5cbb6
+  metadata.gz: 95066d5ccb69388c431a7b4b963853211c3ef57d8e776de1f8468ecdc983899b
+  data.tar.gz: 83a55caa84c9d54eda5b104727ce0ee4615b4780270d14d0cea4d2001b2fe9fd
 SHA512:
-  metadata.gz: 94b02be805bc7aaf025501fb825b5d50986760d5167939165d00694e006a62e7ba729e9249ee3b6c5eea2bee46dcde333b6005979bb2b5dfed1c425668ce5654
-  data.tar.gz: 204b347cd0f708967d5ce264622ef6f0fc45ba8a70b60ebd531547959f9eacf3cc84f960d1894cdca3f1a715e4ea520bdb181a6e6cefe11701ad1e8912d70da7
+  metadata.gz: a6e8f3cf4ed18ec8cd2bdbfbb8ee458f7662546619f31c55bb00123d22bb9150888e405a692cbeea9c67b10bad2e3c82c621efae9992223e1d0c9bd51281f0a2
+  data.tar.gz: 7cb61c0021e8864897a5b23077dadf54586bf11b11a546ec9b19cbb59083dce4c60d7c8bd996c39380d1a80ea266a364008a1a3f2e3fba7f362ad57c2d97c1d0

data/lib/milk_tea/base.rb

@@ -3,7 +3,7 @@
 require "pathname"
 
 module MilkTea
-  VERSION = "0.3.24"
+  VERSION = "0.3.26"
 
   def self.root
     @root ||= Pathname.new(File.expand_path("../..", __dir__))

data/lib/milk_tea/core/bindings/attribute_binding.rb

@@ -1,56 +1,58 @@
 # frozen_string_literal: true
 
 module MilkTea
-  AttributeBinding = Data.define(:name, :targets, :params, :module_name, :builtin, :ast)
-  BUILTIN_ATTRIBUTE_NAMES = %w[packed align deprecated test expect_fatal].freeze
+  module Bindings
+    AttributeBinding = Data.define(:name, :targets, :params, :module_name, :builtin, :ast)
+    BUILTIN_ATTRIBUTE_NAMES = %w[packed align deprecated test expect_fatal].freeze
 
-  def self.builtin_attribute_binding(name, types)
-    case name
-    when "packed"
-      AttributeBinding.new(
-        name: "packed",
-        targets: [:struct].freeze,
-        params: [].freeze,
-        module_name: nil,
-        builtin: true,
-        ast: nil,
-      )
-    when "align"
-      AttributeBinding.new(
-        name: "align",
-        targets: [:struct].freeze,
-        params: [Types::Registry.parameter("bytes", types.fetch("ptr_uint"))].freeze,
-        module_name: nil,
-        builtin: true,
-        ast: nil,
-      )
-    when "deprecated"
-      AttributeBinding.new(
-        name: "deprecated",
-        targets: %i[callable struct const enum flags union variant event].freeze,
-        params: [Types::Registry.parameter("message", types.fetch("str"))].freeze,
-        module_name: nil,
-        builtin: true,
-        ast: nil,
-      )
-    when "test"
-      AttributeBinding.new(
-        name: "test",
-        targets: [:callable].freeze,
-        params: [].freeze,
-        module_name: nil,
-        builtin: true,
-        ast: nil,
-      )
-    when "expect_fatal"
-      AttributeBinding.new(
-        name: "expect_fatal",
-        targets: [:callable].freeze,
-        params: [].freeze,
-        module_name: nil,
-        builtin: true,
-        ast: nil,
-      )
+    def self.builtin_attribute_binding(name, types)
+      case name
+      when "packed"
+        AttributeBinding.new(
+          name: "packed",
+          targets: [:struct].freeze,
+          params: [].freeze,
+          module_name: nil,
+          builtin: true,
+          ast: nil,
+        )
+      when "align"
+        AttributeBinding.new(
+          name: "align",
+          targets: [:struct].freeze,
+          params: [Types::Registry.parameter("bytes", types.fetch("ptr_uint"))].freeze,
+          module_name: nil,
+          builtin: true,
+          ast: nil,
+        )
+      when "deprecated"
+        AttributeBinding.new(
+          name: "deprecated",
+          targets: %i[callable struct const enum flags union variant event].freeze,
+          params: [Types::Registry.parameter("message", types.fetch("str"))].freeze,
+          module_name: nil,
+          builtin: true,
+          ast: nil,
+        )
+      when "test"
+        AttributeBinding.new(
+          name: "test",
+          targets: [:callable].freeze,
+          params: [].freeze,
+          module_name: nil,
+          builtin: true,
+          ast: nil,
+        )
+      when "expect_fatal"
+        AttributeBinding.new(
+          name: "expect_fatal",
+          targets: [:callable].freeze,
+          params: [].freeze,
+          module_name: nil,
+          builtin: true,
+          ast: nil,
+        )
+      end
     end
   end
 end

data/lib/milk_tea/core/bindings/function_binding.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module MilkTea
-  FunctionBinding = Data.define(:name, :type, :body_params, :body_return_type, :ast, :external, :async, :type_params, :type_param_constraints, :instances, :type_arguments, :owner, :specialization_owner, :type_substitutions, :declared_receiver_type)
+  module Bindings
+    FunctionBinding = Data.define(:name, :type, :body_params, :body_return_type, :ast, :external, :async, :type_params, :type_param_constraints, :instances, :type_arguments, :owner, :specialization_owner, :type_substitutions, :declared_receiver_type)
+  end
 end

data/lib/milk_tea/core/bindings/module_binding.rb

@@ -1,58 +1,60 @@
 # frozen_string_literal: true
 
 module MilkTea
-  ModuleBinding = Data.define(:name, :types, :type_declarations, :interfaces, :attributes, :attribute_applications, :values, :functions, :methods, :implemented_interfaces, :imports, :private_types, :private_interfaces, :private_attributes, :private_values, :private_functions, :private_methods, :private_implemented_interfaces) do
-    def private_type?(name)
-      private_types.key?(name)
-    end
-
-    def private_interface?(name)
-      private_interfaces.key?(name)
-    end
+  module Bindings
+    ModuleBinding = Data.define(:name, :types, :type_declarations, :interfaces, :attributes, :attribute_applications, :values, :functions, :methods, :implemented_interfaces, :imports, :private_types, :private_interfaces, :private_attributes, :private_values, :private_functions, :private_methods, :private_implemented_interfaces) do
+      def private_type?(name)
+        private_types.key?(name)
+      end
 
-    def private_attribute?(name)
-      private_attributes.key?(name)
-    end
+      def private_interface?(name)
+        private_interfaces.key?(name)
+      end
 
-    def private_value?(name)
-      private_values.key?(name)
-    end
+      def private_attribute?(name)
+        private_attributes.key?(name)
+      end
 
-    def private_function?(name)
-      private_functions.key?(name)
-    end
+      def private_value?(name)
+        private_values.key?(name)
+      end
 
-    def private_method?(receiver_type, name)
-      return true if private_methods.fetch(receiver_type, {}).key?(name)
-
-      if receiver_type.is_a?(Types::GenericInstance)
-        dispatch_receiver_type = Types::Registry.generic_instance(
-          receiver_type.name,
-          receiver_type.arguments.each_with_index.map do |argument, index|
-            argument.is_a?(Types::LiteralTypeArg) ? argument : Types::TypeVar.new("__receiver_arg#{index}")
-          end,
-        )
-        return true if dispatch_receiver_type != receiver_type && private_methods.fetch(dispatch_receiver_type, {}).key?(name)
+      def private_function?(name)
+        private_functions.key?(name)
       end
 
-      if receiver_type.is_a?(Types::Nullable)
-        dispatch_base_type = receiver_type.base
-        if dispatch_base_type.is_a?(Types::StructInstance)
-          dispatch_base_type = dispatch_base_type.definition
-        elsif dispatch_base_type.is_a?(Types::GenericInstance)
-          dispatch_base_type = Types::Registry.generic_instance(
-            dispatch_base_type.name,
-            dispatch_base_type.arguments.each_with_index.map do |argument, index|
+      def private_method?(receiver_type, name)
+        return true if private_methods.fetch(receiver_type, {}).key?(name)
+
+        if receiver_type.is_a?(Types::GenericInstance)
+          dispatch_receiver_type = Types::Registry.generic_instance(
+            receiver_type.name,
+            receiver_type.arguments.each_with_index.map do |argument, index|
               argument.is_a?(Types::LiteralTypeArg) ? argument : Types::TypeVar.new("__receiver_arg#{index}")
             end,
           )
+          return true if dispatch_receiver_type != receiver_type && private_methods.fetch(dispatch_receiver_type, {}).key?(name)
         end
 
-        dispatch_receiver_type = Types::Registry.nullable(dispatch_base_type)
-        return true if dispatch_receiver_type != receiver_type && private_methods.fetch(dispatch_receiver_type, {}).key?(name)
-      end
+        if receiver_type.is_a?(Types::Nullable)
+          dispatch_base_type = receiver_type.base
+          if dispatch_base_type.is_a?(Types::StructInstance)
+            dispatch_base_type = dispatch_base_type.definition
+          elsif dispatch_base_type.is_a?(Types::GenericInstance)
+            dispatch_base_type = Types::Registry.generic_instance(
+              dispatch_base_type.name,
+              dispatch_base_type.arguments.each_with_index.map do |argument, index|
+                argument.is_a?(Types::LiteralTypeArg) ? argument : Types::TypeVar.new("__receiver_arg#{index}")
+              end,
+            )
+          end
+
+          dispatch_receiver_type = Types::Registry.nullable(dispatch_base_type)
+          return true if dispatch_receiver_type != receiver_type && private_methods.fetch(dispatch_receiver_type, {}).key?(name)
+        end
 
-      receiver_type.is_a?(Types::StructInstance) && private_methods.fetch(receiver_type.definition, {}).key?(name)
+        receiver_type.is_a?(Types::StructInstance) && private_methods.fetch(receiver_type.definition, {}).key?(name)
+      end
     end
   end
 end

data/lib/milk_tea/core/bindings/value_binding.rb

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 
 module MilkTea
-  ValueBinding = Data.define(:id, :name, :storage_type, :flow_type, :mutable, :kind, :const_value) do
-    def type
-      flow_type || storage_type
-    end
+  module Bindings
+    ValueBinding = Data.define(:id, :name, :storage_type, :flow_type, :mutable, :kind, :const_value) do
+      def type
+        flow_type || storage_type
+      end
 
-    def with_flow_type(refined_type)
-      ValueBinding.new(
-        id:,
-        name:,
-        storage_type:,
-        flow_type: refined_type == storage_type ? nil : refined_type,
-        mutable:,
-        kind:,
-        const_value:,
-      )
+      def with_flow_type(refined_type)
+        ValueBinding.new(
+          id:,
+          name:,
+          storage_type:,
+          flow_type: refined_type == storage_type ? nil : refined_type,
+          mutable:,
+          kind:,
+          const_value:,
+        )
+      end
     end
   end
 end

data/lib/milk_tea/core/bindings.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "flow_scope"
+
 require_relative "bindings/value_binding"
 require_relative "bindings/function_binding"
 require_relative "bindings/module_binding"
 require_relative "bindings/attribute_binding"
 
 module MilkTea
-  class FlowScope
-    def initialize = (@bindings = {})
-    def [](key) = @bindings[key]
-    def []=(key, val); @bindings[key] = val; end
-    def key?(key) = @bindings.key?(key)
-    def empty? = @bindings.empty?
-    def each(&block) = @bindings.each(&block)
-    def each_with_object(init, &block) = @bindings.each_with_object(init, &block)
+  module Bindings
   end
-end
+end

data/lib/milk_tea/core/c_backend/control_flow_emission.rb

@@ -52,26 +52,26 @@ module MilkTea
         end
       end
 
-      def statements_need_explicit_break_label_after_emission?(statements, label_name, loop_break_label_active:)
+      def block_requires_break_label?(statements, label_name, loop_break_label_active:)
         statements.any? do |statement|
-          statement_needs_explicit_break_label_after_emission?(statement, label_name, loop_break_label_active:)
+          statement_requires_break_label?(statement, label_name, loop_break_label_active:)
         end
       end
 
-      def statement_needs_explicit_break_label_after_emission?(statement, label_name, loop_break_label_active:)
+      def statement_requires_break_label?(statement, label_name, loop_break_label_active:)
         case statement
         when IR::BlockStmt, IR::IfStmt
           then_body = statement.is_a?(IR::IfStmt) ? statement.then_body : statement.body
           else_body = statement.is_a?(IR::IfStmt) ? statement.else_body : nil
-          statements_need_explicit_break_label_after_emission?(then_body, label_name, loop_break_label_active:) ||
-            (else_body && statements_need_explicit_break_label_after_emission?(else_body, label_name, loop_break_label_active:))
+          block_requires_break_label?(then_body, label_name, loop_break_label_active:) ||
+            (else_body && block_requires_break_label?(else_body, label_name, loop_break_label_active:))
         when IR::WhileStmt, IR::ForStmt
-          statements_need_explicit_break_label_after_emission?(statement.body, label_name, loop_break_label_active: false)
+          block_requires_break_label?(statement.body, label_name, loop_break_label_active: false)
         when IR::SwitchStmt
           return false unless statement_references_label?(statement, label_name)
 
-          active = loop_break_label_active && switch_emittable_as_if?(statement, loop_break_label: label_name)
-          statements_need_explicit_break_label_after_emission?(
+          active = loop_break_label_active && can_emit_switch_as_if?(statement, loop_break_label: label_name)
+          block_requires_break_label?(
             statement.cases.flat_map(&:body),
             label_name,
             loop_break_label_active: active,
@@ -83,7 +83,7 @@ module MilkTea
         end
       end
 
-      def switch_emittable_as_if?(statement, loop_break_label: nil)
+      def can_emit_switch_as_if?(statement, loop_break_label: nil)
         return false unless loop_break_label
         return false unless statement.exhaustive
         return false unless statement.cases.length == 2
@@ -183,7 +183,7 @@ module MilkTea
         lines = ["#{indent}if (#{emit_expression(statement.condition)}) {"]
         lines.concat(emit_statement_sequence(statement.then_body, level + 1, function:, used_labels:, loop_continue_label:, loop_break_label:))
 
-        nested_else_if = nested_else_if_statement(statement.else_body)
+        nested_else_if = extract_nested_else_if(statement.else_body)
         if nested_else_if
           nested_lines = emit_if_statement(nested_else_if, level, function:, used_labels:, loop_continue_label:, loop_break_label:)
           lines << "#{indent}} else #{nested_lines.first.sub(/^#{Regexp.escape(indent)}/, "") }"
@@ -199,7 +199,7 @@ module MilkTea
         lines
       end
 
-      def nested_else_if_statement(else_body)
+      def extract_nested_else_if(else_body)
         return unless else_body && else_body.length == 1
 
         nested = else_body.first

data/lib/milk_tea/core/c_backend/expressions.rb

@@ -45,7 +45,7 @@ module MilkTea
             "#{expression.operator}#{wrap_expression(expression.operand)}"
           end
         when IR::Binary
-          return emit_str_equality_expression(expression) if str_equality_expression?(expression)
+          return emit_string_equality_expression(expression) if string_equality_expression?(expression)
           return emit_variant_equality_expression(expression) if variant_equality_expression?(expression)
           return emit_nullable_null_comparison(expression) if nullable_null_comparison?(expression)
 
@@ -53,7 +53,7 @@ module MilkTea
         when IR::Conditional
           emit_conditional_expression(expression)
         when IR::ReinterpretExpr
-          if no_op_reinterpret?(expression.target_type, expression.source_type)
+          if identity_reinterpret?(expression.target_type, expression.source_type)
             emit_expression(expression.expression)
           else
             "#{reinterpret_helper_name(expression.target_type, expression.source_type)}(#{emit_expression(expression.expression)})"
@@ -88,7 +88,7 @@ module MilkTea
             emit_address_of_operand(expression.expression)
           end
         when IR::Cast
-          if no_op_cast?(expression)
+          if identity_cast?(expression)
             emit_expression(expression.expression)
           else
             "(#{c_type(expression.target_type)}) #{emit_cast_operand(expression.expression)}"
@@ -106,7 +106,7 @@ module MilkTea
         end
       end
 
-      def str_equality_expression?(expression)
+      def string_equality_expression?(expression)
         EQUALITY_OPERATORS.include?(expression.operator) && expression.left.type.is_a?(Types::StringView) && expression.right.type.is_a?(Types::StringView)
       end
 
@@ -164,7 +164,7 @@ module MilkTea
         end
       end
 
-      def emit_str_equality_expression(expression)
+      def emit_string_equality_expression(expression)
         call = "mt_str_equal(#{emit_expression(expression.left)}, #{emit_expression(expression.right)})"
         expression.operator == "!=" ? "!#{call}" : call
       end
@@ -278,7 +278,7 @@ module MilkTea
         return call unless omit_receiver && expression.arguments.any?
         return call if side_effect_free_expression?(expression.arguments.first)
 
-        "(#{discarded_expression(expression.arguments.first)}, #{call})"
+        "(#{emit_void_expression(expression.arguments.first)}, #{call})"
       end
 
       def emit_array_call_statement(expression, out_argument, indent)
@@ -300,7 +300,7 @@ module MilkTea
         ]
       end
 
-      def emitted_function_params(function)
+      def call_emission_params(function)
         omitted_method_receiver_function?(function) ? function.params.drop(1) : function.params
       end
 
@@ -320,7 +320,7 @@ module MilkTea
           name_reference_count_in_statements(function.body, function.params.first.linkage_name).zero?
       end
 
-      def discarded_expression(expression)
+      def emit_void_expression(expression)
         "(void)#{wrap_expression(expression)}"
       end
 
@@ -411,7 +411,7 @@ module MilkTea
         field_type = aggregate_field_type(type, field.name)
         if field_type.is_a?(Types::Nullable) && !field.value.type.is_a?(Types::Nullable) && !c_backend_pointer_like_type?(field_type.base)
           emit_nullable_some_initializer(field_type, field.value)
-        elsif void_storage_field?(field_type)
+        elsif void_typed_field?(field_type)
           emit_void_field_initializer(field.value)
         else
           emit_initializer(field.value)
@@ -434,7 +434,7 @@ module MilkTea
           emit_cyclic_array_initializer(field_type, field.value)
         elsif aggregate_field_creates_cycle?(field_type, outer_c) && !field_type.is_a?(Types::GenericInstance)
           emit_cyclic_struct_initializer(field_type, field.value)
-        elsif void_storage_field?(field_type)
+        elsif void_typed_field?(field_type)
           emit_void_field_initializer(field.value)
         else
           emit_initializer(field.value)
@@ -469,7 +469,7 @@ module MilkTea
         "(#{emit_expression(expression)}, 0)"
       end
 
-      def void_storage_field?(type)
+      def void_typed_field?(type)
         type.is_a?(Types::Primitive) && type.void?
       end
 

data/lib/milk_tea/core/c_backend/feature_detection.rb

@@ -152,10 +152,6 @@ module MilkTea
         emitted_functions.any? { |function| function_uses_named_call?(function, %w[mt_entry_argv_to_span_str mt_free_entry_argv_strs]) }
       end
 
-      def uses_text_buffer_helpers?
-        uses_str_buffer_helpers?
-      end
-
       def uses_str_buffer_helpers?
         emitted_functions.any? { |function| function_uses_named_call?(function, %w[mt_str_buffer_len mt_str_buffer_as_cstr mt_str_buffer_clear mt_str_buffer_assign mt_str_buffer_append mt_str_buffer_prepare_write]) }
       end
@@ -229,8 +225,8 @@ module MilkTea
         ]
       end
 
-      def used_format_helpers
-        @used_format_helpers ||= begin
+      def required_format_helper_callees
+        @required_format_helper_callees ||= begin
           helpers = {}
 
           emitted_functions.each do |function|
@@ -286,7 +282,7 @@ module MilkTea
       }.freeze
 
       def uses_format_helpers?
-        !used_format_helpers.empty?
+        !required_format_helper_callees.empty?
       end
 
       def uses_str_equality_helper?
@@ -342,29 +338,29 @@ module MilkTea
         function.body.any? { |statement| statement_uses_str_equality?(statement) }
       end
 
-      def any_ir_statement?(statement, expression_pred:, **kwargs)
+      def statement_matches_expression_predicate?(statement, expression_pred:, **kwargs)
         case statement
         when IR::LocalDecl
           statement.value && expression_pred.call(statement.value, **kwargs)
         when IR::Assignment
           expression_pred.call(statement.target, **kwargs) || expression_pred.call(statement.value, **kwargs)
         when IR::BlockStmt
-          statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) }
+          statement.body.any? { |inner| statement_matches_expression_predicate?(inner, expression_pred:, **kwargs) }
         when IR::WhileStmt
           expression_pred.call(statement.condition, **kwargs) ||
-            statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) }
+            statement.body.any? { |inner| statement_matches_expression_predicate?(inner, expression_pred:, **kwargs) }
         when IR::ForStmt
-          any_ir_statement?(statement.init, expression_pred:, **kwargs) ||
+          statement_matches_expression_predicate?(statement.init, expression_pred:, **kwargs) ||
             expression_pred.call(statement.condition, **kwargs) ||
-            statement.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } ||
-            any_ir_statement?(statement.post, expression_pred:, **kwargs)
+            statement.body.any? { |inner| statement_matches_expression_predicate?(inner, expression_pred:, **kwargs) } ||
+            statement_matches_expression_predicate?(statement.post, expression_pred:, **kwargs)
         when IR::IfStmt
           expression_pred.call(statement.condition, **kwargs) ||
-            statement.then_body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } ||
-            (statement.else_body && statement.else_body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) })
+            statement.then_body.any? { |inner| statement_matches_expression_predicate?(inner, expression_pred:, **kwargs) } ||
+            (statement.else_body && statement.else_body.any? { |inner| statement_matches_expression_predicate?(inner, expression_pred:, **kwargs) })
         when IR::SwitchStmt
           expression_pred.call(statement.expression, **kwargs) ||
-            statement.cases.any? { |switch_case| switch_case.body.any? { |inner| any_ir_statement?(inner, expression_pred:, **kwargs) } }
+            statement.cases.any? { |switch_case| switch_case.body.any? { |inner| statement_matches_expression_predicate?(inner, expression_pred:, **kwargs) } }
         when IR::StaticAssert
           expression_pred.call(statement.condition, **kwargs) || expression_pred.call(statement.message, **kwargs)
         when IR::ReturnStmt
@@ -377,11 +373,11 @@ module MilkTea
       end
 
       def statement_uses_named_call?(statement, callees)
-        any_ir_statement?(statement, expression_pred: ->(e) { expression_uses_named_call?(e, callees) })
+        statement_matches_expression_predicate?(statement, expression_pred: ->(e) { expression_uses_named_call?(e, callees) })
       end
 
       def statement_uses_str_equality?(statement)
-        any_ir_statement?(statement, expression_pred: ->(e) { expression_uses_str_equality?(e) })
+        statement_matches_expression_predicate?(statement, expression_pred: ->(e) { expression_uses_str_equality?(e) })
       end
 
       def expression_uses_named_call?(expression, callees)
@@ -416,7 +412,7 @@ module MilkTea
       def expression_uses_str_equality?(expression)
         case expression
         when IR::Binary
-          str_equality_expression?(expression) || expression_uses_str_equality?(expression.left) || expression_uses_str_equality?(expression.right)
+          string_equality_expression?(expression) || expression_uses_str_equality?(expression.left) || expression_uses_str_equality?(expression.right)
         when IR::Call
           (!expression.callee.is_a?(String) && expression_uses_str_equality?(expression.callee)) || expression.arguments.any? { |argument| expression_uses_str_equality?(argument) }
         when IR::Member

data/lib/milk_tea/core/c_backend/format_helpers.rb

@@ -4,7 +4,7 @@ module MilkTea
   class CBackend
     module FormatHelpers
       def emit_format_helpers
-        helpers = used_format_helpers
+        helpers = required_format_helper_callees
         lines = []
 
         if helpers['mt_format_str_make']

data/lib/milk_tea/core/c_backend/reinterpret.rb

@@ -72,7 +72,7 @@ module MilkTea
           collect_reinterpret_helpers_from_expression(expression.then_expression, helpers, seen)
           collect_reinterpret_helpers_from_expression(expression.else_expression, helpers, seen)
         when IR::ReinterpretExpr
-          return if no_op_reinterpret?(expression.target_type, expression.source_type)
+          return if identity_reinterpret?(expression.target_type, expression.source_type)
 
           key = [expression.target_type, expression.source_type]
           unless seen[key]
@@ -112,7 +112,7 @@ module MilkTea
         "mt_reinterpret_#{sanitize_identifier(target_type.to_s)}_from_#{sanitize_identifier(source_type.to_s)}"
       end
 
-      def no_op_cast?(expression)
+      def identity_cast?(expression)
         return false if expression.expression.type.is_a?(Types::Null)
 
         c_type(expression.target_type) == c_type(expression.expression.type)
@@ -120,37 +120,37 @@ module MilkTea
         false
       end
 
-      def no_op_reinterpret?(target_type, source_type)
+      def identity_reinterpret?(target_type, source_type)
         c_type(target_type) == c_type(source_type)
       rescue StandardError
         false
       end
 
       def checked_array_index_helper_name(type)
-        return "mt_checked_index_array_#{sanitize_identifier(c_declaration(array_element_type(type), 'value'))}_#{array_length(type)}" if array_type?(type) && callable_container_element_type?(array_element_type(type))
+        return "mt_checked_index_array_#{sanitize_identifier(c_declaration(array_element_type(type), 'value'))}_#{array_length(type)}" if array_type?(type) && function_or_proc_element_type?(array_element_type(type))
 
         "mt_checked_index_#{sanitize_identifier(type.to_s)}"
       end
 
       def checked_span_index_helper_name(type)
-        return "mt_checked_span_index_#{sanitize_identifier(c_declaration(type.element_type, 'value'))}" if callable_container_element_type?(type.element_type)
+        return "mt_checked_span_index_#{sanitize_identifier(c_declaration(type.element_type, 'value'))}" if function_or_proc_element_type?(type.element_type)
 
         "mt_checked_span_index_#{sanitize_identifier(type.to_s)}"
       end
 
       def nullable_array_index_helper_name(type)
-        return "mt_nullable_index_array_#{sanitize_identifier(c_declaration(array_element_type(type), 'value'))}_#{array_length(type)}" if array_type?(type) && callable_container_element_type?(array_element_type(type))
+        return "mt_nullable_index_array_#{sanitize_identifier(c_declaration(array_element_type(type), 'value'))}_#{array_length(type)}" if array_type?(type) && function_or_proc_element_type?(array_element_type(type))
 
         "mt_nullable_index_#{sanitize_identifier(type.to_s)}"
       end
 
       def nullable_span_index_helper_name(type)
-        return "mt_nullable_span_index_#{sanitize_identifier(c_declaration(type.element_type, 'value'))}" if callable_container_element_type?(type.element_type)
+        return "mt_nullable_span_index_#{sanitize_identifier(c_declaration(type.element_type, 'value'))}" if function_or_proc_element_type?(type.element_type)
 
         "mt_nullable_span_index_#{sanitize_identifier(type.to_s)}"
       end
 
-      def callable_container_element_type?(type)
+      def function_or_proc_element_type?(type)
         type.is_a?(Types::Function) || type.is_a?(Types::Proc)
       end
 
@@ -184,7 +184,7 @@ module MilkTea
         end
 
         (expression.is_a?(IR::Name) && expression.pointer) ||
-          (expression.respond_to?(:type) && (raw_pointer_type?(expression.type) || ref_type?(expression.type) || nullable_pointer_like_ir_type?(expression.type)))
+          (expression.respond_to?(:type) && (raw_pointer_type?(expression.type) || ref_type?(expression.type) || nullable_pointer_like_type?(expression.type)))
       end
 
       def variant_arm_payload_field_type(member_expr)
@@ -196,7 +196,7 @@ module MilkTea
         variant_type.arm(arm_name)&.fetch(member_expr.member)
       end
 
-      def nullable_pointer_like_ir_type?(type)
+      def nullable_pointer_like_type?(type)
         return false unless type.is_a?(Types::Nullable)
 
         c_backend_pointer_like_type?(type.base)