konpeito 0.1.0

data/lib/konpeito.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "konpeito/version"
+
+module Konpeito
+  class Error < StandardError; end
+  class ParseError < Error; end
+  class TypeError < Error; end
+  class CodegenError < Error; end
+
+  class DependencyError < Error
+    attr_reader :from_file, :line, :cycle, :missing_file
+
+    def initialize(message, from_file: nil, line: nil, cycle: nil, missing_file: nil)
+      @from_file = from_file
+      @line = line
+      @cycle = cycle  # Array of file names in the cycle
+      @missing_file = missing_file
+      super(message)
+    end
+  end
+
+  module Diagnostics
+    autoload :SourceSpan, "konpeito/diagnostics/diagnostic"
+    autoload :Label, "konpeito/diagnostics/diagnostic"
+    autoload :Diagnostic, "konpeito/diagnostics/diagnostic"
+    autoload :DiagnosticRenderer, "konpeito/diagnostics/renderer"
+    autoload :Collector, "konpeito/diagnostics/collector"
+  end
+
+  autoload :Platform, "konpeito/platform"
+  autoload :CLI, "konpeito/cli"
+  autoload :LegacyCLI, "konpeito/cli"
+  autoload :Compiler, "konpeito/compiler"
+  autoload :DependencyResolver, "konpeito/dependency_resolver"
+
+  # Commands module for CLI subcommands
+  module Commands
+    autoload :Config, "konpeito/cli/config"
+    autoload :BaseCommand, "konpeito/cli/base_command"
+    autoload :BuildCommand, "konpeito/cli/build_command"
+    autoload :CheckCommand, "konpeito/cli/check_command"
+    autoload :LspCommand, "konpeito/cli/lsp_command"
+    autoload :InitCommand, "konpeito/cli/init_command"
+    autoload :FmtCommand, "konpeito/cli/fmt_command"
+    autoload :TestCommand, "konpeito/cli/test_command"
+    autoload :WatchCommand, "konpeito/cli/watch_command"
+  end
+
+  module Parser
+    autoload :PrismAdapter, "konpeito/parser/prism_adapter"
+  end
+
+  module TypeChecker
+    # Types must be loaded first as other modules depend on it
+    require_relative "konpeito/type_checker/types"
+
+    autoload :Checker, "konpeito/type_checker/checker"
+    autoload :Inferrer, "konpeito/type_checker/inferrer"
+    autoload :HMInferrer, "konpeito/type_checker/hm_inferrer"
+    autoload :RBSLoader, "konpeito/type_checker/rbs_loader"
+    autoload :TypeVar, "konpeito/type_checker/unification"
+    autoload :FunctionType, "konpeito/type_checker/unification"
+    autoload :Unifier, "konpeito/type_checker/unification"
+    autoload :TypeScheme, "konpeito/type_checker/unification"
+    autoload :UnificationError, "konpeito/type_checker/unification"
+  end
+
+  module AST
+    autoload :TypedNode, "konpeito/ast/typed_ast"
+    autoload :TypedASTBuilder, "konpeito/ast/typed_ast"
+    autoload :Visitor, "konpeito/ast/visitor"
+  end
+
+  module HIR
+    autoload :Builder, "konpeito/hir/builder"
+    # Load nodes directly since they define classes in HIR namespace
+    require_relative "konpeito/hir/nodes"
+  end
+
+  module Codegen
+    autoload :LLVMGenerator, "konpeito/codegen/llvm_generator"
+    autoload :CRubyBackend, "konpeito/codegen/cruby_backend"
+    autoload :Monomorphizer, "konpeito/codegen/monomorphizer"
+    autoload :Inliner, "konpeito/codegen/inliner"
+    autoload :LoopOptimizer, "konpeito/codegen/loop_optimizer"
+  end
+
+  module LSP
+    autoload :Server, "konpeito/lsp/server"
+    autoload :Transport, "konpeito/lsp/transport"
+    autoload :DocumentManager, "konpeito/lsp/document_manager"
+  end
+
+  module RBSInline
+    autoload :Preprocessor, "konpeito/rbs_inline/preprocessor"
+  end
+
+  # Convenience method
+  def self.compile(source_file, output_file: nil, format: :cruby_ext, verbose: false, optimize: true)
+    Compiler.new(
+      source_file: source_file,
+      output_file: output_file,
+      format: format,
+      verbose: verbose,
+      optimize: optimize
+    ).compile
+  end
+end

data/test_native_array.rb

@@ -0,0 +1,172 @@
+# 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

@@ -0,0 +1,197 @@
+# 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"

data/test_native_class.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+# Simple test for NativeClass (Point with x, y fields)
+
+$LOAD_PATH.unshift File.expand_path("lib", __dir__)
+require "konpeito"
+
+source = <<~RUBY
+  def test_create
+    p = Point.new
+    p.x = 3.0
+    p.y = 4.0
+    p.x
+  end
+
+  def test_distance(x1, y1, x2, y2)
+    p1 = Point.new
+    p1.x = x1
+    p1.y = y1
+
+    p2 = Point.new
+    p2.x = x2
+    p2.y = y2
+
+    dx = p2.x - p1.x
+    dy = p2.y - p1.y
+    dx * dx + dy * dy
+  end
+
+  def test_sum_coords
+    p = Point.new
+    p.x = 10.0
+    p.y = 20.0
+    p.x + p.y
+  end
+RUBY
+
+rbs = <<~RBS
+  # @native
+  class Point
+    @x: Float
+    @y: Float
+
+    def self.new: () -> Point
+    def x: () -> Float
+    def x=: (Float value) -> Float
+    def y: () -> Float
+    def y=: (Float value) -> Float
+  end
+
+  class Object
+    def test_create: () -> Float
+    def test_distance: (Float x1, Float y1, Float x2, Float y2) -> Float
+    def test_sum_coords: () -> Float
+  end
+RBS
+
+require "tempfile"
+require "fileutils"
+
+tmp_dir = "tmp"
+FileUtils.mkdir_p(tmp_dir)
+
+source_path = File.join(tmp_dir, "test_native_class.rb")
+rbs_path = File.join(tmp_dir, "test_native_class.rbs")
+output_path = File.join(tmp_dir, "test_native_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|
+      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_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_class"
+)
+backend.generate
+puts "Generated: #{output_path}"
+
+puts "\n=== Testing ==="
+require File.expand_path(output_path)
+
+puts "\nTest 1: test_create"
+result = Object.new.send(:test_create)
+expected = 3.0
+puts "test_create() = #{result}"
+puts "Expected: #{expected}"
+puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"
+
+puts "\nTest 2: test_distance"
+# Distance squared from (0,0) to (3,4) = 9 + 16 = 25
+result = Object.new.send(:test_distance, 0.0, 0.0, 3.0, 4.0)
+expected = 25.0
+puts "test_distance(0, 0, 3, 4) = #{result}"
+puts "Expected: #{expected}"
+puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"
+
+puts "\nTest 3: test_sum_coords"
+result = Object.new.send(:test_sum_coords)
+expected = 30.0
+puts "test_sum_coords() = #{result}"
+puts "Expected: #{expected}"
+puts (result - expected).abs < 0.001 ? "PASS" : "FAIL"

data/tools/konpeito-asm/build.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# Build the Konpeito ASM tool
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+JAVA="${JAVA_HOME:-/opt/homebrew/opt/openjdk@21}/bin/javac"
+JAR_CMD="${JAVA_HOME:-/opt/homebrew/opt/openjdk@21}/bin/jar"
+ASM_JAR="$SCRIPT_DIR/lib/asm-9.7.1.jar"
+BUILD_DIR="$SCRIPT_DIR/build"
+OUT_JAR="$SCRIPT_DIR/konpeito-asm.jar"
+
+# Use javac/jar from PATH if JAVA_HOME not set and homebrew path doesn't exist
+if [ ! -f "$JAVA" ]; then
+    JAVA="javac"
+    JAR_CMD="jar"
+fi
+
+echo "Building konpeito-asm tool..."
+
+# Clean and create build directory
+rm -rf "$BUILD_DIR"
+mkdir -p "$BUILD_DIR/com/konpeito/asm"
+mkdir -p "$BUILD_DIR/konpeito/runtime"
+
+# Compile ASM tool and runtime classes
+"$JAVA" -cp "$ASM_JAR" \
+    -Xlint:none \
+    -nowarn \
+    -d "$BUILD_DIR" \
+    "$SCRIPT_DIR/src/KonpeitoAssembler.java" \
+    "$SCRIPT_DIR/src/ClassIntrospector.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KArray.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KHash.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KThread.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KConditionVariable.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KSizedQueue.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KJSON.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KCrypto.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KCompression.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KHTTP.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KTime.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KFile.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KMath.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KRactor.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/KRactorPort.java" \
+    "$SCRIPT_DIR/src/konpeito/runtime/RubyDispatch.java"
+
+# Copy runtime classes to a separate directory for JAR bundling
+RUNTIME_DIR="$SCRIPT_DIR/runtime-classes"
+rm -rf "$RUNTIME_DIR"
+mkdir -p "$RUNTIME_DIR/konpeito/runtime"
+cp "$BUILD_DIR/konpeito/runtime/"*.class "$RUNTIME_DIR/konpeito/runtime/"
+
+# Create manifest
+echo "Main-Class: com.konpeito.asm.KonpeitoAssembler" > "$BUILD_DIR/MANIFEST.MF"
+
+# Extract ASM classes into build dir (to create a fat jar)
+cd "$BUILD_DIR"
+"$JAR_CMD" xf "$ASM_JAR"
+rm -rf META-INF/MANIFEST.MF 2>/dev/null || true
+
+# Create fat jar
+"$JAR_CMD" cfm "$OUT_JAR" "$BUILD_DIR/MANIFEST.MF" -C "$BUILD_DIR" .
+
+echo "Built: $OUT_JAR"