konpeito 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7f18a84d8cfece0c51becca2067ab474195205b4d5ce09b7a4e197b129851a
-  data.tar.gz: ca0f8a113919d8ca6b28e8109fd2ed031979de67e695c9aaad9f659b425dab89
+  metadata.gz: b559f8a6de1d213b466939fb5fbde0a797a6808a7ce664f28d55ed0496696dde
+  data.tar.gz: 6809762994527a50fcf96c1644f24cde5f2324b668e1dc646bf32077ea679af0
 SHA512:
-  metadata.gz: 62a1bd26cf53ddc918f1129772574021154079e492c33f48437290179fd71bdba65ca78c95890f16c224cf58930fbc879040c595580eb73a1d7e6868f0460cd9
-  data.tar.gz: 295d6ac004cda8c7823ad711dca5015a95c78302fd0f3c2da0796cb30ef0c638a13bac53f0c8ae439fc50556bb1262e6a304facdd4dfaa3c6b425f1d3842f85a
+  metadata.gz: c8c43cca2f5e3812ee706a9b2b2c833ad9036d98e997b4481ce701d0edfa98b03a967f935c2b6aec7b8b2dfb19d27225b0e7a6f5e091ecc993a0786cec3cc2d7
+  data.tar.gz: 27acd8361e403febf7fd4e45b5ab832f1c767deedf329b8e164c8b62f7f1aa127c0ea75eeccaee7d5ef6767ea7f45c787baa526461bfa6dbf6ba034f90815bff

data/CHANGELOG.md

@@ -5,6 +5,28 @@ 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
+- Castella UI: include padding and respect FIXED sizes in Column/Row measure
+- Castella UI: use lighter accent variant for normal button hover across all themes
+- JVM backend: preserve subclass type through inherited self-returning method chains
+
+### Changed
+- Documentation: reorganize Castella UI section in README with DSL / Reactive State / Style Composition subheadings
+- Documentation: add Style Composition example and screenshot to README
+- Documentation: remove filler spacers from counter demos (EXPANDING default makes them unnecessary)
+- Documentation: update counter screenshot
+
 ## [0.1.1] - 2026-02-16
 
 ### Fixed
@@ -86,5 +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,43 +135,238 @@ The JVM backend supports seamless Java interop — call Java libraries directly
 
 ## Castella UI
 
-Castella is a reactive GUI framework that runs on the JVM backend, powered by [JWM](https://github.com/nicenote/jwm) + [Skija](https://github.com/nicenote/skija) for cross-platform rendering. Based on a port of [Castella for Python](https://github.com/i2y/castella).
+A reactive GUI framework for the JVM backend, powered by [JWM](https://github.com/HumbleUI/JWM) + [Skija](https://github.com/HumbleUI/Skija).
+
+### DSL
+
+Ruby's block syntax becomes a UI DSL — `column`, `row`, `text`, `button` etc. nest naturally with keyword arguments. A plain Ruby method is a reusable component.
+
+<p align="center">
+  <img src="docs/screenshots/dashboard.png" alt="Analytics Dashboard" width="720" />
+</p>
+
+```ruby
+def view
+  column(padding: 20.0, spacing: 16.0) {
+    row(spacing: 12.0) {
+      text("Analytics Dashboard", font_size: 26.0, bold: true)
+      spacer
+      button("Refresh", width: 90.0) {}
+    }.fixed_height(40.0)
+
+    # KPI Cards — extract a method, and it's a reusable component
+    row(spacing: 12.0) {
+      kpi_card("Revenue", "$48,250", "+12.5%", $theme.accent)
+      kpi_card("Users",   "3,842",   "+8.1%",  $theme.success)
+      kpi_card("Orders",  "1,205",   "-2.3%",  $theme.error)
+    }
+
+    # Charts, tables, and layouts compose with blocks
+    row(spacing: 12.0) {
+      column(expanding_width: true, bg_color: $theme.bg_primary, border_radius: 10.0, padding: 14.0) {
+        bar_chart(labels, data, ["Revenue", "Costs"]).title("Monthly Overview").fixed_height(220.0)
+      }
+      column(expanding_width: true, bg_color: $theme.bg_primary, border_radius: 10.0, padding: 14.0) {
+        data_table(headers, widths, rows).fixed_height(200.0)
+      }
+    }
+  }
+end
+
+# A Ruby method is a reusable component
+def kpi_card(label, value, change, color)
+  column(spacing: 6.0, bg_color: $theme.bg_primary, border_radius: 10.0, padding: 16.0, expanding_width: true) {
+    text(label, font_size: 12.0, color: $theme.text_secondary)
+    text(value, font_size: 24.0, bold: true)
+    text(change, font_size: 13.0, color: color)
+  }
+end
+```
+
+### Reactive State
+
+`state(0)` creates an observable value, and the UI re-renders automatically when it changes:
+
+<p align="center">
+  <img src="docs/screenshots/counter.png" alt="Counter App" width="320" />
+</p>
 
 ```ruby
-class CounterApp < Component
+class Counter < Component
   def initialize
     super
     @count = state(0)
   end
 
   def view
-    label = "Count: " + @count.value.to_s
-    Column(
-      Text(label).font_size(32),
-      Row(
-        Button("  -  ").on_click { @count -= 1 },
-        Button("  +  ").on_click { @count += 1 }
-      )
-    )
+    column(padding: 16.0, spacing: 8.0) {
+      text "Count: #{@count}", font_size: 32.0, align: :center
+      row(spacing: 8.0) {
+        button(" - ") { @count -= 1 }
+        button(" + ") { @count += 1 }
+      }
+    }
   end
 end
 ```
 
-A block-based DSL is also available:
+An OOP-style API (`Column(...)`, `Row(...)`) is also available. Available widgets: `Text`, `Button`, `TextInput`, `MultilineText`, `Column`, `Row`, `Image`, `Checkbox`, `Slider`, `ProgressBar`, `Tabs`, `DataTable`, `TreeView`, `BarChart`, `LineChart`, `PieChart`, `Markdown`, and more.
+
+### Style Composition
+
+Styles are first-class objects — store them in variables and compose with `+`:
+
+<p align="center">
+  <img src="docs/screenshots/style_composition.png" alt="Style Composition" width="480" />
+</p>
 
 ```ruby
-def view
-  column(padding: 16.0) do
-    text "Counter: #{@count}", font_size: 24.0, color: 0xFFC0CAF5
-    row(spacing: 8.0) do
-      button("-", width: 60.0) { @count -= 1 }
-      button("+", width: 60.0) { @count += 1 }
+card = Style.new.bg_color($theme.bg_primary).border_radius(10.0).padding(16.0)
+green_card = card + Style.new.border_color($theme.success)
+
+column(spacing: 12.0) {
+  container(card)       { text "Default card" }
+  container(green_card) { text "Green border variant" }
+}
+```
+
+### 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
-```
 
-Available widgets: `Text`, `Button`, `TextInput`, `MultilineText`, `Column`, `Row`, `Image`, `Checkbox`, `Slider`, `ProgressBar`, `Tabs`, `DataTable`, `TreeView`, `BarChart`, `Markdown`, and more.
+frame = JWMFrame.new("Castella Calculator", 320, 480)
+app = App.new(frame, Calc.new)
+app.run
+```
 
 ## Performance
 

data/lib/konpeito/codegen/jvm_generator.rb

@@ -3148,6 +3148,22 @@ module Konpeito
             ensure_slot(result_var, ret_type)
             instructions << store_instruction(result_var, ret_type)
             @variable_types[result_var] = ret_type
+
+            # Propagate class type so subsequent method chains resolve the receiver.
+            # Without this, `Button("Animate!").kind(1)` fails because the receiver
+            # class of `.kind(1)` is unknown after the static call to `Button()`.
+            if ret_type.is_a?(Symbol) && ret_type.to_s.start_with?("class:")
+              cls = ret_type.to_s.sub("class:", "")
+              @variable_class_types[result_var] = cls if @class_info.key?(cls)
+            end
+            # Also check HM-inferred type from the call instruction
+            if !@variable_class_types[result_var] && inst.respond_to?(:type) && inst.type
+              call_type = inst.type
+              call_type = call_type.prune if call_type.respond_to?(:prune)
+              if call_type.is_a?(TypeChecker::Types::ClassInstance) && @class_info.key?(call_type.name.to_s)
+                @variable_class_types[result_var] = call_type.name.to_s
+              end
+            end
           end
         end
 
@@ -3262,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
@@ -4013,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)
@@ -4391,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)
@@ -4419,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
@@ -5114,8 +5210,16 @@ module Konpeito
           # checkcast when return type is a user class (descriptor returns Object but actual is specific class)
           if ret_type == :value
             rbs_class = resolve_rbs_return_class_name(owner_class, method_name)
-            # Also check inferred return class from function_return_type (self-returning methods)
-            rbs_class ||= inferred_return_class
+            # When function returns self (SelfRef), preserve the receiver's actual class type.
+            # RBS annotations declare the defining class (e.g., Widget#fixed_height → Widget)
+            # but `self` at runtime is the receiver's class (e.g., Button). Without this,
+            # method chains like Button(...).fixed_height(36.0).on_click { ... } break because
+            # the receiver type narrows to Widget and on_click (defined on Button) is not found.
+            if inferred_return_class
+              rbs_class = inferred_return_class
+            else
+              rbs_class ||= inferred_return_class
+            end
             if rbs_class && @class_info.key?(rbs_class)
               instructions << { "op" => "checkcast", "type" => @class_info[rbs_class][:jvm_name] }
               @variable_class_types[result_var] = rbs_class
@@ -5372,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)
 
@@ -5392,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
@@ -5415,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/type_checker/hm_inferrer.rb

@@ -1429,6 +1429,10 @@ module Konpeito
       # Score how well an argument type matches an RBS parameter type
       def overload_match_score(arg_type, rbs_param_type)
         case rbs_param_type
+        when RBS::Types::Alias
+          # Resolve common aliases: ::int -> Integer, ::string -> String, etc.
+          resolved = resolve_rbs_alias(rbs_param_type)
+          return overload_match_score(arg_type, resolved) if resolved
         when RBS::Types::ClassInstance
           param_name = rbs_param_type.name.name
           if arg_type.is_a?(Types::ClassInstance)
@@ -1444,6 +1448,24 @@ module Konpeito
         0
       end
 
+      # Resolve RBS type aliases to their underlying ClassInstance types
+      def resolve_rbs_alias(alias_type)
+        alias_name = alias_type.name.name
+        class_name = case alias_name
+                     when :int then :Integer
+                     when :string then :String
+                     when :float then :Float
+                     when :bool then :Bool
+                     when :boolish then :Bool
+                     end
+        return nil unless class_name
+        RBS::Types::ClassInstance.new(
+          name: RBS::TypeName.new(name: class_name, namespace: RBS::Namespace.root),
+          args: [],
+          location: alias_type.location
+        )
+      end
+
       def numeric_compatible?(arg_name, param_name)
         numerics = %i[Integer Float Rational Complex Numeric]
         numerics.include?(arg_name) && numerics.include?(param_name)

data/lib/konpeito/type_checker/unification.rb

@@ -186,6 +186,9 @@ module Konpeito
         elsif singleton_value_compatible?(t1, t2)
           # ClassSingleton (value constant like EXPANDING) is compatible with its base type.
           # e.g., singleton(EXPANDING) ↔ Integer when EXPANDING = 2
+        elsif literal_compatible?(t1, t2)
+          # Literals are subtypes of their base type (e.g., Literal(1) <: Integer, Literal("x") <: String)
+          # Unions of same-type literals are also compatible (e.g., -1 | 0 | 1 <: Integer)
         else
           raise UnificationError.new(t1, t2)
         end
@@ -207,6 +210,38 @@ module Konpeito
         (t2.is_a?(Types::ClassSingleton) && t1.is_a?(Types::ClassInstance))
       end
 
+      # Check if a literal type (or union of literals) is compatible with its base class type.
+      # e.g., Literal(1) <: Integer, Literal("hello") <: String, Literal(1.0) <: Float
+      #        Union(Literal(-1), Literal(0), Literal(1)) <: Integer
+      def literal_compatible?(t1, t2)
+        (literal_subtype_of_class?(t1, t2)) || (literal_subtype_of_class?(t2, t1))
+      end
+
+      def literal_subtype_of_class?(literal_side, class_side)
+        return false unless class_side.is_a?(Types::ClassInstance)
+
+        if literal_side.is_a?(Types::Literal)
+          literal_base_type_name(literal_side.value) == class_side.name
+        elsif literal_side.is_a?(Types::Union)
+          literal_side.types.all? do |sub|
+            sub.is_a?(Types::Literal) && literal_base_type_name(sub.value) == class_side.name
+          end
+        else
+          false
+        end
+      end
+
+      # Map a Ruby literal value to its base type name
+      def literal_base_type_name(value)
+        case value
+        when Integer then :Integer
+        when Float then :Float
+        when String then :String
+        when Symbol then :Symbol
+        when true, false then :Bool
+        end
+      end
+
       # Check if `from` can be widened to `to` (Java/Kotlin-style widening primitive conversion).
       # Integer → Float is safe (no precision loss for typical values).
       # Float → Integer is NOT supported (requires explicit conversion).