konpeito 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3daf2b84b1f0d775d0cc7ca3a3ed5937f82a44d44a068131b62a326049893f5d
-  data.tar.gz: 0ebda1e25a79a24d8bbed4376d048945a595202060802315d69eebf23293be2c
+  metadata.gz: 968753a2cfabd2d2b237dd5125d6ae0818848a3f7243e7fdbb408a50dc802f48
+  data.tar.gz: 724dcd3309cb7e42fbd2cf7e3ffa0b6b1eac07840a8ba46affcad3c0bab6a21a
 SHA512:
-  metadata.gz: 355daf3587c553762d23be9cf1620a08f87c13afc825114cb4b6413e64a33ca7173a5c569109c21745390732a603ade72d3cca8c67c5953b5418fbfe8b94fd18
-  data.tar.gz: 50b4130ab80368df57e5466e4b0faadebdd40f385b018cdcc1a3f8b1da6557c0ae559b55b277b3f0619a47ff1edbf9a18b0ad153fc044a4707649f2c9c54f3f3
+  metadata.gz: e23cbc46176d84f51b1706e1125eae4f02a1ff31f6e9f64bc49856c79c8061a1aae6441cac1ee638c1a7eb8b0884cb235a40d11c509783e8e82b502d0b77e477
+  data.tar.gz: 3ead6d2c4b880aae4f687cfabf4f2c75c07f3b1939ed610a20ca0b1af301ff27153acfc25007720aaad772ae2581cb55c11558d7c6e9d9a16876012911081394

data/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to Konpeito will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.3] - 2026-02-24
+
+### Added
+- Conformance test suite expansion: 77 spec files with 1,095+ assertions
+- JVM runtime: Fiber support, ConditionVariable deadlock fix, Math module (PI, E, sqrt)
+- `&blk` block argument support at call sites (e.g., `arr.map(&blk)`)
+
+### Fixed
+- Native backend: BUS error in `defined?(:method)` at top-level
+- Native backend: inliner no longer inlines functions with `&blk` block params
+- JVM backend: ConditionVariable deadlock — rewritten to release mutex during wait
+- JVM backend: Math::PI, Math::E constants and Math.sqrt dispatch
+- JVM backend: nested rescue, pattern matching, SizedQueue#empty?
+- JVM backend: Integer()/Float() kernel methods, String#split limit, sleep, Symbol#frozen?
+- JVM backend: hash iteration, KArray methods, splat args, user-defined ==, super(args)
+- JVM backend: VerifyError for widened instance method parameters
+- JVM backend: Fiber resume/yield, thread_mutex, runtime class identity
+
 ## [0.2.2] - 2026-02-21
 
 ### Added

data/lib/konpeito/codegen/builtin_methods.rb

@@ -69,8 +69,10 @@ module Konpeito
         :+ => { 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 },
+        # Array transformation
+        # Note: rb_ary_reverse is in-place mutation, so we use rb_funcallv fallback
+        # to get Ruby's Array#reverse behavior (returns new array without modifying original)
+        # reverse: removed from builtin_methods - falls back to rb_funcallv
         sort: { c_func: "rb_ary_sort", arity: 0, return_type: :Array, conv: :simple },
 
         # Array query with args - exported

data/lib/konpeito/codegen/cruby_backend.rb

@@ -152,6 +152,25 @@ module Konpeito
               lines << "extern VALUE #{mangled_name}(#{(['VALUE'] * (arity + 1)).join(', ')});"
             end
           end
+
+          # Declare extern for alias-renamed functions
+          (llvm_generator.alias_renamed_methods || {}).each do |key, renamed|
+            class_name, _method_name = key.split("#", 2)
+            next unless class_name == class_def.name.to_s
+
+            owner = class_name.gsub(/[^a-zA-Z0-9_]/, "_")
+            sanitized = renamed.gsub(/[^a-zA-Z0-9_]/, "_")
+            mangled = "rn_#{owner}_#{sanitized}"
+            func = llvm_generator.mod.functions[mangled]
+            next unless func
+
+            if llvm_generator.variadic_functions[mangled]
+              lines << "extern VALUE #{mangled}(int argc, VALUE *argv, VALUE self);"
+            else
+              arity = func.params.size - 1
+              lines << "extern VALUE #{mangled}(#{(['VALUE'] * (arity + 1)).join(', ')});"
+            end
+          end
         end
 
         # Declare external functions from LLVM module (modules)
@@ -264,12 +283,12 @@ module Konpeito
             lines << "    rb_define_singleton_method(#{module_var}, \"#{method_name}\", #{mangled_name}, #{arity});"
           end
 
-          # Register module constants
-          module_def.constants.each do |const_name, _value|
-            # Constants are typically registered at runtime via rb_const_set
-            # For compile-time literals, we could use rb_define_const here
-            # For now, mark them for runtime initialization
-            lines << "    /* Module constant #{module_def.name}::#{const_name} registered at runtime */"
+          # Register module constants (e.g., VERSION = "2.0")
+          module_def.constants.each do |const_name, value_node|
+            c_value = hir_literal_to_c_value(value_node)
+            next unless c_value
+
+            lines << "    rb_const_set(#{module_var}, rb_intern(\"#{const_name}\"), #{c_value});"
           end
         end
 
@@ -297,17 +316,20 @@ module Konpeito
 
           # Prepend modules (must come before include to maintain proper method resolution order)
           class_def.prepended_modules.each do |module_name|
-            lines << "    rb_prepend_module(#{class_var}, m#{module_name});"
+            module_expr = resolve_module_c_expr(module_name)
+            lines << "    rb_prepend_module(#{class_var}, #{module_expr});"
           end
 
           # Include modules
           class_def.included_modules.each do |module_name|
-            lines << "    rb_include_module(#{class_var}, m#{module_name});"
+            module_expr = resolve_module_c_expr(module_name)
+            lines << "    rb_include_module(#{class_var}, #{module_expr});"
           end
 
           # Extend modules (adds module methods as singleton methods on the class)
           class_def.extended_modules.each do |module_name|
-            lines << "    rb_extend_object(#{class_var}, m#{module_name});"
+            module_expr = resolve_module_c_expr(module_name)
+            lines << "    rb_extend_object(#{class_var}, #{module_expr});"
           end
 
           class_def.method_names.each do |method_name|
@@ -343,7 +365,41 @@ module Konpeito
 
           # Register aliases
           class_def.aliases.each do |new_name, old_name|
-            lines << "    rb_define_alias(#{class_var}, \"#{new_name}\", \"#{old_name}\");"
+            renamed_key = "#{class_def.name}##{old_name}"
+            if llvm_generator.alias_renamed_methods&.key?(renamed_key)
+              # Method was redefined after alias — point alias to renamed original
+              renamed = llvm_generator.alias_renamed_methods[renamed_key]
+              owner = class_def.name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+              sanitized = renamed.gsub(/[^a-zA-Z0-9_]/, "_")
+              mangled = "rn_#{owner}_#{sanitized}"
+              llvm_func = llvm_generator.mod.functions[mangled]
+              if llvm_generator.variadic_functions[mangled]
+                arity = -1
+              elsif llvm_func
+                arity = llvm_func.params.size - 1
+              else
+                arity = 0
+              end
+              lines << "    rb_define_method(#{class_var}, \"#{new_name}\", #{mangled}, #{arity});"
+            else
+              lines << "    rb_define_alias(#{class_var}, \"#{new_name}\", \"#{old_name}\");"
+            end
+          end
+
+          # Register class body constants (e.g., PI = 3, VERSION = "1.0")
+          class_def.body_constants.each do |const_name, value_node|
+            c_value = hir_literal_to_c_value(value_node)
+            next unless c_value
+
+            lines << "    rb_const_set(#{class_var}, rb_intern(\"#{const_name}\"), #{c_value});"
+          end
+
+          # Register class body class variables (e.g., @@count = 0)
+          class_def.body_class_vars.each do |cvar_name, value_node|
+            c_value = hir_literal_to_c_value(value_node)
+            next unless c_value
+
+            lines << "    rb_cvar_set(#{class_var}, rb_intern(\"#{cvar_name}\"), #{c_value});"
           end
         end
 
@@ -1019,6 +1075,25 @@ module Konpeito
         "Comparable" => "rb_mComparable",
       }.freeze
 
+      # Known Ruby stdlib modules that can be included/extended/prepended
+      KNOWN_MODULE_MAP = {
+        "Comparable" => "rb_mComparable",
+        "Enumerable" => "rb_mEnumerable",
+        "Kernel" => "rb_mKernel",
+        "Math" => "rb_mMath",
+      }.freeze
+
+      # Resolve a module name to its C expression for include/extend/prepend
+      def resolve_module_c_expr(module_name)
+        # Check known stdlib modules first
+        if KNOWN_MODULE_MAP[module_name]
+          return KNOWN_MODULE_MAP[module_name]
+        end
+
+        # User-defined module (defined earlier in Init function as mModuleName)
+        "m#{module_name}"
+      end
+
       def resolve_superclass_c_expr(superclass_name, non_native_classes)
         return "rb_cObject" unless superclass_name
 
@@ -1041,6 +1116,43 @@ module Konpeito
         "rb_const_get(rb_cObject, rb_intern(\"#{superclass_name}\"))"
       end
 
+      # Convert an HIR literal node to a C VALUE expression for use in Init function.
+      # Returns nil for non-literal nodes that cannot be statically initialized.
+      def hir_literal_to_c_value(node)
+        case node
+        when HIR::IntegerLit
+          "INT2FIX(#{node.value})"
+        when HIR::FloatLit
+          "DBL2NUM(#{node.value})"
+        when HIR::StringLit
+          escaped = node.value.to_s.gsub("\\", "\\\\\\\\").gsub('"', '\\"').gsub("\n", "\\n").gsub("\t", "\\t")
+          "rb_str_new_cstr(\"#{escaped}\")"
+        when HIR::SymbolLit
+          "ID2SYM(rb_intern(\"#{node.value}\"))"
+        when HIR::BoolLit
+          node.value ? "Qtrue" : "Qfalse"
+        when HIR::NilLit
+          "Qnil"
+        when HIR::Literal
+          # Generic literal fallback
+          case node.type
+          when TypeChecker::Types::INTEGER
+            "INT2FIX(#{node.value})"
+          when TypeChecker::Types::FLOAT
+            "DBL2NUM(#{node.value})"
+          when TypeChecker::Types::STRING
+            escaped = node.value.to_s.gsub("\\", "\\\\\\\\").gsub('"', '\\"').gsub("\n", "\\n").gsub("\t", "\\t")
+            "rb_str_new_cstr(\"#{escaped}\")"
+          when TypeChecker::Types::BOOL
+            node.value ? "Qtrue" : "Qfalse"
+          else
+            nil
+          end
+        else
+          nil
+        end
+      end
+
       # Generate extern declaration for a @cfunc C function
       def generate_cfunc_extern_declaration(cfunc_type)
         lines = []

data/lib/konpeito/codegen/inliner.rb

@@ -74,9 +74,9 @@ module Konpeito
         # 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 rest params (*args), keyword_rest (**kwargs), or block params (&blk)
+        # The inliner doesn't support rest param array aggregation or block capture context
+        return false if func.params.any? { |p| p.rest || p.keyword_rest || p.block }
 
         # Skip functions with multiple blocks (contains if/while/etc.)
         # These have complex control flow that can't be simply inlined
@@ -91,6 +91,7 @@ module Konpeito
         # 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)
+        # Skip functions containing ThreadNew/FiberNew (callbacks reference specific allocas)
         func.body.each do |block|
           block.instructions.each do |inst|
             return false if inst.is_a?(HIR::Call) && inst.block
@@ -98,6 +99,8 @@ module Konpeito
             return false if inst.is_a?(HIR::BeginRescue)
             return false if inst.is_a?(HIR::CaseStatement)
             return false if inst.is_a?(HIR::CaseMatchStatement)
+            return false if inst.is_a?(HIR::ThreadNew)
+            return false if inst.is_a?(HIR::FiberNew)
           end
         end
 
@@ -158,6 +161,9 @@ module Konpeito
       def can_inline_call?(inst)
         return false unless self_call?(inst)
 
+        # Don't inline calls with splat arguments - they need rb_apply
+        return false if inst.args.any? { |a| a.is_a?(HIR::SplatArg) }
+
         callee_name = inst.method_name.to_s
         @inline_candidates[callee_name] == true
       end