konpeito 0.2.2 → 0.2.3

data/lib/konpeito/codegen/llvm_generator.rb

@@ -56,7 +56,7 @@ module Konpeito
         end
       end
 
-      attr_reader :profiler, :variadic_functions
+      attr_reader :profiler, :variadic_functions, :alias_renamed_methods
 
       def generate(hir_program)
         @hir_program = hir_program
@@ -83,16 +83,23 @@ module Konpeito
         # Scan HIR to register NativeClassTypes before code generation
         scan_for_native_class_types(hir_program)
 
+        # Pre-scan: detect parameters that can receive nil at call sites
+        @nil_possible_params = scan_nil_possible_params(hir_program)
+
         # Generate vtables for classes that use them
         generate_vtables
 
+        # Deduplicate functions: when a method is redefined (def speak ... def speak),
+        # keep only the last definition to avoid LLVM name collisions (.1 suffix)
+        functions = deduplicate_functions(hir_program.functions)
+
         # First pass: declare all functions (needed for forward references / monomorphization)
-        hir_program.functions.each do |func|
+        functions.each do |func|
           declare_function(func)
         end
 
         # Second pass: generate code for each function
-        hir_program.functions.each do |func|
+        functions.each do |func|
           generate_function_body(func)
         end
 
@@ -104,6 +111,38 @@ module Konpeito
         @mod
       end
 
+      # Remove earlier definitions when a method is redefined in the same class.
+      # Keeps the last definition (which is the override).
+      def deduplicate_functions(functions)
+        # Build alias map: method_name -> [alias_names] per class
+        alias_targets = {}  # "ClassName#method_name" -> true (method is aliased)
+        @hir_program.classes.each do |cd|
+          (cd.aliases || []).each do |new_name, old_name|
+            alias_targets["#{cd.name}##{old_name}"] = true
+          end
+        end
+
+        seen = {}
+        @alias_renamed_methods = {}  # "ClassName#old_name" -> renamed_func_name
+
+        functions.each_with_index do |func, i|
+          key = [func.owner_class, func.owner_module, func.name.to_s, func.class_method?]
+          if seen.key?(key) && alias_targets["#{func.owner_class}##{func.name}"]
+            # This method was aliased and is now being redefined.
+            # Rename the earlier definition so the alias can point to it.
+            old_idx = seen[key]
+            old_func = functions[old_idx]
+            renamed = "#{old_func.name}$alias_orig"
+            @alias_renamed_methods["#{func.owner_class}##{func.name}"] = renamed
+            # Create a copy of the old function with the renamed name
+            old_func.instance_variable_set(:@name, renamed.to_sym)
+          end
+          seen[key] = i
+        end
+        # Keep all functions (including renamed originals)
+        functions
+      end
+
       # Declare a function (create LLVM function without body)
       def declare_function(hir_func)
         native_class_type = detect_native_class_for_function(hir_func)
@@ -158,8 +197,8 @@ module Konpeito
 
       # Declare a standard Ruby function signature
       def declare_ruby_function(hir_func)
-        # Count regular parameters (non-keyword, non-keyword_rest, non-rest)
-        regular_params = hir_func.params.reject { |p| p.keyword || p.keyword_rest || p.rest }
+        # Count regular parameters (non-keyword, non-keyword_rest, non-rest, non-block)
+        regular_params = hir_func.params.reject { |p| p.keyword || p.keyword_rest || p.rest || p.block }
         keyword_params = hir_func.params.select(&:keyword)
         keyword_rest_param = hir_func.params.find(&:keyword_rest)
         rest_param = hir_func.params.find(&:rest)
@@ -234,6 +273,53 @@ module Konpeito
         end
       end
 
+      # Pre-scan all HIR functions to detect parameters that can receive nil at call sites.
+      # Returns a Hash: { "ClassName#method_name" => Set[param_index], ... }
+      # so codegen can keep those parameters as VALUE type (not unboxed).
+      def scan_nil_possible_params(hir_program)
+        # Build function index: function_name → HIR::Function (for param count)
+        func_index = {}
+        hir_program.functions.each do |func|
+          key = func.owner_class ? "#{func.owner_class}##{func.name}" : func.name
+          func_index[key] = func
+        end
+
+        nil_params = {}  # "ClassName#method" => Set[param_index]
+
+        hir_program.functions.each do |func|
+          func.body.each do |block|
+            block.instructions.each do |inst|
+              next unless inst.is_a?(HIR::Call)
+
+              # Detect ClassName.new(nil, ...) → maps to ClassName#initialize
+              target_key = nil
+              if inst.method_name == "new" && inst.receiver.is_a?(HIR::ConstantLookup)
+                class_name = inst.receiver.name.to_s
+                target_key = "#{class_name}#initialize"
+              elsif inst.receiver.is_a?(HIR::SelfRef) || inst.receiver.nil?
+                # Self call or bare function call
+                if func.owner_class
+                  target_key = "#{func.owner_class}##{inst.method_name}"
+                else
+                  target_key = inst.method_name
+                end
+              end
+
+              next unless target_key
+
+              inst.args.each_with_index do |arg, i|
+                if arg.is_a?(HIR::NilLit)
+                  nil_params[target_key] ||= Set.new
+                  nil_params[target_key] << i
+                end
+              end
+            end
+          end
+        end
+
+        nil_params
+      end
+
       # Auto-generate NativeClassType from HM-inferred ivar types (RBS-free classes)
       def auto_generate_native_class_types(hir_program)
         hir_program.classes.each do |class_def|
@@ -567,8 +653,8 @@ module Konpeito
         # void rb_cvar_set(VALUE klass, ID id, VALUE val)
         @rb_cvar_set = @mod.functions.add("rb_cvar_set", [value_type, id_type, value_type], LLVM.Void)
 
-        # VALUE rb_class_of(VALUE obj) - get class of object
-        @rb_class_of = @mod.functions.add("rb_class_of", [value_type], value_type)
+        # VALUE rb_obj_class(VALUE obj) - get class of object (exported C API)
+        @rb_obj_class = @mod.functions.add("rb_obj_class", [value_type], value_type)
 
         # Block/Yield functions
         # VALUE rb_yield(VALUE val) - yield with single value
@@ -581,6 +667,9 @@ module Konpeito
         # int rb_block_given_p(void) - check if block is given
         @rb_block_given_p = @mod.functions.add("rb_block_given_p", [], LLVM::Int32)
 
+        # VALUE rb_block_proc(void) - capture the current block as a Proc object
+        @rb_block_proc = @mod.functions.add("rb_block_proc", [], value_type)
+
         # rb_block_call - call method with block callback
         # VALUE rb_block_call(VALUE obj, ID mid, int argc, const VALUE *argv,
         #                     rb_block_call_func_t proc, VALUE data2)
@@ -1048,10 +1137,11 @@ module Konpeito
           @variable_types[var_name] = type_tag
         end
 
-        # Separate regular, keyword, and keyword_rest parameters
-        regular_params = hir_func.params.reject { |p| p.keyword || p.keyword_rest || p.rest }
+        # Separate regular, keyword, keyword_rest, and block parameters
+        regular_params = hir_func.params.reject { |p| p.keyword || p.keyword_rest || p.rest || p.block }
         keyword_params = hir_func.params.select(&:keyword)
         keyword_rest_param = hir_func.params.find(&:keyword_rest)
+        block_param = hir_func.params.find(&:block)
 
         # Check if this is a variadic function
         variadic_info = @variadic_functions[mangled]
@@ -1341,6 +1431,36 @@ module Konpeito
           end
         end  # End of variadic_info else block
 
+        # Handle &blk block parameter: capture the current block as a Proc
+        if block_param
+          alloca = @variable_allocas[block_param.name]
+          if alloca
+            # Use rb_block_given_p to check, then rb_block_proc to capture
+            current_func = @builder.insert_block.parent
+            has_block_bb = current_func.basic_blocks.append("has_block_param")
+            no_block_bb = current_func.basic_blocks.append("no_block_param")
+            block_param_continue = current_func.basic_blocks.append("block_param_continue")
+
+            given = @builder.call(@rb_block_given_p)
+            is_given = @builder.icmp(:ne, given, LLVM::Int32.from_i(0))
+            @builder.cond(is_given, has_block_bb, no_block_bb)
+
+            @builder.position_at_end(has_block_bb)
+            proc_val = @builder.call(@rb_block_proc)
+            @builder.br(block_param_continue)
+
+            @builder.position_at_end(no_block_bb)
+            @builder.br(block_param_continue)
+
+            @builder.position_at_end(block_param_continue)
+            block_value = @builder.phi(value_type, { has_block_bb => proc_val, no_block_bb => @qnil })
+            @builder.store(block_value, alloca)
+
+            # Remap entry block since we created new basic blocks
+            @blocks[hir_func.body.first.label] = block_param_continue
+          end
+        end
+
         # Insert profiling entry probe after parameter setup
         insert_profile_entry_probe(hir_func)
 
@@ -1435,9 +1555,18 @@ module Konpeito
       def collect_local_variables_with_types(hir_func)
         vars = {}
 
+        # Build function key for nil-possible param lookup
+        func_key = hir_func.owner_class ? "#{hir_func.owner_class}##{hir_func.name}" : hir_func.name
+        nil_param_indices = @nil_possible_params&.[](func_key)
+
         # Add parameters with their types
-        hir_func.params.each do |p|
-          vars[p.name] = p.type
+        hir_func.params.each_with_index do |p, i|
+          if nil_param_indices&.include?(i)
+            # Parameter can receive nil at some call site — force VALUE type
+            vars[p.name] = TypeChecker::Types::UNTYPED
+          else
+            vars[p.name] = p.type
+          end
         end
 
         # First pass: collect temp vars that come from safe navigation calls
@@ -1897,6 +2026,8 @@ module Konpeito
           generate_super_call(inst)
         when HIR::MultiWriteExtract
           generate_multi_write_extract(inst)
+        when HIR::MultiWriteSplat
+          generate_multi_write_splat(inst)
         else
           # Unknown instruction, store nil
           if inst.result_var
@@ -2215,7 +2346,7 @@ module Konpeito
           when :i8 then LLVM::Int8
           else value_type
           end
-          @builder.load2(llvm_type, alloca, var_name)
+          @builder.load2(llvm_type, alloca, "#{var_name}_val")
         else
           @variables[var_name] || @qnil
         end
@@ -2457,6 +2588,13 @@ module Konpeito
             type_tag = @variable_types[var_name] || :value
             [value, type_tag]
           end
+        when HIR::SelfRef
+          # SelfRef may not have a result_var (e.g. implicit self in method calls)
+          if hir_value.result_var && @variables.key?(hir_value.result_var)
+            [@variables[hir_value.result_var], @variable_types[hir_value.result_var] || :value]
+          else
+            [get_self_value, :value]
+          end
         when HIR::Instruction
           if hir_value.result_var
             # Check if instruction was already generated
@@ -2717,7 +2855,7 @@ module Konpeito
         elsif @current_hir_func&.owner_class
           # For instance methods, get the class from self using rb_class_of
           self_value = get_self_value
-          @builder.call(@rb_class_of, self_value)
+          @builder.call(@rb_obj_class, self_value)
         else
           # Top-level: use rb_cObject (need to load the global)
           @builder.load2(value_type, @rb_cObject, "rb_cObject")
@@ -2995,7 +3133,6 @@ module Konpeito
           if arg.is_a?(HIR::SplatArg)
             # Concat the splat array into the args array
             splat_value = get_value_as_ruby(arg.expression)
-            # Convert to array if not already (rb_ary_to_ary)
             @builder.call(@rb_ary_concat, args_array, splat_value)
           else
             # Push regular arg
@@ -3234,9 +3371,14 @@ module Konpeito
           # Bool can be either TrueClass or FalseClass; return TrueClass as representative
           @builder.load2(value_type, @rb_cTrueClass, "rb_cTrueClass")
         else
-          # For other types, use rb_path2class
-          type_ptr = @builder.global_string_pointer(type_str)
-          @builder.call(@rb_path2class, type_ptr)
+          # Skip unresolved RBS type parameters (Elem, K, V, etc.) — return rb_cObject as fallback
+          if type_str.match?(/\A[A-Z][a-z]*\z/) && %w[Elem K V U T S R E A B C D N M].include?(type_str)
+            @builder.load2(value_type, @rb_cObject, "rb_cObject")
+          else
+            # For other types, use rb_path2class
+            type_ptr = @builder.global_string_pointer(type_str)
+            @builder.call(@rb_path2class, type_ptr)
+          end
         end
       end
 
@@ -3668,9 +3810,21 @@ module Konpeito
 
         # Generate block body instructions
         body_result = nil
+        body_result_type = :value
+        last_body_inst = nil
         block.body.each do |basic_block|
           basic_block.instructions.each do |body_inst|
             body_result = generate_instruction(body_inst)
+            last_body_inst = body_inst
+          end
+        end
+
+        # Determine the type tag of the block body result
+        if last_body_inst
+          if last_body_inst.respond_to?(:result_var) && last_body_inst.result_var
+            body_result_type = @variable_types[last_body_inst.result_var] || :value
+          elsif last_body_inst.is_a?(HIR::StoreLocal)
+            body_result_type = @variable_types[last_body_inst.var.name] || :value
           end
         end
 
@@ -3682,16 +3836,13 @@ module Konpeito
         # Handle result based on method type
         case method_sym
         when :map, :collect
-          # Push block result to result array (box if unboxed)
+          # Push block result to result array (box if needed)
+          # Only re-box if the result is actually unboxed (not a VALUE from a method call)
           mapped_val = if body_result
-            if use_unboxed && body_result.is_a?(LLVM::Value)
-              if body_result.type == LLVM::Int64
-                @builder.call(@rb_int2inum, body_result)
-              elsif body_result.type == LLVM::Double
-                @builder.call(@rb_float_new, body_result)
-              else
-                ensure_ruby_value(body_result)
-              end
+            if body_result_type == :i64 && body_result.is_a?(LLVM::Value)
+              @builder.call(@rb_int2inum, body_result)
+            elsif body_result_type == :double && body_result.is_a?(LLVM::Value)
+              @builder.call(@rb_float_new, body_result)
             else
               ensure_ruby_value(body_result)
             end
@@ -4261,6 +4412,10 @@ module Konpeito
         #   - If argc < params.size: destructure yielded_arg with rb_ary_entry (e.g., Hash#each yields [k,v] pair)
         if block_def.params.size == 1
           param_name = block_def.params.first.name
+          # Create alloca for single parameter (needed for method calls like it.to_s)
+          param_alloca = @builder.alloca(value_type, "#{param_name}_alloca")
+          @builder.store(callback_func.params[0], param_alloca)
+          @variable_allocas[param_name] = param_alloca
           @variables[param_name] = callback_func.params[0]  # yielded_arg
           @variable_types[param_name] = :value
         elsif block_def.params.size > 1
@@ -4807,10 +4962,12 @@ module Konpeito
         saved_vars = @variables.dup
         saved_types = @variable_types.dup
         saved_allocas = @variable_allocas.dup
+        saved_current_function = @current_function
 
         # Create entry block for callback
         entry = callback_func.basic_blocks.append("entry")
         @builder.position_at_end(entry)
+        @current_function = callback_func
 
         # Reset variable tracking for callback scope
         @variables = {}
@@ -4872,6 +5029,7 @@ module Konpeito
         @variables = saved_vars
         @variable_types = saved_types
         @variable_allocas = saved_allocas
+        @current_function = saved_current_function
 
         callback_func
       end
@@ -6593,16 +6751,39 @@ module Konpeito
           return result
         end
 
-        # Look up a constant (typically a class name)
-        # Use rb_const_get(rb_cObject, rb_intern(name))
-        const_name_ptr = @builder.global_string_pointer(inst.name)
-        const_id = @builder.call(@rb_intern, const_name_ptr)
-
-        # Load rb_cObject (for top-level constants)
-        rb_cobject_val = @builder.load2(value_type, @rb_cObject, "rb_cObject")
-
-        # Look up the constant
-        result = @builder.call(@rb_const_get, rb_cobject_val, const_id)
+        parts = inst.name.to_s.split("::")
+
+        if parts.size > 1
+          # Qualified constant path (e.g., CoMath::PI, Foo::Bar::BAZ)
+          # Chain rb_const_get calls: rb_const_get(rb_const_get(rb_cObject, "CoMath"), "PI")
+          scope = @builder.load2(value_type, @rb_cObject, "rb_cObject")
+          parts.each do |part|
+            part_ptr = @builder.global_string_pointer(part)
+            part_id = @builder.call(@rb_intern, part_ptr)
+            scope = @builder.call(@rb_const_get, scope, part_id)
+          end
+          result = scope
+        else
+          # Unqualified constant - search current class/module first, then Object
+          const_name = parts.first
+          owner_class = @current_hir_func&.owner_class || @current_hir_func&.owner_module
+          if owner_class
+            # Look up constant in the owning class/module
+            owner_ptr = @builder.global_string_pointer(owner_class)
+            owner_id = @builder.call(@rb_intern, owner_ptr)
+            rb_cobject_val = @builder.load2(value_type, @rb_cObject, "rb_cObject")
+            owner_value = @builder.call(@rb_const_get, rb_cobject_val, owner_id)
+            const_name_ptr = @builder.global_string_pointer(const_name)
+            const_id = @builder.call(@rb_intern, const_name_ptr)
+            result = @builder.call(@rb_const_get, owner_value, const_id)
+          else
+            # Top-level constant
+            const_name_ptr = @builder.global_string_pointer(const_name)
+            const_id = @builder.call(@rb_intern, const_name_ptr)
+            rb_cobject_val = @builder.load2(value_type, @rb_cObject, "rb_cObject")
+            result = @builder.call(@rb_const_get, rb_cobject_val, const_id)
+          end
+        end
 
         if inst.result_var
           @variables[inst.result_var] = result
@@ -6659,6 +6840,65 @@ module Konpeito
         result
       end
 
+      # Multi-write splat extraction: *rest = arr[start..-(end_offset+1)]
+      # Collects a sub-array from the source array
+      def generate_multi_write_splat(inst)
+        array_val = get_value_as_ruby(inst.array)
+
+        # Get array length via rb_funcallv("length")
+        len_id = @builder.call(@rb_intern, @builder.global_string_pointer("length"))
+        arr_len_val = @builder.call(@rb_funcallv, array_val, len_id, LLVM::Int.from_i(0), LLVM::Pointer(LLVM::Int64).null_pointer)
+        arr_len = @builder.call(@rb_num2long, arr_len_val)
+
+        start_idx = LLVM::Int64.from_i(inst.start_index)
+        end_off = LLVM::Int64.from_i(inst.end_offset)
+
+        # splat_len = max(0, arr_len - start_index - end_offset)
+        splat_len = @builder.sub(arr_len, start_idx)
+        splat_len = @builder.sub(splat_len, end_off)
+        zero = LLVM::Int64.from_i(0)
+        is_negative = @builder.icmp(:slt, splat_len, zero)
+        splat_len = @builder.select(is_negative, zero, splat_len)
+
+        # Create new array: rb_ary_new_capa(splat_len)
+        result_arr = @builder.call(@rb_ary_new_capa, splat_len)
+
+        # Loop: for i = 0; i < splat_len; i++ { rb_ary_push(result, rb_ary_entry(arr, start + i)) }
+        func = @builder.insert_block.parent
+        loop_bb = func.basic_blocks.append("splat_loop")
+        body_bb = func.basic_blocks.append("splat_body")
+        done_bb = func.basic_blocks.append("splat_done")
+
+        # alloca for loop counter
+        counter_alloca = @builder.alloca(LLVM::Int64, "splat_i")
+        @builder.store(zero, counter_alloca)
+        @builder.br(loop_bb)
+
+        # Loop condition
+        @builder.position_at_end(loop_bb)
+        counter = @builder.load2(LLVM::Int64, counter_alloca, "splat_counter")
+        cond = @builder.icmp(:slt, counter, splat_len)
+        @builder.cond(cond, body_bb, done_bb)
+
+        # Loop body
+        @builder.position_at_end(body_bb)
+        idx = @builder.add(start_idx, counter)
+        elem = @builder.call(@rb_ary_entry, array_val, idx)
+        @builder.call(@rb_ary_push, result_arr, elem)
+        next_counter = @builder.add(counter, LLVM::Int64.from_i(1))
+        @builder.store(next_counter, counter_alloca)
+        @builder.br(loop_bb)
+
+        # Done
+        @builder.position_at_end(done_bb)
+
+        if inst.result_var
+          @variables[inst.result_var] = result_arr
+          @variable_types[inst.result_var] = :value
+        end
+        result_arr
+      end
+
       # Generate defined? check
       def generate_defined_check(inst)
         func = @builder.insert_block.parent
@@ -6670,16 +6910,56 @@ module Konpeito
           result = @builder.call(@rb_str_new_cstr, str_ptr)
         when :constant
           # Use rb_const_defined to check at runtime
+          # Handle path-style names like "CoMath::PI" by resolving each component
           rb_const_defined = @mod.functions["rb_const_defined"] || @mod.functions.add(
             "rb_const_defined",
             [value_type, value_type],
             LLVM::Int32
           )
-          rb_cobject_val = @builder.load2(value_type, @rb_cObject, "rb_cObject")
-          name_ptr = @builder.global_string_pointer(inst.name)
-          name_id = @builder.call(@rb_intern, name_ptr)
-          is_defined = @builder.call(rb_const_defined, rb_cobject_val, name_id)
-          is_true = @builder.icmp(:ne, is_defined, LLVM::Int32.from_i(0))
+
+          parts = inst.name.split("::")
+          current_mod = @builder.load2(value_type, @rb_cObject, "rb_cObject")
+
+          if parts.size == 1
+            # Simple constant: defined?(FOO)
+            name_ptr = @builder.global_string_pointer(parts[0])
+            name_id = @builder.call(@rb_intern, name_ptr)
+            is_defined = @builder.call(rb_const_defined, current_mod, name_id)
+            is_true = @builder.icmp(:ne, is_defined, LLVM::Int32.from_i(0))
+          else
+            # Path constant: defined?(Foo::Bar::BAZ)
+            # Check each component exists, then resolve all but last, check last
+            # For simplicity, check all components exist then return "constant"
+            all_ok = nil
+            parts.each_with_index do |part, i|
+              name_ptr = @builder.global_string_pointer(part)
+              name_id = @builder.call(@rb_intern, name_ptr)
+              check = @builder.call(rb_const_defined, current_mod, name_id)
+              check_bool = @builder.icmp(:ne, check, LLVM::Int32.from_i(0))
+
+              if i < parts.size - 1
+                # Resolve intermediate module (only if defined)
+                # Use rb_const_get to get the module for the next lookup
+                resolve_bb = func.basic_blocks.append("resolve_#{part}")
+                fail_bb = func.basic_blocks.append("fail_#{part}")
+                @builder.cond(check_bool, resolve_bb, fail_bb)
+
+                @builder.position_at_end(resolve_bb)
+                current_mod = @builder.call(@rb_const_get, current_mod, name_id)
+
+                # We'll merge fail paths at the end
+                if all_ok.nil?
+                  all_ok = { fail_bbs: [fail_bb] }
+                else
+                  all_ok[:fail_bbs] << fail_bb
+                end
+              else
+                # Last component: just check if defined
+                all_ok ||= { fail_bbs: [] }
+                is_true = check_bool
+              end
+            end
+          end
 
           defined_bb = func.basic_blocks.append("defined_yes")
           undefined_bb = func.basic_blocks.append("defined_no")
@@ -6692,11 +6972,22 @@ module Konpeito
           defined_val = @builder.call(@rb_str_new_cstr, str_ptr)
           @builder.br(merge_bb)
 
+          # All fail paths (intermediate components not found) go to undefined
           @builder.position_at_end(undefined_bb)
           @builder.br(merge_bb)
+          if all_ok && all_ok[:fail_bbs]
+            all_ok[:fail_bbs].each do |fail_bb|
+              @builder.position_at_end(fail_bb)
+              @builder.br(merge_bb)
+            end
+          end
 
           @builder.position_at_end(merge_bb)
-          result = @builder.phi(value_type, { defined_bb => defined_val, undefined_bb => @qnil })
+          phi_incoming = { defined_bb => defined_val, undefined_bb => @qnil }
+          if all_ok && all_ok[:fail_bbs]
+            all_ok[:fail_bbs].each { |fb| phi_incoming[fb] = @qnil }
+          end
+          result = @builder.phi(value_type, phi_incoming)
         when :method
           # Use rb_respond_to to check if method exists
           rb_respond_to = @mod.functions["rb_respond_to"] || @mod.functions.add(
@@ -6705,9 +6996,7 @@ module Konpeito
             LLVM::Int32
           )
           # Check on main object (self)
-          self_val = @variables["self"] || @builder.call(@rb_funcallv, @rb_cObject,
-            @builder.call(@rb_intern, @builder.global_string_pointer("new")),
-            LLVM::Int32.from_i(0), LLVM::Pointer(value_type).null)
+          self_val = @variables["self"] || @builder.load2(value_type, @rb_cObject, "rb_cObject_self")
           name_ptr = @builder.global_string_pointer(inst.name)
           name_id = @builder.call(@rb_intern, name_ptr)
           is_defined = @builder.call(rb_respond_to, self_val, name_id)

data/lib/konpeito/codegen/monomorphizer.rb

@@ -194,8 +194,10 @@ module Konpeito
         skip_functions.merge(detect_nil_compared_functions)
 
         grouped.each do |(func_name, types), sites|
-          next if types.all? { |t| t == TypeChecker::Types::UNTYPED }
+          next if types.any? { |t| t == TypeChecker::Types::UNTYPED || t.is_a?(TypeChecker::Types::Untyped) }
           next if skip_functions.include?(func_name.to_s)
+          # Skip if any type is an unresolved RBS type parameter (Elem, K, V, etc.)
+          next if types.any? { |t| t.is_a?(TypeChecker::Types::ClassInstance) && RBS_TYPE_PARAMS.include?(t.name) }
 
           type_suffix = types.map { |t| type_to_suffix(t) }.join("_")
           specialized = "#{func_name}_#{type_suffix}"
@@ -326,10 +328,20 @@ module Konpeito
         end
       end
 
+      # RBS type parameter names that should not be used as monomorphized suffixes
+      # These are unresolved generic type variables, not concrete Ruby classes
+      RBS_TYPE_PARAMS = Set.new(%w[Elem K V U T S R E A B C D N M].map(&:to_sym)).freeze
+
       def type_to_suffix(type)
         case type
         when TypeChecker::Types::ClassInstance
-          type.name.to_s
+          # If the type name is an unresolved RBS type parameter (Elem, K, V, etc.),
+          # treat it as untyped to avoid generating rb_const_get("Elem") at runtime
+          if RBS_TYPE_PARAMS.include?(type.name)
+            "Any"
+          else
+            type.name.to_s
+          end
         when TypeChecker::Types::NilType
           "Nil"
         when TypeChecker::Types::BoolType