Merge pull request #140 from sue445/feature/rb_num2int_inline

[WIP] Support static inline function

Author: sue445

Gemfile

@@ -6,6 +6,7 @@ gem "rake"
 gem "rspec"
 gem "rspec-its"
 gem "rspec-parameterized"
+gem "rspec-temp_dir"
 gem "rubocop", require: false
 gem "rubocop_auto_corrector", require: false
 gem "serverspec"

Gemfile.lock

@@ -88,6 +88,8 @@ GEM
       binding_of_caller
       rspec-parameterized-core (< 2)
     rspec-support (3.13.1)
+    rspec-temp_dir (1.1.1)
+      rspec (>= 3.0)
     rubocop (1.66.1)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
@@ -154,6 +156,7 @@ DEPENDENCIES
   rspec
   rspec-its
   rspec-parameterized
+  rspec-temp_dir
   rubocop
   rubocop_auto_corrector
   serverspec

_tools/ruby_h_to_go/lib/ruby_h_to_go/cli.rb

@@ -30,13 +30,6 @@ def perform
       go_fmt
     end
 
-    private
-
-    # @return [RubyHeaderParser::Parser]
-    def parser
-      @parser ||= RubyHeaderParser::Parser.new(header_dir)
-    end
-
     def write_type_definitions_to_go_file
       type_definitions = parser.extract_type_definitions.map do |definition|
         RubyHToGo::TypeDefinition.new(definition:, header_dir:)
@@ -62,11 +55,28 @@ def write_function_definitions_to_go_file
         RubyHToGo::FunctionDefinition.new(definition:, header_dir:)
       end
 
+      static_inline_function_definitions = parser.extract_static_inline_function_definitions.map do |definition|
+        RubyHToGo::FunctionDefinition.new(definition:, header_dir:)
+      end
+
+      static_inline_function_definitions.each do |static_inline_function_definition|
+        unless function_definitions.map(&:name).include?(static_inline_function_definition.name)
+          function_definitions << static_inline_function_definition
+        end
+      end
+
       function_definitions.each do |definition|
         definition.write_go_file(dist_dir)
       end
     end
 
+    private
+
+    # @return [RubyHeaderParser::Parser]
+    def parser
+      @parser ||= RubyHeaderParser::Parser.new(header_dir)
+    end
+
     # Clean all generated files in dist/
     def clean_generated_files
       FileUtils.rm_f(Dir.glob(File.join(dist_dir, "*.go")))

_tools/ruby_h_to_go/lib/ruby_header_parser/parser.rb

@@ -2,7 +2,7 @@
 
 module RubyHeaderParser
   # parse `ruby.h` using `ctags`
-  class Parser
+  class Parser # rubocop:disable Metrics/ClassLength
     # @!attribute [r] header_dir
     #   @return [String]
     attr_reader :header_dir
@@ -19,43 +19,17 @@ def initialize(header_dir)
 
     # @return [Array<RubyHeaderParser::FunctionDefinition>]
     def extract_function_definitions
-      stdout = `ctags --recurse --c-kinds=p --languages=C --language-force=C --fields=+nS --extras=+q -f - #{header_dir}` # rubocop:disable Layout/LineLength
-
-      stdout.each_line.with_object([]) do |line, definitions|
-        parts = line.split("\t")
-
-        function_name = parts[0]
-
-        next unless data.should_generate_function?(function_name)
-
-        definition =
-          if parts[2].end_with?(";$/;\"")
-            parts[2].delete_prefix("/^").delete_suffix(";$/;\"")
-          else
-            line_num = Util.find_field(parts, "line").to_i
-            read_definition_from_header_file(parts[1], line_num).delete_suffix(";")
-          end
-
-        definition.gsub!(/\);.*/, ")")
-
-        args = parse_definition_args(function_name, Util.find_field(parts, "signature"))
-
-        # Exclude functions with variable-length arguments
-        next if args&.last&.type == "..."
+      __extract_function_definitions(c_kinds: "p", is_parse_multiline_definition: true)
+    end
 
-        definitions << FunctionDefinition.new(
-          definition:,
-          name:       parts[0],
-          filepath:   parts[1],
-          typeref:    create_typeref(definition, function_name),
-          args:,
-        )
-      end
+    # @return [Array<RubyHeaderParser::FunctionDefinition>]
+    def extract_static_inline_function_definitions
+      __extract_function_definitions(c_kinds: "+p-d", is_parse_multiline_definition: false)
     end
 
     # @return [Array<RubyHeaderParser::StructDefinition>]
     def extract_struct_definitions
-      stdout = `ctags --recurse --c-kinds=s --languages=C --language-force=C --fields=+n -f - #{header_dir}`
+      stdout = execute_ctags("--c-kinds=s --fields=+n")
 
       stdout.each_line.with_object([]) do |line, definitions|
         parts = line.split("\t")
@@ -73,7 +47,7 @@ def extract_struct_definitions
 
     # @return [Array<RubyHeaderParser::TyperefDefinition>]
     def extract_type_definitions
-      stdout = `ctags --recurse --c-kinds=t --languages=C --language-force=C --fields=+n -f - #{header_dir}`
+      stdout = execute_ctags("--c-kinds=t --fields=+n")
 
       stdout.each_line.with_object([]) do |line, definitions|
         parts = line.split("\t")
@@ -91,6 +65,46 @@ def extract_type_definitions
 
     private
 
+    # @param c_kinds [String]
+    # @param is_parse_multiline_definition [Boolean]
+    # @return [Array<RubyHeaderParser::FunctionDefinition>]
+    def __extract_function_definitions(c_kinds:, is_parse_multiline_definition:)
+      stdout = execute_ctags("--c-kinds=#{c_kinds} --fields=+nS --extras=+q")
+
+      stdout.each_line.with_object([]) do |line, definitions|
+        parts = line.split("\t")
+
+        function_name = parts[0]
+
+        next unless data.should_generate_function?(function_name)
+
+        line_num = Util.find_field(parts, "line").to_i
+        definition =
+          parse_function_definition(filepath: parts[1], pattern: parts[2], line_num:, is_parse_multiline_definition:)
+
+        args = parse_definition_args(function_name, Util.find_field(parts, "signature"))
+
+        # Exclude functions with variable-length arguments
+        next if args&.last&.type == "..."
+
+        typeref_field = Util.find_field(parts, "typeref:typename")
+
+        definitions << FunctionDefinition.new(
+          definition:,
+          name:       parts[0],
+          filepath:   parts[1],
+          typeref:    create_typeref(definition:, function_name:, typeref_field:),
+          args:,
+        )
+      end
+    end
+
+    # @param args [String]
+    # @return [String]
+    def execute_ctags(args = "")
+      `ctags --recurse --languages=C --language-force=C #{args} -f - #{header_dir}`
+    end
+
     # @param file [String]
     # @param line_num [Integer]
     def read_definition_from_header_file(file, line_num)
@@ -107,6 +121,24 @@ def read_definition_from_header_file(file, line_num)
       ""
     end
 
+    # @param filepath [String]
+    # @param pattern [String]
+    # @param line_num [Integer]
+    # @param is_parse_multiline_definition [Boolean]
+    # @return [String]
+    def parse_function_definition(filepath:, pattern:, line_num:, is_parse_multiline_definition:)
+      definition =
+        if pattern.end_with?("$/;\"")
+          pattern.delete_prefix("/^").delete_suffix("$/;\"")
+        elsif is_parse_multiline_definition
+          read_definition_from_header_file(filepath, line_num)
+        else
+          pattern.delete_prefix("/^")
+        end
+
+      definition.delete_suffix(";")
+    end
+
     # @param function_name [String]
     # @param signature [String,nil]
     # @return [Array<RubyHeaderParser::ArgumentDefinition>]
@@ -176,10 +208,17 @@ def parse_definition_args(function_name, signature)
 
     # @param definition [String]
     # @param function_name [String]
+    # @param typeref_field [String,nil]
     # @return [RubyHeaderParser::TyperefDefinition]
-    def create_typeref(definition, function_name)
-      typeref_type = definition[0...definition.index(function_name)].gsub("char *", "char*").strip
-      typeref_type = Util.sanitize_type(typeref_type)
+    def create_typeref(definition:, function_name:, typeref_field:)
+      typeref_type =
+        if typeref_field
+          typeref_field.gsub(/^RBIMPL_ATTR_NONNULL\s*\(\(\)\)/, "").strip
+        else
+          # parse typeref in definition
+          type = definition[0...definition.index(function_name)].gsub("char *", "char*").strip
+          Util.sanitize_type(type)
+        end
 
       typeref_pointer = nil
       if typeref_type.match?(/\*+$/)

_tools/ruby_h_to_go/spec/ruby_h_to_go/cli_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RSpec.describe RubyHToGo::Cli do
+  include_context "uses temp dir"
+
+  let(:cli) do
+    RubyHToGo::Cli.new(
+      header_dir: RbConfig::CONFIG["rubyhdrdir"],
+      dist_dir:   temp_dir,
+    )
+  end
+
+  describe "#write_type_definitions_to_go_file" do
+    subject { cli.write_type_definitions_to_go_file }
+
+    it { expect { subject }.not_to raise_error }
+  end
+
+  describe "#write_struct_definitions_to_go_file" do
+    subject { cli.write_struct_definitions_to_go_file }
+
+    it { expect { subject }.not_to raise_error }
+  end
+
+  describe "#write_function_definitions_to_go_file" do
+    subject { cli.write_function_definitions_to_go_file }
+
+    it { expect { subject }.not_to raise_error }
+  end
+end

_tools/ruby_h_to_go/spec/ruby_header_parser/parser_spec.rb

@@ -138,6 +138,28 @@
     end
   end
 
+  describe "#extract_static_inline_function_definitions" do
+    subject(:definitions) { parser.extract_static_inline_function_definitions }
+
+    its(:count) { should be > 0 }
+
+    context "rb_num2int_inline" do
+      subject { definitions.find { |d| d.name == "rb_num2int_inline" } }
+
+      let(:args) do
+        [
+          argument(type: "VALUE", name: "x"),
+        ]
+      end
+
+      its(:name)       { should eq "rb_num2int_inline" }
+      its(:definition) { should eq "rb_num2int_inline(VALUE x)" }
+      its(:filepath)   { should be_end_with "/ruby/internal/arithmetic/int.h" }
+      its(:typeref)    { should eq typedef(type: "int") }
+      its(:args)       { should eq args }
+    end
+  end
+
   describe "#extract_struct_definitions" do
     subject(:definitions) { parser.extract_struct_definitions }
 

_tools/ruby_h_to_go/spec/spec_helper.rb

@@ -2,6 +2,7 @@
 
 require "rspec/its"
 require "rspec/parameterized"
+require "rspec/temp_dir"
 
 require_relative "../lib/ruby_header_parser"
 require_relative "../lib/ruby_h_to_go"