rigortype 0.4.2 → 0.4.4

data/lib/rigor/sig_gen/generator.rb

@@ -57,7 +57,8 @@ module Rigor
     #   a parameter-only inline `# @rbs` annotation) is the ABSENCE of a return statement, not the author's
     #   word about it — the opposite of `void`. It is treated like no declaration at all: the inferred return
     #   is proposed as `tighter-return`, carrying `untyped` as the declared spelling so `--diff` still shows a
-    #   declaration existed (#995; see {#declared_untyped?}).
+    #   declaration existed (#995; see {#declared_untyped?}). A value literal the body proves (Integer, String,
+    #   Symbol) is widened to its class there unless the `untyped` is only the inline reader's synthesis (#1489).
     # - A `tighter-return` over the class's own declaration replaces the return and nothing else: the rest of
     #   the line is the declaration's, spelled as written, so `--overwrite` never changes which calls the
     #   signature accepts. A declaration with more than one overload, or one spelled as an `alias`, is left
@@ -1416,14 +1417,53 @@ module Rigor
         declared.is_a?(Type::Dynamic)
       end
 
-      # Proposed without {#compare_against_declared}'s tightening guards: a declared `untyped` return carries no
-      # information to weigh {#tighter?} or {#literal_decline?} against, the same position a method with no
-      # declaration at all is in. The line is built as for any tightening ({#tighter_return_line}), and
-      # `declared_return_rbs` carries `"untyped"` so the `[tighter, was: untyped]` print tag says one existed.
+      # Proposed without {#tighter?}: a declared `untyped` return carries no information to weigh it against, the
+      # same position a method with no declaration at all is in. Over a declaration the author wrote, though, a
+      # VALUE literal the body proves (`-> 1`, `-> "x"`, `-> :k`) is an implementation detail the `untyped` was
+      # abstracting over, so it is widened to its class (`1 | 2` to `Integer`, `"S" | nil` to `(String | nil)`; #1489).
+      # `nil`, `true` and `false` are honest types and stay, as does a computed `Float`. An `untyped` that is only
+      # the inline reader's synthesis ({#synthesized_declaration?}) is no word of the author's and keeps the
+      # strictest carrier. `declared_return_rbs` carries `"untyped"` so the `[tighter, was: untyped]` print tag
+      # says a declaration existed.
       def declared_untyped_candidate(path, def_node, class_name, kind, inferred, method_def, rendered: nil)
+        unless synthesized_declaration?(method_def)
+          widened = widen_value_literals(inferred)
+          unless widened.equal?(inferred)
+            # A `rendered` line was spelled from the unwidened type; there is nothing to rebuild it from.
+            return equivalent(path, def_node, class_name, kind, inferred, "untyped") if rendered
+
+            inferred = widened
+          end
+        end
+
         tighter_return_candidate(path, def_node, class_name, kind, inferred, method_def, "untyped", rendered)
       end
 
+      VALUE_LITERAL_CLASSES = [Integer, String, Symbol].freeze
+      private_constant :VALUE_LITERAL_CLASSES
+
+      # The same object back when nothing needed widening.
+      def widen_value_literals(type)
+        case type
+        when Type::Constant
+          return type unless VALUE_LITERAL_CLASSES.any? { |klass| type.value.instance_of?(klass) }
+
+          Type::Combinator.nominal_of(type.value.class.name)
+        when Type::Union
+          members = type.members.map { |member| widen_value_literals(member) }
+          members.each_with_index.all? { |m, i| m.equal?(type.members[i]) } ? type : Type::Combinator.union(*members)
+        else
+          type
+        end
+      end
+
+      # A declaration only the inline reader's synthesis (a `virtual:` buffer) supplies — ADR-93 gives every `def` an
+      # `untyped` member, annotated or not — is no word of the author's about the return, so it keeps the proposal
+      # a method with no declaration at all gets: the strictest carrier the body proves.
+      def synthesized_declaration?(method_def)
+        method_def.defs.all? { |type_def| type_def.member.location&.buffer&.name.to_s.start_with?("virtual:") }
+      end
+
       def build_declared_return(method_def)
         translated = method_def.method_types.filter_map { |mt| translate_method_type_return(mt) }
         return nil if translated.empty?

data/lib/rigor/sig_gen/layout_index.rb

@@ -20,7 +20,26 @@ module Rigor
     # First-found wins on duplicate declarations across files; RBS itself allows the same class to be declared
     # in multiple files for additive member contributions, but the writer only needs one canonical target per
     # class.
+    #
+    # ADR-122 WD2 adds the member level: `(class_name, method_name, kind) → sig_file_path`, so a member the project
+    # already declares in one file is updated there rather than inserted a second time into the class's
+    # first-found file (#1488).
     class LayoutIndex
+      # The `[method_name, kind]` keys a member declaration answers for, `kind` being `:instance` or
+      # `:singleton`. A `def self?.f` answers for both kinds; an `attr_accessor` answers for its reader and its
+      # writer. Shared with {Writer}, which asks the same question of the target file it is merging into.
+      def self.member_keys(member)
+        case member
+        when RBS::AST::Members::MethodDefinition
+          kinds = member.kind == :singleton_instance ? %i[instance singleton] : [member.kind]
+          kinds.map { |kind| [member.name, kind] }
+        when RBS::AST::Members::AttrReader then [[member.name, member.kind]]
+        when RBS::AST::Members::AttrWriter then [[:"#{member.name}=", member.kind]]
+        when RBS::AST::Members::AttrAccessor then [[member.name, member.kind], [:"#{member.name}=", member.kind]]
+        else []
+        end
+      end
+
       # @param signature_paths —
       #   the `.rigor.yml`-configured signature directories.
       #   When `nil` or empty, falls back to `<project_root>/sig`
@@ -29,6 +48,7 @@ module Rigor
       def initialize(signature_paths:, project_root: Dir.pwd)
         @signature_paths = resolve_paths(signature_paths, project_root)
         @index = nil
+        @members = nil
       end
 
       # @param class_name — fully-qualified Ruby class
@@ -40,6 +60,13 @@ module Rigor
         index[class_name]
       end
 
+      # @return absolute path of the first sig file (in the same order as {#file_for}) that declares
+      #   `method_name` of `kind` on `class_name`, or `nil` when no file does.
+      def member_file_for(class_name, method_name, kind)
+        index
+        @members[[class_name, method_name, kind]]
+      end
+
       def empty?
         index.empty?
       end
@@ -60,6 +87,7 @@ module Rigor
 
       def build_index
         accumulator = {}
+        @members = {}
         Array(@signature_paths).each do |dir|
           base = Pathname(dir)
           next unless base.directory?
@@ -68,6 +96,7 @@ module Rigor
             index_file(Pathname(rbs_file), accumulator)
           end
         end
+        @members.freeze
         accumulator.freeze
       end
 
@@ -97,6 +126,13 @@ module Rigor
         local_name = decl.name.to_s.sub(/\A::/, "")
         full = prefix.empty? ? local_name : "#{prefix.join('::')}::#{local_name}"
         accumulator[full] ||= rbs_path
+        decl.members.each do |member|
+          # An `overloading?` member (`def f: ... | ...`) adds to a declaration elsewhere; routing a candidate to
+          # it would replace the user's overload.
+          next if member.is_a?(RBS::AST::Members::MethodDefinition) && member.overloading?
+
+          self.class.member_keys(member).each { |name, kind| @members[[full, name, kind]] ||= rbs_path }
+        end
 
         record_decls(decl.members, prefix + [local_name], rbs_path, accumulator)
       end

data/lib/rigor/sig_gen/method_candidate.rb

@@ -68,6 +68,14 @@ module Rigor
         @declared_annotations + @annotations + [@rbs].compact
       end
 
+      # The RBS member kind `rbs` declares: `:singleton_instance` for a `def self?.` line (a `module_function`
+      # method, whose `kind` stays `:instance`), `kind` otherwise. The writer replaces only a member of this
+      # kind, so an overwrite neither drops a `self?.` member's singleton half nor adds one beside a split
+      # `def self.f` / `def f` pair (#1488).
+      def rbs_kind
+        kind == :instance && rbs.to_s.start_with?("def self?.") ? :singleton_instance : kind
+      end
+
       # A copy carrying a different annotation decision. The generator's effect pass rebuilds rather than
       # mutates, because a candidate is frozen the moment it is built.
       def with_effect_annotation(annotations, reason)

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/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
@@ -562,7 +565,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 +595,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 +636,20 @@ 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}). 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 +718,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 +730,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 +745,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 +754,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)
+
+          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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.4.2"
+  VERSION = "0.4.4"
 end

data/plugins/rigor-active-model-serializers/lib/rigor/plugin/active_model_serializers/serializer_discoverer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rigor/source/node_children"
+require "rigor/source/symbol_name"
 
 require "prism"
 
@@ -81,11 +82,16 @@ module Rigor
         # fixed point rather than recursing keeps a cyclic `class A < B; class B < A` source — which Ruby
         # rejects but a static parse can still be handed — from recursing forever.
         def close_over_roots(candidates)
-          by_name = candidates.to_h { |entry| [entry.class_name, entry] }
+          groups = candidates.group_by(&:class_name)
+          # Files that name different superclasses for one class are a TypeError in Ruby, so no ancestry
+          # reading of that class is correct. It is declined outright, and so is everything beneath it.
+          conflicted = groups.filter_map { |name, group| name if group.map(&:superclass_name).uniq.size > 1 }.to_set
+          by_name = groups.except(*conflicted).transform_values { |group| merge_reopened(group) }
           reached = @base_classes.to_set
           loop do
             grown = candidates.select do |entry|
-              !reached.include?(entry.class_name) && reached.include?(entry.superclass_name)
+              !conflicted.include?(entry.class_name) && !reached.include?(entry.class_name) &&
+                reached.include?(entry.superclass_name)
             end
             break if grown.empty?
 
@@ -94,6 +100,21 @@ module Rigor
           reached.filter_map { |name| by_name[name] }
         end
 
+        # A class declared in several files that each name its superclass is one class to Ruby, so its names
+        # are the union of every file's. Keeping only the last file's entry let a sibling that declared nothing
+        # usable shadow the valid one. The `own_method_names` union assumes every reopening file is loaded; a
+        # file Zeitwerk shadows is not modelled. A superclass-less reopening is not a candidate (see visit_class).
+        def merge_reopened(entries)
+          return entries.first if entries.size == 1
+
+          first = entries.first
+          first.with(
+            declared_names: entries.flat_map(&:declared_names).uniq.sort.freeze,
+            object_reads: entries.flat_map(&:object_reads).uniq.sort.freeze,
+            own_method_names: entries.flat_map(&:own_method_names).uniq.sort.freeze
+          )
+        end
+
         def read_safely(path)
           @io_boundary.read_file(path)
         rescue Plugin::AccessDeniedError, Errno::ENOENT
@@ -180,9 +201,14 @@ module Rigor
             receiver.arguments.nil?
         end
 
+        # A name whose bytes no Symbol can hold (`attributes :"\xff"` in a file that does not parse cleanly)
+        # is dropped here, so it never reaches the index or the `project_defines?` lookup that would raise.
+        # The file's other names are kept: a recoverable syntax error elsewhere in it does not void them.
         def symbol_arguments(node)
           (node.arguments&.arguments || []).filter_map do |argument|
-            argument.unescaped if argument.is_a?(Prism::SymbolNode)
+            next unless argument.is_a?(Prism::SymbolNode)
+
+            Rigor::Source::SymbolName.of(argument.unescaped)&.to_s
           end
         end
 

data/plugins/rigor-active-model-serializers/lib/rigor/plugin/active_model_serializers.rb

@@ -239,7 +239,11 @@ module Rigor
       def project_defines?(class_name, method_name, scope)
         return false unless scope.respond_to?(:user_def_through_ancestors)
 
-        !scope.user_def_through_ancestors(class_name, method_name.to_sym).first.nil?
+        # A name no Symbol can hold cannot be a method the project defines (#1831): decline, do not raise.
+        method = Rigor::Source::SymbolName.of(method_name.to_s)
+        return false if method.nil?
+
+        !scope.user_def_through_ancestors(class_name, method).first.nil?
       end
 
       # `REST::AccountSerializer` offers two readings — the namespaced `REST::Account` and the

data/plugins/rigor-dry-schema/lib/rigor/plugin/dry_schema.rb

@@ -168,10 +168,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb

@@ -142,10 +142,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/discoverer.rb

@@ -5,13 +5,20 @@ require "prism"
 module Rigor
   module Plugin
     class FFI < Base
+      # Issue #1803 — the walk lists and reads through the plugin's {Rigor::Plugin::IoBoundary} (`io:`), so every
+      # `.rb` the catalog was built from is a dependency row of the `:ffi_catalog` producer's cache entry and of
+      # every run-result cache built on the run. The producer declares no `watch:`, so before this its entry
+      # carried no row at all and was served after any edit, an analysed file's included, until `--no-cache`.
       class Discoverer
-        def self.discover(root:)
-          new(root: root).discover
+        RUBY_GLOB = "**/*.rb"
+
+        def self.discover(root:, io:)
+          new(root: root, io: io).discover
         end
 
-        def initialize(root:)
+        def initialize(root:, io:)
           @root = root
+          @io = io
         end
 
         def discover
@@ -24,7 +31,7 @@ module Rigor
           callbacks = {}
 
           ruby_files.each do |file_path|
-            parse_result = Prism.parse_file(file_path)
+            parse_result = parse(file_path)
             next unless parse_result.value
 
             walk_tree(parse_result.value, nil) do |node, mod_name|
@@ -61,9 +68,24 @@ module Rigor
         private
 
         def ruby_files
-          return [] unless @root && File.directory?(@root)
+          return [] unless @root && @io.directory?(@root.to_s)
+
+          boundary_glob.reject { |p| p.include?("/vendor/") || p.include?("/.git/") }
+        end
+
+        # One `:names` `**/*.rb` row over the root, `vendor/` included: a per-entry walk that skipped it recorded
+        # names only, so a top-level entry that changed kind under the same name went unseen. The boundary
+        # answers absolute paths; they are spelled back under `@root` as `Dir.glob` spells them, so the filter
+        # above sees the same strings it always did.
+        def boundary_glob
+          root = @root.to_s
+          prefix = "#{File.absolute_path(root)}/"
+          @io.glob(root, RUBY_GLOB).map { |path| File.join(root, path.delete_prefix(prefix)) }
+        end
 
-          Dir.glob(File.join(@root, "**", "*.rb")).reject { |p| p.include?("/vendor/") || p.include?("/.git/") }
+        # The glob's rows record which files match; this read's row carries an edit.
+        def parse(file_path)
+          Prism.parse(@io.read_file(file_path))
         end
 
         def walk_tree(node, current_module, &)

data/plugins/rigor-ffi/lib/rigor/plugin/ffi.rb

@@ -32,7 +32,7 @@ module Rigor
 
       producer :ffi_catalog do
         root = config["root"] || Dir.pwd
-        Discoverer.discover(root: root)
+        Discoverer.discover(root: root, io: io_boundary)
       end
 
       # Dynamic return rule for attached FFI functions

data/plugins/rigor-graphql/lib/rigor/plugin/graphql.rb

@@ -151,10 +151,14 @@ module Rigor
 
       # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
       # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
+      # #1803 — so is the walk: `IoBoundary#glob` records which `.rb` files the entry holds, and a file
+      # `exclude:` keeps out of analysis, which no analysed-file row covers, reaches the run-result caches
+      # when it appears or disappears. The matches are spelled under `entry`, as `Dir.glob` spelled them.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            prefix = "#{File.absolute_path(entry)}/"
+            io_boundary.glob(entry, "**/*.rb").map { |path| File.join(entry, path.delete_prefix(prefix)) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else