konpeito 0.2.4 → 0.3.0

data/lib/konpeito/dependency_resolver.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
 module Konpeito
-  # Known standard library names that can be loaded at runtime via rb_require
-  # This list is derived from Ruby's bundled RBS stdlib definitions
+  # Native extension file extensions to check when scanning gem directories
+  NATIVE_EXTENSIONS = %w[.bundle .so .dll .dylib].freeze
+
+  # Known standard library names that can be loaded at runtime via rb_require.
+  # This list acts as a fast path; dynamic gem detection via Gem.path covers the rest.
   KNOWN_STDLIB_LIBRARIES = %w[
-    json fileutils find pathname tempfile timeout uri yaml
+    json fileutils find pathname tempfile timeout uri yaml tmpdir
     digest openssl socket stringio csv date time set
     net/http net/https net/ftp net/smtp net/pop net/imap
     securerandom base64 benchmark erb logger optparse
@@ -184,9 +187,9 @@ module Konpeito
             @cache_manager.add_dependency(path, dep_path)
           end
           resolve_file(dep_path)
-        elsif req[:type] == :require && stdlib_library?(req[:name])
-          # Known stdlib library - will be loaded at runtime via rb_require
-          log "  Detected stdlib require: #{req[:name]}"
+        elsif req[:type] == :require && runtime_loadable?(req[:name])
+          # Stdlib or installed gem — will be loaded at runtime via rb_require
+          log "  Detected runtime require: #{req[:name]}"
           @stdlib_requires << req[:name]
         elsif req[:type] == :require_relative
           # Check if this points to a native extension (.bundle/.so/.dll)
@@ -207,10 +210,10 @@ module Konpeito
             )
           end
         else
-          # Unknown require - likely a gem that must be required at runtime
+          # Unknown require that cannot be resolved statically or found in gems.
           raise DependencyError.new(
             "Cannot resolve require: #{req[:name]}. " \
-            "If this is a gem, use require at runtime in Ruby code instead of compile-time.",
+            "If this is a gem, ensure it is installed (`gem install #{req[:name]}`).",
             from_file: path,
             line: req[:line],
             missing_file: req[:name]
@@ -283,7 +286,27 @@ module Konpeito
       %w[.bundle .so .dll .dylib].any? { |ext| File.exist?("#{base}#{ext}") }
     end
 
-    # Check if a name is a known stdlib library
+    # Check whether a require target can be loaded at runtime (stdlib or installed gem).
+    # This replaces the hardcoded KNOWN_STDLIB_LIBRARIES approach with dynamic detection.
+    def runtime_loadable?(name)
+      # Fast path: known stdlib names (avoids gem lookup overhead for common stdlib)
+      return true if stdlib_library?(name)
+
+      # Dynamic gem detection: scan all GEM_PATH directories for a matching lib file.
+      # Using Gem.path (not Gem.find_files) because bundler restricts Gem.find_files
+      # to only activated gems, while Gem.path covers all installed gem homes.
+      name_rb = name.end_with?(".rb") ? name : "#{name}.rb"
+      Gem.path.any? do |gem_home|
+        Dir.glob(File.join(gem_home, "gems", "*", "lib")).any? do |lib_dir|
+          File.exist?(File.join(lib_dir, name_rb)) ||
+            NATIVE_EXTENSIONS.any? { |ext| File.exist?(File.join(lib_dir, "#{name}#{ext}")) }
+        end
+      end
+    rescue LoadError, NameError
+      false
+    end
+
+    # Check if a name is a known stdlib library (fast path, kept for backwards compat)
     def stdlib_library?(name)
       # Normalize: convert dashes to underscores for matching
       normalized = name.tr("-", "_")

data/lib/konpeito/hir/builder.rb

@@ -134,6 +134,10 @@ module Konpeito
       end
 
       def visit_program(typed_node)
+        # Scan top-level statements for include/extend/prepend before visiting
+        # These need to be executed in the Init function before class definitions
+        scan_toplevel_includes(typed_node.children.first)
+
         # Create a main function for top-level code
         main_func = Function.new(
           name: "__main__",
@@ -541,6 +545,26 @@ module Konpeito
         NilLit.new
       end
 
+      # Scan top-level statements for include/extend/prepend calls
+      # These must be executed in Init before class definitions so that
+      # constants from included modules are available for superclass resolution.
+      def scan_toplevel_includes(statements_node)
+        return unless statements_node&.children
+
+        statements_node.children.each do |child|
+          if include_statement?(child)
+            module_name = extract_include_module_name(child)
+            @program.toplevel_includes << [:include, module_name] if module_name
+          elsif extend_statement?(child)
+            module_name = extract_include_module_name(child)
+            @program.toplevel_includes << [:extend, module_name] if module_name
+          elsif prepend_statement?(child)
+            module_name = extract_include_module_name(child)
+            @program.toplevel_includes << [:prepend, module_name] if module_name
+          end
+        end
+      end
+
       # Check if a node is an include statement
       def include_statement?(typed_node)
         return false unless typed_node.node_type == :call
@@ -781,7 +805,11 @@ module Konpeito
 
         method_names = []
         singleton_method_names = []
+        module_function_method_names = []
+        module_private_method_names = Set.new
         module_constants = {}
+        # Track current visibility state within this module body
+        module_visibility = :public
 
         # Visit body within module context
         old_module = @current_module
@@ -802,6 +830,12 @@ module Konpeito
                   func.is_instance_method = false if func && func.name.to_s == method_name
                 else
                   method_names << method_name
+                  case module_visibility
+                  when :module_function
+                    module_function_method_names << method_name
+                  when :private
+                    module_private_method_names << method_name
+                  end
                 end
               elsif child.node_type == :singleton_class
                 # class << self in module - collect singleton methods
@@ -818,13 +852,29 @@ module Konpeito
                   end
                 end
               elsif child.node_type == :constant_write
-                # Handle constant assignment within module
+                # Handle constant assignment within module.
+                # Collect literal value for C Init optimization (simple constants only).
+                # Also emit StoreConstant into __main__ for non-literal values (Mutex.new,
+                # {}, File.join(...), etc.) so they get initialized at runtime via rb_const_set.
+                # Simple literals are already set in C Init, so we skip them here to avoid
+                # "already initialized constant" warnings.
                 const_name = child.node.name.to_s
-                module_constants[const_name] = visit_literal_value(child.children.first)
+                lit_val = visit_literal_value(child.children.first)
+                module_constants[const_name] = lit_val
+                # Only emit for non-literal values (literals handled by C Init)
+                unless lit_val.is_a?(HIR::IntegerLit) || lit_val.is_a?(HIR::FloatLit) ||
+                       lit_val.is_a?(HIR::StringLit) || lit_val.is_a?(HIR::SymbolLit) ||
+                       lit_val.is_a?(HIR::BoolLit) || lit_val.is_a?(HIR::NilLit)
+                  visit(child)
+                end
               elsif child.node_type == :class_variable_write
                 # Handle class variable initialization within module
                 # (modules can have class variables too)
                 visit(child)
+              elsif module_visibility_modifier?(child)
+                # module_function / private / public / protected as bare calls — compilation
+                # directive only, must NOT emit a runtime rb_funcallv call into __main__.
+                module_visibility = extract_module_visibility(child)
               else
                 visit(child)
               end
@@ -834,17 +884,45 @@ module Konpeito
 
         @current_module = old_module
 
-        module_def = ModuleDef.new(
-          name: name,
-          methods: method_names,
-          singleton_methods: singleton_method_names,
-          constants: module_constants
-        )
-
-        @program.modules << module_def
+        # Merge into existing ModuleDef if this module was already opened (multi-file projects)
+        existing_module_def = @program.modules.find { |m| m.name == name }
+        if existing_module_def
+          existing_module_def.methods.concat(method_names)
+          existing_module_def.singleton_methods.concat(singleton_method_names)
+          existing_module_def.module_function_methods.concat(module_function_method_names)
+          existing_module_def.private_methods.merge(module_private_method_names)
+          existing_module_def.constants.merge!(module_constants)
+        else
+          module_def = ModuleDef.new(
+            name: name,
+            methods: method_names,
+            singleton_methods: singleton_method_names,
+            constants: module_constants
+          )
+          module_def.module_function_methods.concat(module_function_method_names)
+          module_def.private_methods.merge(module_private_method_names)
+          @program.modules << module_def
+        end
         NilLit.new
       end
 
+      # Check if a node is a bare visibility modifier inside a module body
+      # (module_function, private, public, protected with no arguments and no receiver)
+      def module_visibility_modifier?(typed_node)
+        return false unless typed_node.node_type == :call
+        return false unless typed_node.node.receiver.nil?
+        name = typed_node.node.name.to_s
+        return false unless %w[module_function private public protected].include?(name)
+        # Must be bare (no arguments) or have only symbol arguments (per-method form)
+        true
+      end
+
+      # Extract the visibility symbol from a visibility modifier call node
+      def extract_module_visibility(typed_node)
+        name = typed_node.node.name.to_s
+        name == "module_function" ? :module_function : name.to_sym
+      end
+
       # Check if a def node is a singleton method (def self.method)
       def singleton_method?(typed_node)
         return false unless typed_node.node_type == :def
@@ -2098,6 +2176,7 @@ module Konpeito
         # Get arguments and keyword arguments
         args = []
         keyword_args = {}
+        keyword_splat = nil
         args_child = typed_node.children.find { |c| c.node_type == :arguments }
         if args_child
           args_child.children.each do |arg|
@@ -2117,6 +2196,15 @@ module Konpeito
                     # Fallback: create typed node for the value
                     keyword_args[key_name] = visit_node_directly(elem.value)
                   end
+                elsif elem.is_a?(Prism::AssocSplatNode) && elem.value
+                  # **hash at call site — capture the splatted hash expression
+                  typed_assoc = arg.children[ei]
+                  splat_expr = if typed_assoc && typed_assoc.children && !typed_assoc.children.empty?
+                    visit(typed_assoc.children.first)
+                  else
+                    visit_node_directly(elem.value)
+                  end
+                  keyword_splat = splat_expr
                 end
               end
             elsif arg.node.is_a?(Prism::SplatNode)
@@ -2211,6 +2299,7 @@ module Konpeito
           args: args,
           block: block,
           keyword_args: keyword_args,
+          keyword_splat: keyword_splat,
           type: typed_node.type,
           result_var: result_var,
           safe_navigation: is_safe_nav
@@ -5990,13 +6079,84 @@ module Konpeito
 
       # Detect variables from outer scope that are used in the block
       def detect_captured_variables(outer_vars)
-        # For now, capture all outer variables that exist
-        # A more sophisticated approach would analyze actual usage
-        outer_vars.keys.map do |name|
+        # Only capture outer variables that are actually referenced (read or written)
+        # in the block body or any nested block bodies within it.
+        referenced = Set.new
+        block_body = @current_function.body
+        scan_block_body_for_captures(block_body, outer_vars, referenced)
+        referenced.map do |name|
           Capture.new(name: name, type: outer_vars[name].type)
         end
       end
 
+      # Recursively scan basic blocks for variable references to outer scope,
+      # including nested block definitions (e.g., mutex.synchronize { ... })
+      def scan_block_body_for_captures(blocks, outer_vars, referenced)
+        blocks.each do |bb|
+          bb.instructions.each do |inst|
+            scan_instruction_for_captures(inst, outer_vars, referenced)
+          end
+          # Also check terminator for variable references
+          if bb.terminator
+            scan_instruction_for_captures(bb.terminator, outer_vars, referenced)
+          end
+        end
+      end
+
+      # Recursively scan a single HIR instruction (and its sub-expressions) for captures
+      def scan_instruction_for_captures(node, outer_vars, referenced)
+        return unless node.is_a?(Instruction)
+        case node
+        when LoadLocal
+          referenced << node.var.name if outer_vars.key?(node.var.name)
+        when StoreLocal
+          referenced << node.var.name if outer_vars.key?(node.var.name)
+          scan_instruction_for_captures(node.value, outer_vars, referenced) if node.value.is_a?(Instruction)
+        when Call
+          scan_instruction_for_captures(node.receiver, outer_vars, referenced) if node.receiver
+          node.args.each { |a| scan_instruction_for_captures(a, outer_vars, referenced) }
+          if node.block && node.block.respond_to?(:body) && node.block.body
+            scan_block_body_for_captures(node.block.body, outer_vars, referenced)
+          end
+        when ThreadNew, ProcNew, FiberNew, RactorNew
+          if node.respond_to?(:block_def) && node.block_def
+            scan_block_body_for_captures(node.block_def.body, outer_vars, referenced)
+          end
+        else
+          # Generic fallback: scan sub-expressions and nested block bodies
+          # for instruction types like MutexSynchronize, BeginRescue, etc.
+          if node.respond_to?(:block_def) && node.block_def
+            scan_block_body_for_captures(node.block_def.body, outer_vars, referenced)
+          end
+          # Scan known sub-expression attributes that may reference outer variables
+          [:mutex, :cv, :queue, :value, :receiver, :ractor, :port, :max_size, :key].each do |attr|
+            if node.respond_to?(attr)
+              sub = node.send(attr)
+              scan_instruction_for_captures(sub, outer_vars, referenced) if sub.is_a?(Instruction)
+            end
+          end
+          # Scan args array if present
+          if node.respond_to?(:args) && node.args.is_a?(Array)
+            node.args.each { |a| scan_instruction_for_captures(a, outer_vars, referenced) }
+          end
+          # Scan nested HIR blocks (BeginRescue try/rescue/else/ensure blocks)
+          if node.respond_to?(:try_hir_blocks) && node.try_hir_blocks
+            scan_block_body_for_captures(node.try_hir_blocks, outer_vars, referenced)
+          end
+          if node.respond_to?(:rescue_clauses) && node.rescue_clauses
+            node.rescue_clauses.each do |clause|
+              scan_block_body_for_captures(clause.body, outer_vars, referenced) if clause.respond_to?(:body) && clause.body
+            end
+          end
+          if node.respond_to?(:else_blocks) && node.else_blocks
+            scan_block_body_for_captures(node.else_blocks, outer_vars, referenced)
+          end
+          if node.respond_to?(:ensure_blocks) && node.ensure_blocks
+            scan_block_body_for_captures(node.ensure_blocks, outer_vars, referenced)
+          end
+        end
+      end
+
       def build_block_params(params_node)
         result = []
         params_node.parameters&.requireds&.each do |param|
@@ -6624,14 +6784,56 @@ module Konpeito
         ensure_child = typed_node.children.find { |c| c.node_type == :ensure }
 
         result_var = new_temp_var
+        has_rescue = rescue_child != nil
 
-        # Collect try instructions (without creating new blocks)
+        # When rescue clauses are present, collect the try body into a separate HIR block
+        # list using BlockBodyCollector so that control flow (if/else etc.) inside the try
+        # body does NOT bleed into the outer function's basic block graph.
+        # This prevents invalid phi-node predecessors in the rescue try callback.
+        try_hir_blocks = nil
         try_instructions = []
-        if statements_child
+
+        if has_rescue && statements_child
+          saved_function    = @current_function
+          saved_current_blk = @current_block
+
+          @block_counter += 1
+          try_entry = BasicBlock.new(label: "rescue_try_entry_#{@block_counter}")
+          try_hir_blocks = [try_entry]
+          @current_function = BlockBodyCollector.new(try_hir_blocks)
+          set_current_block(try_entry)
+
           statements_child.children.each do |stmt|
             inst = visit(stmt)
             try_instructions << inst if inst
           end
+
+          # Close the last open block with a Return
+          unless @current_block.terminator
+            last_val = try_instructions.last
+            @current_block.set_terminator(Return.new(value: last_val || NilLit.new))
+          end
+
+          @current_function = saved_function
+          set_current_block(saved_current_blk)
+        elsif statements_child
+          # No rescue clauses: inline (original behaviour)
+          # Capture ALL emitted instructions (not just return values) because
+          # visit() for assignment nodes emits StoreLocal but returns the value.
+          # Guard: visit() may change @current_block (if/else, while, etc.),
+          # in which case fall back to original behavior.
+          statements_child.children.each do |stmt|
+            saved_block = @current_block
+            before_idx = @current_block.instructions.size
+            inst = visit(stmt)
+            if @current_block.equal?(saved_block) && @current_block.instructions.size >= before_idx
+              @current_block.instructions[before_idx..]&.each do |emitted|
+                try_instructions << emitted
+              end
+            else
+              try_instructions << inst if inst
+            end
+          end
         end
 
         # Record instruction count after try body - everything emitted after this
@@ -6644,26 +6846,43 @@ module Konpeito
           rescue_clauses = build_rescue_clauses(rescue_child)
         end
 
-        # Collect else instructions
+        # Collect else instructions - capture ALL emitted instructions
+        # (visit() for assignments emits StoreLocal but returns the value)
         else_instructions = []
         if else_child
           else_statements = else_child.children.find { |c| c.node_type == :statements }
           if else_statements
             else_statements.children.each do |stmt|
+              saved_block = @current_block
+              before_idx = @current_block.instructions.size
               inst = visit(stmt)
-              else_instructions << inst if inst
+              if @current_block.equal?(saved_block) && @current_block.instructions.size >= before_idx
+                @current_block.instructions[before_idx..]&.each do |emitted|
+                  else_instructions << emitted
+                end
+              else
+                else_instructions << inst if inst
+              end
             end
           end
         end
 
-        # Collect ensure instructions
+        # Collect ensure instructions - capture ALL emitted instructions
         ensure_instructions = []
         if ensure_child
           ensure_statements = ensure_child.children.find { |c| c.node_type == :statements }
           if ensure_statements
             ensure_statements.children.each do |stmt|
+              saved_block = @current_block
+              before_idx = @current_block.instructions.size
               inst = visit(stmt)
-              ensure_instructions << inst if inst
+              if @current_block.equal?(saved_block) && @current_block.instructions.size >= before_idx
+                @current_block.instructions[before_idx..]&.each do |emitted|
+                  ensure_instructions << emitted
+                end
+              else
+                ensure_instructions << inst if inst
+              end
             end
           end
         end
@@ -6671,12 +6890,13 @@ module Konpeito
         # Collect ALL instruction object_ids emitted during rescue/else/ensure visitation
         # This includes sub-expression instructions (e.g. StringLit for literal args)
         non_try_ids = Set.new
-        @current_block.instructions[non_try_start_idx..].each do |i|
+        (@current_block.instructions[non_try_start_idx..] || []).each do |i|
           non_try_ids << i.object_id
         end
 
         inst = BeginRescue.new(
           try_blocks: try_instructions,
+          try_hir_blocks: try_hir_blocks,
           rescue_clauses: rescue_clauses,
           else_blocks: else_instructions,
           ensure_blocks: ensure_instructions,
@@ -6710,13 +6930,23 @@ module Konpeito
             exception_var = current.node.reference.name.to_s
           end
 
-          # Collect body instructions
+          # Collect body instructions - capture ALL emitted instructions
+          # (visit() for assignments emits StoreLocal but returns the value)
+          # Guard: visit() may change @current_block (if/else, while, etc.)
           body_instructions = []
           statements_child = current.children.find { |c| c.node_type == :statements }
           if statements_child
             statements_child.children.each do |stmt|
+              saved_block = @current_block
+              before_idx = @current_block.instructions.size
               inst = visit(stmt)
-              body_instructions << inst if inst
+              if @current_block.equal?(saved_block) && @current_block.instructions.size >= before_idx
+                @current_block.instructions[before_idx..]&.each do |emitted|
+                  body_instructions << emitted
+                end
+              else
+                body_instructions << inst if inst
+              end
             end
           end
 
@@ -6735,7 +6965,10 @@ module Konpeito
       end
 
       def visit_case(typed_node)
-        # Handle case/when/else statements
+        # Handle case/when/else statements by creating proper HIR basic blocks,
+        # like visit_if does. This avoids the CaseStatement-embedding approach which
+        # caused when-body instructions to execute unconditionally in the entry block.
+        #
         # case x
         # when 1 then "one"
         # when 2, 3 then "small"
@@ -6753,62 +6986,141 @@ module Konpeito
           end
         end
 
-        # Record instruction count after predicate - everything after is when/else sub-instructions
-        sub_start_idx = @current_block.instructions.size
+        # Create merge block
+        merge_block = new_block("case_merge")
+        incoming = {}   # { hir_block_label => result_hir_node }
+
+        when_nodes = typed_node.children.select { |c| c.node_type == :when }
+        has_else = typed_node.children.any? { |c| c.node_type == :else }
+
+        when_nodes.each_with_index do |when_child, i|
+          # Extract conditions and body statements
+          conditions = []
+          body_stmts = nil
+          when_child.children.each do |child|
+            if child.node_type == :statements
+              body_stmts = child
+            else
+              # Evaluate condition in the current check block
+              cond = visit(child)
+              conditions << cond
+            end
+          end
+
+          body_block = new_block("when_body")
+          is_last_when = (i == when_nodes.size - 1)
+          next_block = new_block(is_last_when && !has_else ? "when_else" : "when_check")
 
-        # Build when clauses
-        when_clauses = []
-        typed_node.children.select { |c| c.node_type == :when }.each do |when_child|
-          when_clause = build_when_clause(when_child)
-          when_clauses << when_clause
+          # Generate condition checks with OR logic for multiple conditions
+          if predicate.nil?
+            # No predicate: treat conditions as boolean (truthy) directly
+            if conditions.empty?
+              @current_block.set_terminator(Jump.new(target: body_block.label))
+            else
+              # OR chain: if any condition is truthy, execute body
+              remaining = conditions.dup
+              last_cond = remaining.pop
+              remaining.each do |cond|
+                or_check_block = new_block("when_or_check")
+                @current_block.set_terminator(Branch.new(
+                  condition: cond,
+                  then_block: body_block.label,
+                  else_block: or_check_block.label
+                ))
+                set_current_block(or_check_block)
+              end
+              @current_block.set_terminator(Branch.new(
+                condition: last_cond,
+                then_block: body_block.label,
+                else_block: next_block.label
+              ))
+            end
+          else
+            # With predicate: use === comparison
+            if conditions.empty?
+              @current_block.set_terminator(Jump.new(target: body_block.label))
+            else
+              remaining = conditions.dup
+              last_cond = remaining.pop
+              remaining.each do |cond|
+                check_var = new_temp_var
+                check = CaseEqualityCheck.new(condition: cond, predicate: predicate, result_var: check_var)
+                emit(check)
+                or_check_block = new_block("when_or_check")
+                @current_block.set_terminator(Branch.new(
+                  condition: check,
+                  then_block: body_block.label,
+                  else_block: or_check_block.label
+                ))
+                set_current_block(or_check_block)
+              end
+              check_var = new_temp_var
+              check = CaseEqualityCheck.new(condition: last_cond, predicate: predicate, result_var: check_var)
+              emit(check)
+              @current_block.set_terminator(Branch.new(
+                condition: check,
+                then_block: body_block.label,
+                else_block: next_block.label
+              ))
+            end
+          end
+
+          # Generate body in body_block
+          set_current_block(body_block)
+          body_result = NilLit.new
+          if body_stmts
+            body_stmts.children.each do |stmt|
+              result = visit(stmt)
+              body_result = result if result
+            end
+          end
+          body_exit = @current_block
+          unless @current_block.terminator
+            @current_block.set_terminator(Jump.new(target: merge_block.label))
+          end
+          incoming[body_exit.label] = body_result
+
+          # Move to next check block
+          set_current_block(next_block)
         end
 
-        # Build else body
-        else_body = nil
+        # Else body (in the last check/else block = @current_block)
         else_child = typed_node.children.find { |c| c.node_type == :else }
+        else_result = NilLit.new
         if else_child
-          else_body = []
-          else_statements = else_child.children.find { |c| c.node_type == :statements }
-          if else_statements
-            else_statements.children.each do |stmt|
-              inst = visit(stmt)
-              else_body << inst if inst
+          else_stmts = else_child.children.find { |c| c.node_type == :statements }
+          if else_stmts
+            else_stmts.children.each do |stmt|
+              result = visit(stmt)
+              else_result = result if result
             end
           end
         end
-
-        # Collect ALL instruction IDs emitted during when/else visitation
-        sub_ids = Set.new
-        @current_block.instructions[sub_start_idx..].each do |i|
-          sub_ids << i.object_id
+        else_exit = @current_block
+        unless @current_block.terminator
+          @current_block.set_terminator(Jump.new(target: merge_block.label))
         end
+        incoming[else_exit.label] = else_result
 
-        inst = CaseStatement.new(
-          predicate: predicate,
-          when_clauses: when_clauses,
-          else_body: else_body,
-          type: typed_node.type,
-          result_var: result_var
-        )
-        inst.sub_instruction_ids = sub_ids
-        emit(inst)
-        inst
+        # Merge block with phi node
+        set_current_block(merge_block)
+        phi = Phi.new(incoming: incoming, type: typed_node.type, result_var: result_var)
+        emit(phi)
+        phi
       end
 
       def build_when_clause(when_typed_node)
-        # Extract conditions and body from when clause
+        # Extract conditions and body from when clause (kept for backward compatibility)
         conditions = []
         body = []
 
         when_typed_node.children.each do |child|
           if child.node_type == :statements
-            # This is the body
             child.children.each do |stmt|
               inst = visit(stmt)
               body << inst if inst
             end
           else
-            # This is a condition
             conditions << visit(child)
           end
         end
@@ -7470,7 +7782,7 @@ module Konpeito
 
       def new_temp_var
         @var_counter += 1
-        "t#{@var_counter}"
+        "__t#{@var_counter}"
       end
     end
   end