Remove @builder_ipps and @empty_builders cross-file state from the Rice generator. Replace @builder_ipps with

  cursor-based .ipp path computation via ipp_path_for_cursor, and always generate builder functions for class templates
  (even when empty), eliminating the need for @empty_builders.

Author: cfis

lib/ruby-bindgen/generators/rice/class_template_specialization.erb

@@ -6,20 +6,5 @@
                  template_specialization.gsub(/<.*>/, "").split("::").last.camelize + template_arguments.split(",").map(&:strip).map { |t| t.gsub(/[^a-zA-Z0-9]/, " ").split.map(&:capitalize).join }.join
                end -%>
 <%- ruby_class_name = @namer.apply_rename_types(raw_name) -%>
-<%- has_instantiate = !@empty_builders.include?(cursor_template.spelling) -%>
-<%- if has_instantiate -%>
-<%- # New pattern: call the instantiate function which handles everything -%>
 <%- parent_module = under ? under.cruby_name : "Rice::Module(rb_cObject)" -%>
 Rice::Data_Type<<%= template_specialization %>> <%= var_name %> = <%= cursor_template.spelling %>_instantiate<<%= template_arguments %>>(<%= parent_module %>, "<%= ruby_class_name %>");
-<%- else -%>
-<%- # Empty template: no instantiate function, just define the class -%>
-<%- if under && base_spelling -%>
-Rice::Data_Type<<%= template_specialization %>> <%= var_name %> = define_class_under<<%= template_specialization %>, <%= base_spelling %>>(<%= under.cruby_name %>, "<%= ruby_class_name %>");
-<%- elsif under -%>
-Rice::Data_Type<<%= template_specialization %>> <%= var_name %> = define_class_under<<%= template_specialization %>>(<%= under.cruby_name %>, "<%= ruby_class_name %>");
-<%- elsif base_spelling -%>
-Rice::Data_Type<<%= template_specialization %>> <%= var_name %> = define_class<<%= template_specialization %>, <%= base_spelling %>>("<%= ruby_class_name %>");
-<%- else -%>
-Rice::Data_Type<<%= template_specialization %>> <%= var_name %> = define_class<<%= template_specialization %>>("<%= ruby_class_name %>");
-<%- end -%>
-<%- end -%>

lib/ruby-bindgen/generators/rice/rice.rb

@@ -154,10 +154,6 @@ def initialize(inputter, outputter, config)
         @incomplete_iterators = Hash.new
         # Iterator names per class (for aliasing each_const -> each)
         @class_iterator_names = Hash.new { |h, k| h[k] = Set.new }
-        # Template classes with no bindable content (all methods deprecated/skipped)
-        @empty_builders = Set.new
-        # Maps builder function name -> -rb.ipp basename (persists across files for cross-file deps)
-        @builder_ipps = {}
       end
 
       def generate
@@ -245,6 +241,13 @@ def rice_include_header
         @include_header || "#{@project || 'rice'}_include.hpp"
       end
 
+      # Compute the .ipp path for a template defined in a different file.
+      def ipp_path_for_cursor(cursor)
+        template_file = cursor.file_location.file
+        relative = Pathname.new(template_file).relative_path_from(Pathname.new(@inputter.base_path)).to_s
+        File.join(File.dirname(relative), "#{File.basename(relative, '.*')}-rb.ipp")
+      end
+
       # Generate default Rice include header if user didn't specify one
       def create_rice_include_header
         return if @include_header  # User specified their own header
@@ -535,12 +538,6 @@ def visit_class_template_builder(cursor)
                                    only_kinds: [:cursor_cxx_method, :cursor_constructor, :cursor_field_decl, :cursor_variable,
                                                 :cursor_enum_decl, :cursor_conversion_function])
 
-        # If no children (all methods deprecated/skipped), don't generate builder
-        if children.empty?
-          @empty_builders.add(cursor.spelling)
-          return ""
-        end
-
         # TODO: Calling get_base_spelling crashes libclang on certain templates.
         # Fix the instantiate functions by hand for now.
         #base_spelling = get_base_spelling(cursor)
@@ -564,12 +561,6 @@ def visit_class_template_builder(cursor)
         param_names = template_parameters.map(&:spelling).join(", ")
         fully_qualified_type = "#{cursor.qualified_name}<#{param_names}>"
 
-        # Track builder for cross-file dependency detection.
-        # Store the full relative path (e.g., "opencv2/core/cvstd_wrapper-rb.ipp")
-        # so consumers in different directories can compute the correct include path.
-        builder_name = "#{cursor.spelling}_instantiate"
-        @builder_ipps[builder_name] = File.join(@relative_dir, "#{@basename}.ipp")
-
         children_content = merge_children(children, :indentation => 4, :separator => ".\n",
                                                     :terminator => ";", :strip => true)
 
@@ -1898,14 +1889,14 @@ def visit_template_specialization(cursor, cursor_template, underlying_type)
 
         template_specialization = type_spelling(underlying_type)
 
-        # Check if the template's _instantiate builder was generated in a different file
-        builder_name = "#{cursor_template.spelling}_instantiate"
-        builder_ipp = @builder_ipps[builder_name]
-        current_ipp = File.join(@relative_dir, "#{@basename}.ipp")
-        if builder_ipp && builder_ipp != current_ipp
-          # Compute relative path from current file's directory to the ipp file
-          ipp_relative = Pathname.new(builder_ipp).relative_path_from(Pathname.new(@relative_dir)).to_s
-          @includes << "#include \"#{ipp_relative}\""
+        # If template is defined in a different file, include its .ipp for the _instantiate builder
+        unless cursor_template.file_location.file == cursor_template.translation_unit.file.name
+          builder_ipp = ipp_path_for_cursor(cursor_template)
+          current_ipp = File.join(@relative_dir, "#{@basename}.ipp")
+          if builder_ipp != current_ipp
+            ipp_relative = Pathname.new(builder_ipp).relative_path_from(Pathname.new(@relative_dir)).to_s
+            @includes << "#include \"#{ipp_relative}\""
+          end
         end
 
         @classes[cursor.cruby_name] = template_specialization

test/bindings/cpp/cross_file_derived-rb.ipp

@@ -7,4 +7,9 @@ inline Rice::Data_Type<CrossFile::DerivedVector<T, N>> DerivedVector_instantiate
       Arg("other"));
 }
 
+template<typename T>
+inline Rice::Data_Type<CrossFile::DataType<T>> DataType_instantiate(Rice::Module parent, const char* name)
+{
+  return Rice::define_class_under<CrossFile::DataType<T>>(parent, name);
+}
 

test/bindings/cpp/filtering-rb.cpp

@@ -32,7 +32,7 @@ void Init_Filtering()
     define_method<void(Outer::Wrapper<int>::*)(int*)>("wrap", &Outer::Wrapper<int>::wrap,
       ArgBuffer("obj"));
 
-  Rice::Data_Type<Outer::DeprecatedTemplate<int>> rb_cDeprecatedTemplateInt = define_class_under<Outer::DeprecatedTemplate<int>>(rb_mOuter, "DeprecatedTemplateInt");
+  Rice::Data_Type<Outer::DeprecatedTemplate<int>> rb_cDeprecatedTemplateInt = DeprecatedTemplate_instantiate<int>(rb_mOuter, "DeprecatedTemplateInt");
 
   Rice::Data_Type<Outer::OtherClass> rb_cOuterOtherClass = define_class_under<Outer::OtherClass>(rb_mOuter, "OtherClass").
     define_constructor(Constructor<Outer::OtherClass>());

test/bindings/cpp/filtering-rb.ipp

@@ -15,4 +15,9 @@ inline Rice::Data_Type<Outer::Wrapper<T>> Wrapper_instantiate(Rice::Module paren
       std::conditional_t<std::is_fundamental_v<T>, ArgBuffer, Arg>("obj"));
 }
 
+template<typename T>
+inline Rice::Data_Type<Outer::DeprecatedTemplate<T>> DeprecatedTemplate_instantiate(Rice::Module parent, const char* name)
+{
+  return Rice::define_class_under<Outer::DeprecatedTemplate<T>>(parent, name);
+}
 

test/bindings/cpp/functions-rb.cpp

@@ -3,7 +3,7 @@
 
 using namespace Rice;
 
-
+#include "functions-rb.ipp"
 
 void Init_Functions()
 {
@@ -79,7 +79,7 @@ void Init_Functions()
 
   Module rb_mNontypeArgs = define_module("NontypeArgs");
 
-  Rice::Data_Type<nontype_args::Container<double, nontype_args::Config::Size>> rb_cNontype_argsContainerDoubleNontype_argsConfigSize = define_class_under<nontype_args::Container<double, nontype_args::Config::Size>>(rb_mNontypeArgs, "ContainerDoubleNontypeArgsConfigSize");
+  Rice::Data_Type<nontype_args::Container<double, nontype_args::Config::Size>> rb_cNontype_argsContainerDoubleNontype_argsConfigSize = Container_instantiate<double, nontype_args::Config::Size>(rb_mNontypeArgs, "ContainerDoubleNontypeArgsConfigSize");
 
   Rice::Data_Type<nontype_args::Config> rb_cNontypeArgsConfig = define_class_under<nontype_args::Config>(rb_mNontypeArgs, "Config").
     define_constructor(Constructor<nontype_args::Config>()).

test/bindings/cpp/functions-rb.ipp

@@ -0,0 +1,6 @@
+template<typename T, int N>
+inline Rice::Data_Type<nontype_args::Container<T, N>> Container_instantiate(Rice::Module parent, const char* name)
+{
+  return Rice::define_class_under<nontype_args::Container<T, N>>(parent, name);
+}
+