crystalruby 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 542a695dee21acb928d1c758ce8a48f31422b8b71940b6ea61d87c2744b3fc5c
-  data.tar.gz: 988da32111ca2a2a13f1b8da93c850a76ea6dda4191f55feabd768b35444e316
+  metadata.gz: cccd1a9a08608d1973ec2cca190828d8475652337dbe6ec16b9d7cac1646cdab
+  data.tar.gz: 441bf39c0a3627d6df202c54c3440bb69e47c91473c1974b3caa330e0defa7a9
 SHA512:
-  metadata.gz: c5109478ed499c9737dc008cae0f720ae03d30a31bffb9add0034303ba7d39b943b437074fb033b52f307cb09f838d64a1a037b36f80bf985e4141614b8ec983
-  data.tar.gz: 4e1f0831bf0eb15a889ad7ca0bd797ae02377968f41b365593102663ff828b0791cd500871e6ba3145b4613a2ed797690ca0b4866e57ee18d9032ddee546aa96
+  metadata.gz: fafb4fecf18aa7e5221642fbb956457987b286d50600f0ced48a91eaf10a4e2ccc83546d2632058b765256fc3510ce17cc5a6aa37455583279fb101a0c56fe70
+  data.tar.gz: 77fdc7ebdd02dab88243aec94eb6e06fc0bf2b65685b2eeb0b0304ad3087903879759823045c4ee07c9453715800237c1a230a1fdc7fb0e8eb2bc3636fb90e18

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [0.3.4] - 2025-05-04
+
+- Added support for Crystal 1.16.0
+
 ## [Unreleased]
 
 - Added support for running `crustalruby` without the `crystal` binary in dry mode. [#15]

data/lib/crystalruby/adapter.rb

@@ -36,7 +36,7 @@ module CrystalRuby
     # @option options [Boolean] :async (false) Mark the method as async (allows multiplexing).
     # @option options [String] :lib ("crystalruby") The name of the library to compile the Crystal code into.
     # @option options [Proc] :block An optional wrapper Ruby block that wraps around any invocations of the crystal code
-    def crystallize( returns=:void, raw: false, async: false, lib: "crystalruby", &block)
+    def crystallize(returns = :void, raw: false, async: false, lib: "crystalruby", &block)
       (self == TOPLEVEL_BINDING.receiver ? Object : self).instance_eval do
         @crystallize_next = {
           raw: raw,
@@ -49,7 +49,7 @@ module CrystalRuby
     end
 
     # Alias for `crystallize`
-    alias :crystalize :crystallize
+    alias crystalize crystallize
 
     # Exposes a Ruby method to one or more Crystal libraries.
     # Type annotations follow the same rules as the `crystallize` method, but are
@@ -58,7 +58,7 @@ module CrystalRuby
     # @param [Hash] options The options hash.
     # @option options [Boolean] :raw (false) Pass raw Crystal code to the compiler as a string.
     # @option options [String] :libs (["crystalruby"]) The name of the Crystal librarie(s) to expose the Ruby code to.
-    def expose_to_crystal( returns=:void, libs: ["crystalruby"])
+    def expose_to_crystal(returns = :void, libs: ["crystalruby"])
       (self == TOPLEVEL_BINDING.receiver ? Object : self).instance_eval do
         @expose_next_to_crystal = {
           returns: returns,
@@ -70,7 +70,7 @@ module CrystalRuby
     # Define a shard dependency
     # This dependency will be automatically injected into the shard.yml file for
     # the given library and installed upon compile if it is not already installed.
-    def shard(shard_name, lib: 'crystalruby', **opts)
+    def shard(shard_name, lib: "crystalruby", **opts)
       CrystalRuby::Library[lib].require_shard(shard_name, **opts)
     end
 
@@ -78,14 +78,18 @@ module CrystalRuby
     # This is useful for defining classes, modules, performing set-up tasks etc.
     # See: docs for .crystallize to understand the `raw` and `lib` parameters.
     def crystal(raw: false, lib: "crystalruby", &block)
-      inline_crystal_body = respond_to?(:name) ? Template::InlineChunk.render(
-        {
-          module_name: name,
-          body: SourceReader.extract_source_from_proc(block, raw: raw),
-          mod_or_class: self.kind_of?(Class) && self < Types::Type ? "class" : "module",
-          superclass: self.kind_of?(Class) && self < Types::Type ? "< #{self.crystal_supertype}" : ""
-        }) :
-        SourceReader.extract_source_from_proc(block, raw: raw)
+      inline_crystal_body = if respond_to?(:name)
+                              Template::InlineChunk.render(
+                                {
+                                  module_name: name,
+                                  body: SourceReader.extract_source_from_proc(block, raw: raw),
+                                  mod_or_class: is_a?(Class) && self < Types::Type ? "class" : "module",
+                                  superclass: is_a?(Class) && self < Types::Type ? "< #{crystal_supertype}" : ""
+                                }
+                              )
+                            else
+                              SourceReader.extract_source_from_proc(block, raw: raw)
+                            end
 
       CrystalRuby::Library[lib].crystallize_chunk(
         self,
@@ -94,7 +98,6 @@ module CrystalRuby
       )
     end
 
-
     # This method provides a useful DSL for defining Crystal types in pure Ruby
     # MyType = CRType{ Int32 | Hash(String, Array(Bool) | Float65 | Nil) }
     # @param [Proc] block The block within which we build the type definition.
@@ -152,14 +155,16 @@ module CrystalRuby
 
       owner = method.owner.singleton_class? ? method.owner.attached_object : method.owner
       owner.class_eval(src)
-      owner.instance_eval(src) unless method.kind_of?(UnboundMethod) && method.owner.ancestors.include?(CrystalRuby::Types::Type)
-      method = owner.send(method.kind_of?(UnboundMethod) ? :instance_method : :method, method.name)
+      unless method.is_a?(UnboundMethod) && method.owner.ancestors.include?(CrystalRuby::Types::Type)
+        owner.instance_eval(src)
+      end
+      method = owner.send(method.is_a?(UnboundMethod) ? :instance_method : :method, method.name)
 
       libs.each do |lib|
         CrystalRuby::Library[lib].expose_method(
           method,
           args,
-          returns,
+          returns
         )
       end
     end

data/lib/crystalruby/function.rb

@@ -66,6 +66,7 @@ module CrystalRuby
           raise ArgumentError, "no block given but function expects block" if !blk && func.takes_block?
 
           args << blk if blk
+
           func.map_args!(args)
           args.unshift(memory) if func.instance_method
 
@@ -86,27 +87,35 @@ module CrystalRuby
     def register_callback!
       return unless ruby
 
-      @callback_func = FFI::Function.new(ffi_ret_type, ffi_types) do |*args|
+      ret_type = ffi_ret_type == :string ? :pointer : ffi_ret_type
+      @callback_func = FFI::Function.new(ret_type, ffi_types) do |*args|
         receiver = instance_method ? owner.new(args.shift) : owner
-        ret_val = if takes_block?
-                    block_arg = arg_type_map[:__yield_to][:crystalruby_type].new(args.pop)
-                    receiver.send(name, *unmap_args(args)) do |*args|
-                      args = args.map.with_index do |arg, i|
-                        arg = block_arg.inner_types[i].new(arg) unless arg.is_a?(block_arg.inner_types[i])
-                        arg.memory
-                      end
-                      return_val = block_arg.invoke(*args)
-                      unless return_val.is_a?(block_arg.inner_types[-1])
-                        return_val = block_arg.inner_types[-1].new(return_val)
-                      end
-                      block_arg.inner_types[-1].anonymous? ? return_val.value : return_val
-                    end
-                  else
-                    receiver.send(name, *unmap_args(args))
-                  end
+        ret_val = \
+          if takes_block?
+            block_arg = arg_type_map[:__yield_to][:crystalruby_type].new(args.pop)
+            receiver.send(name, *unmap_args(args)) do |*args|
+              args = args.map.with_index do |arg, i|
+                arg = block_arg.inner_types[i].new(arg) unless arg.is_a?(block_arg.inner_types[i])
+                arg.memory
+              end
+              return_val = block_arg.invoke(*args)
+              return_val = block_arg.inner_types[-1].new(return_val) unless return_val.is_a?(block_arg.inner_types[-1])
+              block_arg.inner_types[-1].anonymous? ? return_val.value : return_val
+            end
+          else
+            receiver.send(name, *unmap_args(args))
+          end
         unmap_retval(ret_val)
       end
-      Reactor.schedule_work!(lib, :"register_#{name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback", @callback_func, :void, blocking: true, async: false)
+
+      Reactor.schedule_work!(
+        lib,
+        :"register_#{name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback",
+        @callback_func,
+        :void,
+        blocking: true,
+        async: false
+      )
     end
 
     # Attaches the crystallized FFI functions to their related Ruby modules and classes.
@@ -245,7 +254,7 @@ module CrystalRuby
 
     def register_custom_types!(lib)
       custom_types.each do |crystalruby_type|
-        next unless crystalruby_type.is_a?(Class) && crystalruby_type < Types::Type
+        next unless Types::Type.subclass?(crystalruby_type)
 
         [*crystalruby_type.nested_types].uniq.each do |type|
           lib.register_type!(type)
@@ -263,7 +272,7 @@ module CrystalRuby
 
         mapped = argmap[args[index]]
         case mapped
-        when CrystalRuby::Types::Type then
+        when CrystalRuby::Types::Type
           args[index] = mapped.memory
           (refs ||= []) << mapped
         else
@@ -291,10 +300,12 @@ module CrystalRuby
     end
 
     def unmap_retval(retval)
+      return FFI::MemoryPointer.from_string(retval) if return_type_map[:ffi_ret_type] == :string
       return retval unless return_type_map[:arg_mapper]
 
       retval = return_type_map[:arg_mapper][retval]
-      retval = retval.memory if retval.kind_of?(CrystalRuby::Types::Type)
+
+      retval = retval.memory if retval.is_a?(CrystalRuby::Types::Type)
       retval
     end
 

data/lib/crystalruby/library.rb

@@ -214,9 +214,7 @@ module CrystalRuby
         unless compiled?
           FileUtils.rm_f(lib_file)
 
-          if shard_dependencies.any? && shards.empty?
-            rewrite_shards_file!
-          end
+          rewrite_shards_file! if shard_dependencies.any? && shards.empty?
 
           CrystalRuby::Compilation.install_shards!(src_dir)
           CrystalRuby::Compilation.compile!(
@@ -239,14 +237,16 @@ module CrystalRuby
         singleton_class.class_eval do
           extend FFI::Library
           ffi_lib lib_file
-          %i[yield init].each do |method_name|
+          %i[yield init gc].each do |method_name|
             singleton_class.undef_method(method_name) if singleton_class.method_defined?(method_name)
             undef_method(method_name) if method_defined?(method_name)
           end
           attach_function :init, %i[string pointer pointer], :void
           attach_function :yield, %i[], :int
+          attach_function :gc, %i[], :void
           lib_methods.each_value.select(&:ruby).each do |method|
-            attach_function :"register_#{method.name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback", %i[pointer], :void
+            attach_function :"register_#{method.name.to_s.gsub("?", "q").gsub("=", "eq").gsub("!", "bang")}_callback",
+                            %i[pointer], :void
           end
         end
 

data/lib/crystalruby/reactor.rb

@@ -1,5 +1,6 @@
+require "json"
+
 module CrystalRuby
-  require 'json'
   # The Reactor represents a singleton Thread responsible for running all Ruby/crystal interop code.
   # Crystal's Fiber scheduler and GC assume all code is run on a single thread.
   # This class is responsible for multiplexing Ruby and Crystal code onto a single thread.
@@ -9,12 +10,21 @@ module CrystalRuby
     module_function
 
     class SingleThreadViolation < StandardError; end
+
     class StopReactor < StandardError; end
 
+    @op_count = 0
     @single_thread_mode = false
 
     REACTOR_QUEUE = Queue.new
 
+    # Invoke GC every 100 ops
+    GC_OP_THRESHOLD = ENV.fetch("CRYSTAL_GC_OP_THRESHOLD", 100).to_i
+    # Or every 0.05 seconds
+    GC_INTERVAL = ENV.fetch("CRYSTAL_GC_INTERVAL", 0.05).to_f
+    # Or if we've gotten hold of a reference to at least 100KB or more of fresh memory since last GC
+    GC_BYTES_SEEN_THRESHOLD = ENV.fetch("CRYSTAL_GC_BYTES_SEEN_THRESHOLD", 100 * 1024).to_i
+
     # We maintain a map of threads, each with a mutex, condition variable, and result
     THREAD_MAP = Hash.new do |h, tid_or_thread, tid = tid_or_thread|
       if tid_or_thread.is_a?(Thread)
@@ -36,7 +46,7 @@ module CrystalRuby
 
     # We memoize callbacks, once per return type
     CALLBACKS_MAP = Hash.new do |h, rt|
-      h[rt] = FFI::Function.new(:void, [:int, *(rt == :void ? [] : [rt])]) do |tid, ret|
+      h[rt] = FFI::Function.new(:void, [:int, *((rt == :void) ? [] : [rt])]) do |tid, ret|
         THREAD_MAP[tid][:error] = nil
         THREAD_MAP[tid][:result] = ret
         THREAD_MAP[tid][:cond].signal
@@ -49,7 +59,7 @@ module CrystalRuby
       error_type = is_exception_type ? Object.const_get(error_type) : RuntimeError
       error = error_type.new(message)
       error.set_backtrace(JSON.parse(backtrace))
-      raise error  unless THREAD_MAP.key?(tid)
+      raise error unless THREAD_MAP.key?(tid)
 
       THREAD_MAP[tid][:error] = error
       THREAD_MAP[tid][:result] = nil
@@ -62,10 +72,12 @@ module CrystalRuby
 
     def await_result!
       mux, cond, result, err = thread_conditions.values_at(:mux, :cond, :result, :error)
-      cond.wait(mux) unless (result || err)
+      cond.wait(mux) unless result || err
       result, err, thread_conditions[:result], thread_conditions[:error] = thread_conditions.values_at(:result, :error)
       if err
-        combined_backtrace = err.backtrace[0..(err.backtrace.index{|m| m.include?('call_blocking_function')} || 2) - 3] + caller[5..-1]
+        combined_backtrace = err.backtrace[0..(err.backtrace.index { |m|
+                                                 m.include?("call_blocking_function")
+                                               } || 2) - 3] + caller[5..-1]
         err.set_backtrace(combined_backtrace)
         raise err
       end
@@ -78,30 +90,74 @@ module CrystalRuby
     end
 
     def stop!
-      if @main_loop
-        schedule_work!(self, :halt_loop!, :void, blocking: true, async: false)
-        @main_loop.join
-        @main_loop = nil
-        CrystalRuby.log_info "Reactor loop stopped"
-      end
+      return unless @main_loop
+
+      schedule_work!(self, :halt_loop!, :void, blocking: true, async: false)
+      @main_loop.join
+      @main_loop = nil
+      CrystalRuby.log_info "Reactor loop stopped"
     end
 
     def start!
+      @op_count = 0
       @main_loop ||= Thread.new do
         @main_thread_id = Thread.current.object_id
         CrystalRuby.log_debug("Starting reactor")
         CrystalRuby.log_debug("CrystalRuby initialized")
         while true
-          handler, *args = REACTOR_QUEUE.pop
-          send(handler, *args)
+          handler, *args, lib = REACTOR_QUEUE.pop
+          send(handler, *args, lib)
+          @op_count += 1
+          invoke_gc_if_due!(lib)
         end
-      rescue StopReactor => e
-      rescue StandardError => e
+      rescue StopReactor
+      rescue => e
         CrystalRuby.log_error "Error: #{e}"
         CrystalRuby.log_error e.backtrace
       end
     end
 
+    def invoke_gc_if_due!(lib)
+      schedule_work!(lib, :gc, :void, blocking: true, async: false, lib: lib) if lib && gc_due?
+    end
+
+    def gc_due?
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # Initialize state variables if not already set.
+      @last_gc_time ||= now
+      @op_count ||= 0
+      @last_gc_op_count ||= @op_count
+      @last_mem_check_time ||= now
+
+      # Calculate differences based on ops and time.
+      ops_since_last_gc = @op_count - @last_gc_op_count
+      time_since_last_gc = now - @last_gc_time
+
+      # Start with our two “cheap” conditions.
+      due = (ops_since_last_gc >= GC_OP_THRESHOLD) || (time_since_last_gc >= GC_INTERVAL) || Types::Allocator.gc_bytes_seen > GC_BYTES_SEEN_THRESHOLD
+
+      if due
+        # Update the baseline values after GC is scheduled.
+        @last_gc_time = now
+        # If we just did a memory check, use that value; otherwise, fetch one now.
+        @last_gc_op_count = @op_count
+        Types::Allocator.gc_hint_reset!
+        true
+      else
+        false
+      end
+    end
+
+    def start_gc_thread!(lib)
+      Thread.new do
+        loop do
+          schedule_work!(lib, :gc, :void, blocking: true, async: false, lib: lib) if gc_due?
+          sleep GC_INTERVAL
+        end
+      end
+    end
+
     def thread_id
       Thread.current.object_id
     end
@@ -116,14 +172,14 @@ module CrystalRuby
       yield!(lib: lib, time: 0)
     end
 
-    def invoke_blocking!(receiver, op_name, *args, tvars)
+    def invoke_blocking!(receiver, op_name, *args, tvars, _lib)
       tvars[:error] = nil
       begin
         tvars[:result] = receiver.send(op_name, *args)
-      rescue StopReactor => e
+      rescue StopReactor
         tvars[:cond].signal
         raise
-      rescue StandardError => e
+      rescue => e
         tvars[:error] = e
       end
       tvars[:cond].signal
@@ -138,9 +194,10 @@ module CrystalRuby
       if @single_thread_mode || (Thread.current.object_id == @main_thread_id && op_name != :yield)
         unless Thread.current.object_id == @main_thread_id
           raise SingleThreadViolation,
-                "Single thread mode is enabled, cannot run in multi-threaded mode. " \
-                "Reactor was started from: #{@main_thread_id}, then called from #{Thread.current.object_id}"
+            "Single thread mode is enabled, cannot run in multi-threaded mode. " \
+            "Reactor was started from: #{@main_thread_id}, then called from #{Thread.current.object_id}"
         end
+        invoke_gc_if_due!(lib)
         return receiver.send(op_name, *args)
       end
 
@@ -149,7 +206,7 @@ module CrystalRuby
         REACTOR_QUEUE.push(
           case true
           when async then [:invoke_async!, receiver, op_name, *args, tvars[:thread_id], CALLBACKS_MAP[return_type], lib]
-          when blocking then [:invoke_blocking!, receiver, op_name, *args, tvars]
+          when blocking then [:invoke_blocking!, receiver, op_name, *args, tvars, lib]
           else [:invoke_await!, receiver, op_name, *args, lib]
           end
         )

data/lib/crystalruby/source_reader.rb

@@ -4,12 +4,12 @@ module CrystalRuby
 
     # Reads code line by line from a given source location and returns the first valid Ruby expression found
     def extract_expr_from_source_location(source_location)
-      lines = source_location.then{|f,l| IO.readlines(f)[l-1..]}
+      lines = source_location.then { |f, l| IO.readlines(f)[l - 1..] }
       lines[0] = lines[0][/CRType.*/] if lines[0] =~ /<\s+CRType/ || lines[0] =~ /= CRType/
       lines.each.with_object([]) do |line, expr_source|
-        break expr_source.join("") if (Prism.parse((expr_source << line).join("")).success?)
+        break expr_source.join("") if Prism.parse((expr_source << line).join("")).success?
       end
-    rescue
+    rescue StandardError
       raise "Failed to extract expression from source location: #{source_location}. Ensure the file exists and the line number is correct. Extraction from a REPL is not supported"
     end
 
@@ -27,26 +27,25 @@ module CrystalRuby
       block_source = extract_expr_from_source_location(block.source_location)
       parsed_source = Prism.parse(block_source).value
 
-      node = parsed_source.statements.body[0].arguments&.arguments&.find{|x| search_node(x, Prism::StatementsNode) }
+      node = parsed_source.statements.body[0].arguments&.arguments&.find { |x| search_node(x, Prism::StatementsNode) }
       node ||= parsed_source.statements.body[0]
-      body_node =  search_node(node, Prism::StatementsNode)
+      body_node = search_node(node, Prism::StatementsNode)
 
-      return raw ?
-        extract_raw_string_node(body_node) :
-        node_to_s(body_node)
+      raw ? extract_raw_string_node(body_node) : node_to_s(body_node)
     end
 
     def extract_raw_string_node(node)
-      search_node(node, Prism::InterpolatedStringNode)&.parts&.map(&:unescaped)&.join("") ||
-      search_node(node, Prism::StringNode).unescaped
+      search_node(node, Prism::InterpolatedStringNode)&.parts&.map do |p|
+        p.respond_to?(:unescaped) ? p.unescaped : p.slice
+      end&.join("") ||
+        search_node(node, Prism::StringNode).unescaped
     end
 
-
     # Simple helper function to turn a SyntaxTree node back into a Ruby string
     # The default formatter will turn a break/return of [1,2,3] into a brackless 1,2,3
     # Can't have that in Crystal as it turns it into a Tuple
     def node_to_s(node)
-      node&.slice || ''
+      node&.slice || ""
     end
 
     # Given a method, extracts the source code of the block passed to it
@@ -69,14 +68,14 @@ module CrystalRuby
     def extract_args_and_source_from_method(method, raw: false)
       method_source = extract_expr_from_source_location(method.source_location)
       parsed_source = Prism.parse(method_source).value
-      params =  search_node(parsed_source, Prism::ParametersNode)
-      args = params ? params.keywords.map{|kw| [kw.name, node_to_s(kw.value)] }.to_h : {}
-      body_node =  parsed_source.statements.body[0].body
+      params = search_node(parsed_source, Prism::ParametersNode)
+      args = params ? params.keywords.map { |kw| [kw.name, node_to_s(kw.value)] }.to_h : {}
+      body_node = parsed_source.statements.body[0].body
       if body_node.respond_to?(:rescue_clause) && body_node.rescue_clause
-        wrapped = %{begin\n#{body_node.statements.slice}\n#{body_node.rescue_clause.slice}\nend}
+        wrapped = %(begin\n#{body_node.statements.slice}\n#{body_node.rescue_clause.slice}\nend)
         body_node = Prism.parse(wrapped).value
       end
-      body = raw ?  extract_raw_string_node(body_node) : node_to_s(body_node)
+      body = raw ? extract_raw_string_node(body_node) : node_to_s(body_node)
 
       args.transform_values! do |type_exp|
         if CrystalRuby::Typemaps::CRYSTAL_TYPE_MAP.key?(type_exp[1..-1].to_sym)
@@ -85,8 +84,7 @@ module CrystalRuby
           TypeBuilder.build_from_source(type_exp, context: method.owner)
         end
       end.to_h
-      return args, body
+      [args, body]
     end
-
   end
 end

data/lib/crystalruby/templates/index.cr

@@ -25,9 +25,12 @@ module CrystalRuby
     return if self.initialized
     self.initialized = true
     argv_ptr = ARGV1.to_unsafe
+    {%% if compare_versions(Crystal::VERSION, "1.16.0") >= 0  %%}
+      Crystal.init_runtime
+    {%% end %%}
     Crystal.main_user_code(0, pointerof(argv_ptr))
     self.libname = String.new(libname)
-    LibGC.set_finalize_on_demand(1)
+    GC.init
   end
 
   # Explicit error handling (triggers exception within Ruby on the same thread)
@@ -57,7 +60,7 @@ module CrystalRuby
     self.callbacks.send(callback)
   end
 
-  def self.synchronize
+  def self.synchronize(&)
     LibC.pthread_mutex_lock(self.rc_mux)
     yield
     LibC.pthread_mutex_unlock(self.rc_mux)
@@ -100,6 +103,11 @@ module GC
   end
 end
 
+# Trigger GC
+fun gc : Void
+  GC.collect
+end
+
 # Yield to the Crystal scheduler from Ruby
 # If there's callbacks to process, we flush them
 # Otherwise, we yield to the Crystal scheduler and let Ruby know

data/lib/crystalruby/typemaps.rb

@@ -3,31 +3,30 @@
 module CrystalRuby
   module Typemaps
     CRYSTAL_TYPE_MAP = {
-      char: "Int8",             # In Crystal, :char is typically represented as Int8
-      uchar: "UInt8",           # Unsigned char
-      int8: "Int8",             # Same as :char
-      uint8: "UInt8",           # Same as :uchar
-      short: "Int16",           # Short integer
-      ushort: "UInt16",         # Unsigned short integer
-      int16: "Int16",           # Same as :short
-      uint16: "UInt16",         # Same as :ushort
-      int: "Int32",             # Integer, Crystal defaults to 32 bits
-      uint: "UInt32",           # Unsigned integer
-      int32: "Int32",           # 32-bit integer
-      uint32: "UInt32",         # 32-bit unsigned integer
-      long: "Int32 | Int64",    # Long integer, size depends on the platform (32 or 64 bits)
-      ulong: "UInt32 | UInt64", # Unsigned long integer, size depends on the platform
-      int64: "Int64",           # 64-bit integer
-      uint64: "UInt64",         # 64-bit unsigned integer
-      long_long: "Int64",       # Same as :int64
-      ulong_long: "UInt64",     # Same as :uint64
-      float: "Float32",         # Floating point number (single precision)
-      double: "Float64",        # Double precision floating point number
-      bool: "Bool",             # Boolean type
-      void: "Void",             # Void type
-      string: "String",         # String type
-      pointer: "Pointer(Void)"  # Pointer type
-
+      char: "::Int8",             # In Crystal, :char is typically represented as Int8
+      uchar: "::UInt8",           # Unsigned char
+      int8: "::Int8",             # Same as :char
+      uint8: "::UInt8",           # Same as :uchar
+      short: "::Int16",           # Short integer
+      ushort: "::UInt16",         # Unsigned short integer
+      int16: "::Int16",           # Same as :short
+      uint16: "::UInt16",         # Same as :ushort
+      int: "::Int32",             # Integer, Crystal defaults to 32 bits
+      uint: "::UInt32",           # Unsigned integer
+      int32: "::Int32",           # 32-bit integer
+      uint32: "::UInt32",         # 32-bit unsigned integer
+      long: "::Int32 | Int64",    # Long integer, size depends on the platform (32 or 64 bits)
+      ulong: "::UInt32 | UInt64", # Unsigned long integer, size depends on the platform
+      int64: "::Int64",           # 64-bit integer
+      uint64: "::UInt64",         # 64-bit unsigned integer
+      long_long: "::Int64",       # Same as :int64
+      ulong_long: "::UInt64",     # Same as :uint64
+      float: "::Float32",         # Floating point number (single precision)
+      double: "::Float64",        # Double precision floating point number
+      bool: "::Bool",             # Boolean type
+      void: "::Void",             # Void type
+      string: "::String",         # String type
+      pointer: "::Pointer(Void)"  # Pointer type
     }
 
     FFI_TYPE_MAP = CRYSTAL_TYPE_MAP.invert
@@ -61,13 +60,13 @@ module CrystalRuby
 
     C_TYPE_MAP = CRYSTAL_TYPE_MAP.merge(
       {
-        string: "Pointer(UInt8)"
+        string: "Pointer(::UInt8)"
       }
     )
 
     C_TYPE_CONVERSIONS = {
       string: {
-        from: "String.new(%s)",
+        from: "::String.new(%s.not_nil!)",
         to: "%s.to_unsafe"
       },
       void: {
@@ -86,6 +85,11 @@ module CrystalRuby
 
     def build_type_map(crystalruby_type)
       crystalruby_type = CRType(&crystalruby_type) if crystalruby_type.is_a?(Proc)
+
+      if Types::Type.subclass?(crystalruby_type) && crystalruby_type.ffi_primitive_type
+        crystalruby_type = crystalruby_type.ffi_primitive_type
+      end
+
       {
         ffi_type: ffi_type(crystalruby_type),
         ffi_ret_type: ffi_type(crystalruby_type),
@@ -93,19 +97,25 @@ module CrystalRuby
         crystalruby_type: crystalruby_type,
         lib_type: lib_type(crystalruby_type),
         error_value: error_value(crystalruby_type),
-        arg_mapper: if crystalruby_type.is_a?(Class) && crystalruby_type < Types::Type
+        arg_mapper: if Types::Type.subclass?(crystalruby_type)
                       lambda { |arg|
                         arg = crystalruby_type.new(arg.memory) if arg.is_a?(Types::Type) && !arg.is_a?(crystalruby_type)
                         arg = crystalruby_type.new(arg) unless arg.is_a?(Types::Type)
+
+                        Types::FixedWidth.increment_ref_count!(arg.memory) if arg.class < Types::FixedWidth
+
                         arg
                       }
                     end,
-        retval_mapper: if crystalruby_type.is_a?(Class) && crystalruby_type < Types::Type
+        retval_mapper: if Types::Type.subclass?(crystalruby_type)
                          lambda { |arg|
                            if arg.is_a?(Types::Type) && !arg.is_a?(crystalruby_type)
                              arg = crystalruby_type.new(arg.memory)
                            end
                            arg = crystalruby_type.new(arg) unless arg.is_a?(Types::Type)
+
+                           Types::FixedWidth.decrement_ref_count!(arg.memory) if arg.class < Types::FixedWidth
+
                            crystalruby_type.anonymous? ? arg.native : arg
                          }
                        # Strings in Crystal are UTF-8 encoded by default

data/lib/crystalruby/types/concerns/allocator.rb

@@ -2,9 +2,21 @@ module CrystalRuby
   module Types
     # Module for memory allocation and tracking functionality
     module Allocator
-
       # Called when module is included in a class
       # @param base [Class] The class including this module
+
+      def self.gc_hint!(size)
+        @bytes_seen_since_gc = (@bytes_seen_since_gc || 0) + size
+      end
+
+      def self.gc_bytes_seen
+        @bytes_seen_since_gc ||= 0
+      end
+
+      def self.gc_hint_reset!
+        @bytes_seen_since_gc = 0
+      end
+
       def self.included(base)
         base.class_eval do
           # Synchronizes a block using mutex
@@ -21,7 +33,7 @@ module CrystalRuby
 
           extend FFI::Library
           ffi_lib "c"
-          attach_function :_calloc, :calloc, [:size_t, :size_t], :pointer
+          attach_function :_calloc, :calloc, %i[size_t size_t], :pointer
           attach_function :_free, :free, [:pointer], :void
           define_singleton_method(:ptr, &FFI::Pointer.method(:new))
           define_method(:ptr, &FFI::Pointer.method(:new))

data/lib/crystalruby/types/fixed_width/proc.rb

@@ -4,7 +4,8 @@ module CrystalRuby::Types
     "and a single return type (or Nil if it does not return a value)")
 
   def self.Proc(*types)
-    proc_type = FixedWidth.build(:Proc, convert_if: [::Proc], inner_types: types, ffi_type: :pointer) do
+    proc_type = FixedWidth.build(:Proc, convert_if: [::Proc], inner_types: types,
+                                        ffi_type: :pointer) do
       @data_offset = 4
 
       def self.cast!(rbval)
@@ -57,12 +58,12 @@ module CrystalRuby::Types
                   result = nil
                   if Fiber.current == Thread.current.main_fiber
                     block_value = #{inner_types[-1].crystal_class_name}.new(__yield_to.call(#{inner_types.size.-(1).times.map { |i| "v#{i}" }.join(",")}))
-                    result = #{inner_types[-1].anonymous? ? "block_value.native" : "block_value"}
+                    result = #{inner_types[-1].anonymous? ? "block_value.native_decr" : "block_value"}
                     next #{inner_types.last == CrystalRuby::Types::Nil ? "result" : "result.not_nil!"}
                   else
                     CrystalRuby.queue_callback(->{
                       block_value = #{inner_types[-1].crystal_class_name}.new(__yield_to.call(#{inner_types.size.-(1).times.map { |i| "v#{i}" }.join(",")}))
-                      result = #{inner_types[-1].anonymous? ? "block_value.native" : "block_value"}
+                      result = #{inner_types[-1].anonymous? ? "block_value.native_decr" : "block_value"}
                       callback_done_channel.send(nil)
                     })
                   end

data/lib/crystalruby/types/fixed_width/tagged_union.rb

@@ -57,6 +57,11 @@ module CrystalRuby::Types
         union_types
       end
 
+      def total_memsize
+        type = self.class.union_types[data_pointer.read_uint8]
+        memsize + refsize + (type.primitive? ? type.memsize : value.total_memsize)
+      end
+
       define_singleton_method(:memsize) do
         union_types.map(&:refsize).max + 1
       end

data/lib/crystalruby/types/fixed_width.cr

@@ -35,6 +35,17 @@ module CrystalRuby
         8
       end
 
+      def self.new_decr(arg)
+        new_value = self.new(arg)
+        self.decrement_ref_count!(new_value.memory)
+        new_value
+      end
+
+      def native_decr
+        self.class.decrement_ref_count!(@memory)
+        native
+      end
+
 
       def self.free!(memory)
         # Decrease ref counts for any data we are pointing to
@@ -66,6 +77,13 @@ module CrystalRuby
         memory.as(Pointer(::UInt32))[0] = value
       end
 
+      # When we pass to Ruby, we increment the ref count
+      # for Ruby to decrement again once it receives.
+      def return_value
+        FixedWidth.increment_ref_count!(memory)
+        memory
+      end
+
       # Data pointer follows the ref count (and size for variable width types)
       # In the case of variable width types the data pointer points to the start of a separate data block
       # So this method is overridden inside variable_width.rb to resolve this pointer.

data/lib/crystalruby/types/fixed_width.rb

@@ -12,13 +12,14 @@ module CrystalRuby
         else allocate_new_from_value!(rbval)
         end
         self.class.increment_ref_count!(memory)
-        ObjectSpace.define_finalizer(self, self.class.finalize(memory))
+        ObjectSpace.define_finalizer(self, self.class.finalize(memory, self.class))
+        Allocator.gc_hint!(total_memsize)
       end
 
-      def self.finalize(memory)
-        lambda { |_|
+      def self.finalize(memory, type)
+        lambda do |_|
           decrement_ref_count!(memory)
-        }
+        end
       end
 
       def allocate_new_from_value!(rbval)
@@ -137,6 +138,10 @@ module CrystalRuby
         memory[size_offset].read_int32
       end
 
+      def total_memsize
+        memsize + refsize + size
+      end
+
       def address
         @memory.address
       end
@@ -180,6 +185,7 @@ module CrystalRuby
         superclass: FixedWidth,
         size_offset: 4,
         data_offset: 4,
+        ffi_primitive: false,
         &block
       )
         inner_types&.each(&Type.method(:validate!))
@@ -187,7 +193,7 @@ module CrystalRuby
         Class.new(superclass) do
           bind_local_vars!(
             %i[typename error inner_types inner_keys ffi_type memsize convert_if size_offset data_offset
-               refsize], binding
+               refsize ffi_primitive], binding
           )
           class_eval(&block) if block_given?
 

data/lib/crystalruby/types/primitive.rb

@@ -60,11 +60,12 @@ module CrystalRuby
         memsize: FFI.type_size(ffi_type),
         convert_if: [],
         error: nil,
+        ffi_primitive: false,
         superclass: Primitive,
         &block
       )
         Class.new(superclass) do
-          %w[typename ffi_type memsize convert_if error].each do |name|
+          %w[typename ffi_type memsize convert_if error ffi_primitive].each do |name|
             define_singleton_method(name) { binding.local_variable_get("#{name}") }
             define_method(name) { binding.local_variable_get("#{name}") }
           end

data/lib/crystalruby/types/primitive_types/numbers.rb

@@ -1,7 +1,7 @@
 module CrystalRuby::Types
   %i[UInt8 UInt16 UInt32 UInt64 Int8 Int16 Int32 Int64 Float32 Float64].each do |type_name|
-    ffi_type = CrystalRuby::Typemaps::FFI_TYPE_MAP.fetch(type_name.to_s)
-    const_set(type_name, Primitive.build(type_name, convert_if: [::Numeric], ffi_type: ffi_type) do
+    ffi_type = CrystalRuby::Typemaps::FFI_TYPE_MAP.fetch("::#{type_name}")
+    const_set(type_name, Primitive.build(type_name, convert_if: [::Numeric], ffi_type: ffi_type, ffi_primitive: ffi_type) do
       def value=(val)
         raise "Expected a numeric value, got #{val}" unless val.is_a?(::Numeric)
 

data/lib/crystalruby/types/primitive_types/symbol.rb

@@ -30,6 +30,10 @@ module CrystalRuby::Types
       define_singleton_method(:type_digest) do
         Digest::MD5.hexdigest(native_type_expr.to_s + allowed_values.map(&:to_s).join(","))
       end
+
+      def self.ffi_primitive_type
+        nil
+      end
     end
   end
 end

data/lib/crystalruby/types/type.cr

@@ -17,6 +17,14 @@ module CrystalRuby
       def to_s
         native.to_s
       end
+      
+      def self.new_decr(arg)
+        self.new(arg)
+      end
+
+      def native_decr
+        native
+      end
 
       def synchronize
         CrystalRuby.synchronize do

data/lib/crystalruby/types/type.rb

@@ -47,7 +47,7 @@ module CrystalRuby
                      :write_mixed_byte_slices_to_uint8_array, :data_offset, :size_offset,
                      :union_types
 
-      attr_accessor :value, :memory
+      attr_accessor :value, :memory, :ffi_primitive
 
       def initialize(_rbval)
         @class = self.class
@@ -133,7 +133,7 @@ module CrystalRuby
       end
 
       def self.pointer_to_crystal_type_conversion(expr)
-        anonymous? ? "#{crystal_class_name}.new(#{expr}).native" : "#{crystal_class_name}.new(#{expr})"
+        anonymous? ? "#{crystal_class_name}.new(#{expr}).native_decr" : "#{crystal_class_name}.new_decr(#{expr})"
       end
 
       def self.crystal_type_to_pointer_type_conversion(expr)
@@ -243,6 +243,17 @@ module CrystalRuby
         inner_types.map(&:memsize).sum
       end
 
+      def total_memsize
+        memsize
+      end
+
+      # For non-container ffi_primitive non-named types,
+      # just use the raw FFI type, as it's much more efficient
+      # due to skipping Arc overhead.
+      def self.ffi_primitive_type
+        respond_to?(:ffi_primitive) && anonymous? ? ffi_primitive : nil
+      end
+
       def self.crystal_type
         lib_type(ffi_type)
       end
@@ -265,6 +276,10 @@ module CrystalRuby
         inner_types.first
       end
 
+      def self.subclass?(type)
+        type.is_a?(Class) && type < Types::Type
+      end
+
       def self.type_expr
         if !inner_types
           inspect_name

data/lib/crystalruby/types/variable_width/string.rb

@@ -1,5 +1,5 @@
 module CrystalRuby::Types
-  String = VariableWidth.build(:String, convert_if: [String, Root::String]) do
+  String = VariableWidth.build(:String, ffi_primitive: :string, convert_if: [String, Root::String]) do
     def self.cast!(rbval)
       rbval.to_s
     end

data/lib/crystalruby/types/variable_width.rb

@@ -19,6 +19,7 @@ module CrystalRuby
         inner_types: nil,
         inner_keys: nil,
         ffi_type: :pointer,
+        ffi_primitive: false,
         size_offset: 4,
         data_offset: 8,
         memsize: FFI.type_size(ffi_type),
@@ -32,7 +33,7 @@ module CrystalRuby
         Class.new(superclass) do
           bind_local_vars!(
             %i[typename error inner_types inner_keys ffi_type memsize convert_if data_offset size_offset
-               refsize], binding
+               refsize ffi_primitive], binding
           )
           class_eval(&block) if block_given?
         end

data/lib/crystalruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CrystalRuby
-  VERSION = "0.3.2"
+  VERSION = "0.3.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-22 00:00:00.000000000 Z
+date: 2025-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest
@@ -42,30 +42,36 @@ dependencies:
   name: fileutils
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
 description: Embed Crystal code directly in Ruby.
 email:
 - wc@pico.net.nz
@@ -82,7 +88,6 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- crystalruby.gemspec
 - examples/adder/adder.rb
 - exe/crystalruby
 - lib/crystalruby.rb

data/crystalruby.gemspec

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/crystalruby/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "crystalruby"
-  spec.version = CrystalRuby::VERSION
-  spec.authors = ["Wouter Coppieters"]
-  spec.email = ["wc@pico.net.nz"]
-
-  spec.summary = "Embed Crystal code directly in Ruby."
-  spec.description = "Embed Crystal code directly in Ruby."
-  spec.homepage = "https://github.com/wouterken/crystalruby"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.7.2"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-  spec.add_dependency "digest"
-  spec.add_dependency "ffi"
-  spec.add_dependency "fileutils"
-  spec.add_dependency "prism"
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
-end