konpeito 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85de87c8abf1bbf3ecaf6303ba4fd875f16016099a38734c55c108f123fa4086
-  data.tar.gz: 843f4b6d722d68526d031734c035c9126c520d9869a2488259dbf39ce1eade84
+  metadata.gz: 9b3a19c0259a27b1d396334b57f827f784b5aeebe022d714fb68a5b8e40537f8
+  data.tar.gz: a248d9e0166ef1643bb5e0a15922432cdcbd7c6758dcc6c97aa1ecebd36c48a2
 SHA512:
-  metadata.gz: eaf22b341a9135b2d81fcda350790330a78f2da9255771833676047086fbcd861919295f8cf7f4967f380cc62c8ea882499cd6b89a863b86bbd1c53e6e6f2b9e
-  data.tar.gz: ab456db3432eca45ff8b658b80c07d38cdbec33c1e4cd6e379d59dbb0cf8f3384b6f715b3bac61f7d120dfb25e479fe86b65dc4c44ad5c7e86ab18703ff6e6a9
+  metadata.gz: 5c8ea1d3161e5173f30714897b5921faa0c9aa330e65e0ad7188ac166d730a6f35ff0ee3239ce010b4c33904b0dcd60370545bf37fe33279617688c1051e609e
+  data.tar.gz: 83a0fee1954e7cb1870f378ddb0031ce9885183688b23f1782f20770252e12176ed2255da83deda37bd1411fe64fc137835eb8f78ecc5ad20d603558d8de0c08

data/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to Konpeito will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.1] - 2026-02-20
+
+### Added
+- Conformance test framework (`spec/conformance/`) for verifying LLVM and JVM backend output against CRuby reference
+
+### Fixed
+- Code generation: if/unless truthiness evaluation for non-boolean values (phi type mixing)
+- Code generation: method argument count mismatch in certain call patterns
+- Code generation: block yield / `block_given?` interaction with monomorphizer inconsistent call sites
+
 ## [0.2.0] - 2026-02-19
 
 ### Added
@@ -121,6 +131,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `%a{extern}` - external C struct wrappers
 - `%a{simd}` - SIMD vectorization
 
+[0.2.1]: https://github.com/i2y/konpeito/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/i2y/konpeito/compare/v0.1.3...v0.2.0
 [0.1.3]: https://github.com/i2y/konpeito/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/i2y/konpeito/compare/v0.1.1...v0.1.2

data/Rakefile

@@ -8,4 +8,19 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
+desc "Run conformance tests against Ruby/Native/JVM backends"
+task :conformance do
+  ruby "spec/conformance/runner.rb", *ARGV.drop_while { |a| a != "--" }.drop(1)
+end
+
+desc "Run conformance tests (native backend only)"
+task "conformance:native" do
+  ruby "spec/conformance/runner.rb", "--native-only"
+end
+
+desc "Run conformance tests (JVM backend only)"
+task "conformance:jvm" do
+  ruby "spec/conformance/runner.rb", "--jvm-only"
+end
+
 task default: :test

data/lib/konpeito/codegen/inliner.rb

@@ -176,6 +176,10 @@ module Konpeito
         callee.params.each_with_index do |param, i|
           if call_inst.args[i]
             param_map[param.name] = call_inst.args[i]
+          elsif param.default_value
+            # Use the default value for missing optional args
+            default_hir = prism_to_hir_literal(param.default_value)
+            param_map[param.name] = default_hir if default_hir
           end
         end
         # Also map keyword arguments by name
@@ -224,6 +228,33 @@ module Konpeito
         result_instructions
       end
 
+      # Convert a Prism AST default value node to an HIR literal node.
+      # Assigns a result_var so the LLVM generator can generate it properly.
+      def prism_to_hir_literal(prism_node)
+        @default_var_counter ||= 0
+        @default_var_counter += 1
+        rv = "_default_#{@default_var_counter}"
+
+        case prism_node
+        when Prism::IntegerNode
+          HIR::IntegerLit.new(value: prism_node.value, result_var: rv)
+        when Prism::FloatNode
+          HIR::FloatLit.new(value: prism_node.value, result_var: rv)
+        when Prism::StringNode
+          HIR::StringLit.new(value: prism_node.unescaped, result_var: rv)
+        when Prism::SymbolNode
+          HIR::SymbolLit.new(value: prism_node.value, result_var: rv)
+        when Prism::NilNode
+          HIR::NilLit.new(result_var: rv)
+        when Prism::TrueNode
+          HIR::BoolLit.new(value: true, result_var: rv)
+        when Prism::FalseNode
+          HIR::BoolLit.new(value: false, result_var: rv)
+        else
+          nil
+        end
+      end
+
       def clone_and_rename(inst, prefix, param_map)
         case inst
         when HIR::LoadLocal

data/lib/konpeito/codegen/jvm_generator.rb

@@ -191,6 +191,12 @@ module Konpeito
         # global variables referenced inside blocks have fields available.
         prescan_global_variables(hir_program)
 
+        # Pre-scan: detect functions called with inconsistent argument types
+        # across call sites, and widen those params to :value (Object).
+        # This prevents JVM VerifyError when e.g. assert_equal is called with
+        # both Integer and String arguments at different sites.
+        prescan_call_site_arg_types(hir_program)
+
         # Generate module interfaces FIRST (before classes that may implement them)
         hir_program.modules.each do |module_def|
           @block_methods = []
@@ -340,6 +346,80 @@ module Konpeito
         end
       end
 
+      # Pre-scan: detect functions called with inconsistent argument types.
+      # When a function like assert_equal(expected, actual, desc) is called with
+      # Integer args at one site and String args at another, the JVM needs a single
+      # method descriptor. If HM inference resolves params to a concrete type (e.g. :i64)
+      # based on the first call site, later call sites with different types cause VerifyError.
+      # This pre-scan detects such cases and marks params for widening to :value (Object).
+      def prescan_call_site_arg_types(hir_program)
+        # Collect argument types at each call site per function
+        call_arg_types = Hash.new { |h, k| h[k] = Hash.new { |h2, k2| h2[k2] = Set.new } }
+
+        # Scan all functions (top-level + class methods are both in functions list)
+        # Note: top-level method calls may have SelfRef receiver (implicit self),
+        # so we check for both nil and SelfRef receivers.
+        hir_program.functions.each do |func|
+          each_instruction_recursive(func.body) do |inst|
+            next unless inst.is_a?(HIR::Call)
+            next if inst.receiver && !inst.receiver.is_a?(HIR::SelfRef)
+            target = inst.method_name.to_s
+            inst.args.each_with_index do |arg, i|
+              call_arg_types[target][i] << static_arg_type(arg)
+            end
+          end
+        end
+
+        # Build widened params map: func_name => Set of param indices that need widening
+        @widened_params = {}
+        hir_program.functions.each do |func|
+          func_name = func.name.to_s
+          sites = call_arg_types[func_name]
+          next if sites.empty?
+
+          widened = Set.new
+          func.params.each_with_index do |param, i|
+            site_types = sites[i]
+            next if site_types.nil? || site_types.size <= 1
+
+            # Multiple different types at call sites — widen to :value
+            widened << i
+          end
+
+          @widened_params[func_name] = widened unless widened.empty?
+        end
+      end
+
+      # Infer the JVM type tag of an HIR node statically (without @variable_types).
+      # Used by prescan_call_site_arg_types.
+      def static_arg_type(node)
+        case node
+        when HIR::IntegerLit then :i64
+        when HIR::FloatLit then :double
+        when HIR::StringLit then :string
+        when HIR::BoolLit then :i8
+        when HIR::NilLit then :value
+        else
+          if node.respond_to?(:type) && node.type
+            konpeito_type_to_tag(node.type)
+          else
+            :value
+          end
+        end
+      end
+
+      # Get the effective param type for a function, applying widening if needed.
+      # Widening occurs when different call sites pass different types for the same param.
+      def widened_param_type(func, param, index)
+        widened = @widened_params && @widened_params[func.name.to_s]
+        if widened && widened.include?(index)
+          :value
+        else
+          param_type(param)
+        end
+      end
+
+
       # Returns the complete JSON IR as a Hash
       def to_json_ir
         { "classes" => @class_defs }
@@ -481,9 +561,9 @@ module Konpeito
         ret_type = function_return_type(func)
         @current_function_return_type = ret_type
 
-        # Allocate parameter slots
-        func.params.each do |param|
-          type = param_type(param)
+        # Allocate parameter slots (use widened types for functions called with mixed arg types)
+        func.params.each_with_index do |param, i|
+          type = widened_param_type(func, param, i)
           allocate_slot(param.name, type)
           # *args (rest param) is a Ruby Array, **kwargs (keyword_rest) is a Hash
           if param.rest || param.keyword_rest
@@ -1033,6 +1113,16 @@ module Konpeito
           @variable_native_array_element_type[target_var] = @variable_native_array_element_type[source_var] if @variable_native_array_element_type[source_var]
           @variable_array_element_types[target_var] = @variable_array_element_types[source_var] if @variable_array_element_types[source_var]
           @variable_is_class_ref[target_var] = @variable_is_class_ref[source_var] if @variable_is_class_ref[source_var]
+        elsif value.is_a?(HIR::IntegerLit) || value.is_a?(HIR::FloatLit) ||
+              value.is_a?(HIR::StringLit) || value.is_a?(HIR::BoolLit) ||
+              value.is_a?(HIR::NilLit) || value.is_a?(HIR::SymbolLit)
+          # Literal value (e.g. from inlined default parameter) — generate inline
+          loaded_type = infer_type_from_hir(value) || :value
+          type = reconcile_store_type(target_var, loaded_type)
+          ensure_slot(target_var, type)
+          instructions.concat(load_value(value, type))
+          instructions << store_instruction(target_var, type)
+          @variable_types[target_var] = type
         else
           # Value should already be on the stack or in a temp var
           source_var = value.respond_to?(:result_var) ? value.result_var : nil
@@ -3112,15 +3202,19 @@ module Konpeito
                                 "name" => "<init>", "descriptor" => "()V" }
             end
           elsif i < args.size
-            param_t = param_type(param)
+            param_t = widened_param_type(target_func, param, i)
             instructions.concat(load_value(args[i], param_t))
             # Unbox if loaded type is :value but function expects primitive
             loaded_t = infer_loaded_type(args[i])
             instructions.concat(unbox_if_needed(loaded_t, param_t))
           else
             # Optional parameter not provided at call site — push default value
-            param_t = param_type(param)
-            instructions.concat(default_value_instructions(param_t))
+            param_t = widened_param_type(target_func, param, i)
+            if param.default_value
+              instructions.concat(prism_default_to_jvm(param.default_value, param_t))
+            else
+              instructions.concat(default_value_instructions(param_t))
+            end
           end
         end
 
@@ -3339,10 +3433,9 @@ module Konpeito
           # boolean: ifeq jumps to else (false = 0)
           instructions << { "op" => "ifeq", "target" => else_label }
         when :i64
-          # long: compare with 0
-          instructions << { "op" => "lconst_0" }
-          instructions << { "op" => "lcmp" }
-          instructions << { "op" => "ifeq", "target" => else_label }
+          # Ruby: all integers (including 0) are truthy.
+          # Pop the loaded long value and always fall through to then.
+          instructions << { "op" => "pop2" }
         when :value
           # Ruby truthiness: null (nil) and Boolean.FALSE (false) are falsy.
           # A simple ifnull misses Boolean.FALSE, causing && short-circuit bugs.
@@ -10985,6 +11078,63 @@ module Konpeito
         end
       end
 
+      # Convert a Prism default value node to JVM bytecode instructions.
+      # Used when optional parameters are missing at a call site.
+      def prism_default_to_jvm(prism_node, expected_type)
+        case prism_node
+        when Prism::IntegerNode
+          val = prism_node.value
+          insts = if val == 0
+            [{ "op" => "lconst_0" }]
+          elsif val == 1
+            [{ "op" => "lconst_1" }]
+          else
+            [{ "op" => "ldc2_w", "value" => val, "type" => "long" }]
+          end
+          if expected_type == :value
+            insts << { "op" => "invokestatic", "owner" => "java/lang/Long",
+                       "name" => "valueOf", "descriptor" => "(J)Ljava/lang/Long;" }
+          end
+          insts
+        when Prism::FloatNode
+          val = prism_node.value
+          insts = if val == 0.0
+            [{ "op" => "dconst_0" }]
+          elsif val == 1.0
+            [{ "op" => "dconst_1" }]
+          else
+            [{ "op" => "ldc2_w", "value" => val, "type" => "double" }]
+          end
+          if expected_type == :value
+            insts << { "op" => "invokestatic", "owner" => "java/lang/Double",
+                       "name" => "valueOf", "descriptor" => "(D)Ljava/lang/Double;" }
+          end
+          insts
+        when Prism::StringNode
+          [{ "op" => "ldc", "value" => prism_node.unescaped }]
+        when Prism::SymbolNode
+          [{ "op" => "ldc", "value" => prism_node.value }]
+        when Prism::NilNode
+          [{ "op" => "aconst_null" }]
+        when Prism::TrueNode
+          insts = [{ "op" => "iconst", "value" => 1 }]
+          if expected_type == :value
+            insts << { "op" => "invokestatic", "owner" => "java/lang/Boolean",
+                       "name" => "valueOf", "descriptor" => "(Z)Ljava/lang/Boolean;" }
+          end
+          insts
+        when Prism::FalseNode
+          insts = [{ "op" => "iconst", "value" => 0 }]
+          if expected_type == :value
+            insts << { "op" => "invokestatic", "owner" => "java/lang/Boolean",
+                       "name" => "valueOf", "descriptor" => "(Z)Ljava/lang/Boolean;" }
+          end
+          insts
+        else
+          default_value_instructions(expected_type)
+        end
+      end
+
       def default_value_instructions(type)
         case type
         when :i64 then [{ "op" => "lconst_0" }]
@@ -11539,8 +11689,8 @@ module Konpeito
       end
 
       def method_descriptor(func)
-        params_desc = func.params.map do |param|
-          t = param_type(param)
+        params_desc = func.params.each_with_index.map do |param, i|
+          t = widened_param_type(func, param, i)
           t = :value if t == :void  # Nil/void is not valid as JVM param type
           type_to_descriptor(t)
         end.join

data/lib/konpeito/codegen/llvm_generator.rb

@@ -40,6 +40,7 @@ module Konpeito
         @dibuilder = nil          # DIBuilder for debug info
         @profiler = nil           # Profiler for instrumentation
         @variadic_functions = {}  # Track functions with **kwargs or *args
+        @comparison_result_vars = Set.new  # Track variables holding comparison results (0/1 boolean)
 
         # Register all NativeClass types from RBS upfront
         register_native_classes_from_rbs
@@ -719,8 +720,8 @@ module Konpeito
           var.linkage = :external
         end
 
-        # rb_eArgumentError global
-        @rb_eArgumentError = @mod.globals.add(value_type, "rb_eArgumentError") do |var|
+        # rb_eArgError global (CRuby's ArgumentError class)
+        @rb_eArgumentError = @mod.globals.add(value_type, "rb_eArgError") do |var|
           var.linkage = :external
         end
 
@@ -968,6 +969,12 @@ module Konpeito
         # Insert profiling entry probe after parameter setup
         insert_profile_entry_probe(hir_func)
 
+        # Track blocks with Return terminators so phi nodes can skip them
+        @return_blocks = Set.new
+        hir_func.body.each do |hir_block|
+          @return_blocks << hir_block.label if hir_block.terminator.is_a?(HIR::Return)
+        end
+
         # Generate code for each block
         hir_func.body.each do |hir_block|
           generate_block(func, hir_block)
@@ -1205,9 +1212,7 @@ module Konpeito
 
             # Determine default value
             default_value = if param.default_value
-              # Has explicit default - we need to generate the default value
-              # For now, use Qnil as placeholder; proper default handling requires more work
-              @qnil
+              generate_keyword_default_value(param.default_value)
             else
               # Required keyword - use Qundef to detect missing
               @qundef
@@ -1277,6 +1282,14 @@ module Konpeito
               @builder.store(kwargs_hash, alloca)
             end
           end
+
+          # After keyword processing, remap entry block to current position.
+          # Required keyword params create branch blocks (kwarg_missing/kwarg_ok),
+          # leaving the builder positioned in a continuation block rather than
+          # the original entry block. Function body code must be generated there.
+          if keyword_params.any? { |p| !p.default_value }
+            @blocks[hir_func.body.first.label] = @builder.insert_block
+          end
         end  # End of variadic_info else block
 
         # Insert profiling entry probe after parameter setup
@@ -1286,6 +1299,13 @@ module Konpeito
         # Blocks with phi nodes referencing results from other blocks must come after those blocks
         sorted_blocks = sort_blocks_by_phi_dependencies(hir_func.body)
 
+        # Track blocks with Return terminators so phi nodes can skip them
+        # (a block that returns doesn't branch to the merge block)
+        @return_blocks = Set.new
+        sorted_blocks.each do |hir_block|
+          @return_blocks << hir_block.label if hir_block.terminator.is_a?(HIR::Return)
+        end
+
         # Generate code for each block in dependency order
         sorted_blocks.each do |hir_block|
           generate_block(func, hir_block)
@@ -2244,6 +2264,14 @@ module Konpeito
           target_type = source_type
           # Need to recreate alloca with the new unboxed type
           @variable_allocas.delete(var_name)
+        elsif %i[double i64 i8].include?(target_type) && source_type == :value && inst.value.is_a?(HIR::Phi)
+          # Downgrade from unboxed to VALUE type for phi nodes with mixed types.
+          # This happens when a phi with mixed types (e.g., bool + int from &&/||)
+          # stores into a variable that was pre-allocated as unboxed based on static
+          # type analysis. The phi resolves to :value at codegen time, so we must
+          # widen the variable to :value to avoid unsafe unboxing (e.g., rb_num2long on Qfalse).
+          target_type = :value
+          @variable_allocas.delete(var_name)
         end
 
         value_to_store = convert_value(value, source_type, target_type)
@@ -2279,6 +2307,13 @@ module Konpeito
 
         @variables[var_name] = value_to_store
         @variable_types[var_name] = target_type
+
+        # Propagate comparison result flag through variable assignments
+        src_var = inst.value.respond_to?(:result_var) ? inst.value.result_var : nil
+        if src_var && @comparison_result_vars.include?(src_var)
+          @comparison_result_vars.add(var_name)
+        end
+
         value_to_store
       end
 
@@ -2726,7 +2761,10 @@ module Konpeito
         # Skip direct call optimizations when splat args are present
         has_splat = inst.args.any? { |a| a.is_a?(HIR::SplatArg) }
 
-        unless has_splat
+        # Skip direct call when a block is passed — direct LLVM calls bypass
+        # CRuby's call frame, so rb_yield/rb_block_given_p inside the callee
+        # would fail with LocalJumpError. Use rb_block_call instead.
+        unless has_splat || inst.block
           # Check for monomorphized function call (direct call optimization)
           if (specialized_target = inst.instance_variable_get(:@specialized_target))
             result = generate_direct_call(inst, specialized_target)
@@ -2781,6 +2819,14 @@ module Konpeito
           end
         end
 
+        # If a block is passed to a user-defined function, use rb_block_call
+        # so CRuby sets up the block context for rb_yield/rb_block_given_p.
+        if inst.block
+          result = generate_rb_block_call_for_user_func(inst)
+          @variables[inst.result_var] = result if inst.result_var
+          return result
+        end
+
         # Get receiver as Ruby VALUE (box if needed)
         receiver = get_value_as_ruby(inst.receiver)
 
@@ -3899,6 +3945,13 @@ module Konpeito
         @builder.phi(value_type, phi_incoming, "#{method_sym}_result")
       end
 
+      # Generate rb_block_call for user-defined functions that receive a block.
+      # This ensures CRuby sets up the block context so rb_yield/rb_block_given_p
+      # work correctly inside the callee.
+      def generate_rb_block_call_for_user_func(inst)
+        generate_rb_block_call(inst, nil)
+      end
+
       # Fallback: generate rb_block_call
       def generate_rb_block_call(inst, builtin)
         # Get receiver as Ruby VALUE
@@ -5172,6 +5225,7 @@ module Konpeito
         if inst.result_var
           @variables[inst.result_var] = result
           @variable_types[inst.result_var] = :i64
+          @comparison_result_vars.add(inst.result_var)
         end
         result
       end
@@ -5231,6 +5285,7 @@ module Konpeito
         if inst.result_var
           @variables[inst.result_var] = result
           @variable_types[inst.result_var] = :i64
+          @comparison_result_vars.add(inst.result_var)
         end
         result
       end
@@ -6329,8 +6384,8 @@ module Konpeito
           # yield with no arguments - pass Qnil
           @builder.call(@rb_yield, @qnil)
         elsif inst.args.size == 1
-          # yield with single argument
-          arg_value = get_value(inst.args.first)
+          # yield with single argument — must be boxed VALUE for rb_yield
+          arg_value = get_value_as_ruby(inst.args.first)
           @builder.call(@rb_yield, arg_value)
         else
           # yield with multiple arguments - use rb_yield_values2
@@ -6340,7 +6395,7 @@ module Konpeito
           argv = @builder.alloca(LLVM::Array(value_type, inst.args.size))
 
           inst.args.each_with_index do |arg, i|
-            arg_value = get_value(arg)
+            arg_value = get_value_as_ruby(arg)
             ptr = @builder.gep(argv, [LLVM::Int32.from_i(0), LLVM::Int32.from_i(i)])
             @builder.store(arg_value, ptr)
           end
@@ -7040,6 +7095,31 @@ module Konpeito
         @builder.select(is_true, @qtrue, @qfalse)
       end
 
+      # Generate LLVM value for keyword argument default from Prism AST node
+      def generate_keyword_default_value(prism_node)
+        case prism_node
+        when Prism::StringNode
+          str_ptr = @builder.global_string_pointer(prism_node.unescaped)
+          @builder.call(@rb_str_new_cstr, str_ptr)
+        when Prism::IntegerNode
+          @builder.call(@rb_int2inum, LLVM::Int64.from_i(prism_node.value))
+        when Prism::FloatNode
+          @builder.call(@rb_float_new, LLVM::Double.from_f(prism_node.value))
+        when Prism::NilNode
+          @qnil
+        when Prism::TrueNode
+          @qtrue
+        when Prism::FalseNode
+          @qfalse
+        when Prism::SymbolNode
+          sym_ptr = @builder.global_string_pointer(prism_node.value)
+          sym_id = @builder.call(@rb_intern, sym_ptr)
+          @builder.call(@rb_id2sym, sym_id)
+        else
+          @qnil
+        end
+      end
+
       # Convert Ruby VALUE to i1 boolean
       def ruby_to_bool(value)
         # In Ruby, only nil and false are falsy
@@ -7701,6 +7781,9 @@ module Konpeito
         inst.incoming.each do |label, hir_value|
           llvm_block = @blocks[label]
           next unless llvm_block
+          # Skip blocks with Return terminators — they don't branch to the
+          # merge block, so they cannot be predecessors in the phi node.
+          next if @return_blocks&.include?(label)
           llvm_value, type_tag = get_value_with_type(hir_value)
           incoming_data << [llvm_block, llvm_value, type_tag]
         end
@@ -7755,11 +7838,25 @@ module Konpeito
 
           is_truthy = case cond_type
           when :i64
-            # For i64 (from comparison), non-zero is truthy
-            @builder.icmp(:ne, condition, LLVM::Int64.from_i(0))
+            if comparison_result?(term.condition)
+              # Comparison result (0=false, 1=true): use C-style truthiness
+              @builder.icmp(:ne, condition, LLVM::Int64.from_i(0))
+            else
+              # Ruby: all integers (including 0) are truthy.
+              # Box to VALUE and use Ruby truthiness (RTEST).
+              boxed = @builder.call(@rb_int2inum, condition)
+              ruby_to_bool(boxed)
+            end
           when :double
-            # For double, non-zero is truthy
-            @builder.fcmp(:one, condition, LLVM::Double.from_f(0.0))
+            if comparison_result?(term.condition)
+              # Comparison result: use C-style truthiness
+              @builder.fcmp(:one, condition, LLVM::Double.from_f(0.0))
+            else
+              # Ruby: all floats (including 0.0) are truthy.
+              # Box to VALUE and use Ruby truthiness (RTEST).
+              boxed = @builder.call(@rb_float_new, condition)
+              ruby_to_bool(boxed)
+            end
           when :i8
             # For i8 (Bool field), non-zero is truthy
             @builder.icmp(:ne, condition, LLVM::Int8.from_i(0))
@@ -7779,6 +7876,25 @@ module Konpeito
         end
       end
 
+      # Check if an HIR condition node represents a comparison result (boolean 0/1)
+      # rather than a raw integer/float value.
+      # In Ruby, only nil and false are falsy — integers (including 0) and floats are always truthy.
+      COMPARISON_METHODS = %w[== != < > <= >=].freeze
+
+      def comparison_result?(hir_condition)
+        case hir_condition
+        when HIR::Call
+          COMPARISON_METHODS.include?(hir_condition.method_name)
+        when HIR::LoadLocal
+          var_name = hir_condition.var&.name
+          @comparison_result_vars.include?(var_name)
+        when HIR::Instruction
+          hir_condition.result_var && @comparison_result_vars.include?(hir_condition.result_var)
+        else
+          false
+        end
+      end
+
       # Generate return for a native method (unboxed return value)
       def generate_native_return(term)
         method_name = @current_hir_func&.name&.to_sym

data/lib/konpeito/codegen/monomorphizer.rb

@@ -186,8 +186,15 @@ module Konpeito
         # Group call sites by (function, types)
         grouped = @call_sites.group_by { |cs| [cs[:target], cs[:types]] }
 
+        # Detect functions called with inconsistent arg types across call sites.
+        # If the same param position receives different types at different sites
+        # (e.g., assert_equal called with both Integer and String as first arg),
+        # monomorphization is not useful — skip the function entirely.
+        skip_functions = detect_inconsistent_call_sites
+
         grouped.each do |(func_name, types), sites|
           next if types.all? { |t| t == TypeChecker::Types::UNTYPED }
+          next if skip_functions.include?(func_name.to_s)
 
           type_suffix = types.map { |t| type_to_suffix(t) }.join("_")
           specialized = "#{func_name}_#{type_suffix}"
@@ -211,6 +218,30 @@ module Konpeito
         consolidate_union_dispatches
       end
 
+      # Detect functions where different call sites pass different types for
+      # the same parameter position. These functions should not be monomorphized
+      # because specialized variants would have incompatible signatures.
+      def detect_inconsistent_call_sites
+        # Group non-union call sites by target function
+        by_func = @call_sites.reject { |cs| cs[:union_dispatch] }
+                             .group_by { |cs| cs[:target].to_s }
+
+        skip = Set.new
+        by_func.each do |func_name, sites|
+          next if sites.size <= 1
+          # Check each param position for type consistency
+          max_arity = sites.map { |s| s[:types].size }.max
+          max_arity.times do |i|
+            types_at_i = sites.map { |s| s[:types][i]&.to_s }.compact.uniq
+            if types_at_i.size > 1
+              skip.add(func_name)
+              break
+            end
+          end
+        end
+        skip
+      end
+
       # Group union call sites by their original (pre-expansion) call
       def consolidate_union_dispatches
         @union_dispatches = {}

data/lib/konpeito/type_checker/hm_inferrer.rb

@@ -2068,17 +2068,46 @@ module Konpeito
       def infer_and(node)
         left_type = infer(node.left)
         right_type = infer(node.right)
-        # a && b: if a is falsy, result is a (nil/false); otherwise result is b
-        # Return right_type as it's the most common use case
-        right_type
+        # a && b: if a is falsy, result is a; if a is truthy, result is b
+        if left_type == right_type
+          right_type
+        elsif always_falsy_type?(left_type)
+          left_type
+        elsif always_truthy_type?(left_type)
+          right_type
+        else
+          Types::Union.new([left_type, right_type])
+        end
       end
 
       def infer_or(node)
         left_type = infer(node.left)
         right_type = infer(node.right)
-        # a || b: if a is truthy, result is a; otherwise result is b
-        # Return left_type as it's the most common use case
-        left_type
+        # a || b: if a is truthy, result is a; if a is falsy, result is b
+        if left_type == right_type
+          left_type
+        elsif always_truthy_type?(left_type)
+          left_type
+        elsif always_falsy_type?(left_type)
+          right_type
+        else
+          Types::Union.new([left_type, right_type])
+        end
+      end
+
+      # NilClass and FalseClass are always falsy in Ruby
+      def always_falsy_type?(type)
+        type.is_a?(Types::NilType) ||
+          (type.is_a?(Types::ClassInstance) && type.name == :FalseClass)
+      end
+
+      # Everything except nil, false, and bool is always truthy in Ruby
+      def always_truthy_type?(type)
+        return false if type.is_a?(Types::NilType)
+        return false if type.is_a?(Types::BoolType)
+        return false if type.is_a?(Types::ClassInstance) && type.name == :FalseClass
+        return false if type.is_a?(Types::Union)
+        true
       end
 
       # Compound assignment operators
@@ -2095,15 +2124,36 @@ module Konpeito
         existing = lookup(node.name)
         var_type = existing ? existing.instantiate : TypeVar.new
         value_type = infer(node.value)
-        # x ||= val: result is either existing value or val
-        var_type
+        # x ||= val: if x is falsy, x becomes val; if truthy, x stays
+        result = if var_type == value_type
+          var_type
+        elsif always_falsy_type?(var_type)
+          value_type
+        elsif always_truthy_type?(var_type)
+          var_type
+        else
+          Types::Union.new([var_type, value_type])
+        end
+        bind(node.name, result)
+        result
       end
 
       def infer_local_variable_and_write(node)
         existing = lookup(node.name)
         var_type = existing ? existing.instantiate : TypeVar.new
         value_type = infer(node.value)
-        value_type
+        # x &&= val: if x is truthy, x becomes val; if falsy, x stays
+        result = if var_type == value_type
+          value_type
+        elsif always_truthy_type?(var_type)
+          value_type
+        elsif always_falsy_type?(var_type)
+          var_type
+        else
+          Types::Union.new([var_type, value_type])
+        end
+        bind(node.name, result)
+        result
       end
 
       def infer_instance_variable_write(node)

data/lib/konpeito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Konpeito
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konpeito
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Yasushi Itoh