rigortype 0.4.3 → 0.4.5

data/lib/rigor/sig_gen/path_mapper.rb

@@ -37,8 +37,11 @@ module Rigor
       #   returned instead of the 1:1 mirror.
       # @return absolute path of the target `.rbs`
       #   file for the candidate.
-      def target_for(source_path, class_name: nil)
-        existing = existing_target_for(class_name)
+      #
+      # A member the signature tree already declares (`method_name` / `kind`, ADR-122 WD2) is routed to the file
+      # that declares it, even when another file declares its class first (#1488).
+      def target_for(source_path, class_name: nil, method_name: nil, kind: nil)
+        existing = existing_member_target_for(class_name, method_name, kind) || existing_target_for(class_name)
         return existing if existing
 
         rel_to_root = source_relative_to_root(source_path)
@@ -46,6 +49,19 @@ module Rigor
         sig_root_dir / "#{stripped.sub_ext('')}.rbs"
       end
 
+      # `kind` may be `:singleton_instance` (a `def self?.` candidate), which routes to whichever file declares
+      # either half.
+      def existing_member_target_for(class_name, method_name, kind)
+        return nil if class_name.nil? || method_name.nil? || @layout_index.nil?
+
+        kinds = kind == :singleton_instance ? %i[instance singleton] : [kind]
+        kinds.each do |k|
+          file = @layout_index.member_file_for(class_name, method_name, k)
+          return file if file
+        end
+        nil
+      end
+
       def existing_target_for(class_name)
         return nil if class_name.nil? || @layout_index.nil?
 

data/lib/rigor/sig_gen/renderer.rb

@@ -4,6 +4,7 @@ require "json"
 
 require_relative "classification"
 require_relative "superclass_spelling"
+require_relative "write_reporter"
 
 module Rigor
   module SigGen
@@ -26,9 +27,11 @@ module Rigor
       # @param selection — subset of
       #   {Classification} constants to include; an empty
       #   array means "all emittable classifications".
-      def render(candidates:, mode:, format:, selection:)
+      # @param observation — `{ paths:, missing: }` under `--params=observed`, else `nil`; JSON carries it
+      #   as the top-level `observation` key (#1398).
+      def render(candidates:, mode:, format:, selection:, observation: nil)
         case format
-        when "json" then render_json(filter(candidates, selection, with_skipped: true))
+        when "json" then render_json(filter(candidates, selection, with_skipped: true), observation)
         when "text"
           filtered = filter(candidates, selection)
           mode == :diff ? render_diff(filtered) : render_print(filtered)
@@ -121,175 +124,30 @@ module Rigor
         end
       end
 
-      def render_json(candidates)
+      def render_json(candidates, observation = nil)
         payload = { candidates: candidates.map(&:to_h) }
+        payload[:observation] = observation if observation
         @out.puts(JSON.pretty_generate(payload))
       end
 
       public
 
-      # Renders the per-source-file outcomes of a `--write` run. Distinct from {#render} because the write
-      # path's reporting surface is action-oriented (created / updated / skipped) rather than candidate-oriented.
-      # @param refused — methods refused as `sig.skipped.inline-differs`; the JSON payload names them under
-      #   `refused` (absent when there are none, so an ordinary payload is unchanged), and text mode leaves them
-      #   to the command's stderr `REFUSED` lines.
+      # The per-source-file outcomes of a `--write` run, and the `--check` verdict, are reported by
+      # {WriteReporter}; these delegate so the command keeps one renderer.
       def render_write(results:, format:, refused: [])
-        case format
-        when "json" then render_write_json(results, refused)
-        when "text" then render_write_text(results)
-        else raise ArgumentError, "unsupported format: #{format}"
-        end
+        WriteReporter.new(out: @out).render_write(results: results, format: format, refused: refused)
       end
 
-      # ADR-112 WD4 — `sig-gen --check`: the results of a dry-run `--write`. Only the targets `--write` would
-      # change (or refuse) are shown, each with the lines it would add; the verdict is the exit status, which
-      # the command derives from the same results ({.out_of_date}).
-      #
-      # @param refused — the methods the generator refused to reconcile (`sig.skipped.inline-differs`):
-      #   `sig/` is not up to date while one stands, and `--write` cannot fix it.
       def render_check(results:, format:, refused: [])
-        stale = self.class.out_of_date(results)
-        case format
-        when "json"
-          @out.puts(JSON.pretty_generate({ up_to_date: stale.empty? && refused.empty?,
-                                           results: stale.map { |r| check_entry(r) },
-                                           refused: refused.map(&:to_h) }))
-        when "text" then render_check_text(stale, refused)
-        else raise ArgumentError, "unsupported format: #{format}"
-        end
+        WriteReporter.new(out: @out).render_check(results: results, format: format, refused: refused)
       end
 
-      # One line per method sig-gen refused to reconcile with its `sig/` copy. Shared by `--write` (on stderr,
-      # next to the write report) and `--check`.
       def self.refusal_lines(refused)
-        refused.map do |candidate|
-          separator = candidate.kind == :singleton ? "." : "#"
-          "REFUSED #{candidate.path}: #{candidate.class_name}#{separator}#{candidate.method_name} — its inline " \
-            "declaration and its sig/ declaration disagree, so neither was changed " \
-            "(#{Classification::SKIP_DIAGNOSTIC_IDS.fetch(candidate.skip_reason)}). Make them agree, or pass " \
-            "--overwrite to replace the sig/ member with the inline declaration; `rigor explain " \
-            "#{Classification::SKIP_DIAGNOSTIC_IDS.fetch(candidate.skip_reason)}` says when that is not enough."
-        end
+        WriteReporter.refusal_lines(refused)
       end
 
-      # The results that make a `--check` fail: a target `--write` would create or change, and one it would
-      # refuse, since a write that cannot happen is not an up-to-date `sig/` either.
       def self.out_of_date(results)
-        results.reject { |result| %i[noop skipped_outside_sig_root].include?(result.action) }
-      end
-
-      # Nothing was written, so the entry must not read like one that was: `created` / `updated` become
-      # `would_create` / `would_update`. A refusal keeps its action — `--write` would refuse the same way.
-      CHECK_ACTIONS = { created: "would_create", updated: "would_update" }.freeze
-      private_constant :CHECK_ACTIONS
-
-      private
-
-      def check_entry(result)
-        entry = result.to_h
-        entry[:action] = CHECK_ACTIONS.fetch(result.action, entry[:action])
-        entry
-      end
-
-      def render_check_text(stale, refused)
-        if stale.empty? && refused.empty?
-          @out.puts("sig/ is up to date")
-          return
-        end
-
-        self.class.refusal_lines(refused).each { |line| @out.puts(line) }
-
-        stale.each do |result|
-          case result.action
-          when :created, :updated then render_check_change(result)
-          when :skipped_invalid_rbs then render_write_invalid(result)
-          when :skipped_invalid_encoding then render_write_invalid_encoding(result)
-          end
-        end
-      end
-
-      def render_check_change(result)
-        counts = result.action == :created ? "#{result.applied.size} method(s)" : applied_counts(result)
-        verb = result.action == :created ? "would create" : "would update"
-        @out.puts("#{verb} #{result.target_path} (#{counts})")
-        result.applied.each do |candidate|
-          @out.puts("  - #{candidate.declared_rbs}") if candidate.declared_rbs
-          candidate.rbs_lines.each { |line| @out.puts("  + #{line}") }
-        end
-      end
-
-      def render_write_text(results)
-        if results.all? { |r| r.action == :noop }
-          @out.puts("No changes")
-          return
-        end
-
-        results.each do |result|
-          case result.action
-          when :created then render_write_created(result)
-          when :updated then render_write_updated(result)
-          when :skipped_outside_sig_root then render_write_skipped(result)
-          when :skipped_invalid_rbs then render_write_invalid(result)
-          when :skipped_invalid_encoding then render_write_invalid_encoding(result)
-          end
-        end
-      end
-
-      # `+N` counts added lines; an existing line replaced (`--overwrite`, or an inline update) is counted apart,
-      # because "added 2" when one of them rewrote a line the project already had would understate the change.
-      def applied_counts(result)
-        added = "+#{result.applied.size - result.replaced.size}"
-        result.replaced.empty? ? added : "#{added}, replaced #{result.replaced.size}"
-      end
-
-      def render_write_created(result)
-        @out.puts("created #{result.target_path} (#{result.applied.size} method(s))")
-      end
-
-      def render_write_updated(result)
-        @out.puts("updated #{result.target_path} (#{applied_counts(result)}, " \
-                  "skipped #{result.skipped.size} user-authored)")
-        render_left_unreadable(result)
-      end
-
-      # ADR-103 WD9 — the declarations whose annotation region the writer refused to rewrite. Named per
-      # method rather than counted: the fix is a human reading one existing annotation and deciding what
-      # it should say, and there is no count of those a reader could act on.
-      def render_left_unreadable(result)
-        return if result.left_unreadable.empty?
-
-        @out.puts("  left #{result.left_unreadable.size} existing annotation(s) byte-untouched " \
-                  "(sig.effect.left-unreadable):")
-        result.left_unreadable.each do |candidate|
-          @out.puts("    #{candidate.class_name}##{candidate.method_name} — " \
-                    "would have emitted #{candidate.annotations.join(' ')}")
-        end
-      end
-
-      def render_write_skipped(result)
-        @out.puts("skipped #{result.source_path} -> #{result.target_path} (outside sig root)")
-      end
-
-      # The assembled file does not parse, so it was NOT written. Writing it would poison the sig tree — the
-      # consumer quarantines an unparseable `.rbs` whole, taking every other type in that file down with it,
-      # including the user's own hand-written ones.
-      def render_write_invalid(result)
-        @out.puts("REFUSED #{result.target_path} — the generated RBS does not parse, so it was not written")
-        @out.puts("  #{result.error}")
-        @out.puts("  This is a bug in Rigor's RBS rendering, not in your code — please report it.")
-      end
-
-      # The EXISTING target file is not valid UTF-8, so the writer will not merge into it — the opposite
-      # attribution from {#render_write_invalid}: this one is the file's problem, and the fix is the user's.
-      def render_write_invalid_encoding(result)
-        @out.puts("REFUSED #{result.target_path} — the existing file is not valid UTF-8, so it was not updated")
-        @out.puts("  Re-save the file as UTF-8 and re-run; sig-gen never modifies a file it cannot read faithfully.")
-      end
-
-      def render_write_json(results, refused)
-        payload = { results: results.map(&:to_h) }
-        payload[:refused] = refused.map(&:to_h) unless refused.empty?
-        @out.puts(JSON.pretty_generate(payload))
+        WriteReporter.out_of_date(results)
       end
     end
   end

data/lib/rigor/sig_gen/skip_reason_catalog.rb

@@ -147,6 +147,17 @@ module Rigor
                        "not reported.",
           next_step: "Nothing is required. To type the method, move it into a module (`module_function` or " \
                      "`extend self` keeps the call sites), or write the `Object` declaration by hand in `sig/`."
+        ),
+        "sig.skipped.uncertain-module-function" => Entry.new(
+          id: "sig.skipped.uncertain-module-function",
+          summary: "Whether the method is a module function depends on a visibility call that may not run.",
+          explanation: "A bare `module_function` makes the module's later methods module functions, and a later " \
+                       "bare `public`, `private` or `protected` ends that. Here such a call sits in control " \
+                       "flow or a block between the two, so it may or may not run, and the method is either a " \
+                       "module function (`def self?.name`) or an instance method only (`def name`). sig-gen " \
+                       "writes neither rather than guess (#1968).",
+          next_step: "Move the visibility call to the module body's own statements, or name the methods it " \
+                     "should cover (`public :name`, `module_function :name`), so the reading is certain."
         )
       }.freeze
 

data/lib/rigor/sig_gen/write_reporter.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "classification"
+
+module Rigor
+  module SigGen
+    # Reports a `rigor sig-gen --write` run (the per-target {WriteResult}s) and the `--check` verdict. Split out of
+    # {Renderer}, which formats candidates; this formats what the writer did with them.
+    class WriteReporter
+      def initialize(out:)
+        @out = out
+      end
+
+      # Renders the per-source-file outcomes of a `--write` run. Distinct from {Renderer#render} because the write
+      # path's reporting surface is action-oriented (created / updated / skipped) rather than candidate-oriented.
+      # @param refused — methods refused as `sig.skipped.inline-differs`; the JSON payload names them under
+      #   `refused` (absent when there are none, so an ordinary payload is unchanged), and text mode leaves them
+      #   to the command's stderr `REFUSED` lines.
+      def render_write(results:, format:, refused: [])
+        case format
+        when "json" then render_write_json(results, refused)
+        when "text" then render_write_text(results)
+        else raise ArgumentError, "unsupported format: #{format}"
+        end
+      end
+
+      # ADR-112 WD4 — `sig-gen --check`: the results of a dry-run `--write`. Only the targets `--write` would
+      # change (or refuse) are shown, each with the lines it would add; the verdict is the exit status, which
+      # the command derives from the same results ({.out_of_date}).
+      #
+      # @param refused — the methods the generator refused to reconcile (`sig.skipped.inline-differs`):
+      #   `sig/` is not up to date while one stands, and `--write` cannot fix it.
+      def render_check(results:, format:, refused: [])
+        stale = self.class.out_of_date(results)
+        case format
+        when "json"
+          @out.puts(JSON.pretty_generate({ up_to_date: stale.empty? && refused.empty?,
+                                           results: stale.map { |r| check_entry(r) },
+                                           refused: refused.map(&:to_h) }))
+        when "text" then render_check_text(stale, refused)
+        else raise ArgumentError, "unsupported format: #{format}"
+        end
+      end
+
+      # One line per method sig-gen refused to reconcile with its `sig/` copy. Shared by `--write` (on stderr,
+      # next to the write report) and `--check`.
+      def self.refusal_lines(refused)
+        refused.map do |candidate|
+          separator = candidate.kind == :singleton ? "." : "#"
+          "REFUSED #{candidate.path}: #{candidate.class_name}#{separator}#{candidate.method_name} — its inline " \
+            "declaration and its sig/ declaration disagree, so neither was changed " \
+            "(#{Classification::SKIP_DIAGNOSTIC_IDS.fetch(candidate.skip_reason)}). Make them agree, or pass " \
+            "--overwrite to replace the sig/ member with the inline declaration; `rigor explain " \
+            "#{Classification::SKIP_DIAGNOSTIC_IDS.fetch(candidate.skip_reason)}` says when that is not enough."
+        end
+      end
+
+      # The results that make a `--check` fail: a target `--write` would create or change, and one it would
+      # refuse, since a write that cannot happen is not an up-to-date `sig/` either.
+      def self.out_of_date(results)
+        results.reject { |result| %i[noop skipped_outside_sig_root].include?(result.action) }
+      end
+
+      # Nothing was written, so the entry must not read like one that was: `created` / `updated` become
+      # `would_create` / `would_update`. A refusal keeps its action — `--write` would refuse the same way.
+      CHECK_ACTIONS = { created: "would_create", updated: "would_update" }.freeze
+      private_constant :CHECK_ACTIONS
+
+      private
+
+      def check_entry(result)
+        entry = result.to_h
+        entry[:action] = CHECK_ACTIONS.fetch(result.action, entry[:action])
+        entry
+      end
+
+      def render_check_text(stale, refused)
+        if stale.empty? && refused.empty?
+          @out.puts("sig/ is up to date")
+          return
+        end
+
+        self.class.refusal_lines(refused).each { |line| @out.puts(line) }
+
+        stale.each do |result|
+          case result.action
+          when :created, :updated then render_check_change(result)
+          when :skipped_invalid_rbs then render_write_invalid(result)
+          when :skipped_invalid_encoding then render_write_invalid_encoding(result)
+          end
+        end
+      end
+
+      def render_check_change(result)
+        counts = result.action == :created ? "#{result.applied.size} method(s)" : applied_counts(result)
+        verb = result.action == :created ? "would create" : "would update"
+        @out.puts("#{verb} #{result.target_path} (#{counts})")
+        result.applied.each do |candidate|
+          @out.puts("  - #{candidate.declared_rbs}") if candidate.declared_rbs
+          candidate.rbs_lines.each { |line| @out.puts("  + #{line}") }
+        end
+      end
+
+      def render_write_text(results)
+        if results.all? { |r| r.action == :noop && r.skipped.empty? }
+          @out.puts("No changes")
+          return
+        end
+
+        results.each do |result|
+          case result.action
+          when :created then render_write_created(result)
+          when :updated then render_write_updated(result)
+          when :noop then render_write_unchanged(result)
+          when :skipped_outside_sig_root then render_write_skipped(result)
+          when :skipped_invalid_rbs then render_write_invalid(result)
+          when :skipped_invalid_encoding then render_write_invalid_encoding(result)
+          end
+        end
+      end
+
+      # `+N` counts added lines; an existing line replaced (`--overwrite`, or an inline update) is counted apart,
+      # because "added 2" when one of them rewrote a line the project already had would understate the change.
+      def applied_counts(result)
+        added = "+#{result.applied.size - result.replaced.size}"
+        result.replaced.empty? ? added : "#{added}, replaced #{result.replaced.size}"
+      end
+
+      def render_write_created(result)
+        @out.puts("created #{result.target_path} (#{result.applied.size} method(s))")
+      end
+
+      def render_write_updated(result)
+        @out.puts("updated #{result.target_path} (#{applied_counts(result)}, " \
+                  "skipped #{result.skipped.size} user-authored)")
+        render_write_skips(result)
+        render_left_unreadable(result)
+      end
+
+      # A target the writer opened and changed nothing in, because every proposal for it was a member the
+      # project already declares (#1975). Without this line the run read as "No changes" or said nothing about it.
+      def render_write_unchanged(result)
+        return if result.skipped.empty?
+
+        @out.puts("unchanged #{result.target_path} (skipped #{result.skipped.size} user-authored)")
+        render_write_skips(result)
+      end
+
+      # One line per proposal the writer declined, so a change `--diff` or `--print` showed is never dropped
+      # without a reason. The same entries are the `skipped` rows of the `--format=json` payload.
+      def render_write_skips(result)
+        result.skipped.each do |candidate, reason|
+          separator = candidate.kind == :singleton ? "." : "#"
+          label = "#{candidate.class_name}#{separator}#{candidate.method_name}"
+          @out.puts("  skipped #{label} (#{reason.to_s.tr('_', '-')}): #{candidate.rbs_lines.join(' ')}")
+        end
+      end
+
+      # ADR-103 WD9 — the declarations whose annotation region the writer refused to rewrite. Named per
+      # method rather than counted: the fix is a human reading one existing annotation and deciding what
+      # it should say, and there is no count of those a reader could act on.
+      def render_left_unreadable(result)
+        return if result.left_unreadable.empty?
+
+        @out.puts("  left #{result.left_unreadable.size} existing annotation(s) byte-untouched " \
+                  "(sig.effect.left-unreadable):")
+        result.left_unreadable.each do |candidate|
+          @out.puts("    #{candidate.class_name}##{candidate.method_name} — " \
+                    "would have emitted #{candidate.annotations.join(' ')}")
+        end
+      end
+
+      def render_write_skipped(result)
+        @out.puts("skipped #{result.source_path} -> #{result.target_path} (outside sig root)")
+        render_write_skips(result)
+      end
+
+      # The assembled file does not parse, so it was NOT written. Writing it would poison the sig tree — the
+      # consumer quarantines an unparseable `.rbs` whole, taking every other type in that file down with it,
+      # including the user's own hand-written ones.
+      def render_write_invalid(result)
+        @out.puts("REFUSED #{result.target_path} — the generated RBS does not parse, so it was not written")
+        @out.puts("  #{result.error}")
+        @out.puts("  This is a bug in Rigor's RBS rendering, not in your code — please report it.")
+      end
+
+      # The EXISTING target file is not valid UTF-8, so the writer will not merge into it — the opposite
+      # attribution from {#render_write_invalid}: this one is the file's problem, and the fix is the user's.
+      def render_write_invalid_encoding(result)
+        @out.puts("REFUSED #{result.target_path} — the existing file is not valid UTF-8, so it was not updated")
+        @out.puts("  Re-save the file as UTF-8 and re-run; sig-gen never modifies a file it cannot read faithfully.")
+      end
+
+      def render_write_json(results, refused)
+        payload = { results: results.map(&:to_h) }
+        payload[:refused] = refused.map(&:to_h) unless refused.empty?
+        @out.puts(JSON.pretty_generate(payload))
+      end
+    end
+  end
+end

data/lib/rigor/sig_gen/write_result.rb

@@ -16,7 +16,9 @@ module Rigor
     # - `replaced` — the subset of `applied` that replaced an existing declaration rather than adding one
     #   (`--overwrite`'s tighter returns, and inline updates).
     # - `skipped` — the {MethodCandidate}s the writer declined (e.g. tighter-return without `--overwrite`). Each
-    #   entry pairs the candidate with a skip reason keyword (`:user_authored`).
+    #   entry pairs the candidate with a skip reason keyword: `:user_authored` (the target already declares the
+    #   member, and the writer does not replace it) or `:outside_sig_root` (the member routes to a file outside
+    #   the writer's sig root, so nothing was attempted).
     # - `left_unreadable` — the {MethodCandidate}s whose effect annotation was NOT written because the
     #   target declaration already carries annotations, so its bytes were left alone
     #   (`sig.effect.left-unreadable`; see {Writer#splice_annotations}). The signature line itself was

data/lib/rigor/sig_gen/writer.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "rbs"
 
 require_relative "classification"
+require_relative "layout_index"
 require_relative "superclass_spelling"
 require_relative "write_result"
 
@@ -62,8 +63,10 @@ module Rigor
 
         @global_namespace_kinds = build_namespace_kinds(candidates)
         @global_superclasses = build_superclasses(candidates)
-        emittable.group_by { |c| @path_mapper.target_for(c.path, class_name: c.class_name) }
-                 .map { |target, group| write_target(target, group) }
+        grouped = emittable.group_by do |c|
+          @path_mapper.target_for(c.path, class_name: c.class_name, method_name: c.method_name, kind: c.rbs_kind)
+        end
+        grouped.map { |target, group| write_target(target, group) }
       end
 
       # @param candidates — only
@@ -95,7 +98,8 @@ module Rigor
         source_path ||= candidates.first&.path
         unless inside_sig_root?(target)
           return WriteResult.new(source_path: source_path, target_path: target,
-                                 action: :skipped_outside_sig_root)
+                                 action: :skipped_outside_sig_root,
+                                 skipped: candidates.map { |c| [c, :outside_sig_root] })
         end
 
         target.exist? ? update_existing(source_path, target, candidates) : create_new(source_path, target, candidates)
@@ -562,7 +566,10 @@ module Rigor
           state.applied.concat(methods)
           insert_namespace_chain(state, class_name, kinds, supers, methods)
         else
-          state.source = merge_into_existing_class(state.source, decl, methods, state)
+          # A class reopened in one file answers for every member of every opening, not just the first one's
+          # (#1488): a member another opening declares is user-authored, not new.
+          declared = find_class_decls(state.decls, class_name).flat_map { |d| collect_member_pairs(d) }
+          state.source = merge_into_existing_class(state.source, decl, methods, state, declared)
           state.decls = parse_signature(state.source) || state.decls
         end
       end
@@ -589,12 +596,25 @@ module Rigor
         nil
       end
 
+      # Every declaration of `qualified_name` in the file, in {#find_class_decl}'s order (so the first is the one
+      # it returns).
+      def find_class_decls(decls, qualified_name, prefix = [], found = [])
+        decls.each do |decl|
+          next unless decl.is_a?(RBS::AST::Declarations::Class) || decl.is_a?(RBS::AST::Declarations::Module)
+
+          local = decl.name.to_s.sub(/\A::/, "")
+          full = prefix.empty? ? local : "#{prefix.join('::')}::#{local}"
+          found << decl if full == qualified_name
+          find_class_decls(decl.members, qualified_name, prefix + [local], found)
+        end
+        found
+      end
+
       def ends_with_newline?(source)
         source.end_with?("\n")
       end
 
-      def merge_into_existing_class(source, decl, methods, state)
-        existing_pairs = collect_member_pairs(decl)
+      def merge_into_existing_class(source, decl, methods, state, existing_pairs)
         new_methods, conflicting = partition_against_existing(methods, existing_pairs)
 
         source = insert_into_class(source, decl, new_methods)
@@ -617,31 +637,21 @@ module Rigor
       end
 
       # Returns a list of `[method_name (Symbol), kind (Symbol)]` pairs for every method-like member in the
-      # declaration. ADR-14 slice 4 recognises `MethodDefinition`'s `:instance` / `:singleton` kind plus the
-      # three `attr_*` declaration kinds so a source-side `attr_reader :name` and an RBS-side
-      # `attr_reader name: T` are treated as the same member (i.e. user-authored).
+      # declaration ({LayoutIndex.member_keys}); an `alias` declares its new name (#1975). ADR-14 slice 4
+      # recognises the three `attr_*` declaration kinds
+      # so a source-side `attr_reader :name` and an RBS-side `attr_reader name: T` are treated as the same member
+      # (i.e. user-authored); a `def self?.f` counts as both an instance and a singleton `f` (#1488).
       def collect_member_pairs(decl)
-        pairs = []
-        decl.members.each { |m| collect_pairs_for_member(m, pairs) }
-        pairs
-      end
-
-      def collect_pairs_for_member(member, pairs)
-        case member
-        when RBS::AST::Members::MethodDefinition
-          pairs << [member.name, member.kind]
-        when RBS::AST::Members::AttrReader
-          pairs << [member.name, :instance]
-        when RBS::AST::Members::AttrWriter
-          pairs << [:"#{member.name}=", :instance]
-        when RBS::AST::Members::AttrAccessor
-          pairs << [member.name, :instance]
-          pairs << [:"#{member.name}=", :instance]
-        end
+        decl.members.flat_map { |m| LayoutIndex.member_keys(m) }
       end
 
+      # A `def self?.f` candidate conflicts with a declared instance OR singleton `f`: inserting it beside a lone
+      # `def self.f` (or `def f`) would declare that half twice (#1488).
       def partition_against_existing(methods, existing_pairs)
-        methods.partition { |c| !existing_pairs.include?([c.method_name, c.kind]) }
+        methods.partition do |c|
+          kinds = c.rbs_kind == :singleton_instance ? %i[instance singleton] : [c.kind]
+          kinds.none? { |kind| existing_pairs.include?([c.method_name, kind]) }
+        end
       end
 
       # Inserts each new method line one column before the class declaration's `end` keyword. The insertion
@@ -710,7 +720,7 @@ module Rigor
       # part of the contract. A candidate that keeps `void` is still eligible, which is what case 2 is for —
       # the `initialize` stub is always spelled `-> void`.
       def replaces_declared_void?(candidate, decl)
-        member = find_method_member(decl, candidate.method_name, candidate.kind)
+        member = find_method_member(decl, candidate)
         return false if member.nil?
 
         declared_void = member.overloads.any? do |overload|
@@ -722,7 +732,7 @@ module Rigor
       # Compares the existing member's source-side RBS text against the candidate's proposed RBS text
       # ({.fewer_untyped?}).
       def tightens_untyped?(candidate, decl, source)
-        member = find_method_member(decl, candidate.method_name, candidate.kind)
+        member = find_method_member(decl, candidate)
         return false if member.nil?
 
         self.class.fewer_untyped?(candidate.rbs, source[member.location.start_pos...member.location.end_pos])
@@ -737,7 +747,7 @@ module Rigor
       # the same method (ADR-112 WD4), which it replaces in the inline attribute's own spelling; an
       # `overloading?` member (`| ...`) is never its target.
       def replaceable_member(decl, candidate)
-        member = find_method_member(decl, candidate.method_name, candidate.kind)
+        member = find_method_member(decl, candidate)
         return member unless candidate.classification == Classification::INLINE_OVERWRITE
 
         member = nil if member.respond_to?(:overloading?) && member.overloading?
@@ -746,15 +756,20 @@ module Rigor
 
       def find_attr_member(decl, method_name, kind)
         decl.members.find do |m|
-          pairs = []
-          collect_pairs_for_member(m, pairs) unless m.is_a?(RBS::AST::Members::MethodDefinition)
-          m.respond_to?(:kind) && m.kind == kind && pairs.any? { |name, _| name == method_name }
+          next false if m.is_a?(RBS::AST::Members::MethodDefinition) || m.is_a?(RBS::AST::Members::Alias)
+
+          LayoutIndex.member_keys(m).include?([method_name, kind])
         end
       end
 
-      def find_method_member(decl, method_name, kind)
+      # Matches on the candidate's {MethodCandidate#rbs_kind}, so a `def self?.f` proposal finds only a
+      # `def self?.f` member: a `def f` beside a `def self.f`, or a `def self?.f` under a plain `def f`
+      # proposal, is left as the user wrote it. An `overloading?` member (`def f: ... | ...`) adds to a
+      # declaration elsewhere rather than being one, so it is never replaced (#1488).
+      def find_method_member(decl, candidate)
         decl.members.find do |m|
-          m.is_a?(RBS::AST::Members::MethodDefinition) && m.name == method_name && m.kind == kind
+          m.is_a?(RBS::AST::Members::MethodDefinition) && m.name == candidate.method_name &&
+            m.kind == candidate.rbs_kind && !m.overloading?
         end
       end
 

data/lib/rigor/signature_path_audit.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "rooted_glob"
+
 module Rigor
   # Classifies each configured `signature_paths:` entry by what it actually contributes to
   # the RBS environment, so a caller can warn when a configured path resolves to nothing.
@@ -90,7 +92,7 @@ module Rigor
       return Entry.new(path: path, status: :missing, rbs_file_count: 0) unless File.exist?(path)
       return Entry.new(path: path, status: :not_directory, rbs_file_count: 0) unless File.directory?(path)
 
-      count = Dir.glob(File.join(path, "**", "*.rbs")).size
+      count = RootedGlob.glob(path, "**/*.rbs").size
       Entry.new(path: path, status: count.zero? ? :empty : :ok, rbs_file_count: count)
     end
 
@@ -204,7 +206,7 @@ module Rigor
     private_class_method :listed?
 
     def self.canonical_rbs_files(dir)
-      Dir.glob(File.join(dir, "**", "*.rbs")).filter_map { |file| canonical_path(file) }
+      RootedGlob.glob(dir, "**/*.rbs").filter_map { |file| canonical_path(file) }
     end
     private_class_method :canonical_rbs_files