ffi 1.15.5 → 1.17.0

data/lib/ffi/platform.rb

@@ -29,13 +29,15 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.#
 
 require 'rbconfig'
+require_relative 'compat'
+
 module FFI
   class PlatformError < LoadError; end
 
   # This module defines different constants and class methods to play with
   # various platforms.
   module Platform
-    OS = case RbConfig::CONFIG['host_os'].downcase
+    OS = FFI.make_shareable(case RbConfig::CONFIG['host_os'].downcase
     when /linux/
       "linux"
     when /darwin/
@@ -54,13 +56,13 @@ module FFI
       "windows"
     else
       RbConfig::CONFIG['host_os'].downcase
-    end
+    end)
 
     OSVERSION = RbConfig::CONFIG['host_os'].gsub(/[^\d]/, '').to_i
 
-    CPU = RbConfig::CONFIG['host_cpu']
+    CPU = FFI.make_shareable(RbConfig::CONFIG['host_cpu'])
 
-    ARCH = case CPU.downcase
+    ARCH = FFI.make_shareable(case CPU.downcase
     when /amd64|x86_64|x64/
       "x86_64"
     when /i\d86|x86|i86pc/
@@ -81,7 +83,7 @@ module FFI
       end
     else
       RbConfig::CONFIG['host_cpu']
-    end
+    end)
 
     private
     # @param [String) os
@@ -105,21 +107,21 @@ module FFI
     # Add the version for known ABI breaks
     name_version = "12" if IS_FREEBSD && OSVERSION >= 12 # 64-bit inodes
 
-    NAME = "#{ARCH}-#{OS}#{name_version}"
-    CONF_DIR = File.join(File.dirname(__FILE__), 'platform', NAME)
+    NAME = FFI.make_shareable("#{ARCH}-#{OS}#{name_version}")
+    CONF_DIR = FFI.make_shareable(File.join(File.dirname(__FILE__), 'platform', NAME))
 
     public
 
-    LIBPREFIX = case OS
+    LIBPREFIX = FFI.make_shareable(case OS
     when /windows|msys/
       ''
     when /cygwin/
       'cyg'
     else
       'lib'
-    end
+    end)
 
-    LIBSUFFIX = case OS
+    LIBSUFFIX = FFI.make_shareable(case OS
     when /darwin/
       'dylib'
     when /linux|bsd|solaris/
@@ -129,9 +131,9 @@ module FFI
     else
       # Punt and just assume a sane unix (i.e. anything but AIX)
       'so'
-    end
+    end)
 
-    LIBC = if IS_WINDOWS
+    LIBC = FFI.make_shareable(if IS_WINDOWS
       crtname = RbConfig::CONFIG["RUBY_SO_NAME"][/msvc\w+/] || 'ucrtbase'
       "#{crtname}.dll"
     elsif IS_GNU
@@ -143,7 +145,7 @@ module FFI
       "msys-2.0.dll"
     else
       "#{LIBPREFIX}c.#{LIBSUFFIX}"
-    end
+    end)
 
     LITTLE_ENDIAN = 1234 unless defined?(LITTLE_ENDIAN)
     BIG_ENDIAN = 4321 unless defined?(BIG_ENDIAN)

data/lib/ffi/pointer.rb

@@ -45,12 +45,12 @@ module FFI
     SIZE = Platform::ADDRESS_SIZE / 8 unless const_defined?(:SIZE)
 
     # Return the size of a pointer on the current platform, in bytes
-    # @return [Numeric]
+    # @return [Integer]
     def self.size
       SIZE
     end unless respond_to?(:size)
 
-    # @param [nil,Numeric] len length of string to return
+    # @param [nil,Integer] len length of string to return
     # @return [String]
     # Read pointer's contents as a string, or the first +len+ bytes of the
     # equivalent string if +len+ is not +nil+.
@@ -63,7 +63,7 @@ module FFI
       end
     end unless method_defined?(:read_string)
 
-    # @param [Numeric] len length of string to return
+    # @param [Integer] len length of string to return
     # @return [String]
     # Read the first +len+ bytes of pointer's contents as a string.
     #
@@ -83,7 +83,7 @@ module FFI
     end unless method_defined?(:read_string_to_null)
 
     # @param [String] str string to write
-    # @param [Numeric] len length of string to return
+    # @param [Integer] len length of string to return
     # @return [self]
     # Write +len+ first bytes of +str+ in pointer's contents.
     #
@@ -94,7 +94,7 @@ module FFI
     end unless method_defined?(:write_string_length)
 
     # @param [String] str string to write
-    # @param [Numeric] len length of string to return
+    # @param [Integer] len length of string to return
     # @return [self]
     # Write +str+ in pointer's contents, or first +len+ bytes if
     # +len+ is not +nil+.
@@ -106,7 +106,7 @@ module FFI
 
     # @param [Type] type type of data to read from pointer's contents
     # @param [Symbol] reader method to send to +self+ to read +type+
-    # @param [Numeric] length
+    # @param [Integer] length
     # @return [Array]
     # Read an array of +type+ of length +length+.
     # @example

data/lib/ffi/struct.rb

@@ -41,12 +41,12 @@ module FFI
   class Struct
 
     # Get struct size
-    # @return [Numeric]
+    # @return [Integer]
     def size
       self.class.size
     end
 
-    # @return [Fixnum] Struct alignment
+    # @return [Integer] Struct alignment
     def alignment
       self.class.alignment
     end
@@ -87,13 +87,13 @@ module FFI
     end
 
     # Get struct size
-    # @return [Numeric]
+    # @return [Integer]
     def self.size
       defined?(@layout) ? @layout.size : defined?(@size) ? @size : 0
     end
 
     # set struct size
-    # @param [Numeric] size
+    # @param [Integer] size
     # @return [size]
     def self.size=(size)
       raise ArgumentError, "Size already set" if defined?(@size) || defined?(@layout)
@@ -203,9 +203,10 @@ module FFI
       #             :field3, :string
       #    end
       def layout(*spec)
-        warn "[DEPRECATION] Struct layout is already defined for class #{self.inspect}. Redefinition as in #{caller[0]} will be disallowed in ffi-2.0." if defined?(@layout)
         return @layout if spec.size == 0
 
+        warn "[DEPRECATION] Struct layout is already defined for class #{self.inspect}. Redefinition as in #{caller[0]} will be disallowed in ffi-2.0." if defined?(@layout)
+
         builder = StructLayoutBuilder.new
         builder.union = self < Union
         builder.packed = @packed if defined?(@packed)

data/lib/ffi/struct_layout.rb

@@ -35,13 +35,13 @@ module FFI
 
   class StructLayout
 
-    # @return [Array<Array(Symbol, Numeric)>
+    # @return [Array<Array(Symbol, Integer)>
     # Get an array of tuples (field name, offset of the field).
     def offsets
       members.map { |m| [ m, self[m].offset ] }
     end
 
-    # @return [Numeric]
+    # @return [Integer]
     # Get the offset of a field.
     def offset_of(field_name)
       self[field_name].offset
@@ -80,8 +80,8 @@ module FFI
 
     class Mapped < Field
       def initialize(name, offset, type, orig_field)
-        super(name, offset, type)
         @orig_field = orig_field
+        super(name, offset, type)
       end
 
       def get(ptr)

data/lib/ffi/struct_layout_builder.rb

@@ -46,13 +46,13 @@ module FFI
     end
 
     # Set size attribute with +size+ only if +size+ is greater than attribute value.
-    # @param [Numeric] size
+    # @param [Integer] size
     def size=(size)
       @size = size if size > @size
     end
 
     # Set alignment attribute with +align+ only if it is greater than attribute value.
-    # @param [Numeric] align
+    # @param [Integer] align
     def alignment=(align)
       @alignment = align if align > @alignment
       @min_alignment = align
@@ -78,7 +78,7 @@ module FFI
     # @overload packed=(packed) Set alignment and packed attributes to
     #   +packed+.
     #
-    #   @param [Fixnum] packed
+    #   @param [Integer] packed
     #
     #   @return [packed]
     # @overload packed=(packed) Set packed attribute.
@@ -112,11 +112,11 @@ module FFI
       Type::FLOAT64,
       Type::LONGDOUBLE,
       Type::BOOL,
-    ]
+    ].freeze
 
     # @param [String, Symbol] name name of the field
     # @param [Array, DataConverter, Struct, StructLayout::Field, Symbol, Type] type type of the field
-    # @param [Numeric, nil] offset
+    # @param [Integer, nil] offset
     # @return [self]
     # Add a field to the builder.
     # @note Setting +offset+ to +nil+ or +-1+ is equivalent to +0+.
@@ -154,7 +154,7 @@ module FFI
 
     # @param name (see #add)
     # @param type (see #add)
-    # @param [Numeric] count array length
+    # @param [Integer] count array length
     # @param offset (see #add)
     # @return (see #add)
     # Add an array as a field to the builder.
@@ -175,9 +175,9 @@ module FFI
 
     private
 
-    # @param [Numeric] offset
-    # @param [Numeric] align
-    # @return [Numeric]
+    # @param [Integer] offset
+    # @param [Integer] align
+    # @return [Integer]
     def align(offset, align)
       align + ((offset - 1) & ~(align - 1));
     end

data/lib/ffi/types.rb

@@ -33,40 +33,73 @@
 # see {file:README}
 module FFI
 
-  # @param [Type, DataConverter, Symbol] old type definition used by {FFI.find_type}
-  # @param [Symbol] add new type definition's name to add
-  # @return [Type]
-  # Add a definition type to type definitions.
-  def self.typedef(old, add)
-    TypeDefs[add] = self.find_type(old)
+  # Unless custom_typedefs already defined in the C-ext?
+  unless defined?(custom_typedefs)
+    # Truffleruby and JRuby don't support Ractor so far.
+    # So they don't need separation between builtin and custom types.
+    def self.custom_typedefs
+      TypeDefs
+    end
+    writable_typemap = true
   end
 
-  # (see FFI.typedef)
-  def self.add_typedef(old, add)
-    typedef old, add
-  end
+  class << self
 
+    private :custom_typedefs
 
-  # @param [Type, DataConverter, Symbol] name
-  # @param [Hash] type_map if nil, {FFI::TypeDefs} is used
-  # @return [Type]
-  # Find a type in +type_map+ ({FFI::TypeDefs}, by default) from
-  # a type objet, a type name (symbol). If +name+ is a {DataConverter},
-  # a new {Type::Mapped} is created.
-  def self.find_type(name, type_map = nil)
-    if name.is_a?(Type)
-      name
+    # @param [Type, DataConverter, Symbol] old type definition used by {FFI.find_type}
+    # @param [Symbol] add new type definition's name to add
+    # @return [Type]
+    # Add a definition type to type definitions.
+    #
+    # The type definition is local per Ractor.
+    def typedef(old, add)
+      tm = custom_typedefs
+      tm[add] = find_type(old)
+    end
+
+    # (see FFI.typedef)
+    def add_typedef(old, add)
+      typedef old, add
+    end
 
-    elsif type_map && type_map.has_key?(name)
-      type_map[name]
+    private def __typedef(old, add)
+      TypeDefs[add] = find_type(old, TypeDefs)
+    end
 
-    elsif TypeDefs.has_key?(name)
-      TypeDefs[name]
+    # @param [Type, DataConverter, Symbol] name
+    # @param [Hash] type_map if nil, {FFI::TypeDefs} is used
+    # @return [Type]
+    # Find a type in +type_map+ ({FFI::TypeDefs}, by default) from
+    # a type objet, a type name (symbol). If +name+ is a {DataConverter},
+    # a new {Type::Mapped} is created.
+    def find_type(name, type_map = nil)
+      if name.is_a?(Type)
+        name
+
+      elsif type_map&.has_key?(name)
+        type_map[name]
+
+      elsif (tm=custom_typedefs).has_key?(name)
+        tm[name]
+
+      elsif TypeDefs.has_key?(name)
+        TypeDefs[name]
+
+      elsif name.is_a?(DataConverter)
+        # Add a typedef so next time the converter is used, it hits the cache
+        tm = (type_map || custom_typedefs)
+        tm[name] = Type::Mapped.new(name)
+      else
+        raise TypeError, "unable to resolve type '#{name}'"
+      end
+    end
 
-    elsif name.is_a?(DataConverter)
-      (type_map || TypeDefs)[name] = Type::Mapped.new(name)
-    else
-      raise TypeError, "unable to resolve type '#{name}'"
+    # @param type +type+ is an instance of class accepted by {FFI.find_type}
+    # @return [Integer]
+    # Get +type+ size, in bytes.
+    def type_size(type)
+      find_type(type).size
     end
   end
 
@@ -168,14 +201,7 @@ module FFI
     end
   end
 
-  typedef(StrPtrConverter, :strptr)
-
-  # @param type +type+ is an instance of class accepted by {FFI.find_type}
-  # @return [Numeric]
-  # Get +type+ size, in bytes.
-  def self.type_size(type)
-    find_type(type).size
-  end
+  __typedef(StrPtrConverter, :strptr)
 
   # Load all the platform dependent types
   begin
@@ -184,11 +210,13 @@ module FFI
       f.each_line { |line|
         if line.index(prefix) == 0
           new_type, orig_type = line.chomp.slice(prefix.length..-1).split(/\s*=\s*/)
-          typedef(orig_type.to_sym, new_type.to_sym)
+          __typedef(orig_type.to_sym, new_type.to_sym)
         end
       }
     end
-    typedef :pointer, :caddr_t
+    __typedef :pointer, :caddr_t
   rescue Errno::ENOENT
   end
+
+  FFI.make_shareable(TypeDefs) unless writable_typemap
 end

data/lib/ffi/variadic.rb

@@ -54,16 +54,27 @@ module FFI
       invoker = self
       params = "*args"
       call = "call"
-      mod.module_eval <<-code
-      @@#{mname} = invoker
-      def self.#{mname}(#{params})
-        @@#{mname}.#{call}(#{params})
-      end
-      def #{mname}(#{params})
-        @@#{mname}.#{call}(#{params})
-      end
+      mname = mname.to_sym
+      mod.module_eval <<-code, __FILE__, __LINE__
+        @ffi_functions = {} unless defined?(@ffi_functions)
+        @ffi_functions[#{mname.inspect}] = invoker
+
+        def self.#{mname}(#{params})
+          @ffi_functions[#{mname.inspect}].#{call}(#{params})
+        end
+
+        define_method(#{mname.inspect}, &method(#{mname.inspect}))
       code
       invoker
     end
+
+    # Retrieve Array of parameter types
+    #
+    # This method returns an Array of FFI types accepted as function parameters.
+    #
+    # @return [Array<FFI::Type>]
+    def param_types
+      [*@fixed, Type::Builtin::VARARGS]
+    end
   end
 end

data/lib/ffi/version.rb

@@ -1,3 +1,3 @@
 module FFI
-  VERSION = '1.15.5'
+  VERSION = '1.17.0'
 end

data/samples/hello_ractor.rb

@@ -0,0 +1,11 @@
+require 'ffi'
+
+module Foo
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  attach_function("cputs", "puts", [ :string ], :int)
+  freeze
+end
+Ractor.new do
+  Foo.cputs("Hello, World via libc puts using FFI in a Ractor")
+end.take

data/samples/qsort_ractor.rb

@@ -0,0 +1,28 @@
+require 'ffi'
+
+module LibC
+  extend FFI::Library
+  ffi_lib FFI::Library::LIBC
+  callback :qsort_cmp, [ :pointer, :pointer ], :int
+  attach_function :qsort, [ :pointer, :ulong, :ulong, :qsort_cmp ], :int
+
+  freeze # Freeze the module variables, so that it can be shared across ractors.
+end
+
+p = FFI::MemoryPointer.new(:int, 3)
+p.put_array_of_int32(0, [ 2, 3, 1 ])   # Write some unsorted data into the memory
+# Ractor.make_shareable(p)             # freeze the pointer to be shared between ractors instead of copied
+puts "main  -ptr=#{p.inspect}"
+res = Ractor.new(p) do |p|
+  puts "ractor-ptr=#{p.inspect}"
+  puts "Before qsort #{p.get_array_of_int32(0, 3).join(', ')}"
+  LibC.qsort(p, 3, 4) do |p1, p2|
+    i1 = p1.get_int32(0)
+    i2 = p2.get_int32(0)
+    puts "In block: comparing #{i1} and #{i2}"
+    i1 < i2 ? -1 : i1 > i2 ? 1 : 0
+  end
+  puts "After qsort #{p.get_array_of_int32(0, 3).join(', ')}"
+end.take
+
+puts "After ractor termination #{p.get_array_of_int32(0, 3).join(', ')}"

data/sig/ffi/abstract_memory.rbs

@@ -0,0 +1,165 @@
+module FFI
+  class AbstractMemory
+    interface _Size
+      def size: () -> Integer
+    end
+    include _Size
+    type type_size = Integer | _Size | Symbol
+
+    type order_out = :big | :little
+    type order_in = order_out | :network
+
+    def []: (Integer idx) -> instance
+    def clear: () -> self
+    def freeze: ...
+    def get: (ffi_type type, Integer offset) -> top
+    def put: (ffi_type type, Integer offset, top value) -> nil
+    def size_limit?: () -> bool
+    def type_size: () -> Integer
+    alias total size
+
+    def get_int8: (Integer offset) -> Integer
+    def get_int16: (Integer offset) -> Integer
+    def get_int32: (Integer offset) -> Integer
+    def get_int64: (Integer offset) -> Integer
+    def get_uint8: (Integer offset) -> Integer
+    def get_uint16: (Integer offset) -> Integer
+    def get_uint32: (Integer offset) -> Integer
+    def get_uint64: (Integer offset) -> Integer
+    def get_char: (Integer offset) -> Integer
+    def get_short: (Integer offset) -> Integer
+    def get_int: (Integer offset) -> Integer
+    def get_long_long: (Integer offset) -> Integer
+    def get_float32: (Integer offset) -> Float
+    def get_float64: (Integer offset) -> Float
+    def get_pointer: (Integer offset) -> Pointer
+    def get_bytes: (Integer offset, Integer length) -> String
+    def get_string: (Integer offset, ?Integer? length) -> String
+    alias get_float get_float32
+    alias get_double get_float64
+
+    def put_int8: (Integer offset, int value) -> self
+    def put_int16: (Integer offset, int value) -> self
+    def put_int32: (Integer offset, int value) -> self
+    def put_int64: (Integer offset, int value) -> self
+    def put_uint8: (Integer offset, int value) -> self
+    def put_uint16: (Integer offset, int value) -> self
+    def put_uint32: (Integer offset, int value) -> self
+    def put_uint64: (Integer offset, int value) -> self
+    def put_char: (Integer offset, int value) -> self
+    def put_short: (Integer offset, int value) -> self
+    def put_int: (Integer offset, int value) -> self
+    def put_long_long: (Integer offset, int value) -> self
+    def put_float32: (Integer offset, Numeric value) -> self
+    def put_float64: (Integer offset, Numeric value) -> self
+    def put_pointer: (Integer offset, pointer value) -> self
+    def put_bytes: (Integer offset, String str, ?Integer index, ?Integer? length) -> self
+    def put_string: (Integer offset, String value) -> self
+    alias put_float put_float32
+    alias put_double put_float64
+
+    def read_int8: () -> Integer
+    def read_int16: () -> Integer
+    def read_int32: () -> Integer
+    def read_int64: () -> Integer
+    def read_uint8: () -> Integer
+    def read_uint16: () -> Integer
+    def read_uint32: () -> Integer
+    def read_uint64: () -> Integer
+    def read_char: () -> Integer
+    def read_short: () -> Integer
+    def read_int: () -> Integer
+    def read_long_long: () -> Integer
+    def read_float: () -> Float
+    def read_double: () -> Float
+    def read_pointer: () -> Pointer
+    def read_bytes: (Integer length) -> String
+
+    def write_int8: (int value) -> self
+    def write_int16: (int value) -> self
+    def write_int32: (int value) -> self
+    def write_int64: (int value) -> self
+    def write_uint8: (int value) -> self
+    def write_uint16: (int value) -> self
+    def write_uint32: (int value) -> self
+    def write_uint64: (int value) -> self
+    def write_char: (int value) -> self
+    def write_short: (int value) -> self
+    def write_int: (int value) -> self
+    def write_long_long: (int value) -> self
+    def write_float: (Numeric value) -> self
+    def write_double: (Numeric value) -> self
+    def write_pointer: (pointer value) -> self
+    def write_bytes: (String str, ?Integer index, ?Integer? length) -> self
+
+    def get_array_of_int8: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int16: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int32: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int64: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint8: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint16: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint32: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_uint64: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_char: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_short: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_int: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_long_long: (Integer offset, Integer length) -> Array[Integer]
+    def get_array_of_float32: (Integer offset, Integer length) -> Array[Float]
+    def get_array_of_float64: (Integer offset, Integer length) -> Array[Float]
+    def get_array_of_pointer: (Integer offset, Integer length) -> Array[Pointer]
+    def get_array_of_string: (Integer offset, ?Integer? count) -> Array[String?]
+    alias get_array_of_float get_array_of_float32
+    alias get_array_of_double get_array_of_float64
+
+    def put_array_of_int8: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int16: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int32: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int64: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint8: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint16: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint32: (Integer offset, Array[int] ary) -> self
+    def put_array_of_uint64: (Integer offset, Array[int] ary) -> self
+    def put_array_of_char: (Integer offset, Array[int] ary) -> self
+    def put_array_of_short: (Integer offset, Array[int] ary) -> self
+    def put_array_of_int: (Integer offset, Array[int] ary) -> self
+    def put_array_of_long_long: (Integer offset, Array[int] ary) -> self
+    def put_array_of_float32: (Integer offset, Array[Numeric] ary) -> self
+    def put_array_of_float64: (Integer offset, Array[Numeric] ary) -> self
+    def put_array_of_pointer: (Integer offset, Array[pointer] ary) -> self
+    alias put_array_of_float put_array_of_float32
+    alias put_array_of_double put_array_of_float64
+
+    def read_array_of_int8: (Integer length) -> Array[Integer]
+    def read_array_of_int16: (Integer length) -> Array[Integer]
+    def read_array_of_int32: (Integer length) -> Array[Integer]
+    def read_array_of_int64: (Integer length) -> Array[Integer]
+    def read_array_of_uint8: (Integer length) -> Array[Integer]
+    def read_array_of_uint16: (Integer length) -> Array[Integer]
+    def read_array_of_uint32: (Integer length) -> Array[Integer]
+    def read_array_of_uint64: (Integer length) -> Array[Integer]
+    def read_array_of_char: (Integer length) -> Array[Integer]
+    def read_array_of_short: (Integer length) -> Array[Integer]
+    def read_array_of_int: (Integer length) -> Array[Integer]
+    def read_array_of_long_long: (Integer length) -> Array[Integer]
+    def read_array_of_float: (Integer length) -> Array[Float]
+    def read_array_of_double: (Integer length) -> Array[Float]
+    def read_array_of_pointer: (Integer length) -> Array[Pointer]
+    def read_array_of_string: (?Integer? count) -> Array[String?]
+
+    def write_array_of_int8: (Array[int] ary) -> self
+    def write_array_of_int16: (Array[int] ary) -> self
+    def write_array_of_int32: (Array[int] ary) -> self
+    def write_array_of_int64: (Array[int] ary) -> self
+    def write_array_of_uint8: (Array[int] ary) -> self
+    def write_array_of_uint16: (Array[int] ary) -> self
+    def write_array_of_uint32: (Array[int] ary) -> self
+    def write_array_of_uint64: (Array[int] ary) -> self
+    def write_array_of_char: (Array[int] ary) -> self
+    def write_array_of_short: (Array[int] ary) -> self
+    def write_array_of_int: (Array[int] ary) -> self
+    def write_array_of_long_long: (Array[int] ary) -> self
+    def write_array_of_float: (Array[Numeric] ary) -> self
+    def write_array_of_double: (Array[Numeric] ary) -> self
+    def write_array_of_pointer: (Array[pointer] ary) -> self
+  end
+end

data/sig/ffi/auto_pointer.rbs

@@ -0,0 +1,27 @@
+module FFI
+  class AutoPointer < Pointer
+    class Releaser
+      attr_accessor autorelease: boolish
+      interface _Proc[P < Pointer]
+        def call: (P) -> void
+      end
+      def initialize: [P < Pointer] (P ptr, _Proc[P] proc) -> void
+
+      def call: (*untyped) -> void
+      def free: () -> nil
+      def release: (Pointer ptr) -> void
+    end
+
+    def initialize: (Pointer pointer, Method | ^(self) -> void | Releaser::_Proc[self] callable) -> self
+                # | (Pointer pointer) { (self) -> void } -> self # https://github.com/ffi/ffi/issues/1071
+                  | (Pointer pointer) -> self # where class < `def self.release: (instance pointer) -> void`
+
+    extend DataConverter[Pointer, instance, nil]
+    def self.from_native: ...
+    def self.native_type: () -> Type::Builtin
+
+    def autorelease?: ...
+    def autorelease=: ...
+    def free: () -> nil
+  end
+end