konpeito 0.1.0

data/lib/konpeito/codegen/inliner.rb

@@ -0,0 +1,486 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Codegen
+    # Inlines small functions at call sites to eliminate call overhead
+    # and enable further optimizations.
+    #
+    # Inlining criteria:
+    # - Function body has <= MAX_INLINE_INSTRUCTIONS instructions
+    # - No recursion (direct or indirect)
+    # - Not a class method (for simplicity)
+    #
+    class Inliner
+      MAX_INLINE_INSTRUCTIONS = 10
+      MAX_INLINE_DEPTH = 3
+
+      attr_reader :inlined_count
+
+      def initialize(hir_program)
+        @hir_program = hir_program
+        @functions = {}  # name -> HIR::Function
+        @inline_candidates = {}  # name -> true/false
+        @call_graph = {}  # name -> Set of called function names
+        @inlined_count = 0
+        @current_depth = 0
+      end
+
+      # Analyze and transform the HIR program
+      def optimize
+        build_function_map
+        build_call_graph
+        identify_candidates
+        inline_functions
+      end
+
+      private
+
+      def build_function_map
+        @hir_program.functions.each do |func|
+          @functions[func.name.to_s] = func
+        end
+      end
+
+      def build_call_graph
+        @hir_program.functions.each do |func|
+          calls = Set.new
+          func.body.each do |block|
+            block.instructions.each do |inst|
+              if inst.is_a?(HIR::Call) && self_call?(inst)
+                calls << inst.method_name.to_s
+              end
+            end
+          end
+          @call_graph[func.name.to_s] = calls
+        end
+      end
+
+      def self_call?(inst)
+        inst.receiver.is_a?(HIR::SelfRef) ||
+          (inst.receiver.is_a?(HIR::Instruction) &&
+           inst.receiver.type.is_a?(TypeChecker::Types::Untyped))
+      end
+
+      def identify_candidates
+        @functions.each do |name, func|
+          @inline_candidates[name] = should_inline?(func)
+        end
+      end
+
+      def should_inline?(func)
+        # Skip main function
+        return false if func.name.to_s == "__main__"
+
+        # Skip class methods for now
+        return false if func.owner_class
+
+        # Skip functions with rest params (*args) or keyword_rest (**kwargs)
+        # The inliner doesn't support rest param array aggregation
+        return false if func.params.any? { |p| p.rest || p.keyword_rest }
+
+        # Skip functions with multiple blocks (contains if/while/etc.)
+        # These have complex control flow that can't be simply inlined
+        return false if func.body.size > 1
+
+        # Skip functions with Branch terminators (if statements)
+        # The inliner doesn't support control flow structures
+        func.body.each do |block|
+          return false if block.terminator.is_a?(HIR::Branch)
+        end
+
+        # Skip functions containing block calls (captures need complex transformation)
+        # Skip functions containing yield (need KBlock parameter handling)
+        # Skip functions containing BeginRescue (exception handling has complex sub-block structure)
+        func.body.each do |block|
+          block.instructions.each do |inst|
+            return false if inst.is_a?(HIR::Call) && inst.block
+            return false if inst.is_a?(HIR::Yield)
+            return false if inst.is_a?(HIR::BeginRescue)
+            return false if inst.is_a?(HIR::CaseStatement)
+            return false if inst.is_a?(HIR::CaseMatchStatement)
+          end
+        end
+
+        # Count instructions
+        instruction_count = func.body.sum { |block| block.instructions.size }
+        return false if instruction_count > MAX_INLINE_INSTRUCTIONS
+
+        # Check for recursion
+        return false if recursive?(func.name.to_s, Set.new)
+
+        true
+      end
+
+      def recursive?(func_name, visited)
+        return true if visited.include?(func_name)
+        visited = visited + [func_name]
+
+        calls = @call_graph[func_name] || Set.new
+        calls.any? { |callee| recursive?(callee, visited) }
+      end
+
+      def inline_functions
+        # Process each function
+        @hir_program.functions.each do |func|
+          @current_depth = 0
+          inline_in_function(func)
+        end
+      end
+
+      def inline_in_function(func)
+        return if @current_depth >= MAX_INLINE_DEPTH
+
+        changed = true
+        while changed
+          changed = false
+
+          func.body.each do |block|
+            new_instructions = []
+
+            block.instructions.each do |inst|
+              if inst.is_a?(HIR::Call) && can_inline_call?(inst)
+                # Inline this call
+                inlined = inline_call(inst, func)
+                new_instructions.concat(inlined)
+                changed = true
+                @inlined_count += 1
+              else
+                new_instructions << inst
+              end
+            end
+
+            # Replace instructions in block
+            block.instance_variable_set(:@instructions, new_instructions)
+          end
+        end
+      end
+
+      def can_inline_call?(inst)
+        return false unless self_call?(inst)
+
+        callee_name = inst.method_name.to_s
+        @inline_candidates[callee_name] == true
+      end
+
+      def inline_call(call_inst, caller_func)
+        callee = @functions[call_inst.method_name.to_s]
+        return [call_inst] unless callee
+
+        @current_depth += 1
+
+        # Create a unique prefix for inlined variables
+        prefix = "inline_#{@inlined_count}_"
+
+        # Map callee parameters to call arguments
+        param_map = {}
+        callee.params.each_with_index do |param, i|
+          if call_inst.args[i]
+            param_map[param.name] = call_inst.args[i]
+          end
+        end
+
+        # Clone and transform instructions from callee
+        result_instructions = []
+        final_value = nil
+
+        callee.body.each do |block|
+          block.instructions.each do |inst|
+            cloned = clone_and_rename(inst, prefix, param_map)
+            result_instructions << cloned if cloned
+            final_value = cloned
+          end
+
+          # Handle return in terminator
+          if block.terminator.is_a?(HIR::Return)
+            ret_value = block.terminator.value
+            if ret_value
+              final_value = transform_value(ret_value, prefix, param_map)
+            end
+          end
+        end
+
+        # Store result if needed
+        if call_inst.result_var && final_value
+          store = HIR::StoreLocal.new(
+            var: HIR::LocalVar.new(name: call_inst.result_var),
+            value: final_value,
+            type: call_inst.type
+          )
+          result_instructions << store
+        end
+
+        @current_depth -= 1
+        result_instructions
+      end
+
+      def clone_and_rename(inst, prefix, param_map)
+        case inst
+        when HIR::LoadLocal
+          # Check if this is a parameter reference
+          if param_map.key?(inst.var.name)
+            # Return the argument value directly
+            return nil if inst.result_var.nil?
+
+            # Store the argument value in the result variable
+            return HIR::StoreLocal.new(
+              var: HIR::LocalVar.new(name: prefix + inst.result_var),
+              value: param_map[inst.var.name],
+              type: inst.type
+            )
+          end
+
+          # Regular local variable
+          new_var = HIR::LocalVar.new(
+            name: prefix + inst.var.name,
+            type: inst.var.type
+          )
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::LoadLocal.new(var: new_var, type: inst.type, result_var: new_result)
+
+        when HIR::StoreLocal
+          new_var = HIR::LocalVar.new(
+            name: prefix + inst.var.name,
+            type: inst.var.type
+          )
+          new_value = transform_value(inst.value, prefix, param_map)
+          HIR::StoreLocal.new(var: new_var, value: new_value, type: inst.type)
+
+        when HIR::Call
+          new_receiver = transform_value(inst.receiver, prefix, param_map)
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+
+          HIR::Call.new(
+            receiver: new_receiver,
+            method_name: inst.method_name,
+            args: new_args,
+            block: inst.block,
+            type: inst.type,
+            result_var: new_result
+          )
+
+        when HIR::IntegerLit, HIR::FloatLit, HIR::StringLit,
+             HIR::SymbolLit, HIR::BoolLit
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          inst.class.new(value: inst.value, result_var: new_result)
+
+        when HIR::NilLit
+          # NilLit doesn't have a value parameter
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::NilLit.new(result_var: new_result)
+
+        when HIR::SelfRef
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::SelfRef.new(type: inst.type, result_var: new_result)
+
+        when HIR::StringConcat
+          # Transform all parts to handle parameter substitution
+          new_parts = inst.parts.map { |part| transform_value(part, prefix, param_map) }
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::StringConcat.new(parts: new_parts, result_var: new_result)
+
+        when HIR::RangeLit
+          new_left = transform_value(inst.left, prefix, param_map)
+          new_right = transform_value(inst.right, prefix, param_map)
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::RangeLit.new(
+            left: new_left, right: new_right,
+            exclusive: inst.exclusive, type: inst.type, result_var: new_result
+          )
+
+        when HIR::ArrayLit
+          new_elements = inst.elements.map { |e| transform_value(e, prefix, param_map) }
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::ArrayLit.new(
+            elements: new_elements, result_var: new_result
+          )
+
+        when HIR::HashLit
+          new_pairs = inst.pairs.map { |k, v| [transform_value(k, prefix, param_map), transform_value(v, prefix, param_map)] }
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::HashLit.new(
+            pairs: new_pairs, result_var: new_result
+          )
+
+        when HIR::LoadGlobalVar
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::LoadGlobalVar.new(name: inst.name, type: inst.type, result_var: new_result)
+
+        when HIR::StoreGlobalVar
+          new_value = transform_value(inst.value, prefix, param_map)
+          HIR::StoreGlobalVar.new(name: inst.name, value: new_value, type: inst.type)
+
+        when HIR::LoadClassVar
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::LoadClassVar.new(name: inst.name, type: inst.type, result_var: new_result)
+
+        when HIR::StoreClassVar
+          new_value = transform_value(inst.value, prefix, param_map)
+          HIR::StoreClassVar.new(name: inst.name, value: new_value, type: inst.type)
+
+        when HIR::RegexpLit
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::RegexpLit.new(pattern: inst.pattern, options: inst.options, result_var: new_result)
+
+        when HIR::NativeArrayAlloc
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_size = transform_value(inst.size, prefix, param_map)
+          HIR::NativeArrayAlloc.new(
+            size: new_size,
+            element_type: inst.element_type,
+            result_var: new_result
+          )
+
+        when HIR::StaticArrayAlloc
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_initial = inst.initial_value ? transform_value(inst.initial_value, prefix, param_map) : nil
+          HIR::StaticArrayAlloc.new(
+            element_type: inst.element_type,
+            size: inst.size,
+            initial_value: new_initial,
+            result_var: new_result
+          )
+
+        when HIR::NativeArrayGet
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_array = transform_value(inst.array, prefix, param_map)
+          new_index = transform_value(inst.index, prefix, param_map)
+          HIR::NativeArrayGet.new(
+            array: new_array, index: new_index,
+            element_type: inst.element_type, result_var: new_result
+          )
+
+        when HIR::NativeArraySet
+          new_array = transform_value(inst.array, prefix, param_map)
+          new_index = transform_value(inst.index, prefix, param_map)
+          new_value = transform_value(inst.value, prefix, param_map)
+          HIR::NativeArraySet.new(
+            array: new_array, index: new_index, value: new_value,
+            element_type: inst.element_type
+          )
+
+        when HIR::NativeArrayLength
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_array = transform_value(inst.array, prefix, param_map)
+          HIR::NativeArrayLength.new(array: new_array, result_var: new_result)
+
+        when HIR::StaticArrayGet
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_array = transform_value(inst.array, prefix, param_map)
+          new_index = transform_value(inst.index, prefix, param_map)
+          HIR::StaticArrayGet.new(
+            array: new_array, index: new_index,
+            element_type: inst.element_type, size: inst.size, result_var: new_result
+          )
+
+        when HIR::StaticArraySet
+          new_array = transform_value(inst.array, prefix, param_map)
+          new_index = transform_value(inst.index, prefix, param_map)
+          new_value = transform_value(inst.value, prefix, param_map)
+          HIR::StaticArraySet.new(
+            array: new_array, index: new_index, value: new_value,
+            element_type: inst.element_type, size: inst.size
+          )
+
+        when HIR::StaticArraySize
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_array = transform_value(inst.array, prefix, param_map)
+          HIR::StaticArraySize.new(
+            array: new_array, size: inst.size, result_var: new_result
+          )
+
+        when HIR::ConstantLookup
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::ConstantLookup.new(name: inst.name, scope: inst.scope, type: inst.type, result_var: new_result)
+
+        when HIR::NativeNew
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::NativeNew.new(class_type: inst.class_type, result_var: new_result, args: new_args)
+
+        when HIR::NativeFieldGet
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_object = transform_value(inst.object, prefix, param_map)
+          HIR::NativeFieldGet.new(object: new_object, field_name: inst.field_name,
+                                  class_type: inst.class_type, result_var: new_result)
+
+        when HIR::NativeFieldSet
+          new_object = transform_value(inst.object, prefix, param_map)
+          new_value = transform_value(inst.value, prefix, param_map)
+          HIR::NativeFieldSet.new(object: new_object, field_name: inst.field_name,
+                                  value: new_value, class_type: inst.class_type)
+
+        when HIR::NativeMethodCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_receiver = transform_value(inst.receiver, prefix, param_map)
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::NativeMethodCall.new(
+            receiver: new_receiver, method_name: inst.method_name,
+            args: new_args, class_type: inst.class_type,
+            method_sig: inst.method_sig, owner_class: inst.owner_class,
+            result_var: new_result
+          )
+
+        when HIR::LoadInstanceVar
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          HIR::LoadInstanceVar.new(name: inst.name, type: inst.type, result_var: new_result)
+
+        when HIR::StoreInstanceVar
+          new_value = transform_value(inst.value, prefix, param_map)
+          HIR::StoreInstanceVar.new(name: inst.name, value: new_value, type: inst.type)
+
+        when HIR::StoreConstant
+          new_value = transform_value(inst.value, prefix, param_map)
+          HIR::StoreConstant.new(name: inst.name, value: new_value, scope: inst.scope, type: inst.type)
+
+        when HIR::SuperCall
+          new_result = inst.result_var ? prefix + inst.result_var : nil
+          new_args = inst.args.map { |a| transform_value(a, prefix, param_map) }
+          HIR::SuperCall.new(args: new_args, type: inst.type, result_var: new_result)
+
+        else
+          # For other instructions, just return as-is with renamed result
+          inst
+        end
+      end
+
+      def transform_value(value, prefix, param_map)
+        case value
+        when HIR::LoadLocal
+          if param_map.key?(value.var.name)
+            param_map[value.var.name]
+          else
+            new_var = HIR::LocalVar.new(
+              name: prefix + value.var.name,
+              type: value.var.type
+            )
+            HIR::LoadLocal.new(var: new_var, type: value.type, result_var: nil)
+          end
+        when HIR::Instruction
+          if value.result_var
+            # Create a LoadLocal to reference the renamed variable
+            new_var = HIR::LocalVar.new(
+              name: prefix + value.result_var,
+              type: value.type
+            )
+            HIR::LoadLocal.new(var: new_var, type: value.type, result_var: nil)
+          else
+            value
+          end
+        when String
+          # Variable name reference - create a LoadLocal
+          var_name = if param_map.key?(value)
+                       # If it's a parameter, use the argument directly
+                       return param_map[value]
+                     else
+                       prefix + value
+                     end
+          new_var = HIR::LocalVar.new(name: var_name, type: TypeChecker::Types::UNTYPED)
+          HIR::LoadLocal.new(var: new_var, type: TypeChecker::Types::UNTYPED, result_var: nil)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/konpeito/codegen/jvm_backend.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "json"
+require "tmpdir"
+require "fileutils"
+
+module Konpeito
+  module Codegen
+    # JVM Backend: Orchestrates the compilation pipeline from HIR to .jar
+    #
+    # Pipeline:
+    #   HIR → JVMGenerator → JSON IR → ASM tool (subprocess) → .class files → jar → .jar
+    class JVMBackend
+      ASM_TOOL_DIR = File.expand_path("../../../tools/konpeito-asm", __dir__)
+      ASM_TOOL_JAR = File.join(ASM_TOOL_DIR, "konpeito-asm.jar")
+      JAVA_HOME = ENV["JAVA_HOME"] || Platform.default_java_home
+
+      attr_reader :output_file
+
+      def initialize(jvm_generator, output_file:, module_name:, run_after: false, emit_ir: false, classpath: nil, library: false)
+        @jvm_generator = jvm_generator
+        @output_file = output_file
+        @module_name = module_name
+        @run_after = run_after
+        @emit_ir = emit_ir
+        @classpath = classpath
+        @library = library
+      end
+
+      def generate
+        ensure_asm_tool!
+
+        Dir.mktmpdir("konpeito-jvm") do |tmpdir|
+          classes_dir = File.join(tmpdir, "classes")
+          FileUtils.mkdir_p(classes_dir)
+
+          # Step 1: Generate JSON IR
+          json_ir = @jvm_generator.to_json
+
+          # Optionally save JSON IR for debugging
+          if @emit_ir
+            ir_path = @output_file.sub(/\.jar$/, ".json")
+            FileUtils.mkdir_p(File.dirname(File.expand_path(ir_path)))
+            File.write(ir_path, JSON.pretty_generate(@jvm_generator.to_json_ir))
+            puts "JSON IR written to: #{ir_path}"
+          end
+
+          # Step 2: Run ASM tool to generate .class files
+          run_asm_tool(json_ir, classes_dir)
+
+          # Step 2.5: Copy runtime classes (KArray, KHash, etc.)
+          copy_runtime_classes(classes_dir)
+
+          if @library
+            # Library mode: no Main-Class manifest
+            create_jar_without_manifest(classes_dir)
+          else
+            # Step 3: Create manifest
+            manifest_path = File.join(tmpdir, "MANIFEST.MF")
+            main_class = @jvm_generator.send(:main_class_name).gsub("/", ".")
+            File.write(manifest_path, "Main-Class: #{main_class}\n")
+
+            # Step 4: Package into .jar
+            create_jar(classes_dir, manifest_path)
+
+            # Step 5: Optionally run
+            run_jar if @run_after
+          end
+        end
+      end
+
+      private
+
+      def ensure_asm_tool!
+        unless File.exist?(ASM_TOOL_JAR)
+          puts "Building ASM tool (first-time setup)..."
+          build_script = File.join(ASM_TOOL_DIR, "build.sh")
+          unless File.exist?(build_script)
+            raise CodegenError, "ASM tool build script not found: #{build_script}"
+          end
+
+          output = `bash #{build_script} 2>&1`
+          unless $?.success?
+            $stderr.puts output
+            raise CodegenError, "Failed to build ASM tool"
+          end
+          puts "ASM tool ready."
+        end
+      end
+
+      def run_asm_tool(json_ir, output_dir)
+        java_cmd = find_java
+
+        # Run the ASM tool, passing JSON IR via stdin
+        cmd = [java_cmd, "-jar", ASM_TOOL_JAR, output_dir]
+
+        IO.popen(cmd, "r+", err: [:child, :out]) do |io|
+          io.write(json_ir)
+          io.close_write
+          output = io.read
+          unless output.strip.empty?
+            # Check for errors
+            if output.include?("Error") || output.include?("Exception")
+              raise CodegenError, "ASM tool error:\n#{output}"
+            end
+          end
+        end
+
+        unless $?.success?
+          raise CodegenError, "ASM tool failed with exit code #{$?.exitstatus}"
+        end
+      end
+
+      def create_jar_without_manifest(classes_dir)
+        jar_cmd = find_jar
+
+        FileUtils.mkdir_p(File.dirname(File.expand_path(@output_file)))
+
+        output_path = File.expand_path(@output_file)
+        cmd = [jar_cmd, "cf", output_path, "-C", classes_dir, "."]
+
+        result = system(*cmd)
+        unless result
+          raise CodegenError, "jar command failed"
+        end
+      end
+
+      def create_jar(classes_dir, manifest_path)
+        jar_cmd = find_jar
+
+        # Ensure output directory exists
+        FileUtils.mkdir_p(File.dirname(File.expand_path(@output_file)))
+
+        # Create JAR with manifest
+        output_path = File.expand_path(@output_file)
+        cmd = [jar_cmd, "cfm", output_path, manifest_path, "-C", classes_dir, "."]
+
+        result = system(*cmd)
+        unless result
+          raise CodegenError, "jar command failed"
+        end
+      end
+
+      def run_jar
+        java_cmd = find_java
+        if @classpath
+          # Use -cp mode so external JARs are on the classpath
+          cp = "#{File.expand_path(@output_file)}#{Platform.classpath_separator}#{@classpath}"
+          main_class = @jvm_generator.send(:main_class_name).gsub("/", ".")
+          cmd = [java_cmd]
+          cmd << "-XstartOnFirstThread" if RUBY_PLATFORM.include?("darwin")
+          cmd += ["-cp", cp, main_class]
+          puts "Running: #{cmd.join(' ')}"
+          system(*cmd)
+        else
+          puts "Running: java -jar #{@output_file}"
+          system(java_cmd, "-jar", @output_file)
+        end
+      end
+
+      def find_java
+        # Try JAVA_HOME first, then PATH
+        java_path = File.join(JAVA_HOME, "bin", "java")
+        return java_path if File.exist?(java_path)
+
+        # Try PATH
+        java_in_path = Platform.find_executable("java")
+        return java_in_path if java_in_path
+
+        raise CodegenError, "Java not found. Install Java 21+: #{Platform.java_install_hint}"
+      end
+
+      def copy_runtime_classes(classes_dir)
+        runtime_dir = File.join(ASM_TOOL_DIR, "runtime-classes")
+        return unless File.directory?(runtime_dir)
+
+        # Copy runtime .class files preserving directory structure
+        Dir.glob(File.join(runtime_dir, "**", "*.class")).each do |class_file|
+          relative_path = class_file.sub("#{runtime_dir}/", "")
+          dest = File.join(classes_dir, relative_path)
+          FileUtils.mkdir_p(File.dirname(dest))
+          FileUtils.cp(class_file, dest)
+        end
+      end
+
+      def find_jar
+        jar_path = File.join(JAVA_HOME, "bin", "jar")
+        return jar_path if File.exist?(jar_path)
+
+        jar_in_path = Platform.find_executable("jar")
+        return jar_in_path if jar_in_path
+
+        raise CodegenError, "jar command not found. Install Java 21+: #{Platform.java_install_hint}"
+      end
+    end
+  end
+end