konpeito 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d4e25daf950c4a2c5c60e4a646f4c0f74a959e1557761feb3327245ec995bee
-  data.tar.gz: f0e5571b58a2316a729c15872be3e0bfa9cba03573f96f51b79e4b384e2af675
+  metadata.gz: 945682bc2b93e30dbea1e57f3d05b1613c780b8301d1b66fe6b763191727ca64
+  data.tar.gz: 38f644805520a6885c5d583f499fbec84eca513d48c9ca0a7350e469821a8587
 SHA512:
-  metadata.gz: 6c7fd35077041ff22737b3b72a101771f597ebe813a61fbc47b2c5bd29245afd4df77d60d1a0fef50005631fbed9932bb6d9599a9f5d50ed8f833a3691157a36
-  data.tar.gz: 539a02d11cebfc1ad35e0df912fa49043aa8f4cd310088ee5c2f419d6cd14c59a1ed5ec603fa7974fb947f95a6c42d390516f54849d727400707cb218a52484b
+  metadata.gz: 92ad6de982c1d40d9fd821899a32fdde41b5aa3d3bfc618f02feff51f9e8a26ff61b24173f54ef4a0781035ec75898cdb9e2dafec584d06d5f94e8b60f166e1f
+  data.tar.gz: 477c494b53513b16f99de04a91410cdea9d8a30c64b5e14d8f436cae1d14fc48323948c9d42bf4791bdfa3e77e7cffca6e856fe25c9d5a39f60b523134a3f27c

data/CHANGELOG.md

@@ -5,6 +5,26 @@ 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.10.0] - 2026-03-18
+
+### Added
+- **mruby 4 RC2 support**: Version detection (`mruby_version`, `mruby_major_version`
+  in Platform), C-level compatibility guards (`KONPEITO_MRUBY4` macro,
+  `_Static_assert(sizeof(mrb_value)==8)`, `MRB_NO_BOXING` error), runtime version
+  check in MRubyBackend, mruby version display in `konpeito doctor`, and CI matrix
+  for mruby 3.x / 4.x
+- **User-defined generics**: RBS `class Stack[T]` type parameters extracted and
+  propagated through HIR ClassDef, HM inferrer (fresh TypeVars on `.new`), and
+  monomorphizer (class-level specialization generating `Stack_Integer` etc.)
+- **Cosmos demoscene demo** (`examples/mruby_cosmos/`): Procedural graphics showcase
+  with sine lookup table, starfield, orbital particles, glowing nebula, rotating
+  wireframes, pulse rings, aurora wave, and CRT scanlines
+
+### Changed
+- mruby version requirement updated from "3.x" to "3.x or 4.x" in docs
+- Monomorphizer `RBS_TYPE_PARAMS` check replaced with dynamic `unresolved_type_param?`
+  that includes user-defined class type parameters
+
 ## [0.9.1] - 2026-03-16
 
 ### Fixed
@@ -411,6 +431,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.10.0]: https://github.com/i2y/konpeito/compare/v0.9.1...v0.10.0
 [0.9.1]: https://github.com/i2y/konpeito/compare/v0.9.0...v0.9.1
 [0.9.0]: https://github.com/i2y/konpeito/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/i2y/konpeito/compare/v0.7.1...v0.8.0

data/lib/konpeito/cli/doctor_command.rb

@@ -189,6 +189,15 @@ module Konpeito
           hint: "Install: #{Platform.mruby_install_hint}"
         }
 
+        # mruby version
+        mruby_ver = Platform.mruby_version
+        checks << {
+          name: "mruby version",
+          detail: mruby_ver || "unknown",
+          status: mruby_ver ? :ok : :warning,
+          hint: "Supported: mruby 3.x or 4.x"
+        }
+
         # mruby headers
         cflags = Platform.mruby_cflags
         inc_dir = cflags.split.find { |f| f.start_with?("-I") }&.sub(/^-I/, "")

data/lib/konpeito/codegen/monomorphizer.rb

@@ -14,7 +14,7 @@ module Konpeito
     #   identity("hello")  # generates identity_String
     #
     class Monomorphizer
-      attr_reader :specializations, :call_sites, :union_dispatches
+      attr_reader :specializations, :call_sites, :union_dispatches, :class_specializations
 
       def initialize(hir_program, type_info)
         @hir_program = hir_program
@@ -24,6 +24,7 @@ module Konpeito
         @union_call_sites = []  # Calls requiring runtime dispatch
         @union_dispatches = {}  # { [func_name, original_types] => dispatch_info }
         @generated_functions = {}
+        @class_specializations = {}  # { [class_name, type_args_strs] => specialized_class_name }
       end
 
       # Analyze the HIR program to find monomorphization opportunities
@@ -34,6 +35,9 @@ module Konpeito
 
         # Determine which specializations to generate
         determine_specializations
+
+        # Collect and generate class-level specializations for generic classes
+        analyze_class_specializations
       end
 
       # Apply monomorphization transformations
@@ -41,6 +45,9 @@ module Konpeito
         # Generate specialized function copies
         generate_specialized_functions
 
+        # Generate specialized class definitions
+        generate_specialized_classes
+
         # Rewrite call sites to use specialized functions
         rewrite_call_sites
       end
@@ -197,7 +204,7 @@ module Konpeito
           next if types.any? { |t| t == TypeChecker::Types::UNTYPED || t.is_a?(TypeChecker::Types::Untyped) }
           next if skip_functions.include?(func_name.to_s)
           # Skip if any type is an unresolved RBS type parameter (Elem, K, V, etc.)
-          next if types.any? { |t| t.is_a?(TypeChecker::Types::ClassInstance) && RBS_TYPE_PARAMS.include?(t.name) }
+          next if types.any? { |t| t.is_a?(TypeChecker::Types::ClassInstance) && unresolved_type_param?(t.name) }
 
           type_suffix = types.map { |t| type_to_suffix(t) }.join("_")
           specialized = "#{func_name}_#{type_suffix}"
@@ -329,15 +336,27 @@ module Konpeito
       end
 
       # RBS type parameter names that should not be used as monomorphized suffixes
-      # These are unresolved generic type variables, not concrete Ruby classes
-      RBS_TYPE_PARAMS = Set.new(%w[Elem K V U T S R E A B C D N M].map(&:to_sym)).freeze
+      # These are unresolved generic type variables, not concrete Ruby classes.
+      # User-defined type params (from RBS class declarations) are also checked dynamically.
+      BUILTIN_RBS_TYPE_PARAMS = Set.new(%w[Elem K V U T S R E A B C D N M].map(&:to_sym)).freeze
+
+      def unresolved_type_param?(type_name)
+        return true if BUILTIN_RBS_TYPE_PARAMS.include?(type_name)
+        # Check user-defined class type params
+        if @type_info.respond_to?(:class_type_params)
+          @type_info.class_type_params.each_value do |param_map|
+            return true if param_map.key?(type_name)
+          end
+        end
+        false
+      end
 
       def type_to_suffix(type)
         case type
         when TypeChecker::Types::ClassInstance
           # If the type name is an unresolved RBS type parameter (Elem, K, V, etc.),
           # treat it as untyped to avoid generating rb_const_get("Elem") at runtime
-          if RBS_TYPE_PARAMS.include?(type.name)
+          if unresolved_type_param?(type.name)
             "Any"
           else
             type.name.to_s
@@ -422,6 +441,96 @@ module Konpeito
         term
       end
 
+      # Analyze generic classes and collect concrete type instantiations from .new call sites
+      def analyze_class_specializations
+        generic_classes = @hir_program.classes.select { |c| c.type_params && !c.type_params.empty? }
+        return if generic_classes.empty?
+
+        generic_names = generic_classes.map(&:name).to_set
+
+        # Scan all functions for ClassName.new calls that produce typed ClassInstance
+        @hir_program.functions.each do |func|
+          func.body.each do |block|
+            block.instructions.each do |inst|
+              next unless inst.is_a?(HIR::Call) && inst.method_name.to_s == "new"
+              next unless inst.type.is_a?(TypeChecker::Types::ClassInstance)
+              next unless generic_names.include?(inst.type.name.to_s)
+
+              type_args = inst.type.type_args
+              next if type_args.empty?
+
+              # Resolve type args through unifier
+              resolved_args = type_args.map { |ta| @type_info.unifier.apply(ta) }
+              # Skip if any arg is still unresolved
+              next if resolved_args.any? { |ta| ta.is_a?(TypeChecker::TypeVar) || ta == TypeChecker::Types::UNTYPED }
+
+              class_name = inst.type.name.to_s
+              arg_strs = resolved_args.map(&:to_s)
+              key = [class_name, arg_strs]
+              next if @class_specializations.key?(key)
+
+              suffix = resolved_args.map { |t| type_to_suffix(t) }.join("_")
+              @class_specializations[key] = "#{class_name}_#{suffix}"
+            end
+          end
+        end
+      end
+
+      # Generate specialized ClassDef and methods for each class instantiation
+      def generate_specialized_classes
+        @class_specializations.each do |(class_name, type_arg_strs), specialized_name|
+          original_class = @hir_program.classes.find { |c| c.name == class_name }
+          next unless original_class
+
+          # Build substitution: type_param_name → concrete type string
+          substitution = {}
+          original_class.type_params.each_with_index do |tp, i|
+            substitution[tp.to_s] = type_arg_strs[i]
+          end
+
+          # Create specialized ClassDef with concrete ivar types
+          specialized_class = HIR::ClassDef.new(
+            name: specialized_name,
+            superclass: original_class.superclass,
+            method_names: original_class.method_names.dup,
+            instance_vars: original_class.instance_vars.dup,
+            included_modules: original_class.included_modules.dup
+          )
+          specialized_class.type_params = []  # Concrete — no type params
+
+          # Substitute ivar types
+          original_class.instance_var_types.each do |ivar_name, field_tag|
+            specialized_class.instance_var_types[ivar_name] =
+              if substitution.key?(field_tag.to_s)
+                substitution[field_tag.to_s].to_sym
+              else
+                field_tag
+              end
+          end
+
+          @hir_program.classes << specialized_class
+
+          # Copy and rename methods
+          original_class.method_names.each do |method_name|
+            original_func = @hir_program.functions.find do |f|
+              f.owner_class == class_name && f.name.to_s == method_name
+            end
+            next unless original_func
+
+            specialized_body = deep_clone_blocks(original_func.body)
+            specialized_func = HIR::Function.new(
+              name: method_name,
+              params: original_func.params.dup,
+              body: specialized_body,
+              return_type: original_func.return_type,
+              is_instance_method: original_func.is_instance_method,
+              owner_class: specialized_name
+            )
+            @hir_program.functions << specialized_func
+          end
+        end
+      end
+
       def rewrite_call_sites
         # Track which calls have already been processed (for Union calls that appear multiple times)
         processed_calls = Set.new

data/lib/konpeito/codegen/mruby_backend.rb

@@ -31,7 +31,21 @@ module Konpeito
         !!@cross_target
       end
 
+      # Check mruby version compatibility. Raises for unsupported versions, warns for future versions.
+      def check_mruby_compatibility
+        major = Platform.mruby_major_version
+        return unless major # unknown version — skip check
+
+        if major < 3
+          raise "mruby #{Platform.mruby_version} is not supported. Konpeito requires mruby 3.x or 4.x."
+        elsif major > 4
+          warn "Warning: mruby #{Platform.mruby_version} is newer than tested. Konpeito is tested with mruby 3.x and 4.x."
+        end
+      end
+
       def generate
+        check_mruby_compatibility unless cross_compiling?
+
         ir_file = "#{output_base}.ll"
         obj_file = "#{output_base}.o"
         init_c_file = "#{output_base}_mruby_init.c"

data/lib/konpeito/codegen/mruby_helpers.c

@@ -14,6 +14,7 @@
 
 #include <mruby.h>
 #include <mruby/value.h>
+#include <mruby/version.h>
 #include <mruby/class.h>
 #include <mruby/data.h>
 #include <mruby/string.h>
@@ -29,6 +30,26 @@
 #include <stdarg.h>
 #include <stdint.h>
 
+/* ================================================================
+ * mruby version compatibility
+ * ================================================================ */
+
+/* Detect mruby 4.x */
+#if defined(MRUBY_RELEASE_MAJOR) && MRUBY_RELEASE_MAJOR >= 4
+  #define KONPEITO_MRUBY4 1
+#else
+  #define KONPEITO_MRUBY4 0
+#endif
+
+/* Reject boxing modes where mrb_value is not 64-bit.
+ * Konpeito LLVM IR treats mrb_value as i64 — this must hold. */
+#ifdef MRB_NO_BOXING
+  #error "Konpeito requires mrb_value to be 64-bit (NaN-boxing or word-boxing). MRB_NO_BOXING is not supported."
+#endif
+
+_Static_assert(sizeof(mrb_value) == sizeof(uint64_t),
+               "Konpeito requires sizeof(mrb_value) == 8 (64-bit)");
+
 /* ================================================================
  * Global mrb_state pointer (set by main() in generated init code)
  * All CRuby-compatible wrappers below use this to access mruby.
@@ -40,6 +61,15 @@ mrb_state *konpeito_get_mrb_state(void) {
     return konpeito_mrb_state;
 }
 
+/* Return the mruby version description string */
+const char *konpeito_mruby_version(void) {
+#ifdef MRUBY_DESCRIPTION
+    return MRUBY_DESCRIPTION;
+#else
+    return "mruby (unknown version)";
+#endif
+}
+
 /* ================================================================
  * Block stack for rb_yield / rb_block_given_p / rb_block_proc
  *

data/lib/konpeito/hir/builder.rb

@@ -450,6 +450,11 @@ module Konpeito
           )
           # Mark as reopened if it's a known Ruby core class
           class_def.reopened = true if RUBY_CORE_CLASSES.include?(name)
+          # Propagate type_params from RBS (e.g., class Stack[T])
+          if @rbs_loader&.respond_to?(:user_class_type_params)
+            tp = @rbs_loader.user_class_type_params[name]
+            class_def.type_params = tp if tp
+          end
         end
 
         # Visit body within class context

data/lib/konpeito/hir/nodes.rb

@@ -65,6 +65,7 @@ module Konpeito
       attr_accessor :instance_var_types # HM-inferred ivar types: { "name" => :Integer, "age" => :String, ... }
       attr_accessor :body_constants     # Array of [name, value_node] for constants defined in class body
       attr_accessor :body_class_vars    # Array of [name, value_node] for class variables initialized in class body
+      attr_accessor :type_params        # Array of type parameter names (e.g., [:T] for class Stack[T])
 
       def initialize(name:, superclass: nil, method_names: [], instance_vars: [], included_modules: [], extended_modules: [], prepended_modules: [])
         super(type: TypeChecker::Types::NIL)
@@ -83,6 +84,7 @@ module Konpeito
         @instance_var_types = {}
         @body_constants = []
         @body_class_vars = []
+        @type_params = []
       end
     end
 

data/lib/konpeito/platform.rb

@@ -145,6 +145,47 @@ module Konpeito
       File.exist?(File.join(inc_dir, "mruby.h"))
     end
 
+    # Get mruby version string (e.g., "3.4.0" or "4.0.0-rc2")
+    def self.mruby_version
+      # Try mruby-config --version first (mruby 4.x supports this)
+      config = find_mruby_config
+      if config
+        version = `#{config} --version 2>/dev/null`.strip
+        # Only accept if it looks like a version string (not help text)
+        return version if version.match?(/\A\d+\.\d+/)
+      end
+
+      # Fallback: parse mruby/version.h
+      version_h = find_mruby_version_header
+      if version_h
+        content = File.read(version_h)
+        major = content[/MRUBY_RELEASE_MAJOR\s+(\d+)/, 1]
+        minor = content[/MRUBY_RELEASE_MINOR\s+(\d+)/, 1]
+        patch = content[/MRUBY_RELEASE_TEENY\s+(\d+)/, 1]
+        return "#{major}.#{minor}.#{patch}" if major
+      end
+
+      nil
+    end
+
+    # Find mruby/version.h from include paths
+    def self.find_mruby_version_header
+      cflags = mruby_cflags
+      cflags.split.select { |f| f.start_with?("-I") }.each do |flag|
+        inc_dir = flag.sub(/^-I/, "")
+        path = File.join(inc_dir, "mruby", "version.h")
+        return path if File.exist?(path)
+      end
+      nil
+    end
+
+    # Get mruby major version number (e.g., 3 or 4)
+    def self.mruby_major_version
+      version = mruby_version
+      return nil unless version
+      version.split(".").first.to_i
+    end
+
     # Find zig compiler (used for cross-compilation)
     def self.find_zig
       find_executable("zig")

data/lib/konpeito/type_checker/hm_inferrer.rb

@@ -9,7 +9,7 @@ module Konpeito
     # Uses Algorithm W with constraint generation and unification
     class HMInferrer
       attr_reader :errors, :unifier, :node_types, :diagnostics, :ivar_types, :inference_errors,
-                  :unresolved_type_warnings
+                  :unresolved_type_warnings, :class_type_params
 
       def initialize(rbs_loader = nil, file_path: nil, source: nil)
         @rbs_loader = rbs_loader
@@ -35,6 +35,7 @@ module Konpeito
         @keyword_param_vars = {}  # func_key => { :param_name => TypeVar }
         @unresolved_type_warnings = []  # Warnings for types that survived inference
         @polymorphic_methods = {}  # qualified_key => TypeScheme for instance methods
+        @class_type_params = {}  # class_name => { :T => TypeVar, ... } for generic classes
       end
 
       # Main entry: infer types for a program AST
@@ -903,6 +904,22 @@ module Konpeito
           if init_type
             unify_call_args(init_type, arg_types)
           end
+
+          # For generic classes (e.g., class Stack[T] in RBS), create fresh TypeVars
+          # so that Stack.new → Stack[T'] where T' is unified from usage
+          class_name_str = receiver_type.name.to_s
+          rbs_type_params = @rbs_loader&.respond_to?(:user_class_type_params) &&
+                            @rbs_loader.user_class_type_params[class_name_str]
+          if rbs_type_params && !rbs_type_params.empty?
+            fresh_vars = rbs_type_params.map { TypeVar.new }
+            # Store mapping so instance method resolution can build substitution
+            @class_type_params[class_name_str] ||= {}
+            rbs_type_params.each_with_index do |tp_name, i|
+              @class_type_params[class_name_str][tp_name] = fresh_vars[i]
+            end
+            return Types::ClassInstance.new(receiver_type.name, fresh_vars)
+          end
+
           return Types::ClassInstance.new(receiver_type.name)
         end
 

data/lib/konpeito/type_checker/rbs_loader.rb

@@ -9,7 +9,7 @@ module Konpeito
     # Loads and manages RBS type definitions
     class RBSLoader
       attr_reader :environment, :native_classes, :native_modules, :boxed_classes, :cfunc_methods, :ffi_libraries,
-                  :extern_classes, :simd_classes, :jvm_classes
+                  :extern_classes, :simd_classes, :jvm_classes, :user_class_type_params
 
       def initialize
         @environment = nil
@@ -22,6 +22,7 @@ module Konpeito
         @extern_classes = {}  # class_name -> ExternClassType (external C struct wrappers)
         @simd_classes = {}    # class_name -> SIMDClassType (SIMD vector classes)
         @jvm_classes = {}     # "Java::Util::ArrayList" -> { jvm_internal_name:, methods:, static_methods: }
+        @user_class_type_params = {}  # "Stack" => [:T], "Pair" => [:A, :B]
         @rbs_file_contents = {}  # path -> content
         @temp_dirs = []  # Temp directories for single RBS files
         @definition_builder = nil  # Cached DefinitionBuilder
@@ -574,6 +575,11 @@ module Konpeito
           return
         end
 
+        # Extract type parameters (e.g., class Stack[T] → [:T])
+        if decl.type_params && !decl.type_params.empty?
+          @user_class_type_params[class_name.to_s] = decl.type_params.map { |tp| tp.name.to_sym }
+        end
+
         annotations = AnnotationParser.parse_all(decl.annotations)
 
         # Skip built-in types

data/lib/konpeito/version.rb

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

metadata

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