konpeito 0.1.0

data/lib/konpeito/cli.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "cli/config"
+require_relative "cli/base_command"
+require_relative "cli/build_command"
+require_relative "cli/check_command"
+require_relative "cli/lsp_command"
+require_relative "cli/init_command"
+require_relative "cli/fmt_command"
+require_relative "cli/test_command"
+require_relative "cli/watch_command"
+require_relative "cli/run_command"
+require_relative "cli/deps_command"
+require_relative "cli/doctor_command"
+
+module Konpeito
+  # Main CLI router - dispatches to subcommands
+  class CLI
+    COMMANDS = {
+      "build" => Commands::BuildCommand,
+      "run" => Commands::RunCommand,
+      "check" => Commands::CheckCommand,
+      "lsp" => Commands::LspCommand,
+      "init" => Commands::InitCommand,
+      "fmt" => Commands::FmtCommand,
+      "test" => Commands::TestCommand,
+      "watch" => Commands::WatchCommand,
+      "deps" => Commands::DepsCommand,
+      "doctor" => Commands::DoctorCommand
+    }.freeze
+
+    attr_reader :args
+
+    def initialize(args)
+      @args = args.dup
+    end
+
+    def run
+      # Handle global options first
+      if args.empty? || args.first == "-h" || args.first == "--help"
+        show_help
+        exit(args.empty? ? 1 : 0)
+      end
+
+      if args.first == "--version" || args.first == "-V"
+        show_version
+        exit 0
+      end
+
+      # Determine command
+      command_name = args.first
+
+      if COMMANDS.key?(command_name)
+        # Explicit subcommand
+        args.shift
+        run_command(command_name, args)
+      elsif command_name.start_with?("-") || File.exist?(command_name)
+        # Legacy mode: implicit build command for backwards compatibility
+        # Either starts with option flag or is an existing file
+        run_legacy_mode
+      else
+        # Unknown command
+        $stderr.puts "Unknown command: #{command_name}"
+        $stderr.puts "Run 'konpeito --help' for usage information."
+        exit 1
+      end
+    end
+
+    private
+
+    def run_command(command_name, command_args)
+      command_class = COMMANDS[command_name]
+      config = Commands::Config.new
+      command = command_class.new(command_args, config: config)
+      command.run
+    end
+
+    def run_legacy_mode
+      # Parse legacy options and delegate to appropriate command
+      legacy = LegacyCLI.new(args)
+      legacy.run
+    end
+
+    def show_help
+      puts "Konpeito - Ruby AOT Native Compiler"
+      puts ""
+      puts "Usage: konpeito <command> [options] [args]"
+      puts "       konpeito [options] <source.rb>  (legacy build mode)"
+      puts ""
+      puts "Commands:"
+      COMMANDS.each do |name, klass|
+        puts "  %-10s %s" % [name, klass.description]
+      end
+      puts ""
+      puts "Global Options:"
+      puts "  -h, --help       Show this help"
+      puts "  -V, --version    Show version and environment info"
+      puts ""
+      puts "Examples:"
+      puts "  konpeito build src/main.rb            Compile to CRuby extension"
+      puts "  konpeito build --target jvm src/app.rb Compile to JAR"
+      puts "  konpeito run src/main.rb              Build and run"
+      puts "  konpeito check src/main.rb            Type check only"
+      puts "  konpeito test                         Run tests"
+      puts "  konpeito fmt                          Format source files"
+      puts "  konpeito doctor                       Check environment"
+      puts ""
+      puts "Legacy mode (backwards compatible):"
+      puts "  konpeito source.rb                     Same as: konpeito build source.rb"
+      puts "  konpeito -c source.rb                  Same as: konpeito check source.rb"
+      puts ""
+      puts "For help on a specific command, run: konpeito <command> --help"
+    end
+
+    def show_version
+      puts "konpeito #{Konpeito::VERSION}"
+      puts "ruby #{RUBY_VERSION} [#{RUBY_PLATFORM}]"
+
+      # LLVM
+      clang = Platform.find_llvm_tool("clang")
+      if clang
+        llvm_version = clang[/llvm[@-]?(\d+)/, 1]
+        unless llvm_version
+          # Try clang --version
+          begin
+            output = `"#{clang}" --version 2>&1`
+            llvm_version = output[/(?:clang|LLVM)\s+version\s+(\d+)/, 1]
+          rescue
+          end
+        end
+        llvm_version ||= "?"
+        llvm_dir = File.dirname(File.dirname(clang))
+        puts "llvm #{llvm_version} (#{llvm_dir})"
+      else
+        puts "llvm not found"
+      end
+
+      # Java
+      java_home = ENV["JAVA_HOME"] || Platform.default_java_home
+      java_path = File.join(java_home, "bin", "java")
+      java_path = Platform.find_executable("java") unless File.exist?(java_path)
+      if java_path
+        version = begin
+          output = `"#{java_path}" -version 2>&1`
+          output[/version "(\d+)/, 1] || "?"
+        rescue
+          "?"
+        end
+        java_dir = File.dirname(File.dirname(java_path))
+        puts "java #{version} (#{java_dir})"
+      else
+        puts "java not found"
+      end
+    end
+  end
+
+  # Legacy CLI class for backwards compatibility
+  # Supports old-style options like -c, -o, --lsp, etc.
+  class LegacyCLI
+    attr_reader :args, :options
+
+    def initialize(args)
+      @args = args.dup
+      @options = {
+        output: nil,
+        format: :cruby_ext,
+        verbose: false,
+        type_check_only: false,
+        rbs_paths: [],
+        require_paths: [],
+        color: $stderr.tty?,
+        debug: false,
+        lsp: false,
+        profile: false,
+        incremental: false,
+        clean_cache: false
+      }
+    end
+
+    def run
+      parse_options!
+
+      # Start LSP server if requested
+      if options[:lsp]
+        Commands::LspCommand.new([], config: Commands::Config.new).run
+        return
+      end
+
+      if args.empty?
+        puts "Usage: konpeito [options] <source.rb>"
+        puts "Run 'konpeito --help' for more information."
+        exit 1
+      end
+
+      source_file = args.first
+
+      unless File.exist?(source_file)
+        $stderr.puts "Error: File not found: #{source_file}"
+        exit 1
+      end
+
+      if options[:type_check_only]
+        # Delegate to check command
+        check_args = []
+        check_args << "-v" if options[:verbose]
+        check_args << "--no-color" unless options[:color]
+        options[:rbs_paths].each { |p| check_args << "--rbs" << p }
+        options[:require_paths].each { |p| check_args << "-I" << p }
+        check_args << source_file
+        Commands::CheckCommand.new(check_args, config: Commands::Config.new).run
+      else
+        # Delegate to build command
+        build_args = []
+        build_args << "-o" << options[:output] if options[:output]
+        build_args << "-f" << options[:format].to_s if options[:format] != :cruby_ext
+        build_args << "-v" if options[:verbose]
+        build_args << "-g" if options[:debug]
+        build_args << "-p" if options[:profile]
+        build_args << "--no-color" unless options[:color]
+        build_args << "--incremental" if options[:incremental]
+        build_args << "--clean-cache" if options[:clean_cache]
+        options[:rbs_paths].each { |p| build_args << "--rbs" << p }
+        options[:require_paths].each { |p| build_args << "-I" << p }
+        build_args << source_file
+        Commands::BuildCommand.new(build_args, config: Commands::Config.new).run
+      end
+    end
+
+    private
+
+    def parse_options!
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: konpeito [options] <source.rb>"
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("-o", "--output FILE", "Output file name") do |file|
+          options[:output] = file
+        end
+
+        opts.on("-f", "--format FORMAT", %i[cruby_ext standalone],
+                "Output format (cruby_ext, standalone)") do |format|
+          options[:format] = format
+        end
+
+        opts.on("-c", "--check", "Type check only (no code generation)") do
+          options[:type_check_only] = true
+        end
+
+        opts.on("-g", "--debug", "Generate debug info (DWARF) for lldb/gdb") do
+          options[:debug] = true
+        end
+
+        opts.on("-p", "--profile", "Enable profiling (function call counts and timing)") do
+          options[:profile] = true
+        end
+
+        opts.on("-v", "--verbose", "Verbose output") do
+          options[:verbose] = true
+        end
+
+        opts.on("-I", "--require-path PATH", "Add require search path (can be used multiple times)") do |path|
+          options[:require_paths] << path
+        end
+
+        opts.on("--rbs FILE", "RBS type definition file (can be used multiple times)") do |file|
+          options[:rbs_paths] << file
+        end
+
+        opts.on("--no-color", "Disable colored output") do
+          options[:color] = false
+        end
+
+        opts.on("--lsp", "Start Language Server Protocol server") do
+          options[:lsp] = true
+        end
+
+        opts.on("--incremental", "Enable incremental compilation (cache unchanged files)") do
+          options[:incremental] = true
+        end
+
+        opts.on("--clean-cache", "Clear compilation cache before building") do
+          options[:clean_cache] = true
+        end
+
+        opts.on("--version", "Show version") do
+          puts "konpeito #{Konpeito::VERSION}"
+          exit
+        end
+
+        opts.on("-h", "--help", "Show this help") do
+          puts opts
+          exit
+        end
+      end
+
+      parser.parse!(args)
+    end
+  end
+end

data/lib/konpeito/codegen/builtin_methods.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module Konpeito
+  module Codegen
+    # Mapping of Ruby built-in methods to their CRuby C API functions
+    # This enables direct C function calls instead of rb_funcallv dispatch
+    #
+    # IMPORTANT: Only include functions that are actually EXPORTED from libruby.
+    # Many internal Ruby methods (like rb_str_upcase) are static and not callable.
+    # Check with: nm -gU $(ruby -e 'puts RbConfig::CONFIG["libdir"]')/libruby.*.dylib | grep rb_str
+    #
+    # Calling conventions:
+    # - :simple - VALUE func(VALUE recv) or VALUE func(VALUE recv, VALUE arg1, ...)
+    # - :block_iterator - uses rb_block_call with block callback
+    #
+    BUILTIN_METHODS = {
+      Integer: {
+        # Block iterators - use rb_block_call
+        times: { arity: 0, return_type: :Integer, conv: :block_iterator },
+        upto: { arity: 1, return_type: :Integer, conv: :block_iterator },
+        downto: { arity: 1, return_type: :Integer, conv: :block_iterator },
+      },
+
+      String: {
+        # String query methods
+        length: { c_func: "rb_str_length", arity: 0, return_type: :Integer, conv: :simple },
+        size: { c_func: "rb_str_length", arity: 0, return_type: :Integer, conv: :simple },
+
+        # String operations - these are EXPORTED
+        :+ => { c_func: "rb_str_plus", arity: 1, return_type: :String, conv: :simple },
+        :<< => { c_func: "rb_str_concat", arity: 1, return_type: :String, conv: :simple },
+        concat: { c_func: "rb_str_concat", arity: 1, return_type: :String, conv: :simple },
+
+        # String comparison - exported
+        :<=> => { c_func: "rb_str_cmp", arity: 1, return_type: :Integer, conv: :simple },
+        :== => { c_func: "rb_str_equal", arity: 1, return_type: :Bool, conv: :simple },
+
+        # String conversion - exported
+        to_sym: { c_func: "rb_str_intern", arity: 0, return_type: :Symbol, conv: :simple },
+        intern: { c_func: "rb_str_intern", arity: 0, return_type: :Symbol, conv: :simple },
+
+        # String duplication - exported
+        dup: { c_func: "rb_str_dup", arity: 0, return_type: :String, conv: :simple },
+
+        # String hash - exported (useful for Hash key optimization)
+        hash: { c_func: "rb_str_hash", arity: 0, return_type: :Integer, conv: :simple },
+      },
+
+      Array: {
+        # Array query methods - rb_ary_length not directly exported, use RARRAY_LEN macro
+        # length: { c_func: "rb_ary_length", arity: 0, return_type: :Integer, conv: :simple },
+
+        # Array access - exported
+        :[] => { c_func: "rb_ary_entry", arity: 1, return_type: :Any, conv: :ary_entry },
+        # Array#[]= uses rb_ary_store (special handling in llvm_generator)
+        :[]= => { c_func: "rb_ary_store", arity: 2, return_type: :Any, conv: :ary_store },
+
+        # Array modification - exported with simple signatures
+        push: { c_func: "rb_ary_push", arity: 1, return_type: :Array, conv: :simple },
+        :<<  => { c_func: "rb_ary_push", arity: 1, return_type: :Array, conv: :simple },
+        pop: { c_func: "rb_ary_pop", arity: 0, return_type: :Any, conv: :simple },
+        shift: { c_func: "rb_ary_shift", arity: 0, return_type: :Any, conv: :simple },
+        clear: { c_func: "rb_ary_clear", arity: 0, return_type: :Array, conv: :simple },
+        # Array#delete_at uses long index (special handling in llvm_generator)
+        delete_at: { c_func: "rb_ary_delete_at", arity: 1, return_type: :Any, conv: :ary_delete_at },
+        # Note: unshift/prepend/delete use rb_funcallv fallback (args need VALUE boxing)
+
+        # Array operations - exported
+        :+ => { c_func: "rb_ary_plus", arity: 1, return_type: :Array, conv: :simple },
+        concat: { c_func: "rb_ary_concat", arity: 1, return_type: :Array, conv: :simple },
+
+        # Array transformation - exported
+        reverse: { c_func: "rb_ary_reverse", arity: 0, return_type: :Array, conv: :simple },
+        sort: { c_func: "rb_ary_sort", arity: 0, return_type: :Array, conv: :simple },
+
+        # Array query with args - exported
+        include?: { c_func: "rb_ary_includes", arity: 1, return_type: :Bool, conv: :simple },
+
+        # Block iterators - use rb_block_call
+        each: { arity: 0, return_type: :Array, conv: :block_iterator },
+        map: { arity: 0, return_type: :Array, conv: :block_iterator },
+        collect: { arity: 0, return_type: :Array, conv: :block_iterator },
+        select: { arity: 0, return_type: :Array, conv: :block_iterator },
+        filter: { arity: 0, return_type: :Array, conv: :block_iterator },  # alias for select
+        reject: { arity: 0, return_type: :Array, conv: :block_iterator },
+        each_with_index: { arity: 0, return_type: :Array, conv: :block_iterator },
+
+        # Enumerable methods
+        reduce: { arity: -1, return_type: :Any, conv: :block_iterator },  # arity -1 = optional args
+        inject: { arity: -1, return_type: :Any, conv: :block_iterator },  # alias for reduce
+        find: { arity: 0, return_type: :Any, conv: :block_iterator },
+        detect: { arity: 0, return_type: :Any, conv: :block_iterator },   # alias for find
+        find_all: { arity: 0, return_type: :Array, conv: :block_iterator },  # alias for select
+        any?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        all?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        none?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        one?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        count: { arity: -1, return_type: :Integer, conv: :block_iterator },  # optional block
+        min_by: { arity: 0, return_type: :Any, conv: :block_iterator },
+        max_by: { arity: 0, return_type: :Any, conv: :block_iterator },
+        sort_by: { arity: 0, return_type: :Array, conv: :block_iterator },
+        find_index: { arity: -1, return_type: :Any, conv: :block_iterator },
+        first: { arity: -1, return_type: :Any, conv: :block_iterator },
+        take_while: { arity: 0, return_type: :Array, conv: :block_iterator },
+        drop_while: { arity: 0, return_type: :Array, conv: :block_iterator },
+        partition: { arity: 0, return_type: :Array, conv: :block_iterator },
+        group_by: { arity: 0, return_type: :Hash, conv: :block_iterator },
+        flat_map: { arity: 0, return_type: :Array, conv: :block_iterator },
+        collect_concat: { arity: 0, return_type: :Array, conv: :block_iterator },  # alias for flat_map
+      },
+
+      Hash: {
+        # Hash access - rb_hash_aref is exported
+        :[] => { c_func: "rb_hash_aref", arity: 1, return_type: :Any, conv: :simple },
+        :[]= => { c_func: "rb_hash_aset", arity: 2, return_type: :Any, conv: :simple },
+
+        # Hash modification - exported
+        clear: { c_func: "rb_hash_clear", arity: 0, return_type: :Hash, conv: :simple },
+        delete: { c_func: "rb_hash_delete", arity: 1, return_type: :Any, conv: :simple },
+
+        # Hash block iterators with 2-argument blocks (|k, v|)
+        # Uses rb_block_call - CRuby passes key/value through argv for Hash#each
+        each: { arity: 0, return_type: :Hash, conv: :block_iterator },
+        each_pair: { arity: 0, return_type: :Hash, conv: :block_iterator },
+        map: { arity: 0, return_type: :Array, conv: :block_iterator },
+        collect: { arity: 0, return_type: :Array, conv: :block_iterator },
+        select: { arity: 0, return_type: :Hash, conv: :block_iterator },
+        filter: { arity: 0, return_type: :Hash, conv: :block_iterator },
+        reject: { arity: 0, return_type: :Hash, conv: :block_iterator },
+        any?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        all?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        none?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        each_with_object: { arity: 1, return_type: :Any, conv: :block_iterator },
+      },
+
+      Symbol: {
+        # Symbol methods
+        to_s: { c_func: "rb_sym2str", arity: 0, return_type: :String, conv: :simple },
+        id2name: { c_func: "rb_sym2str", arity: 0, return_type: :String, conv: :simple },
+        name: { c_func: "rb_sym2str", arity: 0, return_type: :String, conv: :simple },
+      },
+
+      Object: {
+        # Object identity and comparison
+        :== => { c_func: "rb_obj_equal", arity: 1, return_type: :Bool, conv: :simple },
+        :=== => { c_func: "rb_equal", arity: 1, return_type: :Bool, conv: :simple },
+
+        # Object type checking
+        is_a?: { c_func: "rb_obj_is_kind_of", arity: 1, return_type: :Bool, conv: :simple },
+        kind_of?: { c_func: "rb_obj_is_kind_of", arity: 1, return_type: :Bool, conv: :simple },
+        instance_of?: { c_func: "rb_obj_is_instance_of", arity: 1, return_type: :Bool, conv: :simple },
+
+        # Object info - exported
+        class: { c_func: "rb_obj_class", arity: 0, return_type: :Class, conv: :simple },
+        object_id: { c_func: "rb_obj_id", arity: 0, return_type: :Integer, conv: :simple },
+
+        # Object duplication - exported
+        dup: { c_func: "rb_obj_dup", arity: 0, return_type: :Any, conv: :simple },
+        freeze: { c_func: "rb_obj_freeze", arity: 0, return_type: :Any, conv: :simple },
+      },
+
+      Range: {
+        # Block iterators
+        each: { arity: 0, return_type: :Range, conv: :block_iterator },
+        # Range enumerable methods
+        map: { arity: 0, return_type: :Array, conv: :block_iterator },
+        collect: { arity: 0, return_type: :Array, conv: :block_iterator },
+        select: { arity: 0, return_type: :Array, conv: :block_iterator },
+        filter: { arity: 0, return_type: :Array, conv: :block_iterator },
+        reject: { arity: 0, return_type: :Array, conv: :block_iterator },
+        reduce: { arity: -1, return_type: :Any, conv: :block_iterator },
+        inject: { arity: -1, return_type: :Any, conv: :block_iterator },
+        find: { arity: 0, return_type: :Any, conv: :block_iterator },
+        detect: { arity: 0, return_type: :Any, conv: :block_iterator },
+        any?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        all?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+        none?: { arity: 0, return_type: :Bool, conv: :block_iterator },
+      },
+
+      Float: {
+        # Float comparison
+        :<=> => { c_func: "rb_float_cmp", arity: 1, return_type: :Integer, conv: :simple },
+
+        # Float conversion
+        to_i: { c_func: "rb_num2long", arity: 0, return_type: :Integer, conv: :simple },
+        to_int: { c_func: "rb_num2long", arity: 0, return_type: :Integer, conv: :simple },
+        floor: { c_func: "rb_float_floor", arity: 0, return_type: :Integer, conv: :simple },
+        ceil: { c_func: "rb_float_ceil", arity: 0, return_type: :Integer, conv: :simple },
+        round: { c_func: "rb_float_round", arity: 0, return_type: :Integer, conv: :simple },
+        truncate: { c_func: "rb_float_truncate", arity: 0, return_type: :Integer, conv: :simple },
+
+        # Float query
+        nan?: { c_func: "rb_float_nan_p", arity: 0, return_type: :Bool, conv: :simple },
+        infinite?: { c_func: "rb_float_infinite_p", arity: 0, return_type: :Any, conv: :simple },
+        finite?: { c_func: "rb_float_finite_p", arity: 0, return_type: :Bool, conv: :simple },
+      },
+
+      NilClass: {
+        nil?: { c_func: "rb_true", arity: 0, return_type: :Bool, conv: :simple },
+        to_s: { c_func: "rb_nil_to_s", arity: 0, return_type: :String, conv: :simple },
+        to_a: { c_func: "rb_ary_new", arity: 0, return_type: :Array, conv: :simple },
+        to_h: { c_func: "rb_hash_new", arity: 0, return_type: :Hash, conv: :simple },
+      },
+
+      TrueClass: {
+        to_s: { c_func: "rb_true_to_s", arity: 0, return_type: :String, conv: :simple },
+      },
+
+      FalseClass: {
+        to_s: { c_func: "rb_false_to_s", arity: 0, return_type: :String, conv: :simple },
+      },
+    }.freeze
+
+    # Helper method to look up a builtin method
+    def self.lookup(class_name, method_name)
+      BUILTIN_METHODS.dig(class_name.to_sym, method_name.to_sym)
+    end
+
+    # Get all classes with builtin methods
+    def self.builtin_classes
+      BUILTIN_METHODS.keys
+    end
+
+    # Get all methods for a class
+    def self.methods_for(class_name)
+      BUILTIN_METHODS[class_name.to_sym] || {}
+    end
+  end
+end