rigortype 0.4.4 → 0.4.5

data/lib/rigor/analysis/incremental_run_slot/write_guard.rb

@@ -7,6 +7,7 @@ require_relative "../incremental_run_slot"
 require_relative "../dependency_source_inference/gem_resolver"
 require_relative "../../cache/file_digest"
 require_relative "../../cache/incremental_snapshot"
+require_relative "../../rooted_glob"
 
 module Rigor
   module Analysis
@@ -66,8 +67,8 @@ module Rigor
         # opted-in gems' resolved versions, the key's one input that is neither a file nor the configuration (issue
         # #1814), are read at the mark and watched the same way.
         #
-        # The mark also records which of the paths an existence row can name are present: the lockfiles, the
-        # analysis roots, the `pre_eval:` entries and the signature roots.
+        # The mark also records what each path a presence row can name is ({Cache::Descriptor::FileEntry.kind_of}):
+        # the lockfiles, the analysis roots, the `pre_eval:` entries and the signature roots.
         def self.start(configuration:, roots:, cache_root:, fingerprint:)
           return nil if Gem.win_platform?
 
@@ -79,7 +80,7 @@ module Rigor
           lockfiles = lockfile_paths(configuration)
           named = Array(roots) + configuration.pre_eval + (configuration.signature_paths || ["sig"])
           presence = (lockfiles + named.map { |path| File.absolute_path(path.to_s) }).to_h do |path|
-            [path, File.exist?(path)]
+            [path, Cache::Descriptor::FileEntry.kind_of(path)]
           end
           rows = dependency_rows(configuration)
           return nil if rows.nil?
@@ -174,11 +175,12 @@ module Rigor
         # - no lockfile the key or the fingerprint digests was written, created or removed, and no opted-in gem
         #   resolves to another version than at the mark (issue #1814);
         # - no file `rows` or `pinned` names changed. A content row's file changed if its change time moved. An
-        #   existence row asks only whether its path is there, so a path the mark recorded changed if it came or
-        #   went, and an editor's lock file created and removed beside it, which moves its directory's change
-        #   time, does not count. That needs no clock, so it holds on any filesystem; it cannot see a path that
-        #   comes and goes again within the run. Any other existence row falls back to change times: its own when
-        #   present, its nearest existing ancestor's when absent;
+        #   existence row asks only whether its path is there, and a `:kind` row what it is (#1977), so a path the
+        #   mark recorded changed if it came or went, or for a kind row turned from a directory into a file or back;
+        #   an editor's lock file created and removed beside it, which moves its directory's change time, does not
+        #   count. That needs no clock, so it holds on any filesystem; it cannot see a path that comes and goes
+        #   again within the run. Any other presence row falls back to change times: its own when present, its
+        #   nearest existing ancestor's when absent;
         # - no directory a glob row lists gained or lost an entry, nor, for a stat-mode glob, did any file it
         #   matches change.
         #
@@ -231,15 +233,20 @@ module Rigor
           ns.nil? || device != @device || ns < @started_ns
         end
 
-        # An existence row and a content row for one path are different questions (the first asks only whether it
-        # is there, the second whether it changed), so the row that comes first must not hide the other.
+        # A presence row and a content row for one path are different questions (the first asks only whether it
+        # is there, or what it is, the second whether it changed), so the row that comes first must not hide the
+        # other; nor may an existence row hide a kind row.
+        PRESENCE_COMPARATORS = %i[exists kind].freeze
+        private_constant :PRESENCE_COMPARATORS
+
         def files_unchanged?(entries, strict:)
           seen = Set.new
           entries.none? do |entry|
-            next false unless seen.add?([entry.path, entry.comparator == :exists])
+            presence = PRESENCE_COMPARATORS.include?(entry.comparator) ? entry.comparator : nil
+            next false unless seen.add?([entry.path, presence])
 
-            if entry.comparator == :exists
-              existence_changed?(entry.path, strict: strict)
+            if presence
+              presence_changed?(entry.path, presence, strict: strict)
             else
               changed?(entry.path, strict: strict)
             end
@@ -248,8 +255,8 @@ module Rigor
 
         def globs_unchanged?(entries, strict:)
           entries.none? do |entry|
-            listed = Dir.glob(File.join(entry.root, File.dirname(entry.pattern), ""))
-            matched = entry.mode == :stat ? Dir.glob(File.join(entry.root, entry.pattern)) : []
+            listed = RootedGlob.glob(entry.root, File.join(File.dirname(entry.pattern), ""))
+            matched = entry.mode == :stat ? RootedGlob.glob(entry.root, entry.pattern) : []
             (listed + matched).any? { |path| changed?(path, strict: strict) }
           end
         end
@@ -257,14 +264,25 @@ module Rigor
         # A lockfile is read for its bytes: one absent at the mark must still be absent, one present must still be
         # there with its change time before the mark.
         def lockfile_changed?(path)
-          return File.exist?(path) unless @presence[path]
+          return File.exist?(path) unless present_at_mark?(path)
 
           changed?(path, strict: true, missing: true)
         end
 
-        def existence_changed?(path, strict:)
+        def present_at_mark?(path)
+          kind = @presence[path]
+          !kind.nil? && kind != Cache::Descriptor::FileEntry::KIND_ABSENT
+        end
+
+        # `comparator` is `:exists` or `:kind`: whether the path came or went, or whether it is no longer the kind
+        # of thing the mark recorded.
+        def presence_changed?(path, comparator, strict:)
           absolute = File.absolute_path(path)
-          return File.exist?(absolute) != @presence[absolute] if @presence.key?(absolute)
+          if @presence.key?(absolute)
+            return File.exist?(absolute) != present_at_mark?(absolute) if comparator == :exists
+
+            return Cache::Descriptor::FileEntry.kind_of(absolute) != @presence[absolute]
+          end
 
           nearest = absolute
           nearest = File.dirname(nearest) until File.exist?(nearest) || File.dirname(nearest) == nearest

data/lib/rigor/analysis/incremental_session.rb

@@ -40,15 +40,19 @@ module Rigor
       # unconditional snapshot rewrite.
       # `rebaselined` (#1898) is true when the recheck found its served effect collections stale and answered with a
       # full baseline instead; see {#rebaseline_recheck}.
-      Recheck = Data.define(:diagnostics, :changed, :added, :removed, :affected, :reused, :templates, :rebaselined) do
-        def initialize(rebaselined: false, **rest)
+      # `stale_readers` (#1553) are the files the recheck re-analysed because a plugin read one of them made went
+      # stale ({#plugin_read_affected}).
+      Recheck = Data.define(:diagnostics, :changed, :added, :removed, :affected, :reused, :templates, :rebaselined,
+                            :stale_readers) do
+        def initialize(rebaselined: false, stale_readers: Set.new, **rest)
           super
         end
 
-        # A recheck that changed, added, and removed nothing — the session state is byte-equivalent to the
-        # snapshot that was restored, so persisting it again would only rewrite identical bytes.
+        # A recheck that changed, added, and removed nothing, and found no stale plugin read — the session state is
+        # byte-equivalent to the snapshot that was restored, so persisting it again would only rewrite identical
+        # bytes. A stale reader's refreshed rows differ (#1553): unsaved, every later run would re-analyse it.
         def no_change?
-          changed.empty? && added.empty? && removed.empty?
+          changed.empty? && added.empty? && removed.empty? && stale_readers.empty?
         end
       end
 
@@ -99,6 +103,9 @@ module Rigor
         @cache = {}              # analyzed path => [Diagnostic]
         @sources = {}            # analyzed path => Set<source path it read from>
         @digests = {}            # analyzed path => ADR-87 packed stat-digest entry at last analysis
+        # Issue #1583 — discovered-not-analysed path => the same packed entry, for a run over path arguments that
+        # #684 widened to the configured `paths:`. Empty on every run over the configured paths.
+        @discovery_digests = {}
         @analyzed = []           # the project files analyzed last round
         @dependents = {}         # inverted @sources (file-level)
         # ADR-46 slice 4 — symbol-granularity tracking.
@@ -128,6 +135,10 @@ module Rigor
         # and a missing invalidation edge is impossible by construction — the reason this is a table diff
         # and not the caller→callee edge recording #204 first sketched.
         @param_table = {}
+        # Issue #1553 — analysed path => the plugin reads ({Plugin::IoBoundary.attributing}) its last analysis made:
+        # the frozen `Cache::Descriptor::FileEntry` / `GlobEntry` rows, as each read observed its input. A recheck
+        # re-analyses every file one of whose rows no longer validates ({#plugin_read_affected}).
+        @plugin_reads = {}
         reset_carried_state
         # ADR-88 WD1 — the plugin fact-surface digest computed for THIS invocation (nil until a
         # `#run_incremental` pass runs / a plugin-free project) and the reporting flags a caller (the CLI
@@ -151,6 +162,49 @@ module Rigor
         current_files
       end
 
+      # Issue #1583 (and #1560) — whether a file the run discovers but does not analyse was edited, added or
+      # removed since the snapshot. Such a file feeds the cross-file index the analysed files resolve against
+      # (a constant, a method, an ancestor), but no recorded edge or digest of the analysed set sees it move.
+      # A move re-baselines the session: discovery-only files are not tracked per symbol, so the closure
+      # cannot be narrowed, and the full analysis is over the argument set alone. A session over the
+      # configured `paths:` discovers nothing beyond what it analyses and pays nothing here.
+      def discovery_moved?
+        current = current_discovery_only_files
+        return true unless current.size == @discovery_digests.size
+
+        current.any? do |path|
+          entry = @discovery_digests[path]
+          entry.nil? || !Cache::FileDigest.stat_fresh?(path, entry)
+        end
+      rescue StandardError
+        true
+      end
+
+      # A baseline's freshness entries: each analysed file's, and (issue #1583) each discovered-not-analysed file's.
+      def record_baseline_digests
+        @digests = @analyzed.to_h { |path| [path, pack_digest(path)] }
+        @discovery_digests = current_discovery_only_files.to_h { |path| [path, pack_digest(path)] }
+        forget_unbound_digests
+      end
+
+      def restore_digests(payload)
+        @digests = payload.digests
+        @discovery_digests = payload.discovery_digests # Issue #1583 — `{}` in a payload built without it.
+      end
+
+      # Issue #1583 — the discovered-not-analysed files of a run over this session's paths
+      # ({Runner#discovery_only_file_set}). Asked of a runner WITHOUT the editor buffer: a buffered run does not
+      # widen, so a buffered session (editor mode option B, #146) would read an empty set against the snapshot's
+      # and re-baseline on every keystroke. Globbing without it keeps the comparison the one the snapshot's
+      # writer made, so a sibling edit still declines option B and an unchanged project still serves it.
+      def current_discovery_only_files
+        return [] if @paths.nil?
+
+        Runner.new(configuration: @configuration, cache_store: nil, environment: @environment)
+              .discovery_only_file_set(@paths)
+      end
+      private :discovery_moved?, :record_baseline_digests, :restore_digests, :current_discovery_only_files
+
       # The per-file discovery bundles of the last run, keyed by path (ADR-85 WD2).
       attr_reader :seed_bundles
 
@@ -216,8 +270,8 @@ module Rigor
         @effects_identity = current_effects_identity
         @effect_plugin_digest = effect_plugin_digest_of(runner)
         @cache = per_file(runner.per_file_diagnostics)
-        @digests = @analyzed.to_h { |path| [path, pack_digest(path)] }
-        forget_unbound_digests
+        @plugin_reads = plugin_reads_of(runner, @analyzed)
+        record_baseline_digests
         @run_level_rows = runner.run_level_rows
         diagnostics
       end
@@ -231,6 +285,8 @@ module Rigor
         added = current - previous
         removed = previous - current
         changed = changed_paths(current & previous)
+        return rebaseline_recheck(changed, added, removed) if discovery_moved?
+
         # ADR-67 WD6c lift — recompute the whole-project inferred-param table BEFORE deciding the closure,
         # and diff it against the snapshot's copy: an entry that moved (because a caller's argument type
         # changed, a caller appeared, or one vanished) invalidates the CALLEE's file and its symbol
@@ -251,7 +307,8 @@ module Rigor
 
         absorb(runner, current, analyze_set, removed)
         @param_table = fresh_params
-        recheck_result(merged, [changed, added, removed], affected: affected, reused: reused.to_set, runner: runner)
+        recheck_result(merged, [changed, added, removed], affected: affected, reused: reused.to_set, runner: runner,
+                                                          stale_readers: @stale_plugin_readers)
       end
 
       # Editor mode option B (#146) — a whole-project recheck with the editor's buffer substituted for one
@@ -304,9 +361,10 @@ module Rigor
       # records none at all), so no dependent set can bound who read it. An edit that moved it re-analyses the
       # whole project — what a `sig/` edit already costs through the snapshot fingerprint.
       def affected_closure(changed, added, removed, param_files = Set.new, param_pairs = Set.new)
+        @stale_plugin_readers = plugin_read_affected
         return whole_project_closure(changed, added) if source_rbs_gate.moved?(@seed_bundles, changed, added, removed)
 
-        gated_closure(changed, added, removed, param_files, param_pairs)
+        (gated_closure(changed, added, removed, param_files, param_pairs) | @stale_plugin_readers).freeze
       end
 
       # {#affected_closure} for an edit whose synthesized RBS is byte-identical in every file it touched.
@@ -350,17 +408,47 @@ module Rigor
         closure.freeze
       end
 
+      # Issue #1553 — every analysed file whose last analysis made a plugin read that no longer validates: a file
+      # read through {Plugin::IoBoundary#read_file} or probed through `#file?` / `#directory?` was edited,
+      # removed, or created after a read that found it absent, or a `#list_directory` / `#glob` listing moved.
+      # The ADR-46 edges record type and declaration reads only, so none of these moves a reader into the
+      # closure, and its cached rows were computed from the input as it was. The reader's own text is unchanged,
+      # so it joins the closure alone: a plugin read made while analysing a dependent is credited to that
+      # dependent. Each distinct row is validated once however many files made it (one `File.stat` for a
+      # content row whose stat tuple did not move, one re-glob for a listing row).
+      def plugin_read_affected
+        verdicts = {}
+        @plugin_reads.each_with_object(Set.new) do |(path, rows), stale|
+          next unless rows.any? { |row| !verdicts.fetch(row) { verdicts[row] = plugin_read_fresh?(row) } }
+
+          stale << path
+        end
+      end
+
+      def plugin_read_fresh?(row)
+        if row.is_a?(Cache::Descriptor::GlobEntry)
+          Cache::Descriptor::GlobEntry.fresh?(row)
+        else
+          Cache::Descriptor.new(files: [row]).fresh?
+        end
+      end
+
+      # Issue #1553 — `runner`'s per-file plugin reads for `paths`, each file's rows de-duplicated and frozen.
+      def plugin_reads_of(runner, paths)
+        runner.analysis_reads.slice(*paths).transform_values { |rows| rows.uniq.freeze }
+      end
+
       # Issue #1906 — a file that rewrites a constant's singleton names without declaring it
-      # (`D.singleton_class.alias_method :own, :keep`) contributes opaque singleton envelopes to the constant's bucket,
-      # but a reader's class edge names only the files that declared the constant when the reader last ran, and the
-      # class-declaration diff does not move while the constant stays in the file (`:own` becoming `:keep`, or the
-      # call becoming a `class D` reopening). So a declaration-unstable edit to such a file fires `class:<last
-      # segment>` for each constant that, before the edit, both sat in the file's singleton-source set and held a
-      # singleton envelope entry or an unpositioned singleton side the file recorded (a computed name there leaves the
-      # side unpositioned, and becoming literal reads it again). A file that only includes into a constant
-      # (`ActiveRecord::Base.include(X)`) records neither and fires nothing. A constant the edit makes the file
-      # rewrite needs no key: the class-declaration diff fires if it is new to the file, and the reader's class edge
-      # names the file if the file declared it.
+      # (`D.singleton_class.alias_method :own, :keep`, or, since #1941, `def D.own`) contributes opaque singleton
+      # envelopes to the constant's bucket, but a reader's class edge names only the files that declared the constant
+      # when the reader last ran, and the class-declaration diff does not move while the constant stays in the file
+      # (`:own` becoming `:keep`, or the call becoming a `class D` reopening). So a declaration-unstable edit to such a
+      # file fires `class:<last segment>` for each constant that, before the edit, both sat in the file's
+      # singleton-source set and held a singleton envelope entry or an unpositioned singleton side the file recorded (a
+      # computed name there leaves the side unpositioned, and becoming literal reads it again). A file that only
+      # includes into a constant (`ActiveRecord::Base.include(X)`) records neither and fires nothing. A constant the
+      # edit makes the file rewrite needs no key: the class-declaration diff fires if it is new to the file, and the
+      # reader's class edge names the file if the file declared it.
       def singleton_rewrite_affected(unstable)
         names = unstable.flat_map { |path| singleton_rewritten_constants(@seed_bundles[path]) }.uniq
         return Set.new if names.empty?
@@ -669,7 +757,7 @@ module Rigor
       # the gate could not see. {#run_incremental} re-analyses the project and {#run_buffer_recheck} declines,
       # the way each treats a moved plugin fact surface. A run that changed nothing is exempt: under an
       # untrusted gate every earlier edit already re-analysed the whole project, so the snapshot it serves is
-      # whole, and a null run stays one.
+      # whole, and a null run stays one. A recheck that found a stale plugin read (#1553) is a change.
       def source_rbs_unverified?(result)
         source_rbs_gate.untrusted? && !result.no_change? && !result.reused.empty?
       end
@@ -889,7 +977,7 @@ module Rigor
         @analyzed = payload.analyzed
         @cache = payload.cache
         @sources = payload.sources
-        @digests = payload.digests
+        restore_digests(payload)
         # ADR-85 WD2 — restore the per-file discovery bundles if present (absent in a pre-#85 snapshot → empty,
         # so the recheck's discovery re-walks every file: a cold-quality index, always sound). The SCHEMA bump
         # makes a genuinely stale-shaped bundle unreadable rather than mis-folded.
@@ -903,6 +991,7 @@ module Rigor
         restore_structural_declarations(payload)
         @return_summaries  = payload.return_summaries || {}
         @param_table       = payload.param_table || {} # ADR-67 WD6c lift — the seeds the cache was built under.
+        @plugin_reads      = payload.plugin_reads # Issue #1553 — `{}` in a payload built without it.
         # Issues #796 / #794 — absent (nil) in a snapshot written before schema 22 is impossible (the SCHEMA
         # gate rejects one), so nil here means the writing run genuinely had nothing to say.
         @run_level_rows    = payload.run_level_rows
@@ -942,7 +1031,9 @@ module Rigor
           effect_collections: marshal_safe_effect_collections,
           effects_identity: @effects_identity,
           run_level_rows: @run_level_rows,
-          effect_plugin_digest: @effect_plugin_digest
+          effect_plugin_digest: @effect_plugin_digest,
+          plugin_reads: @plugin_reads,
+          discovery_digests: @discovery_digests
         )
       end
 
@@ -1054,9 +1145,12 @@ module Rigor
         whole_project = current.all? { |path| analyze_set.include?(path) }
         @seed_bundles = source_rbs_gate.stamp(runner.seed_bundles, whole_project: whole_project)
         fresh_by_file = per_file(runner.per_file_diagnostics)
+        # Issue #1553 — a re-analysed file's reads are this run's: a read it no longer makes stops guarding it.
+        fresh_reads = plugin_reads_of(runner, analyze_set)
         analyze_set.each do |path|
           @cache[path] = fresh_by_file[path] || []
           @digests[path] = pack_digest(path)
+          fresh_reads.key?(path) ? @plugin_reads[path] = fresh_reads[path] : @plugin_reads.delete(path)
         end
         forget_unbound_digests
         absorb_dependency_graph(runner)
@@ -1105,6 +1199,7 @@ module Rigor
         @cache.delete(path)
         @digests.delete(path)
         @sources.delete(path)
+        @plugin_reads.delete(path)
         @symbol_sources.delete(path)
         @ancestry_sources.delete(path)
         @missing.delete(path)
@@ -1194,7 +1289,53 @@ module Rigor
         keys.concat(class_move_keys(moved_classes))
         keys.concat(moved_constants.map { |name| "constant:#{name.split('::').last}" })
         Incremental.negative_closure(keys, @negative_dependents) | refinement_affected(changed + removed, summary) |
-          defined_name_affected(changed + removed, summary) | global_write_reporters
+          defined_name_affected(changed + removed, summary) | mark_affected(changed + removed, summary) |
+          global_write_reporters
+      end
+
+      # Issue #1833 — the consumers whose answer read a class mark that moved in this edit. A reader of a class's
+      # envelope bucket records `mark:<last segment>` (`Scope#parameter_envelopes_of`), whichever way it answered, so
+      # a file that adds or drops only a mark (`x.singleton_class.prepend(Comparable)`, `o.extend(Helper)` in a
+      # method body, a `refine` block's refined mark) re-checks it although the file declares nothing it read. A
+      # reader that scans every bucket for an object-extended module (`SourceArity#object_extension_may_shadow?`)
+      # records `mark:*`, which fires when an object-extended mark moves. The before-state is each touched file's
+      # seed bundle, the after-state the scan's merged table.
+      #
+      # Issue #1661 — and `mixin:<qualified name>` for a class or module whose unpositioned mixin edges moved
+      # ({Incremental.changed_unpositioned_owners}): an external chain entry records it for each name it can denote
+      # (`ResolutionChain#record_hooks`), so a new file that taints `Comparable` with `include(*MODS)` re-checks the
+      # readers of a chain through it. It is not `mark:`, which a plain reopening of a module moves (the bucket's
+      # module mark) and which would re-check every reader of `Kernel` on any `module Kernel` reopening.
+      def mark_affected(paths, summary)
+        def_index = summary && summary[:def_index]
+        before = paths.map { |path| @seed_bundles.dig(path, :parameter_envelopes) }
+        moved = Incremental.changed_class_marks(before, [def_index && def_index[:parameter_envelopes]])
+        tainted = Incremental.changed_unpositioned_owners(
+          paths.map { |path| @seed_bundles.dig(path, :unpositioned_mixins) },
+          [def_index && def_index[:unpositioned_mixins]]
+        )
+        return Set.new if moved.empty? && tainted.empty?
+
+        keys = moved.map { |(class_name, _mark)| "mark:#{class_name.split('::').last}" }.uniq
+        keys.concat(mixin_keys(tainted))
+        extended = Scope::DiscoveryIndex::ENVELOPE_OBJECT_EXTENDED_MARK
+        keys << "mark:*" if moved.any? { |(_class_name, mark)| mark == extended }
+        Incremental.negative_closure(keys, @negative_dependents)
+      end
+
+      # Issue #1661 — the `mixin:` keys an owner of a moved unpositioned edge fires. The table keys a receiver-form
+      # owner by the spelling written (`class File; Constants.include(*MODS); end` is `"Constants"`), not the constant
+      # Ruby resolves it to, while the chain files the qualified candidate (`mixin:File::Constants`). The table does
+      # not carry the nesting, and every lexical-prefix candidate of the owner ends in `::<owner>`, so the owner fires
+      # its own key and every recorded `mixin:` key ending in `::<owner>`. A relative spelling over-fires to the
+      # readers of every module sharing its trailing segments; a qualified one fires only its suffix matches.
+      def mixin_keys(owners)
+        keys = owners.map { |name| "mixin:#{name}" }
+        suffixes = owners.map { |name| "::#{name}" }
+        @negative_dependents.each_key do |key|
+          keys << key if key.start_with?("mixin:") && suffixes.any? { |suffix| key.end_with?(suffix) }
+        end
+        keys.uniq
       end
 
       # The negative keys a class-declaration diff fires: `class:<last segment>` for a class name, and (issue #1820)
@@ -1429,9 +1570,10 @@ module Rigor
       end
 
       # A {Recheck} over `deltas` (`[changed, added, removed]`), counting `runner`'s template units.
-      def recheck_result(diagnostics, deltas, affected:, reused:, runner:, rebaselined: false)
+      def recheck_result(diagnostics, deltas, affected:, reused:, runner:, rebaselined: false, stale_readers: Set.new)
         changed, added, removed = deltas.map(&:to_set)
         Recheck.new(diagnostics: diagnostics, changed: changed, added: added, removed: removed, affected: affected,
+                    stale_readers: stale_readers,
                     reused: reused, templates: runner.template_unit_paths.size, rebaselined: rebaselined)
       end
 

data/lib/rigor/analysis/path_expansion.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../rooted_glob"
+
 module Rigor
   module Analysis
     # ADR-87 WD4 — project file-set expansion shared by the {Analysis::Runner} (miss path) and the
@@ -27,7 +29,7 @@ module Rigor
       end
 
       def directory_files(dir, exclude_patterns, base: Dir.pwd)
-        reject_excluded(Dir.glob(File.join(dir, RUBY_GLOB)), exclude_patterns, base: base)
+        reject_excluded(RootedGlob.glob(dir, RUBY_GLOB), exclude_patterns, base: base)
       end
 
       # `exclude_patterns` are matched with `File.fnmatch?` WITHOUT `FNM_PATHNAME`, so `**`/`*` span separators

data/lib/rigor/analysis/reachability/graph.rb

@@ -28,7 +28,10 @@ module Rigor
             next [] if use.name.nil?
 
             name = use.name.delete_prefix("::")
-            targets = use.within ? literal_targets(use, name) : [nil]
+            targets = if use.anywhere then anywhere_targets(name)
+                      elsif use.within then literal_targets(use, name)
+                      else [nil]
+                      end
             targets.map do |target|
               Scan::Reference.new(as_written: target || name, nesting: [].freeze, from: nil,
                                   role: use.role, path: use.path, line: use.line,
@@ -54,29 +57,101 @@ module Rigor
           own = declared_member(receiver, name, local)
           return [own, *runtime].uniq if own
           return runtime unless use.inherit
+          return (anywhere_targets(name) + runtime).uniq if unknown_ancestry?(receiver)
 
           (plausible_ancestors(receiver).filter_map { |scope| declared_member(scope, name, local) } + runtime)
             .uniq + [nil]
         end
 
+        # Every declaration a literal `name` can name from a receiver the walk cannot bound (#1946): each one a
+        # scope's `name` (or a declared prefix of it) could be, and the top level.
+        def anywhere_targets(name)
+          segments = name.split("::")
+          found = segments.length.downto(1).flat_map do |count|
+            suffix = segments.first(count).join("::")
+            by_last_segment.fetch(segments[count - 1], []).select do |fqn|
+              fqn == suffix || fqn.end_with?("::#{suffix}")
+            end
+          end
+          found.uniq + [nil]
+        end
+
+        def by_last_segment
+          @by_last_segment ||= @by_fqn.keys.group_by { |fqn| fqn.split("::").last }
+        end
+
         # The declarations a descendant of `receiver` holding `name` adds (#1878): a `self` standing for the
         # enclosing declaration is whichever subclass, includer, prepender or extender the method runs on, and
         # Ruby looks the name up there first. Each descendant is searched with its own ancestors unless the call
         # passes `inherit = false`. The descendants are over-approximated as {#plausible_ancestors} is.
+        #
+        # A module some unknown receiver includes or extends (`k.include(Mix)`, an `include` in an `included do`
+        # block) has descendants the walk cannot list, so the name may be any declaration's (#1946). A class
+        # with an ancestor the walk cannot name (`K.include(mods.first)`) may be a descendant of any module, so
+        # it is searched too.
         def runtime_targets(receiver, name, inherit, local)
-          descendants_of(receiver).flat_map do |descendant|
+          return anywhere_targets(name) if open_descendants?(receiver)
+
+          (descendants_of(receiver) | unknown_ancestry_classes).flat_map do |descendant|
             scopes = inherit ? [descendant, *plausible_ancestors(descendant)] : [descendant]
             scopes.filter_map { |scope| declared_member(scope, name, local) }
           end.uniq
         end
 
         def descendants_of(fqn)
-          @plausible_descendants ||= @by_fqn.keys.each_with_object(Hash.new { |h, k| h[k] = [] }) do |declared, out|
+          @plausible_descendants ||= (@by_fqn.keys | ancestry.edges.keys)
+                                     .each_with_object(Hash.new { |h, k| h[k] = [] }) do |declared, out|
             plausible_ancestors(declared).each { |ancestor| out[ancestor] << declared }
           end
           @plausible_descendants.fetch(fqn, [])
         end
 
+        def open_descendants?(fqn)
+          ancestry.open.include?(fqn) || ancestry.open.any? { |mod| plausible_ancestors(mod).include?(fqn) }
+        end
+
+        # Whether `fqn` or one of its ancestors has an ancestor the walk cannot name, which may declare anything.
+        def unknown_ancestry?(fqn)
+          ([fqn] + plausible_ancestors(fqn)).any? { |scope| ancestry.unknown.include?(scope) }
+        end
+
+        def unknown_ancestry_classes
+          @unknown_ancestry_classes ||= ancestry.unknown.flat_map { |fqn| [fqn, *descendants_of(fqn)] }.uniq
+        end
+
+        # The {Scan::Ancestry} edges read (#1946): `edges` maps a class to the modules and superclass it gains
+        # outside its declaration; `open` holds the modules an unknown receiver gains, and `unknown` the classes
+        # that gain an ancestor the walk cannot name. A target is every scope its written name could be, declared
+        # or not (a gem class reopened as `class Foo::X` declares `Foo::X` alone); an ancestor, every scope that
+        # declares it.
+        AncestryIndex = Data.define(:edges, :open, :unknown)
+        private_constant :AncestryIndex
+
+        def ancestry
+          @ancestry ||= begin
+            edges = Hash.new { |h, k| h[k] = [] }
+            open = Set.new
+            unknown = Set.new
+            @ancestries.each do |edge|
+              targets = edge.target && written_scopes(edge.target)
+              ancestors = edge.ancestor && written_scopes(edge.ancestor).select { |fqn| @by_fqn.key?(fqn) }
+              if targets.nil? then open.merge(ancestors)
+              elsif ancestors.nil? then unknown.merge(targets)
+              else targets.each { |target| edges[target].concat(ancestors - [target]) }
+              end
+            end
+            AncestryIndex.new(edges: edges, open: open, unknown: unknown)
+          end
+        end
+
+        # Every scope a written reference could name: rooted, itself; otherwise its name under each enclosing scope.
+        def written_scopes(ref)
+          name = ref.as_written.delete_prefix("::")
+          return [name] if ref.rooted
+
+          ref.nesting.length.downto(0).map { |i| (ref.nesting.first(i) + [name]).join("::") }
+        end
+
         # `scope::name`, or the longest declared prefix of it, when one is declared.
         def declared_member(scope, name, local)
           segments = name.split("::")
@@ -99,16 +174,15 @@ module Rigor
           out = []
           until queue.empty?
             current = queue.shift
-            @by_fqn.fetch(current, []).each do |decl|
-              (decl.includes + [decl.superclass]).compact.each do |raw|
-                plausible_resolutions(current, raw).each do |resolved|
-                  next if seen.include?(resolved)
+            resolved = @by_fqn.fetch(current, []).flat_map do |decl|
+              (decl.includes + [decl.superclass]).compact.flat_map { |raw| plausible_resolutions(current, raw) }
+            end
+            (resolved + ancestry.edges.fetch(current, [])).each do |ancestor|
+              next if seen.include?(ancestor)
 
-                  seen << resolved
-                  out << resolved
-                  queue << resolved
-                end
-              end
+              seen << ancestor
+              out << ancestor
+              queue << ancestor
             end
           end
           out.freeze
@@ -174,9 +248,12 @@ module Rigor
         #   A literal-argument site contributes a real reference; a dynamic one taints a namespace (WD4).
         # @param shadows — declarations made in files outside the analysed paths. They are never nodes, but a
         #   reference written in the SAME file resolves to them first, as Ruby would (#1732, see {#resolve_ref}).
-        def initialize(declarations:, references:, root_fqns: [], dynamic_uses: [], shadows: [],
+        # @param ancestries — {Scan::Ancestry} edges written outside a declaration, read only by the dynamic
+        #   lookup (#1946).
+        def initialize(declarations:, references:, root_fqns: [], dynamic_uses: [], shadows: [], ancestries: [],
                        foreign: ->(_fqn) { false })
           @declarations = declarations
+          @ancestries = ancestries
           @root_fqns = root_fqns.to_set
           @foreign = foreign
           @by_fqn = declarations.group_by(&:fqn)