Harden RBS signature loading: module-function keys, broader rescue, stale clearing

Three small fixes around `load_rbs_signatures` and the helper that
walks RBS declarations:

- `rbs_helper.rb` now emits both `Class.foo` and `Class#foo` keys
  when an RBS member's kind is `:singleton_instance` (i.e.
  `def self?.foo`). RDoc generates both a singleton and a private
  instance method for module-function-style definitions, so the
  previous singleton-only key left the instance method without
  type signature lines.
- `rdoc.rb` widens the rescue in `load_rbs_signatures` from
  `RBS::ParsingError` to `RBS::BaseError`. Loader-level failures
  (duplicate declarations, generic-arity mismatches, etc.) inherit
  from `RBS::BaseError` / `RBS::LoadingError` rather than
  `ParsingError`, so they previously aborted documentation
  generation instead of warning and continuing.
- `rdoc.rb` also calls `@store.clear_rbs_signatures` in the rescue.
  In server mode a previous successful load may have populated the
  long-lived store; without clearing, a now-broken sig file leaves
  stale `type_signature_lines` showing on regenerated pages
  alongside the warning.

Author: st0012

lib/rdoc/rbs_helper.rb

@@ -54,9 +54,10 @@ def load_signatures(*dirs)
             decl.members.each do |member|
               case member
               when RBS::AST::Members::MethodDefinition
-                key = member.singleton? ? "#{class_name}.#{member.name}" : "#{class_name}##{member.name}"
                 sigs = member.overloads.map { |o| o.method_type.to_s }
-                signatures[key] ||= sigs
+                method_keys_for(class_name, member).each do |key|
+                  signatures[key] ||= sigs
+                end
               when RBS::AST::Members::AttrReader, RBS::AST::Members::AttrWriter, RBS::AST::Members::AttrAccessor
                 key = member.kind == :singleton ? "#{class_name}.#{member.name}" : "#{class_name}##{member.name}"
                 signatures[key] ||= [member.type.to_s]
@@ -87,6 +88,20 @@ def signature_to_html(lines, lookup:, from_path:)
 
       private
 
+      # `def self?.foo: ...` produces a member whose kind is :singleton_instance —
+      # it defines both Class.foo (singleton) and a private Class#foo (instance),
+      # so we need to register the signature under both keys.
+      def method_keys_for(class_name, member)
+        case member.kind
+        when :singleton
+          ["#{class_name}.#{member.name}"]
+        when :singleton_instance
+          ["#{class_name}.#{member.name}", "#{class_name}##{member.name}"]
+        else
+          ["#{class_name}##{member.name}"]
+        end
+      end
+
       def link_type_names_in_line(line, lookup, from_path)
         escaped = ERB::Util.html_escape(line)
 

lib/rdoc/rdoc.rb

@@ -562,7 +562,11 @@ def load_rbs_signatures
     sig_dirs << sig_dir if File.directory?(sig_dir)
     signatures = RDoc::RbsHelper.load_signatures(*sig_dirs)
     @store.merge_rbs_signatures(signatures)
-  rescue RBS::ParsingError, Errno::ENOENT, LoadError => e
+  rescue RBS::BaseError, Errno::ENOENT, LoadError => e
+    # In server mode, a previous successful load may have populated the store;
+    # drop those signatures so a now-broken sig file doesn't keep showing
+    # stale types alongside the warning.
+    @store.clear_rbs_signatures
     @options.warn "Failed to load RBS type signatures: #{e.message}"
   end
 

test/rdoc/rbs_helper_test.rb

@@ -40,6 +40,20 @@ def greet: (String name) -> void
     end
   end
 
+  def test_load_signatures_registers_module_function_methods_under_both_keys
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, 'test.rbs'), <<~RBS)
+        class Greeter
+          def self?.shout: (String text) -> String
+        end
+      RBS
+
+      sigs = RDoc::RbsHelper.load_signatures(dir)
+      assert_equal ['(String text) -> String'], sigs['Greeter.shout']
+      assert_equal ['(String text) -> String'], sigs['Greeter#shout']
+    end
+  end
+
   def test_load_signatures_keeps_instance_and_singleton_attributes_separate
     Dir.mktmpdir do |dir|
       File.write(File.join(dir, 'test.rbs'), <<~RBS)

test/rdoc/rdoc_rdoc_test.rb

@@ -110,6 +110,41 @@ def greet: () -> String
     end
   end
 
+  def test_load_rbs_signatures_clears_stale_signatures_on_failure
+    temp_dir do |dir|
+      sig_dir = File.join dir, 'sig'
+      sig = File.join sig_dir, 'example.rbs'
+      FileUtils.mkdir_p sig_dir
+
+      File.write sig, <<~RBS
+        class Example
+          def greet: () -> String
+        end
+      RBS
+
+      @options.root = Pathname(dir)
+      @options.op_dir = dir
+      @rdoc.store = RDoc::Store.new(@options)
+
+      top_level = @rdoc.store.add_file 'example.rb'
+      example = top_level.add_class RDoc::NormalClass, 'Example'
+      method = RDoc::AnyMethod.new nil, 'greet'
+      example.add_method method
+
+      @rdoc.load_rbs_signatures
+      assert_equal ['() -> String'], method.type_signature_lines
+
+      File.write sig, "class Example\n  def greet: ( -> "
+      @options.verbosity = 2
+      _out, err = capture_output do
+        @rdoc.load_rbs_signatures
+      end
+
+      assert_includes err, 'Failed to load RBS type signatures'
+      assert_nil method.type_signature_lines
+    end
+  end
+
   def test_document_with_dry_run # functional test
     options = RDoc::Options.new
     options.files = [File.expand_path('../xref_data.rb', __FILE__)]