konpeito 0.2.4 → 0.3.0

data/lib/konpeito/lsp/server.rb

@@ -1,183 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "transport"
-require_relative "document_manager"
-
-module Konpeito
-  module LSP
-    # Main LSP server that handles client requests
-    class Server
-      attr_reader :transport, :document_manager
-
-      def initialize(input: $stdin, output: $stdout)
-        @transport = Transport.new(input: input, output: output)
-        @document_manager = DocumentManager.new(@transport)
-        @running = false
-        @initialized = false
-      end
-
-      # Start the LSP server main loop
-      def start
-        @running = true
-        while @running
-          request = @transport.read
-          break unless request
-
-          response = handle_request(request)
-          @transport.write(response) if response
-        end
-      end
-
-      # Stop the server
-      def stop
-        @running = false
-      end
-
-      # Handle a single request (exposed for testing)
-      # @param request [Hash] The LSP request
-      # @return [Hash, nil] The response or nil for notifications
-      def handle_request(request)
-        method = request[:method]
-        id = request[:id]
-        params = request[:params] || {}
-
-        result = case method
-        when "initialize"
-          handle_initialize(params)
-        when "initialized"
-          # Notification, no response needed
-          nil
-        when "shutdown"
-          handle_shutdown
-        when "exit"
-          @running = false
-          nil
-        when "textDocument/didOpen"
-          handle_did_open(params)
-        when "textDocument/didChange"
-          handle_did_change(params)
-        when "textDocument/didClose"
-          handle_did_close(params)
-        when "textDocument/hover"
-          handle_hover(params)
-        when "textDocument/completion"
-          handle_completion(params)
-        when "textDocument/definition"
-          handle_definition(params)
-        when "textDocument/references"
-          handle_references(params)
-        when "textDocument/rename"
-          handle_rename(params)
-        when "textDocument/prepareRename"
-          handle_prepare_rename(params)
-        else
-          # Unknown method
-          if id
-            { error: { code: -32601, message: "Method not found: #{method}" } }
-          end
-        end
-
-        # Build response for requests (not notifications)
-        if id && result != :notification
-          { jsonrpc: "2.0", id: id, result: result }
-        else
-          nil
-        end
-      end
-
-      private
-
-      def handle_initialize(params)
-        @initialized = true
-
-        {
-          capabilities: {
-            textDocumentSync: {
-              openClose: true,
-              change: 1  # Full content sync
-            },
-            hoverProvider: true,
-            completionProvider: {
-              triggerCharacters: ["."],
-              resolveProvider: false
-            },
-            definitionProvider: true,
-            referencesProvider: true,
-            renameProvider: {
-              prepareProvider: true
-            }
-          },
-          serverInfo: {
-            name: "konpeito-lsp",
-            version: Konpeito::VERSION
-          }
-        }
-      end
-
-      def handle_shutdown
-        @initialized = false
-        nil
-      end
-
-      def handle_did_open(params)
-        uri = params.dig(:textDocument, :uri)
-        text = params.dig(:textDocument, :text)
-        @document_manager.open(uri, text)
-        :notification
-      end
-
-      def handle_did_change(params)
-        uri = params.dig(:textDocument, :uri)
-        # We use full sync, so first contentChanges has full text
-        changes = params[:contentChanges]
-        text = changes&.first&.dig(:text)
-        @document_manager.change(uri, text) if text
-        :notification
-      end
-
-      def handle_did_close(params)
-        uri = params.dig(:textDocument, :uri)
-        @document_manager.close(uri)
-        :notification
-      end
-
-      def handle_hover(params)
-        uri = params.dig(:textDocument, :uri)
-        position = params[:position]
-        @document_manager.hover(uri, position)
-      end
-
-      def handle_completion(params)
-        uri = params.dig(:textDocument, :uri)
-        position = params[:position]
-        @document_manager.completion(uri, position)
-      end
-
-      def handle_definition(params)
-        uri = params.dig(:textDocument, :uri)
-        position = params[:position]
-        @document_manager.definition(uri, position)
-      end
-
-      def handle_references(params)
-        uri = params.dig(:textDocument, :uri)
-        position = params[:position]
-        include_declaration = params.dig(:context, :includeDeclaration) != false
-        @document_manager.references(uri, position, include_declaration: include_declaration)
-      end
-
-      def handle_rename(params)
-        uri = params.dig(:textDocument, :uri)
-        position = params[:position]
-        new_name = params[:newName]
-        @document_manager.rename(uri, position, new_name)
-      end
-
-      def handle_prepare_rename(params)
-        uri = params.dig(:textDocument, :uri)
-        position = params[:position]
-        @document_manager.prepare_rename(uri, position)
-      end
-    end
-  end
-end

data/lib/konpeito/lsp/transport.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "language_server-protocol"
-
-module Konpeito
-  module LSP
-    # Handles LSP JSON-RPC communication over stdio
-    class Transport
-      def initialize(input: $stdin, output: $stdout)
-        @reader = LanguageServer::Protocol::Transport::Io::Reader.new(input)
-        @writer = LanguageServer::Protocol::Transport::Io::Writer.new(output)
-      end
-
-      # Read next request/notification from client
-      # @return [Hash, nil] The request object or nil if EOF
-      def read
-        @reader.read
-      end
-
-      # Write response to client
-      # @param response [Hash] The response object
-      def write(response)
-        @writer.write(response)
-      end
-
-      # Send notification to client (no response expected)
-      # @param method [String] The notification method
-      # @param params [Hash] The notification parameters
-      def notify(method, params)
-        @writer.write({
-          jsonrpc: "2.0",
-          method: method,
-          params: params
-        })
-      end
-    end
-  end
-end

data/test_native_array.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-# Simple test for NativeArray
-
-$LOAD_PATH.unshift File.expand_path("lib", __dir__)
-require "konpeito"
-
-source = <<~RUBY
-  def test_alloc(n)
-    arr = NativeArray.new(n)
-    arr.length
-  end
-
-  def test_set(n)
-    arr = NativeArray.new(n)
-    arr[0] = 3.14
-    arr[0]
-  end
-
-  def test_fill(n)
-    arr = NativeArray.new(n)
-
-    # Just fill array
-    i = 0
-    while i < n
-      arr[i] = i * 1.5
-      i = i + 1
-    end
-
-    arr[0]
-  end
-
-  def test_read_sum(n)
-    arr = NativeArray.new(n)
-
-    # Fill with simple values
-    i = 0
-    while i < n
-      arr[i] = 1.0
-      i = i + 1
-    end
-
-    # Try to read all values
-    total = arr[0]
-    total = total + arr[1]
-    total = total + arr[2]
-
-    total
-  end
-RUBY
-
-rbs = <<~RBS
-  class NativeArray[T]
-    def self.new: (Integer size) -> NativeArray[Float]
-    def []: (Integer index) -> Float
-    def []=: (Integer index, Float value) -> Float
-    def length: () -> Integer
-  end
-
-  class Object
-    def test_alloc: (Integer n) -> Integer
-    def test_set: (Integer n) -> Float
-    def test_fill: (Integer n) -> Float
-    def test_read_sum: (Integer n) -> Float
-  end
-RBS
-
-require "tempfile"
-require "fileutils"
-
-tmp_dir = "tmp"
-FileUtils.mkdir_p(tmp_dir)
-
-source_path = File.join(tmp_dir, "test_native.rb")
-rbs_path = File.join(tmp_dir, "test_native.rbs")
-output_path = File.join(tmp_dir, "test_native.bundle")
-
-File.write(source_path, source)
-File.write(rbs_path, rbs)
-
-compiler = Konpeito::Compiler.new(
-  source_file: source_path,
-  output_file: output_path,
-  format: :cruby_ext,
-  rbs_paths: [rbs_path],
-  optimize: false,  # Disable optimization for debugging
-  verbose: true
-)
-
-# Patch to capture LLVM IR
-module Konpeito
-  module Codegen
-    class LLVMGenerator
-      def to_ir
-        @mod.to_s
-      end
-    end
-  end
-end
-
-puts "Compiling..."
-
-# Manual compilation steps to capture IR
-ast = compiler.send(:parse)
-typed_ast = compiler.send(:type_check_ast, ast)
-hir = compiler.send(:generate_hir, typed_ast)
-
-puts "\n=== HIR Functions ==="
-hir.functions.each do |func|
-  puts "Function: #{func.name}"
-  func.body.each do |block|
-    puts "  Block: #{block.label}"
-    block.instructions.each do |inst|
-      puts "    #{inst.class.name.split('::').last}: #{inst.result_var}"
-    end
-    puts "    Terminator: #{block.terminator.class.name.split('::').last}" if block.terminator
-  end
-end
-
-llvm_gen = Konpeito::Codegen::LLVMGenerator.new(
-  module_name: "test_native",
-  monomorphizer: nil
-)
-llvm_gen.generate(hir)
-
-puts "\n=== LLVM IR ==="
-puts llvm_gen.to_ir
-
-puts "\n=== Compiling to native ==="
-backend = Konpeito::Codegen::CRubyBackend.new(
-  llvm_gen,
-  output_file: output_path,
-  module_name: "test_native"
-)
-backend.generate
-puts "Generated: #{output_path}"
-
-puts "\n=== Testing ==="
-require File.expand_path(output_path)
-
-puts "\nTest 1: test_alloc"
-result = Object.new.send(:test_alloc, 10)
-puts "test_alloc(10) = #{result}"
-puts "Expected: 10"
-puts result == 10 ? "PASS" : "FAIL"
-
-puts "\nTest 2: test_set"
-result = Object.new.send(:test_set, 5)
-expected = 3.14
-puts "test_set(5) = #{result}"
-puts "Expected: #{expected}"
-puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"
-
-puts "\nTest 3: test_fill"
-result = Object.new.send(:test_fill, 5)
-# arr[0] = 0 * 1.5 = 0.0
-expected = 0.0
-puts "test_fill(5) = #{result}"
-puts "Expected: #{expected}"
-puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"
-
-puts "\nTest 4: test_read_sum"
-result = Object.new.send(:test_read_sum, 5)
-# 1.0 + 1.0 + 1.0 = 3.0
-expected = 3.0
-puts "test_read_sum(5) = #{result}"
-puts "Expected: #{expected}"
-puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"
-result = Object.new.send(:test_alloc, 10)
-puts "test_alloc(10) = #{result}"
-puts "Expected: 10"
-puts result == 10 ? "PASS" : "FAIL"

data/test_native_array_class.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-# Test for NativeArray[NativeClass] - array of structs
-
-$LOAD_PATH.unshift File.expand_path("lib", __dir__)
-require "konpeito"
-
-source = <<~RUBY
-  def test_create_and_access(n)
-    particles = NativeArray.new(n)
-
-    # Set first particle
-    particles[0].x = 1.0
-    particles[0].y = 2.0
-
-    # Set second particle
-    particles[1].x = 3.0
-    particles[1].y = 4.0
-
-    # Return sum of all coordinates
-    particles[0].x + particles[0].y + particles[1].x + particles[1].y
-  end
-
-  def test_loop_access(n)
-    particles = NativeArray.new(n)
-
-    # Initialize particles
-    i = 0
-    while i < n
-      particles[i].x = i * 1.0
-      particles[i].y = i * 2.0
-      i = i + 1
-    end
-
-    # Sum all x coordinates
-    total = 0.0
-    i = 0
-    while i < n
-      total = total + particles[i].x
-      i = i + 1
-    end
-
-    total
-  end
-
-  def test_distance_sum(n)
-    particles = NativeArray.new(n)
-
-    # Place particles in a line
-    i = 0
-    while i < n
-      particles[i].x = i * 10.0
-      particles[i].y = 0.0
-      i = i + 1
-    end
-
-    # Sum distances between consecutive particles
-    total = 0.0
-    i = 0
-    while i < n - 1
-      dx = particles[i + 1].x - particles[i].x
-      dy = particles[i + 1].y - particles[i].y
-      total = total + dx * dx + dy * dy
-      i = i + 1
-    end
-
-    total
-  end
-RUBY
-
-rbs = <<~RBS
-  # @native
-  class Particle
-    @x: Float
-    @y: Float
-
-    def self.new: () -> Particle
-    def x: () -> Float
-    def x=: (Float value) -> Float
-    def y: () -> Float
-    def y=: (Float value) -> Float
-  end
-
-  class Object
-    def test_create_and_access: (Integer n) -> Float
-    def test_loop_access: (Integer n) -> Float
-    def test_distance_sum: (Integer n) -> Float
-  end
-RBS
-
-require "tempfile"
-require "fileutils"
-
-tmp_dir = "tmp"
-FileUtils.mkdir_p(tmp_dir)
-
-source_path = File.join(tmp_dir, "test_native_array_class.rb")
-rbs_path = File.join(tmp_dir, "test_native_array_class.rbs")
-output_path = File.join(tmp_dir, "test_native_array_class.bundle")
-
-File.write(source_path, source)
-File.write(rbs_path, rbs)
-
-compiler = Konpeito::Compiler.new(
-  source_file: source_path,
-  output_file: output_path,
-  format: :cruby_ext,
-  rbs_paths: [rbs_path],
-  optimize: false,
-  verbose: true
-)
-
-# Patch to capture LLVM IR
-module Konpeito
-  module Codegen
-    class LLVMGenerator
-      def to_ir
-        @mod.to_s
-      end
-    end
-  end
-end
-
-puts "Compiling..."
-
-# Manual compilation steps to capture IR
-ast = compiler.send(:parse)
-typed_ast = compiler.send(:type_check_ast, ast)
-hir = compiler.send(:generate_hir, typed_ast)
-
-puts "\n=== HIR Functions ==="
-hir.functions.each do |func|
-  puts "Function: #{func.name}"
-  func.body.each do |block|
-    puts "  Block: #{block.label}"
-    block.instructions.each do |inst|
-      case inst
-      when Konpeito::HIR::NativeArrayAlloc
-        puts "    NativeArrayAlloc: #{inst.result_var} (element: #{inst.element_type})"
-      when Konpeito::HIR::NativeArrayGet
-        puts "    NativeArrayGet: #{inst.result_var} (element: #{inst.element_type})"
-      when Konpeito::HIR::NativeFieldGet
-        puts "    NativeFieldGet: #{inst.result_var} (field: #{inst.field_name})"
-      when Konpeito::HIR::NativeFieldSet
-        puts "    NativeFieldSet: (field: #{inst.field_name})"
-      else
-        puts "    #{inst.class.name.split('::').last}: #{inst.result_var}"
-      end
-    end
-    puts "    Terminator: #{block.terminator.class.name.split('::').last}" if block.terminator
-  end
-end
-
-llvm_gen = Konpeito::Codegen::LLVMGenerator.new(
-  module_name: "test_native_array_class",
-  monomorphizer: nil
-)
-llvm_gen.generate(hir)
-
-puts "\n=== LLVM IR ==="
-puts llvm_gen.to_ir
-
-puts "\n=== Compiling to native ==="
-backend = Konpeito::Codegen::CRubyBackend.new(
-  llvm_gen,
-  output_file: output_path,
-  module_name: "test_native_array_class"
-)
-backend.generate
-puts "Generated: #{output_path}"
-
-puts "\n=== Testing ==="
-require File.expand_path(output_path)
-
-puts "\nTest 1: test_create_and_access"
-result = Object.new.send(:test_create_and_access, 5)
-expected = 1.0 + 2.0 + 3.0 + 4.0  # 10.0
-puts "test_create_and_access(5) = #{result}"
-puts "Expected: #{expected}"
-puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"
-
-puts "\nTest 2: test_loop_access"
-result = Object.new.send(:test_loop_access, 5)
-# Sum of 0*1.0 + 1*1.0 + 2*1.0 + 3*1.0 + 4*1.0 = 0+1+2+3+4 = 10.0
-expected = 10.0
-puts "test_loop_access(5) = #{result}"
-puts "Expected: #{expected}"
-puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"
-
-puts "\nTest 3: test_distance_sum"
-result = Object.new.send(:test_distance_sum, 5)
-# Distance squared between consecutive particles at x=0,10,20,30,40
-# Each distance squared = 10*10 = 100, 4 pairs = 400
-expected = 400.0
-puts "test_distance_sum(5) = #{result}"
-puts "Expected: #{expected}"
-puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"