ruby-llvm 20.1.7 → 21.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 338be15f6ae880c42d178d37b15b65ed95928903f7352d4bad8c1befa0eeca3c
-  data.tar.gz: 1ae4814caed4c7180ac10bd66dc5b073f31d5eef50c9d8b8cbdef79d4ab91d31
+  metadata.gz: cbf4a61de5472ea85477b7b0c26d36a9d29512e43a8d1fc5c67babd7ec7ee9d5
+  data.tar.gz: 031f350a31ae2c6202cb765fe1ac01345796ef5c8dfea1972c0048c857d19db3
 SHA512:
-  metadata.gz: 935a16b39d91f47c4ca20a3fbdebc698bd19cafd8be4cde2e03755a4f7f2b4ede34374711e91916135220ae4e450ffcf99c58b744c1b29e2a283ca4c37255506
-  data.tar.gz: 6156148ff3c0445b7a1af00d286da9c1c7d02d941b9b9cba17aa79096b7239ddb9a68b7b83182ca8dcdb5588376226111a4c9d77cc14a8487b4e22ea31d4b0b9
+  metadata.gz: a01da90f6dbe9f65826526a0cc8ca2e428b9e47bc3a4393824d13ae7683fa8b21971ace1aedfedc9f0db92d658e346ff75ca252821c29614355ee0d8aea67ae0
+  data.tar.gz: f228a01b0495163e264410b1f379d60f4dfdd0d4e4716597a50228581371105b5222bbfffa12fdc643bf78d060870fd0f9a3256138f1057fe7b000f534fe5d09

data/lib/llvm/analysis.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require 'llvm'
 require 'llvm/core'
@@ -10,24 +11,28 @@ module LLVM
     # Verify that the module is valid.
     # @return [nil, String] human-readable description of any invalid
     #   constructs if invalid.
+    #: -> String?
     def verify
       do_verification(:return_status)
     end
 
     # Verify that a module is valid, and abort the process if not.
     # @return [nil]
+    #: -> String?
     def verify!
       # :nocov:
       do_verification(:abort_process)
       # :nocov:
     end
 
+    #: -> bool
     def valid?
       verify.nil?
     end
 
     private
 
+    #: (Symbol) -> String?
     def do_verification(action)
       LLVM.with_message_output do |str|
         C.verify_module(self, action, str)
@@ -38,24 +43,28 @@ module LLVM
   class Function
     # Verify that a function is valid.
     # @return [true, false]
+    #: -> bool
     def verify
       do_verification(:return_status)
     end
 
     # Verify that a function is valid, and abort the process if not.
     # @return [true, false]
+    #: -> bool
     def verify!
       # :nocov:
       do_verification(:abort_process)
       # :nocov:
     end
 
+    #: -> bool
     def valid?
       verify
     end
 
     private
 
+    #: (Symbol) -> bool
     def do_verification(action)
       C.verify_function(self, action).zero?
     end

data/lib/llvm/analysis_ffi.rb

@@ -4,7 +4,8 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["LLVM-20", "libLLVM-20.so.1", "libLLVM.so.20", "libLLVM.so.20.1"]
+
+  ffi_lib ["LLVM-21", "libLLVM-21.so.1", "libLLVM.so.21", "libLLVM.so.21.1"]
   # @defgroup LLVMCAnalysis Analysis
   # @ingroup LLVMC
   #

data/lib/llvm/core/attribute.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 module LLVM
   # wrapper for LLVMAttributeRef
@@ -6,6 +7,7 @@ module LLVM
     include PointerIdentity
 
     class << self
+      #: (String | Symbol) -> Attribute?
       def new(from)
         case from
         when String, Symbol
@@ -19,13 +21,20 @@ module LLVM
       #   argmem, inaccessiblemem, memory
       # and the valid values are:
       #   read, write, readwrite
+      #: (?Hash[untyped, untyped]) -> Attribute?
       def memory(opts = {})
         opts = opts.transform_keys(&:to_sym)
         val = bit_value(opts[:argmem]) | (bit_value(opts[:inaccessiblemem]) << 2) | (bit_value(opts[:memory]) << 4)
         enum(:memory, val)
       end
 
+      #: -> Attribute?
+      def captures_none
+        enum(:captures)
+      end
+
       # create enum attribute with optional value and context
+      #: (untyped, ?Integer, ?Context) -> Attribute?
       def enum(kind, value = 0, context = Context.global)
         attr_id = attribute_id(kind)
         ptr = C.create_enum_attribute(context, attr_id, value)
@@ -33,6 +42,7 @@ module LLVM
       end
 
       # create string attribute with key and value
+      #: (untyped, untyped, ?Context) -> Attribute?
       def string(key, value, context = Context.global)
         key = key.to_s
         value = value.to_s
@@ -40,12 +50,14 @@ module LLVM
         from_ptr(ptr)
       end
 
+      #: -> Integer
       def last_enum
         C.get_last_enum_attribute_kind
       end
 
       private
 
+      #: (FFI::Pointer) -> Attribute?
       def from_ptr(ptr)
         return if ptr.null?
         val = allocate
@@ -53,6 +65,7 @@ module LLVM
         val
       end
 
+      #: (String | Symbol) -> String
       def attribute_name(attr_name)
         attr_name = attr_name.to_s
         if /_attribute$/.match?(attr_name)
@@ -62,6 +75,7 @@ module LLVM
         end
       end
 
+      #: (String | Symbol) -> Integer
       def attribute_id(attr_name)
         attr_mem = FFI::MemoryPointer.from_string(attribute_name(attr_name))
         attr_kind_id = C.get_enum_attribute_kind_for_name(attr_mem, attr_mem.size - 1)
@@ -75,6 +89,7 @@ module LLVM
       #   1 = read
       #   2 = write
       #   3 = readwrite
+      #: (String | Symbol)-> Integer
       def bit_value(maybe_value)
         case maybe_value.to_s
         when 'read'
@@ -89,42 +104,51 @@ module LLVM
       end
     end
 
+    #: -> (Integer | String)
     def kind
       return enum_kind if enum?
       return string_kind if string?
       raise
     end
 
+    #: -> (Integer | String)
     def value
       return enum_value if enum?
       return string_value if string?
       raise
     end
 
+    #: -> bool
     def enum?
       C.is_enum_attribute(self)
     end
 
+    #: -> bool
     def string?
       C.is_string_attribute(self)
     end
 
+    #: -> bool
     def type?
       C.is_type_attribute(self)
     end
 
+    #: -> String
     def inspect
       to_s
     end
 
+    #: -> String
     def to_s
       Support::C.get_attribute_as_string(self)
     end
 
+    #: -> Integer
     def kind_id
       enum_kind_id
     end
 
+    #: (untyped) -> bool
     def ==(other)
       super if self.class == other.class
 
@@ -134,56 +158,71 @@ module LLVM
       false
     end
 
+    #: -> bool
     def readnone?
       enum_kind == 'readnone' || (enum_kind == 'memory' && enum_value_mem_none?)
     end
 
+    #: -> bool
     def readonly?
       enum_kind == 'readonly' || (enum_kind == 'memory' && enum_value_mem_read?)
     end
 
+    #: -> bool
     def writeonly?
       enum_kind == 'writeonly' || (enum_kind == 'memory' && enum_value_mem_write?)
     end
 
     private
 
+    #: -> bool
     def enum_value_mem_none?
       enum_value.nobits?(63)
     end
 
+    #: -> bool
     def enum_value_mem_read?
       enum_value.anybits?(21)
     end
 
+    #: -> bool
     def enum_value_mem_write?
       enum_value.anybits?(42)
     end
 
+    #: -> Integer
     def enum_kind_id
       C.get_enum_attribute_kind(self)
     end
 
+    #: -> String
     def enum_kind
       Support::C.get_enum_attribute_name_for_kind(enum_kind_id)
     end
 
+    #: -> Integer
     def enum_value
       C.get_enum_attribute_value(self)
     end
 
     # wraps get_string_attribute_kind
+    #: -> String
     def string_kind
+      ret = ''
       FFI::MemoryPointer.new(:uint64) do |size_ptr|
-        return C.get_string_attribute_kind(self, size_ptr)
+        ret = C.get_string_attribute_kind(self, size_ptr) #: as String
       end
+      ret
     end
 
     # wraps get_string_attribute_value
+    #: -> String
     def string_value
+      ret = ''
       FFI::MemoryPointer.new(:uint) do |size_ptr|
-        return C.get_string_attribute_value(self, size_ptr)
+        ret = C.get_string_attribute_value(self, size_ptr) #: as String
       end
+      ret
     end
   end
 end

data/lib/llvm/core/bitcode.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require 'llvm/core/bitcode_ffi'
 
@@ -7,23 +8,27 @@ module LLVM
     # Parse a module from a memory buffer
     # @param [String, LLVM::MemoryBuffer] path_or_memory_buffer
     # @return [LLVM::Module]
+    #: (untyped) -> LLVM::Module
     def self.parse_bitcode(path_or_memory_buffer)
       memory_buffer = case path_or_memory_buffer
       when MemoryBuffer then path_or_memory_buffer
       else MemoryBuffer.from_file(path_or_memory_buffer)
       end
+      llvm_module = nil #: LLVM::Module?
       FFI::MemoryPointer.new(:pointer) do |mod_ref|
         FFI::MemoryPointer.new(:pointer) do |msg_ref|
           status = C.parse_bitcode(memory_buffer, mod_ref, msg_ref)
           raise msg_ref.get_pointer(0).get_string(0) if status != 0
-          return from_ptr(mod_ref.get_pointer(0))
+          llvm_module = from_ptr(mod_ref.get_pointer(0))
         end
       end
+      llvm_module #: as !nil
     end
 
     # Write bitcode to the given path, IO object or file descriptor
     # @param [String, IO, Integer] path_or_io Pathname, IO object or file descriptor
     # @return [true, false] Success
+    #: (untyped) -> bool
     def write_bitcode(path_or_io)
       status = if path_or_io.respond_to?(:path)
         C.write_bitcode_to_file(self, path_or_io.path)
@@ -37,20 +42,24 @@ module LLVM
       status.zero?
     end
 
+    #: (untyped, ?LLVM::Context) -> LLVM::Module
     def self.parse_ir(path_or_memory_buffer, context = Context.global)
       memory_buffer = case path_or_memory_buffer
       when MemoryBuffer then path_or_memory_buffer
       else MemoryBuffer.from_file(path_or_memory_buffer)
       end
+      llvm_module = nil #: LLVM::Module?
       FFI::MemoryPointer.new(:pointer) do |mod_ref|
         FFI::MemoryPointer.new(:pointer) do |msg_ref|
           status = C.parse_ir_in_context(context, memory_buffer, mod_ref, msg_ref)
           raise msg_ref.get_pointer(0).get_string(0) if status
-          return from_ptr(mod_ref.get_pointer(0))
+          llvm_module = from_ptr(mod_ref.get_pointer(0))
         end
       end
+      llvm_module #: as !nil
     end
 
+    #: (String) -> self
     def write_ir!(filename)
       FFI::MemoryPointer.new(:pointer) do |msg_ref|
         status = C.print_module_to_file(self, filename, msg_ref)
@@ -65,11 +74,13 @@ module LLVM
     private_class_method :new
 
     # @private
+    #: (FFI::Pointer) -> void
     def initialize(ptr)
-      @ptr = ptr
+      @ptr = ptr #: FFI::Pointer?
     end
 
     # @private
+    #: -> FFI::Pointer?
     def to_ptr
       @ptr
     end
@@ -77,28 +88,35 @@ module LLVM
     # Read the contents of a file into a memory buffer
     # @param [String] path
     # @return [LLVM::MemoryBuffer]
+    #: (String) -> LLVM::MemoryBuffer
     def self.from_file(path)
+      buffer = nil #: LLVM::MemoryBuffer?
       FFI::MemoryPointer.new(:pointer) do |buf_ref|
         FFI::MemoryPointer.new(:pointer) do |msg_ref|
           status = C.create_memory_buffer_with_contents_of_file(path.to_str, buf_ref, msg_ref)
           raise msg_ref.get_pointer(0).get_string(0) if status != 0
-          return new(buf_ref.get_pointer(0))
+          buffer = new(buf_ref.get_pointer(0))
         end
       end
+      buffer #: as !nil
     end
 
     # Read STDIN into a memory buffer
     # @return [LLVM::MemoryBuffer]
+    #: -> LLVM::MemoryBuffer
     def self.from_stdin
+      buffer = nil #: LLVM::MemoryBuffer?
       FFI::Buffer.new(:pointer) do |buf_ref|
         FFI::Buffer.new(:pointer) do |msg_ref|
           status = C.create_memory_buffer_with_stdin(buf_ref, msg_ref)
           raise msg_ref.get_pointer(0).get_string(0) if status != 0
-          return new(buf_ref.get_pointer(0))
+          buffer = new(buf_ref.get_pointer(0))
         end
       end
+      buffer #: as !nil
     end
 
+    #: -> void
     def dispose
       return if @ptr.nil?
       C.dispose_memory_buffer(@ptr)

data/lib/llvm/core/bitcode_ffi.rb

@@ -4,7 +4,8 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["LLVM-20", "libLLVM-20.so.1", "libLLVM.so.20", "libLLVM.so.20.1"]
+
+  ffi_lib ["LLVM-21", "libLLVM-21.so.1", "libLLVM.so.21", "libLLVM.so.21.1"]
   # (Not documented)
   #
   # @method parse_bitcode(mem_buf, out_module, out_message)