konpeito 0.2.4 → 0.3.0

data/lib/konpeito/codegen/jvm_generator.rb

@@ -955,14 +955,24 @@ module Konpeito
             }
           elsif has_rescue
             outer_br.rescue_clauses.each_with_index do |clause, i|
-              clause.exception_classes.each do |exc_class|
-                jvm_exc = ruby_exception_to_jvm(exc_class)
+              if clause.exception_classes.empty?
+                # Bare rescue → catch StandardError (Java Exception)
                 @pending_exception_table << {
                   "start" => try_start,
                   "end" => try_end,
                   "handler" => handler_labels[i],
-                  "type" => jvm_exc
+                  "type" => "java/lang/Exception"
                 }
+              else
+                clause.exception_classes.each do |exc_class|
+                  jvm_exc = ruby_exception_to_jvm(exc_class)
+                  @pending_exception_table << {
+                    "start" => try_start,
+                    "end" => try_end,
+                    "handler" => handler_labels[i],
+                    "type" => jvm_exc
+                  }
+                end
               end
             end
           end
@@ -1313,6 +1323,8 @@ module Konpeito
           generate_begin_rescue(inst)
         when HIR::CaseStatement
           generate_case_statement(inst)
+        when HIR::CaseEqualityCheck
+          generate_case_equality_check(inst)
         when HIR::CaseMatchStatement
           generate_case_match_statement(inst)
         when HIR::LoadGlobalVar
@@ -2844,9 +2856,22 @@ module Konpeito
           end
         end
 
-        # Use inlined try body if provided (from block's pre-BeginRescue instructions),
-        # otherwise fall back to BeginRescue's stored try_blocks
-        try_body = inlined_try_body || inst.try_blocks || []
+        # Determine try body. If BeginRescue stores its own try_blocks, use those.
+        # Pre-BeginRescue instructions (inlined_try_body) are only the try body when
+        # the BeginRescue has no stored try_blocks (legacy HIR builder behavior).
+        has_own_try = (inst.try_blocks && !inst.try_blocks.empty?) || (inst.try_hir_blocks && !inst.try_hir_blocks.empty?)
+        pre_try_instructions = []
+        if has_own_try
+          # BeginRescue has its own try body. Pre-BeginRescue instructions that are NOT
+          # already in try_blocks go BEFORE the try scope (e.g. variable initializations
+          # before a begin/rescue block).
+          try_body = inst.try_blocks || []
+          try_block_ids = Set.new(try_body.map(&:object_id))
+          pre_try_instructions = (inlined_try_body || []).reject { |i| try_block_ids.include?(i.object_id) }
+        else
+          # Legacy: pre-BeginRescue instructions ARE the try body
+          try_body = (inlined_try_body && !inlined_try_body.empty?) ? inlined_try_body : []
+        end
 
         # If the begin/rescue has a result variable, pre-initialize it with null
         result_var = inst.result_var
@@ -2874,6 +2899,11 @@ module Konpeito
         # Label for exception ensure path (catch-all)
         finally_handler_label = new_label("finally_handler") if has_ensure
 
+        # 0. Emit pre-try instructions (code before begin/rescue that is NOT in the try scope)
+        pre_try_instructions.each do |pre_inst|
+          instructions.concat(generate_instruction(pre_inst))
+        end
+
         # 1. Try block (generate BEFORE registering outer exception handlers,
         # so that inner/nested BeginRescue handlers appear first in the table.
         # JVM checks exception table entries in order; first match wins.)
@@ -2907,14 +2937,24 @@ module Konpeito
           }
         elsif has_rescue
           inst.rescue_clauses.each_with_index do |clause, i|
-            clause.exception_classes.each do |exc_class|
-              jvm_exc = ruby_exception_to_jvm(exc_class)
+            if clause.exception_classes.empty?
+              # Bare rescue (no exception class) → catch StandardError (Java Exception)
               @pending_exception_table << {
                 "start" => try_start,
                 "end" => try_end,
                 "handler" => handler_labels[i],
-                "type" => jvm_exc
+                "type" => "java/lang/Exception"
               }
+            else
+              clause.exception_classes.each do |exc_class|
+                jvm_exc = ruby_exception_to_jvm(exc_class)
+                @pending_exception_table << {
+                  "start" => try_start,
+                  "end" => try_end,
+                  "handler" => handler_labels[i],
+                  "type" => jvm_exc
+                }
+              end
             end
           end
         end
@@ -3132,6 +3172,48 @@ module Konpeito
         instructions
       end
 
+      # ========================================================================
+      # CaseEqualityCheck (HIR node used by the block-based case/when)
+      # ========================================================================
+
+      # Generate condition === predicate for case/when dispatch.
+      # The condition is the when-value (e.g. 10, "hello") and the predicate is
+      # the case expression (e.g. x). Result is stored as :i8 (boolean).
+      # Uses load_value to either load from already-generated slot or generate inline.
+      def generate_case_equality_check(inst)
+        instructions = []
+        result_var = inst.result_var
+
+        if inst.predicate.nil?
+          # No predicate (bare `case; when cond then ...`): evaluate condition as truthy
+          instructions.concat(load_value(inst.condition, :value))
+          instructions << { "op" => "invokestatic", "owner" => "konpeito/runtime/RubyDispatch",
+                            "name" => "isTruthy", "descriptor" => "(Ljava/lang/Object;)Z" }
+          if result_var
+            ensure_slot(result_var, :i8)
+            instructions << store_instruction(result_var, :i8)
+            @variable_types[result_var.to_s] = :i8
+          end
+        else
+          # condition === predicate: condition is the when value, predicate is the case expr.
+          # Load condition (when value) — box to Object
+          instructions.concat(load_value(inst.condition, :value))
+          # Load predicate (case expression) — box to Object
+          instructions.concat(load_value(inst.predicate, :value))
+          # Call RubyDispatch.caseEqual(condition, predicate) → Z
+          instructions << { "op" => "invokestatic", "owner" => "konpeito/runtime/RubyDispatch",
+                            "name" => "caseEqual",
+                            "descriptor" => "(Ljava/lang/Object;Ljava/lang/Object;)Z" }
+          if result_var
+            ensure_slot(result_var, :i8)
+            instructions << store_instruction(result_var, :i8)
+            @variable_types[result_var.to_s] = :i8
+          end
+        end
+
+        instructions
+      end
+
       # ========================================================================
       # case/when Statement
       # ========================================================================
@@ -15243,6 +15325,15 @@ module Konpeito
         incoming_types = phi.incoming.values.map do |val|
           var = extract_var_name(val)
           type = var ? @variable_types[var] : nil
+          # For LoadInstanceVar, check the CLASS-LEVEL field type instead of HM annotation.
+          # HM inference can produce incorrect types for ivars due to TypeVar pollution
+          # (e.g., @font_family_val typed as Float instead of String).
+          # The class field declaration is the source of truth.
+          if type.nil? && val.is_a?(HIR::LoadInstanceVar) && @current_class_name
+            field_name = val.name.to_s.sub(/^@/, "")
+            ivar_info = resolve_ivar_info(field_name)
+            type = ivar_info[:type] if ivar_info
+          end
           type || infer_type_from_hir(val) || literal_type_tag(val) || :value
         end