konpeito 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53a3bbb24175ed554f9f560c38e6f8138206da3fb6385f87358e9dfa3eed4f10
-  data.tar.gz: 80026dca6352dcb9effa9e7bac8e7ebc58e517ae84cb1f15627935fbb3d5fee4
+  metadata.gz: b559f8a6de1d213b466939fb5fbde0a797a6808a7ce664f28d55ed0496696dde
+  data.tar.gz: 6809762994527a50fcf96c1644f24cde5f2324b668e1dc646bf32077ea679af0
 SHA512:
-  metadata.gz: 4233ae433c5730c64da97806275ca0300d80f77e5af8c338cf2185f54205d69b99091447a097506b5d2944dac437396a8a4e04ae9a97a90df60f8a93d60e730d
-  data.tar.gz: 911c32b9ac29989060b08fe6fc352074a02038ae20f8b516723e56a263bf602b0ee70206cf41a3bbe682044ab4c7511552fa255ef9d7b137da952dcea271f860
+  metadata.gz: c8c43cca2f5e3812ee706a9b2b2c833ad9036d98e997b4481ce701d0edfa98b03a967f935c2b6aec7b8b2dfb19d27225b0e7a6f5e091ecc993a0786cec3cc2d7
+  data.tar.gz: 27acd8361e403febf7fd4e45b5ab832f1c767deedf329b8e164c8b62f7f1aa127c0ea75eeccaee7d5ef6767ea7f45c787baa526461bfa6dbf6ba034f90815bff

data/CHANGELOG.md

@@ -5,6 +5,15 @@ 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.1.3] - 2026-02-18
+
+### Fixed
+- JVM backend: resolve class method descriptor mismatch when called from instance methods (pre-register singleton method descriptors)
+- Documentation: correct JWM and Skija GitHub URLs in README
+
+### Added
+- Documentation: Castella UI calculator demo with Style composition
+
 ## [0.1.2] - 2026-02-17
 
 ### Fixed
@@ -99,6 +108,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `%a{extern}` - external C struct wrappers
 - `%a{simd}` - SIMD vectorization
 
+[0.1.3]: https://github.com/i2y/konpeito/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/i2y/konpeito/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/i2y/konpeito/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/i2y/konpeito/releases/tag/v0.1.0

data/README.md

@@ -135,7 +135,7 @@ The JVM backend supports seamless Java interop — call Java libraries directly
 
 ## Castella UI
 
-A reactive GUI framework for the JVM backend, powered by [JWM](https://github.com/nicenote/jwm) + [Skija](https://github.com/nicenote/skija).
+A reactive GUI framework for the JVM backend, powered by [JWM](https://github.com/HumbleUI/JWM) + [Skija](https://github.com/HumbleUI/Skija).
 
 ### DSL
 
@@ -230,6 +230,144 @@ column(spacing: 12.0) {
 }
 ```
 
+### Calculator Demo
+
+A port of the original Python Castella calculator. Flex layout, button kinds (`KIND_DANGER`, `KIND_WARNING`, `KIND_SUCCESS`), reactive `state()`, and class methods called from instance method callbacks — all in ~130 lines:
+
+<p align="center">
+  <img src="docs/screenshots/calc.png" alt="Calculator" width="320" />
+</p>
+
+```ruby
+class Calc < Component
+  def initialize
+    super
+    @display = state("0")
+    @lhs = 0.0
+    @current_op = ""
+    @is_refresh = true
+  end
+
+  # --- Calculator logic ---
+
+  def press_number(label)
+    if @display.value == "0" || @is_refresh
+      @display.set(label)
+    else
+      @display.set(@display.value + label)
+    end
+    @is_refresh = false
+  end
+
+  def press_dot
+    if @is_refresh
+      @display.set("0.")
+      @is_refresh = false
+      return
+    end
+    if !@display.value.include?(".")
+      @display.set(@display.value + ".")
+    end
+  end
+
+  def all_clear
+    @display.set("0")
+    @lhs = 0.0
+    @current_op = ""
+    @is_refresh = true
+  end
+
+  def self.calc(lhs, op, rhs)
+    if op == "+"
+      lhs + rhs
+    elsif op == "-"
+      lhs - rhs
+    elsif op == "\u00D7"
+      lhs * rhs
+    elsif op == "\u00F7"
+      if rhs == 0.0
+        0.0
+      else
+        lhs / rhs
+      end
+    else
+      rhs
+    end
+  end
+
+  def self.format_result(val)
+    if val == val.to_i.to_f
+      val.to_i.to_s
+    else
+      val.to_s
+    end
+  end
+
+  def press_operator(new_op)
+    rhs = @display.value.to_f
+    if @current_op != ""
+      result = Calc.calc(@lhs, @current_op, rhs)
+      @display.set(Calc.format_result(result))
+      @lhs = result
+    else
+      @lhs = rhs
+    end
+    if new_op == "="
+      @current_op = ""
+    else
+      @current_op = new_op
+    end
+    @is_refresh = true
+  end
+
+  # --- View ---
+
+  def view
+    grid = Style.new.spacing(4.0)
+    btn  = Style.new.font_size(32.0)
+    op   = btn + Style.new.kind(KIND_WARNING)
+    ac   = btn + Style.new.kind(KIND_DANGER).flex(3)
+    eq   = btn + Style.new.kind(KIND_SUCCESS)
+    wide = btn + Style.new.flex(2)
+
+    column(spacing: 4.0, padding: 4.0) {
+      text @display.value, font_size: 48.0, align: :right, kind: KIND_INFO, height: 72.0
+      row(grid) {
+        button("AC", ac) { all_clear }
+        button("\u00F7", op) { press_operator("\u00F7") }
+      }
+      row(grid) {
+        button("7", btn) { press_number("7") }
+        button("8", btn) { press_number("8") }
+        button("9", btn) { press_number("9") }
+        button("\u00D7", op) { press_operator("\u00D7") }
+      }
+      row(grid) {
+        button("4", btn) { press_number("4") }
+        button("5", btn) { press_number("5") }
+        button("6", btn) { press_number("6") }
+        button("-", op) { press_operator("-") }
+      }
+      row(grid) {
+        button("1", btn) { press_number("1") }
+        button("2", btn) { press_number("2") }
+        button("3", btn) { press_number("3") }
+        button("+", op) { press_operator("+") }
+      }
+      row(grid) {
+        button("0", wide) { press_number("0") }
+        button(".", btn) { press_dot }
+        button("=", eq) { press_operator("=") }
+      }
+    }
+  end
+end
+
+frame = JWMFrame.new("Castella Calculator", 320, 480)
+app = App.new(frame, Calc.new)
+app.run
+```
+
 ## Performance
 
 Konpeito shines in compute-heavy, typed loops where unboxed arithmetic and backend optimizations kick in. All benchmarks compare against Ruby 4.0.1 with YJIT enabled on Apple M4 Max.

data/lib/konpeito/codegen/jvm_generator.rb

@@ -3278,6 +3278,24 @@ module Konpeito
             instructions << { "op" => "invokestatic", "owner" => "java/lang/Boolean",
                               "name" => "valueOf", "descriptor" => "(Z)Ljava/lang/Boolean;" }
             type = :value
+          # Unbox Object to match expected primitive return type (static methods only).
+          # Instance method descriptors are always normalized to Object return, so
+          # unboxing would be incorrect — the value might not be the expected wrapper type.
+          elsif !@generating_instance_method && @current_function_return_type == :double && type == :value
+            instructions << { "op" => "checkcast", "type" => "java/lang/Double" }
+            instructions << { "op" => "invokevirtual", "owner" => "java/lang/Double",
+                              "name" => "doubleValue", "descriptor" => "()D" }
+            type = :double
+          elsif !@generating_instance_method && @current_function_return_type == :i64 && type == :value
+            instructions << { "op" => "checkcast", "type" => "java/lang/Long" }
+            instructions << { "op" => "invokevirtual", "owner" => "java/lang/Long",
+                              "name" => "longValue", "descriptor" => "()J" }
+            type = :i64
+          elsif !@generating_instance_method && @current_function_return_type == :i8 && type == :value
+            instructions << { "op" => "checkcast", "type" => "java/lang/Boolean" }
+            instructions << { "op" => "invokevirtual", "owner" => "java/lang/Boolean",
+                              "name" => "booleanValue", "descriptor" => "()Z" }
+            type = :i8
           end
 
           instructions << case type
@@ -4029,6 +4047,33 @@ module Konpeito
 
           @method_descriptors[key] = "(#{params_desc})#{type_to_descriptor(ret_type)}"
         end
+
+        # Pre-register singleton (class) method descriptors
+        (class_def.singleton_methods || []).each do |method_name|
+          key = "#{class_name}.#{method_name}"
+          next if @method_descriptors.key?(key)
+
+          func = find_class_singleton_method(class_name, method_name.to_s)
+          next unless func
+
+          rbs_param_types = resolve_rbs_param_types(class_name, method_name.to_s, true)
+          params_desc = func.params.each_with_index.map do |p, i|
+            rbs_t = rbs_param_types && i < rbs_param_types.size ? rbs_param_types[i] : nil
+            t = (rbs_t && rbs_t != :value) ? rbs_t : param_type(p)
+            t = :value if t == :void
+            type_to_descriptor(t)
+          end.join
+
+          rbs_ret = resolve_rbs_return_type(class_name, method_name.to_s, true)
+          if rbs_ret && rbs_ret != :value
+            ret_type = rbs_ret
+          else
+            frt = function_return_type(func)
+            ret_type = (frt == :void) ? :value : frt
+          end
+
+          @method_descriptors[key] = "(#{params_desc})#{type_to_descriptor(ret_type)}"
+        end
       end
 
       def resolve_class_fields(class_def)
@@ -4407,9 +4452,17 @@ module Konpeito
         @current_generating_func_name = func.name.to_s
         reset_function_state(func)
 
-        # Pre-determine return type so generate_return knows if method returns Object
-        pre_ret = function_return_type(func)
-        @current_function_return_type = (pre_ret == :void) ? :value : pre_ret
+        # Pre-determine return type so generate_return knows if method returns Object.
+        # If a descriptor was pre-registered (from RBS), use its return type to ensure
+        # the generated return instruction matches the pre-registered descriptor.
+        pre_registered = @method_descriptors["#{class_def.name}.#{func.name}"]
+        if pre_registered
+          pre_ret = parse_descriptor_return_type(pre_registered)
+        else
+          pre_ret = function_return_type(func)
+          pre_ret = :value if pre_ret == :void
+        end
+        @current_function_return_type = pre_ret
 
         # Try to resolve param types from RBS if HIR types are unresolved
         rbs_param_types = resolve_rbs_param_types(class_def.name.to_s, func.name.to_s, true)
@@ -4435,9 +4488,36 @@ module Konpeito
           instructions << default_return(ret_type)
         end
 
-        # Build descriptor from actual param types (which may have been corrected from RBS)
-        params_desc = func.params.map { |p| type_to_descriptor(@variable_types[p.name.to_s] || :value) }.join
-        descriptor = "(#{params_desc})#{type_to_descriptor(ret_type)}"
+        # Build descriptor: if pre-registered, use that descriptor directly for consistency.
+        # The pre-registered descriptor was computed from param_type/RBS before code gen,
+        # matching what the call site will use. The code-gen-derived descriptor may differ
+        # because detect_return_type_from_instructions can miss returns in branching code.
+        if pre_registered
+          descriptor = pre_registered
+          # Ensure final return instruction matches the pre-registered return type
+          pre_ret_type = parse_descriptor_return_type(pre_registered)
+          if pre_ret_type != :void && pre_ret_type != :value
+            # Replace trailing void return with typed default return if needed
+            if instructions.last && instructions.last["op"] == "return"
+              instructions.pop
+              case pre_ret_type
+              when :i64
+                instructions << { "op" => "lconst_0" }
+                instructions << { "op" => "lreturn" }
+              when :double
+                instructions << { "op" => "dconst_0" }
+                instructions << { "op" => "dreturn" }
+              when :i8
+                instructions << { "op" => "iconst_0" }
+                instructions << { "op" => "ireturn" }
+              end
+            end
+          end
+        else
+          # Build descriptor from actual param types (which may have been corrected from RBS)
+          params_desc = func.params.map { |p| type_to_descriptor(@variable_types[p.name.to_s] || :value) }.join
+          descriptor = "(#{params_desc})#{type_to_descriptor(ret_type)}"
+        end
 
         # When renaming for conflict avoidance, use prefixed JVM name
         jvm_name = if rename_prefix
@@ -5396,6 +5476,10 @@ module Konpeito
 
         return [] unless target_func
 
+        # Look up the registered descriptor first to determine expected param types
+        registered = @method_descriptors["#{class_name}.#{method_name}"]
+        registered_param_types = registered ? parse_descriptor_param_types(registered) : nil
+
         # Resolve param types: prefer RBS types over HIR types (which may be unresolved TypeVars)
         rbs_param_types = resolve_rbs_param_types(class_name, method_name, true)
 
@@ -5416,18 +5500,17 @@ module Konpeito
             end
             arg_types << :hash
           elsif i < args.size
-            param_t = param_type(param)
-            # Fallback to RBS type if param type is unresolved
-            if param_t == :value && rbs_param_types && i < rbs_param_types.size && rbs_param_types[i] != :value
-              # RBS resolved what HM couldn't — undo typevar fallback
-              @typevar_fallback_count -= 1 if @typevar_fallback_count > 0
-              param_t = rbs_param_types[i]
-            end
-            # Also try inferring from arg itself
-            if param_t == :value
-              arg_var = extract_var_name(args[i])
-              param_t = arg_var ? (@variable_types[arg_var] || :value) : (infer_type_from_hir(args[i]) || :value)
-            end
+            # Use registered descriptor's param type if available (most accurate)
+            param_t = if registered_param_types && i < registered_param_types.size
+                        registered_param_types[i]
+                      else
+                        pt = param_type(param)
+                        if pt == :value && rbs_param_types && i < rbs_param_types.size && rbs_param_types[i] != :value
+                          rbs_param_types[i]
+                        else
+                          pt
+                        end
+                      end
             instructions.concat(load_value(args[i], param_t))
             arg_types << param_t
           else
@@ -5439,7 +5522,6 @@ module Konpeito
         end
 
         # Build descriptor — prefer registered descriptor for consistency
-        registered = @method_descriptors["#{class_name}.#{method_name}"]
         if registered
           descriptor = registered
           ret_type = parse_descriptor_return_type(registered)

data/lib/konpeito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Konpeito
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: konpeito
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Yasushi Itoh