konpeito 0.2.2 → 0.2.3

data/lib/konpeito/hir/builder.rb

@@ -500,6 +500,19 @@ module Konpeito
                   generate_attr_reader_method(attr_name, class_def)
                   generate_attr_writer_method(attr_name, class_def)
                 end
+              elsif child.node_type == :constant_write
+                # Constant assignment in class body (e.g., PI = 3)
+                const_name = child.node.name.to_s
+                value_node = visit_literal_value(child.children.first)
+                class_def.body_constants << [const_name, value_node]
+              elsif child.node_type == :class_variable_write
+                # Class variable initialization in class body (e.g., @@count = 0)
+                cvar_name = child.node.name.to_s
+                value_node = visit_literal_value(child.children.first)
+                class_def.body_class_vars << [cvar_name, value_node]
+                # Also track class variable for the class
+                @class_vars[name] ||= Set.new
+                @class_vars[name] << cvar_name
               else
                 visit(child)
               end
@@ -807,7 +820,11 @@ module Konpeito
               elsif child.node_type == :constant_write
                 # Handle constant assignment within module
                 const_name = child.node.name.to_s
-                module_constants[const_name] = visit(child)
+                module_constants[const_name] = visit_literal_value(child.children.first)
+              elsif child.node_type == :class_variable_write
+                # Handle class variable initialization within module
+                # (modules can have class variables too)
+                visit(child)
               else
                 visit(child)
               end
@@ -2116,6 +2133,42 @@ module Konpeito
           block = visit_block_def(block_child)
         end
 
+        # Handle &blk block argument reference (e.g., arr.map(&blk))
+        unless block
+          block_arg_child = typed_node.children.find { |c| c.node_type == :block_argument }
+          if block_arg_child
+            blk_node = block_arg_child.node
+            if blk_node.respond_to?(:expression) && blk_node.expression
+              blk_name = blk_node.expression.name.to_s
+              # Create a wrapper BlockDef: { |__block_arg_param| blk.call(__block_arg_param) }
+              # Load blk from captures inside the block body (not from outer scope)
+              param_name = "__block_arg_param"
+              param = Param.new(name: param_name, type: TypeChecker::Types::UNTYPED)
+              param_var = LocalVar.new(name: param_name, type: TypeChecker::Types::UNTYPED)
+              param_load = LoadLocal.new(var: param_var, type: TypeChecker::Types::UNTYPED, result_var: new_temp_var)
+              blk_local_var = LocalVar.new(name: blk_name, type: TypeChecker::Types::UNTYPED)
+              blk_load = LoadLocal.new(var: blk_local_var, type: TypeChecker::Types::UNTYPED, result_var: new_temp_var)
+              call_inst = Call.new(
+                receiver: blk_load,
+                method_name: "call",
+                args: [param_load],
+                type: TypeChecker::Types::UNTYPED,
+                result_var: new_temp_var
+              )
+              # Wrap in a BasicBlock (BlockDef.body expects Array[BasicBlock])
+              bb = BasicBlock.new(label: "block_arg_body")
+              bb.add_instruction(blk_load)
+              bb.add_instruction(param_load)
+              bb.add_instruction(call_inst)
+              block = BlockDef.new(
+                params: [param],
+                body: [bb],
+                captures: [Capture.new(name: blk_name, type: TypeChecker::Types::UNTYPED)]
+              )
+            end
+          end
+        end
+
         result_var = new_temp_var
         is_safe_nav = node.respond_to?(:safe_navigation?) && node.safe_navigation?
         inst = Call.new(
@@ -6439,25 +6492,60 @@ module Konpeito
         # RHS value
         rhs = visit(typed_node.children.first)
 
-        targets = typed_node.node.lefts
-        targets.each_with_index do |target, i|
-          case target
-          when Prism::LocalVariableTargetNode
+        lefts = typed_node.node.lefts
+        rest = typed_node.node.rest
+        rights = typed_node.node.rights
+
+        # Process left targets (before splat)
+        lefts.each_with_index do |target, i|
+          emit_multi_write_target(target, rhs, i)
+        end
+
+        # Process splat target: *rest
+        if rest && rest.is_a?(Prism::SplatNode) && rest.expression
+          target = rest.expression
+          if target.is_a?(Prism::LocalVariableTargetNode)
             name = target.name.to_s
-            # Extract element using MultiWriteExtract (rb_ary_entry)
-            elem_var = new_temp_var
-            elem_inst = MultiWriteExtract.new(array: rhs, index: i, type: TypeChecker::Types::UNTYPED, result_var: elem_var)
-            emit(elem_inst)
+            splat_var = new_temp_var
+            end_offset = rights ? rights.length : 0
+            splat_inst = MultiWriteSplat.new(
+              array: rhs, start_index: lefts.length, end_offset: end_offset,
+              type: TypeChecker::Types::UNTYPED, result_var: splat_var
+            )
+            emit(splat_inst)
 
             var = @local_vars[name] ||= LocalVar.new(name: name, type: TypeChecker::Types::UNTYPED)
-            store_inst = StoreLocal.new(var: var, value: elem_inst, type: TypeChecker::Types::UNTYPED)
+            store_inst = StoreLocal.new(var: var, value: splat_inst, type: TypeChecker::Types::UNTYPED)
             emit(store_inst)
           end
         end
 
+        # Process right targets (after splat) — use negative indices from end
+        if rights && !rights.empty?
+          rights.each_with_index do |target, i|
+            # Use negative index: rights[0] = arr[-rights.length], rights[1] = arr[-(rights.length-1)], etc.
+            neg_index = -(rights.length - i)
+            emit_multi_write_target(target, rhs, neg_index)
+          end
+        end
+
         rhs
       end
 
+      def emit_multi_write_target(target, rhs, index)
+        case target
+        when Prism::LocalVariableTargetNode
+          name = target.name.to_s
+          elem_var = new_temp_var
+          elem_inst = MultiWriteExtract.new(array: rhs, index: index, type: TypeChecker::Types::UNTYPED, result_var: elem_var)
+          emit(elem_inst)
+
+          var = @local_vars[name] ||= LocalVar.new(name: name, type: TypeChecker::Types::UNTYPED)
+          store_inst = StoreLocal.new(var: var, value: elem_inst, type: TypeChecker::Types::UNTYPED)
+          emit(store_inst)
+        end
+      end
+
       def visit_return(typed_node)
         value = typed_node.children.any? ? visit(typed_node.children.first) : NilLit.new
         @current_block.set_terminator(Return.new(value: value))
@@ -6726,17 +6814,16 @@ module Konpeito
         end
 
         # Build else body
-        # Use without_emit to prevent instructions from being added to current block
+        # Use with_emit_to to redirect emitted instructions to the else_body array
         else_body = nil
         else_child = typed_node.children.find { |c| c.node_type == :else }
         if else_child
           else_body = []
           else_statements = else_child.children.find { |c| c.node_type == :statements }
           if else_statements
-            without_emit do
+            with_emit_to(else_body) do
               else_statements.children.each do |stmt|
-                inst = visit(stmt)
-                else_body << inst if inst
+                visit(stmt)
               end
             end
           end
@@ -6804,16 +6891,16 @@ module Konpeito
         end
 
         # Second pass: build body with pattern variables in scope
-        # Use without_emit to prevent instructions from being added to current block
-        # They should only be stored in the InClause body
-        without_emit do
+        # Use with_emit_to to redirect emitted instructions to the body array
+        # instead of the current block. This ensures that StoreLocal instructions
+        # (from variable assignments like `captured = a`) are properly captured.
+        with_emit_to(body) do
           in_typed_node.children.each do |child|
             case child.node_type
             when :statements
               # This is the body
               child.children.each do |stmt|
-                inst = visit(stmt)
-                body << inst if inst
+                visit(stmt)
               end
             end
           end
@@ -7293,7 +7380,11 @@ module Konpeito
 
       def emit(instruction)
         return if @suppress_emit
-        @current_block.add_instruction(instruction) if @current_block
+        if @emit_collector
+          @emit_collector << instruction
+        else
+          @current_block.add_instruction(instruction) if @current_block
+        end
       end
 
       def without_emit
@@ -7304,6 +7395,45 @@ module Konpeito
         result
       end
 
+      # Redirect emitted instructions to the given array instead of the current block.
+      # Used for building case/in clause bodies where we need to capture all emitted
+      # instructions (including StoreLocal from variable assignments) without adding
+      # them to the current basic block.
+      def with_emit_to(collector)
+        old_collector = @emit_collector
+        @emit_collector = collector
+        yield
+      ensure
+        @emit_collector = old_collector
+      end
+
+      # Extract a literal value from a typed node without emitting instructions.
+      # Used for class/module body constant and class variable initializations.
+      # Returns an HIR literal node (IntegerLit, FloatLit, StringLit, etc.) or visits the node.
+      def visit_literal_value(typed_node)
+        return NilLit.new unless typed_node
+
+        case typed_node.node_type
+        when :integer
+          IntegerLit.new(value: typed_node.node.value)
+        when :float
+          FloatLit.new(value: typed_node.node.value)
+        when :string
+          StringLit.new(value: typed_node.node.unescaped)
+        when :symbol
+          SymbolLit.new(value: typed_node.node.value.to_s)
+        when :true
+          BoolLit.new(value: true)
+        when :false
+          BoolLit.new(value: false)
+        when :nil
+          NilLit.new
+        else
+          # For non-literal values, try visiting but suppress emit
+          without_emit { visit(typed_node) }
+        end
+      end
+
       def new_temp_var
         @var_counter += 1
         "t#{@var_counter}"

data/lib/konpeito/hir/nodes.rb

@@ -59,6 +59,8 @@ module Konpeito
       attr_accessor :reopened           # true if this is reopening an existing class
       attr_accessor :singleton_methods  # Names of class-level methods (def self.xxx or class << self)
       attr_accessor :instance_var_types # HM-inferred ivar types: { "name" => :Integer, "age" => :String, ... }
+      attr_accessor :body_constants     # Array of [name, value_node] for constants defined in class body
+      attr_accessor :body_class_vars    # Array of [name, value_node] for class variables initialized in class body
 
       def initialize(name:, superclass: nil, method_names: [], instance_vars: [], included_modules: [], extended_modules: [], prepended_modules: [])
         super(type: TypeChecker::Types::NIL)
@@ -75,6 +77,8 @@ module Konpeito
         @reopened = false
         @singleton_methods = []
         @instance_var_types = {}
+        @body_constants = []
+        @body_class_vars = []
       end
     end
 
@@ -483,6 +487,18 @@ module Konpeito
       end
     end
 
+    # Multi-write splat extraction: a, *rest = arr → rest = arr[start..end]
+    class MultiWriteSplat < Instruction
+      attr_reader :array, :start_index, :end_offset
+
+      def initialize(array:, start_index:, end_offset:, type: TypeChecker::Types::UNTYPED, result_var: nil)
+        super(type: type, result_var: result_var)
+        @array = array
+        @start_index = start_index     # Index to start collecting from
+        @end_offset = end_offset       # Number of elements to exclude from end (for trailing targets)
+      end
+    end
+
     # Constant lookup
     class ConstantLookup < Instruction
       attr_reader :name, :scope

data/lib/konpeito/type_checker/hm_inferrer.rb

@@ -34,6 +34,7 @@ module Konpeito
         @deferred_constraints = []  # Deferred method resolution for TypeVar receivers
         @keyword_param_vars = {}  # func_key => { :param_name => TypeVar }
         @unresolved_type_warnings = []  # Warnings for types that survived inference
+        @polymorphic_methods = {}  # qualified_key => TypeScheme for instance methods
       end
 
       # Main entry: infer types for a program AST
@@ -309,9 +310,27 @@ module Konpeito
           @function_types[node.name.to_sym] = func_type
 
           if @in_class_collect
-            # Class methods: monomorphic binding — call-site unification flows into method body
-            # This allows argument types (e.g., Array from call site) to be visible in method body
-            bind_scheme(node.name, TypeScheme.new([], func_type))
+            is_class_method = node.receiver.is_a?(Prism::SelfNode) rescue false
+            is_initialize = node.name.to_sym == :initialize
+            if is_class_method || is_initialize
+              # Class methods and initialize: monomorphic binding — call-site unification
+              # flows into method body. This allows argument types (e.g., Array from call
+              # site) to be visible in method body.
+              bind_scheme(node.name, TypeScheme.new([], func_type))
+            else
+              # Instance methods: polymorphic binding — each call site gets fresh type
+              # variables. This allows methods like []= to accept different types at
+              # different call sites (e.g., c["name"] = "Alice"; c["age"] = 30).
+              all_vars = collect_type_vars(func_type)
+              scheme = TypeScheme.new(all_vars, func_type)
+              bind_scheme(node.name, scheme)
+              # Mark this method as polymorphic for receiver-based call resolution.
+              # The actual scheme will be created lazily at the first call site,
+              # after body inference has established internal TypeVar linkages.
+              if @collect_class_name && !all_vars.empty?
+                @polymorphic_methods[:"#{@collect_class_name}##{node.name}"] = true
+              end
+            end
           else
             # Top-level functions: generalize to type scheme (all type vars are quantified)
             all_vars = collect_type_vars(func_type)
@@ -782,23 +801,43 @@ module Konpeito
 
         # Receiver-based call on user class: look up class-qualified method type
         # Walk up class hierarchy to find inherited methods
-        # Call-site unification flows argument types into method body (monomorphic binding)
         if node.receiver && receiver_type.is_a?(Types::ClassInstance)
           class_name = receiver_type.name.to_s
           cls = class_name
           func_type = nil
+          polymorphic_scheme = nil
           while cls
-            func_type = @function_types[:"#{cls}##{method_name}"]
+            qualified_key = :"#{cls}##{method_name}"
+            # Check if this method has polymorphic binding (instance methods)
+            polymorphic_scheme = @polymorphic_methods[qualified_key]
+            func_type = @function_types[qualified_key]
             break if func_type.is_a?(FunctionType)
             cls = @class_parents[cls]
           end
           if func_type.is_a?(FunctionType)
-            # Directly unify — monomorphic binding allows call-site types to flow into method body
-            unify_call_args(func_type, arg_types)
-            # Unify keyword args from call site
-            unify_keyword_args(node, :"#{class_name}##{method_name}")
-            infer_block_body_without_rbs(node.block) if node.block
-            return @unifier.apply(func_type.return_type)
+            if polymorphic_scheme
+              # Polymorphic instance methods: try unification but allow type mismatches.
+              # If a type mismatch occurs (e.g., []= called with String then Integer),
+              # fall through to dynamic dispatch (UNTYPED return).
+              begin
+                unify_call_args(func_type, arg_types)
+                unify_keyword_args(node, :"#{class_name}##{method_name}")
+                infer_block_body_without_rbs(node.block) if node.block
+                return @unifier.apply(func_type.return_type)
+              rescue UnificationError
+                # Type mismatch on polymorphic instance method — fall through to
+                # dynamic dispatch. This handles cases like c["name"] = "Alice"
+                # followed by c["age"] = 30 where val type differs across calls.
+                infer_block_body_without_rbs(node.block) if node.block
+                return Types::UNTYPED
+              end
+            else
+              # Monomorphic binding: call-site types flow into method body
+              unify_call_args(func_type, arg_types)
+              unify_keyword_args(node, :"#{class_name}##{method_name}")
+              infer_block_body_without_rbs(node.block) if node.block
+              return @unifier.apply(func_type.return_type)
+            end
           end
         end
 
@@ -1208,23 +1247,29 @@ module Konpeito
         # Guard against UntypedFunction (which lacks required_positionals)
         return Types::UNTYPED if method_type.type.is_a?(RBS::Types::UntypedFunction)
 
-        # Unify argument types with parameter types from RBS
-        rbs_params = method_type.type.required_positionals + method_type.type.optional_positionals
-        arg_types.each_with_index do |arg_type, i|
-          next unless rbs_params[i]
-          expected_type = substitute_rbs_type(rbs_params[i].type, substitution)
-          @unifier.unify(arg_type, expected_type)
-        end
+        begin
+          # Unify argument types with parameter types from RBS
+          rbs_params = method_type.type.required_positionals + method_type.type.optional_positionals
+          arg_types.each_with_index do |arg_type, i|
+            next unless rbs_params[i]
+            expected_type = substitute_rbs_type(rbs_params[i].type, substitution)
+            @unifier.unify(arg_type, expected_type)
+          end
 
-        # Convert and return the return type
-        return_type = substitute_rbs_type(method_type.type.return_type, substitution)
+          # Convert and return the return type
+          return_type = substitute_rbs_type(method_type.type.return_type, substitution)
 
-        # Handle block if present
-        if node.block && method_type.block
-          infer_block_for_rbs(node.block, method_type.block, substitution)
-        end
+          # Handle block if present
+          if node.block && method_type.block
+            infer_block_for_rbs(node.block, method_type.block, substitution)
+          end
 
-        @unifier.apply(return_type)
+          @unifier.apply(return_type)
+        rescue UnificationError
+          # RBS type unification failed — fall through to dynamic dispatch
+          infer_block_body_without_rbs(node.block) if node.block
+          nil
+        end
       end
 
       # Build substitution map for singleton method type parameters
@@ -1281,24 +1326,32 @@ module Konpeito
         # Guard against UntypedFunction (which lacks required_positionals)
         return Types::UNTYPED if method_type.type.is_a?(RBS::Types::UntypedFunction)
 
-        # Unify argument types with parameter types from RBS
-        # This allows us to infer argument types from method signatures
-        rbs_params = method_type.type.required_positionals + method_type.type.optional_positionals
-        arg_types.each_with_index do |arg_type, i|
-          next unless rbs_params[i]
-          expected_type = substitute_rbs_type(rbs_params[i].type, substitution)
-          @unifier.unify(arg_type, expected_type)
-        end
+        begin
+          # Unify argument types with parameter types from RBS
+          # This allows us to infer argument types from method signatures
+          rbs_params = method_type.type.required_positionals + method_type.type.optional_positionals
+          arg_types.each_with_index do |arg_type, i|
+            next unless rbs_params[i]
+            expected_type = substitute_rbs_type(rbs_params[i].type, substitution)
+            @unifier.unify(arg_type, expected_type)
+          end
 
-        # Substitute and convert return type
-        return_type = substitute_rbs_type(method_type.type.return_type, substitution)
+          # Substitute and convert return type
+          return_type = substitute_rbs_type(method_type.type.return_type, substitution)
 
-        # Handle block if present (for methods like map)
-        if node.block && method_type.block
-          infer_block_for_rbs(node.block, method_type.block, substitution)
-        end
+          # Handle block if present (for methods like map)
+          if node.block && method_type.block
+            infer_block_for_rbs(node.block, method_type.block, substitution)
+          end
 
-        @unifier.apply(return_type)
+          @unifier.apply(return_type)
+        rescue UnificationError
+          # RBS type unification failed — Ruby stdlib RBS has complex type signatures
+          # (e.g., sort_by block returns Comparable | Array[untyped], flat_map returns Array[U] | U)
+          # that may not unify cleanly with concrete types. Fall through to dynamic dispatch.
+          infer_block_body_without_rbs(node.block) if node.block
+          nil
+        end
       end
 
       # Build substitution map from class type parameters to actual types
@@ -1491,10 +1544,14 @@ module Konpeito
         # The block's return type should unify with the RBS block's return type
         # For example: map's block { (Elem) -> U } means block returns U
 
+        # BlockArgumentNode (&blk) has no parameters or body — skip block inference entirely
+        return Types::UNTYPED if block_node.is_a?(Prism::BlockArgumentNode)
+
         push_env
 
         # Bind block parameters (skip if UntypedFunction)
-        if block_node.parameters && rbs_block.type.respond_to?(:required_positionals)
+        # BlockArgumentNode (&blk) does not have a parameters method - skip it
+        if !block_node.is_a?(Prism::BlockArgumentNode) && block_node.respond_to?(:parameters) && block_node.parameters && rbs_block.type.respond_to?(:required_positionals)
           if block_node.parameters.is_a?(Prism::NumberedParametersNode)
             # Numbered block parameters (_1, _2, ...)
             rbs_positionals = rbs_block.type.required_positionals
@@ -1542,6 +1599,8 @@ module Konpeito
       # Infer block body without RBS block type info.
       # Block parameters become fresh TypeVars; captured variables retain outer scope types.
       def infer_block_body_without_rbs(block_node)
+        return if block_node.is_a?(Prism::BlockArgumentNode)
+
         push_env
         if block_node.parameters
           if block_node.parameters.is_a?(Prism::NumberedParametersNode)

data/lib/konpeito/type_checker/types.rb

@@ -145,13 +145,13 @@ module Konpeito
 
         # Basic Ruby class hierarchy
         CLASS_HIERARCHY = {
-          Integer: [:Numeric, :Object, :BasicObject],
-          Float: [:Numeric, :Object, :BasicObject],
-          Rational: [:Numeric, :Object, :BasicObject],
+          Integer: [:Numeric, :Comparable, :Object, :BasicObject],
+          Float: [:Numeric, :Comparable, :Object, :BasicObject],
+          Rational: [:Numeric, :Comparable, :Object, :BasicObject],
           Complex: [:Numeric, :Object, :BasicObject],
-          Numeric: [:Object, :BasicObject],
-          String: [:Object, :BasicObject],
-          Symbol: [:Object, :BasicObject],
+          Numeric: [:Comparable, :Object, :BasicObject],
+          String: [:Comparable, :Object, :BasicObject],
+          Symbol: [:Comparable, :Object, :BasicObject],
           Array: [:Object, :BasicObject],
           Hash: [:Object, :BasicObject],
           TrueClass: [:Object, :BasicObject],

data/lib/konpeito/type_checker/unification.rb

@@ -18,8 +18,15 @@ module Konpeito
       end
 
       def to_s
+        # Guard against circular type variable references (e.g., TypeVar → Union → TypeVar)
+        visiting = Thread.current[:__typevar_visiting] ||= Set.new
+        return @name if visiting.include?(@id)
+
         if @instance
-          @instance.to_s
+          visiting.add(@id)
+          result = @instance.to_s
+          visiting.delete(@id)
+          result
         else
           @name
         end

data/lib/konpeito/version.rb

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

data/tools/konpeito-asm/build.sh

@@ -44,6 +44,7 @@ mkdir -p "$BUILD_DIR/konpeito/runtime"
     "$SCRIPT_DIR/src/konpeito/runtime/KRactor.java" \
     "$SCRIPT_DIR/src/konpeito/runtime/KRactorPort.java" \
     "$SCRIPT_DIR/src/konpeito/runtime/KMatchData.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KFiber.java" \
     "$SCRIPT_DIR/src/konpeito/runtime/RubyDispatch.java"
 
 # Copy runtime classes to a separate directory for JAR bundling

data/tools/konpeito-asm/src/KonpeitoAssembler.java

@@ -206,7 +206,12 @@ public class KonpeitoAssembler {
             emitInstruction(mv, inst, labels);
         }
 
-        mv.visitMaxs(0, 0); // ASM COMPUTE_MAXS handles this
+        try {
+            mv.visitMaxs(0, 0); // ASM COMPUTE_MAXS handles this
+        } catch (Exception e) {
+            System.err.println("ASM error in class=" + cw + " method=" + name + " descriptor=" + descriptor);
+            throw e;
+        }
         mv.visitEnd();
     }
 
@@ -275,6 +280,13 @@ public class KonpeitoAssembler {
             // --- Arithmetic (int) ---
             case "iadd" -> mv.visitInsn(Opcodes.IADD);
             case "isub" -> mv.visitInsn(Opcodes.ISUB);
+            case "imul" -> mv.visitInsn(Opcodes.IMUL);
+            case "iand" -> mv.visitInsn(Opcodes.IAND);
+            case "ior" -> mv.visitInsn(Opcodes.IOR);
+
+            // --- Short/byte push ---
+            case "bipush" -> mv.visitIntInsn(Opcodes.BIPUSH, getInt(inst, "value"));
+            case "sipush" -> mv.visitIntInsn(Opcodes.SIPUSH, getInt(inst, "value"));
 
             // --- Arithmetic (long) ---
             case "ladd" -> mv.visitInsn(Opcodes.LADD);
@@ -441,6 +453,10 @@ public class KonpeitoAssembler {
             case "dastore" -> mv.visitInsn(Opcodes.DASTORE);
             case "aaload" -> mv.visitInsn(Opcodes.AALOAD);
             case "aastore" -> mv.visitInsn(Opcodes.AASTORE);
+            case "baload" -> mv.visitInsn(Opcodes.BALOAD);
+            case "bastore" -> mv.visitInsn(Opcodes.BASTORE);
+            case "iaload" -> mv.visitInsn(Opcodes.IALOAD);
+            case "iastore" -> mv.visitInsn(Opcodes.IASTORE);
 
             // --- Exception handling ---
             case "athrow" -> mv.visitInsn(Opcodes.ATHROW);