rigortype 0.4.2 → 0.4.4

data/lib/rigor/analysis/incremental_session.rb

@@ -38,7 +38,13 @@ module Rigor
       # gate) can report what was re-analyzed versus served from cache. `added` / `removed` carry the
       # structural delta so {#run_incremental} (ADR-87 WD3) can recognise a zero-change recheck and skip the
       # unconditional snapshot rewrite.
-      Recheck = Data.define(:diagnostics, :changed, :added, :removed, :affected, :reused) do
+      # `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)
+          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.
         def no_change?
@@ -68,9 +74,14 @@ module Rigor
       #   `--verify-incremental` gate use) keeps the sequential recording path bit-for-bit unchanged. The fork
       #   pool records each worker's cross-file reads and marshals them back (PoolCoordinator), so the
       #   dependency graph a pooled recheck rebuilds equals the sequential one.
-      def initialize(configuration:, paths: nil, environment: nil, cache_store: nil, plugin_requirer: nil,
-                     workers: 0, buffer: nil)
+      def initialize(configuration:, paths: nil, environment: nil, cache_store: nil, plugin_requirer: nil, # rubocop:disable Metrics/ParameterLists,Metrics/AbcSize,Metrics/MethodLength
+                     workers: 0, buffer: nil, explain: false, on_file_indexed: nil)
         @configuration = configuration
+        # ADR-113 WD2 — `rigor lens`: {#force_targets=} names files a {#recheck} analyses whether or not they changed,
+        # in this process, so `on_file_indexed` (see {Runner}) sees their seeded index. Neither moves a diagnostic:
+        # a forced file re-analyses under the same seeds its cached rows were computed with.
+        @force_targets = Set.new
+        @on_file_indexed = on_file_indexed
         @paths = paths
         # Editor mode option B (#146) — the in-flight buffer, threaded into every internal Runner so the
         # pre-passes and the closure re-analysis read the editor's bytes at the logical path. A session
@@ -81,6 +92,7 @@ module Rigor
         @cache_store = cache_store
         @plugin_requirer = plugin_requirer
         @workers = workers
+        @explain = explain # #1533: threaded into every Runner; keys the snapshot, and no slot is written
         # ADR-85 WD2 — per-file discovery seed bundles keyed by logical path. A cold baseline builds them; a
         # warm recheck folds them (re-walking only changed files) and refreshes the set. Ride the snapshot.
         @seed_bundles = {}
@@ -122,12 +134,31 @@ module Rigor
         # banner + `--cache-stats`) reads after `#run_incremental`. `@last_runner` is the analysis runner the
         # post-hoc fingerprint reads from; `@plugin_fact_reusable` is the computed decision object.
         @plugin_fact_digest = nil
-        @opaque_plugin_ids = [].freeze
+        @opaque_reasons = {}.freeze
+        @fact_store_unreadable = false
         @fact_surface_invalidated = false
         @last_runner = nil
         @plugin_fact_reusable = nil
       end
 
+      # ADR-113 WD2 — the paths (as {#project_files} spells them) every later {#recheck} analyses in this process.
+      def force_targets=(paths)
+        @force_targets = paths.to_set
+      end
+
+      # The project files a run of this session analyses, as the runner expands the configured paths.
+      def project_files
+        current_files
+      end
+
+      # The per-file discovery bundles of the last run, keyed by path (ADR-85 WD2).
+      attr_reader :seed_bundles
+
+      # The project files `path`'s analysis read from at the last run that analysed it (ADR-46 slice 1).
+      def dependency_sources(path)
+        @sources.fetch(path, Set.new)
+      end
+
       # The project files analyzed at the last baseline / recheck — the set a verify pass partitions and the
       # merge subtracts the affected closure from.
       def analyzed_files
@@ -183,6 +214,7 @@ module Rigor
         # ADR-103 WD13 / #382 — a baseline collects every file, so its collections are the whole world.
         @effect_collections = runner.effect_collections_by_path
         @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
@@ -206,21 +238,20 @@ module Rigor
         fresh_params = fresh_param_table(current, changed, added, removed)
         param_files, param_pairs = param_seed_invalidation(fresh_params)
         affected = affected_closure(changed, added, removed, param_files, param_pairs)
-        analyze_set = affected & current
-        reused = (current & previous) - affected.to_a
+        forced, analyze_set = forced_analyze_set(affected, current)
+        reused = (current & previous) - analyze_set.to_a
         # The freshly collected table is handed to the runner so the run seeds from the SAME table the diff
         # was decided on (and the collector runs once per recheck, not twice). The reused files' cached rows
         # go in too, so the runner lists them in the full run's file order (#1524).
         runner = build_runner(analyze_only: analyze_set, record_dependencies: true,
-                              param_inferred_types: fresh_params,
-                              restored_run_level_rows: @run_level_rows,
-                              served_per_file_diagnostics: @cache.slice(*reused))
+                              param_inferred_types: fresh_params, **forced_target_options(forced),
+                              restored_run_level_rows: @run_level_rows, **served_state(reused))
         merged = run_runner(runner).diagnostics
-        @last_runner = runner # ADR-88 WD1 — the post-hoc fact-surface fingerprint reads this prepared registry.
+        return rebaseline_recheck(changed, added, removed) if served_effects_stale?(runner, reused)
+
         absorb(runner, current, analyze_set, removed)
         @param_table = fresh_params
-        Recheck.new(diagnostics: merged, changed: changed.to_set, added: added.to_set,
-                    removed: removed.to_set, affected: affected, reused: reused.to_set)
+        recheck_result(merged, [changed, added, removed], affected: affected, reused: reused.to_set, runner: runner)
       end
 
       # Editor mode option B (#146) — a whole-project recheck with the editor's buffer substituted for one
@@ -245,6 +276,9 @@ module Rigor
           # latency this mode exists to avoid, so decline and let the caller drop to single-file scope.
           break nil unless @plugin_fact_reusable.reusable_against?(restored.plugin_fact_digest)
           break nil if source_rbs_unverified?(result)
+          # #1898 — a recheck that re-baselined over stale plugin effect facts ran its baseline with the buffer set,
+          # which analyses the buffer alone, so it is not a whole-project answer. Decline, as above.
+          break nil if result.rebaselined
 
           result
         end
@@ -316,6 +350,35 @@ module Rigor
         closure.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.
+      def singleton_rewrite_affected(unstable)
+        names = unstable.flat_map { |path| singleton_rewritten_constants(@seed_bundles[path]) }.uniq
+        return Set.new if names.empty?
+
+        Incremental.negative_closure(names.map { |name| "class:#{name.split('::').last}" }, @negative_dependents)
+      end
+
+      def singleton_rewritten_constants(bundle)
+        return [] if bundle.nil?
+
+        envelopes = bundle[:parameter_envelopes] || {}
+        unpositioned = bundle[:unpositioned_mixins] || {}
+        (bundle[:singleton_class_source_names] || []).select do |name|
+          (envelopes[name] || {}).each_key.any? { |key| key.is_a?(Array) && key.first == :singleton } ||
+            unpositioned.dig(name, :extend)
+        end
+      end
+
       # Issue #1367 — every file whose last result holds a `global.*` diagnostic re-checks on any recheck. What
       # exempts such a write is a fact of the whole program — an alias, or a `write` / `to_str` / `to_int` / hatch
       # defined in any spelling on any receiver, a rewritten ancestor, a mixin — which no name-keyed edge can
@@ -339,13 +402,15 @@ module Rigor
 
       # The dependents contributed by the declaration-unstable changed files and the behaviourally-unstable
       # symbol pairs: the ADR-46 slice-4 symbol-granular fan-out when either is present (ancestry deps of the
-      # unstable files + symbol deps of the changed pairs), else the coarse file-level fan-out.
+      # unstable files + symbol deps of the changed pairs), else the coarse file-level fan-out; plus the readers of
+      # the constants an unstable file rewrote from outside their bodies ({#singleton_rewrite_affected}).
       def dependents_base(unstable, symbol_pairs)
-        if symbol_pairs.any? || unstable.any? { |f| @ancestry_dependents[f] }
-          Incremental.affected_with_symbols(unstable, symbol_pairs, @symbol_dependents, @ancestry_dependents)
-        else
-          Incremental.affected(unstable, @dependents)
-        end
+        base = if symbol_pairs.any? || unstable.any? { |f| @ancestry_dependents[f] }
+                 Incremental.affected_with_symbols(unstable, symbol_pairs, @symbol_dependents, @ancestry_dependents)
+               else
+                 Incremental.affected(unstable, @dependents)
+               end
+        base | singleton_rewrite_affected(unstable)
       end
 
       # ADR-67 WD6c lift — the fresh whole-project inferred-param table for this recheck ({} when the gate
@@ -440,7 +505,7 @@ module Rigor
       def whole_project_closure(changed, added)
         (@analyzed.to_set | changed | added).freeze
       end
-      private :gated_closure, :whole_project_closure
+      private :gated_closure, :whole_project_closure, :singleton_rewrite_affected, :singleton_rewritten_constants
 
       # The current project file set (cheap directory expansion, no analysis), used to detect files added /
       # removed since the last run. Also where an editor buffer's binding is re-spelled onto the set, since
@@ -463,8 +528,7 @@ module Rigor
         # ADR-67 WD6c lift — seed the subset run from the baseline's own table so the verification engine
         # exercises the exact seeds the served cache entries were computed under (and skips a re-collect).
         runner = build_runner(analyze_only: affected, param_inferred_types: @param_table,
-                              restored_run_level_rows: @run_level_rows,
-                              served_per_file_diagnostics: @cache.slice(*reused))
+                              restored_run_level_rows: @run_level_rows, **served_state(reused))
         run_runner(runner).diagnostics
       end
 
@@ -480,6 +544,7 @@ module Rigor
       # to. Every soundness gate below — the fingerprint, the ADR-88 fact surface — is unchanged, so the
       # decision to reuse is made identically whether or not the result is saved.
       def run_incremental(snapshot:, fingerprint:, persist: true)
+        @last_recheck = nil # #1526 — set only by a warm recheck, see {#last_recheck}
         # ADR-87 WD1 — install the per-run digest table + recording instant + strict flag for the whole
         # invocation so change-detection's stat-then-digest freshness (`#pack_digest` / `#stat_fresh?`) honours
         # `cache.validation: digest` (and `RIGOR_STRICT_VALIDATION`, which the env-only path already sees) and
@@ -507,8 +572,8 @@ module Rigor
             result = recheck
             adopt_plugin_fact_fingerprint
             fact_reusable = @plugin_fact_reusable.reusable_against?(restored.plugin_fact_digest)
-            if fact_reusable && effects_reusable && !source_rbs_unverified?(result)
-              diagnostics = result.diagnostics
+            if fact_reusable && effects_reusable && !result.rebaselined && !source_rbs_unverified?(result)
+              diagnostics = keep_recheck(result)
               warm = true
               # ADR-87 WD3 — a warm recheck that changed nothing leaves the session state byte-equivalent to the
               # snapshot it restored, so skip the unconditional rewrite (209ms + 2 MB on gitlab per null recheck).
@@ -522,7 +587,8 @@ module Rigor
               # digest (from the recheck runner) is unchanged by the re-analysis, so it is kept for the save.
               # Only a genuine fact-surface reason sets the reporting flag the CLI banner reads.
               @fact_surface_invalidated = true unless fact_reusable
-              diagnostics = baseline
+              # #1898 — a recheck that already re-baselined over stale plugin effect facts is that re-analysis.
+              diagnostics = result.rebaselined ? result.diagnostics : baseline
               warm = false
               skip_save = false
             end
@@ -539,9 +605,36 @@ module Rigor
 
       # ADR-88 WD1 — reporting hooks the CLI reads after {#run_incremental}. `fact_surface_invalidated?` is true
       # when a valid snapshot was dropped for a fact-surface reason (a plugin sig/catalog edit, or an opaque
-      # plugin) rather than a cold miss. `opaque_plugin_ids` names the contributing-but-surfaceless plugins that
-      # force a full run every invocation.
-      attr_reader :opaque_plugin_ids
+      # plugin) rather than a cold miss. `opaque_reasons` maps each plugin that forces a full run every invocation
+      # to its {PluginFactFingerprint::OpaqueReason}.
+      attr_reader :opaque_reasons
+
+      # #1526 — the {Recheck} of the last {#run_incremental}, or nil unless that run answered warm. A baseline
+      # (cold, or a re-baseline after a fact-surface, effects or source-RBS reason) has no recheck to report.
+      # The diagnostics are not kept: a long-lived session (the LSP) would otherwise retain every merged list.
+      attr_reader :last_recheck
+
+      # Records the warm recheck's sets for {#last_recheck} and hands back its diagnostics.
+      def keep_recheck(result)
+        @last_recheck = result.with(diagnostics: [])
+        result.diagnostics
+      end
+      private :keep_recheck
+
+      # The opaque plugin ids, sorted (the keys of {#opaque_reasons}).
+      def opaque_plugin_ids
+        @opaque_reasons.keys
+      end
+
+      # True when the fact store could not be read, so no single plugin is named (see {PluginFactFingerprint::Result}).
+      def fact_store_unreadable?
+        @fact_store_unreadable
+      end
+
+      # True when the fact surface forces a full run: some plugin is opaque, or the fact store is unreadable.
+      def opaque_fact_surface?
+        !@opaque_reasons.empty? || @fact_store_unreadable
+      end
 
       def fact_surface_invalidated?
         @fact_surface_invalidated
@@ -566,7 +659,8 @@ module Rigor
         registry = prepared_plugin_registry
         fact = compute_plugin_fact_fingerprint(registry)
         @plugin_fact_digest = fact.digest
-        @opaque_plugin_ids = fact.opaque_plugin_ids
+        @opaque_reasons = fact.opaque_reasons
+        @fact_store_unreadable = fact.fact_store_unreadable
         @plugin_fact_reusable = fact
         @seed_bundles = source_rbs_gate.verify(registry, @seed_bundles)
       end
@@ -596,10 +690,10 @@ module Rigor
 
       # ADR-88 WD1 — the plugin fact-surface fingerprint for this invocation. For a SEQUENTIAL run it is read
       # post-hoc from the analysis runner's already-prepared registry (no second `#prepare`, producers already
-      # validated during analysis). A POOLED run's main process skips `#prepare`, so its registry carries no
-      # published facts — there it falls back to the always-sequential probe. Both paths compute the identical
-      # digest for a given fact surface, so the reuse decision is worker-count-independent (the parity spec
-      # asserts this).
+      # validated during analysis). A POOLED run's main process does not run `#prepare` on it (its workers do),
+      # so its registry carries no published facts — there it falls back to the always-sequential probe. Both
+      # paths compute the identical digest for a given fact surface, so the reuse decision is worker-count-independent
+      # (the parity spec asserts this).
       def compute_plugin_fact_fingerprint(registry = prepared_plugin_registry)
         PluginFactFingerprint.from_registry(registry)
       end
@@ -710,7 +804,8 @@ module Rigor
         return nil if fingerprint.nil? || @cache_store.nil? || @cache_store.read_only? || !@buffer.nil?
         # Known before the run: none of these can be written afterwards, so the stamp and the recomputed
         # fingerprint would be spent for nothing.
-        return nil unless @workers.zero? && !@configuration.effects_enabled?
+        # `WriteGuard.start` would also refuse (it recomputes the fingerprint without `explain:`); say so here.
+        return nil unless @workers.zero? && !@configuration.effects_enabled? && !@explain
 
         IncrementalRunSlot::WriteGuard.start(
           configuration: @configuration, roots: @paths || @configuration.paths, cache_root: @cache_store.root,
@@ -724,7 +819,7 @@ module Rigor
       # cold, not the warm run the probe stands in for.
       def run_slot_writable?
         !@cache_store.nil? && !@cache_store.read_only? && @buffer.nil? && @workers.zero? &&
-          !@configuration.effects_enabled? && @opaque_plugin_ids.empty? && !@last_runner.nil?
+          !@configuration.effects_enabled? && !@explain && !opaque_fact_surface? && !@last_runner.nil?
       end
 
       def start_chain(rows)
@@ -817,6 +912,7 @@ module Rigor
         # a partial re-collection cannot be closed into a whole-project fixpoint.
         @effects_identity  = payload.effects_identity
         @effect_collections = effect_collections_reusable?(payload) ? payload.effect_collections.dup : {}
+        @effect_plugin_digest = payload.effect_plugin_digest
         @symbol_dependents = Incremental.invert_symbols(@symbol_sources)
         @ancestry_dependents = Incremental.invert(@ancestry_sources)
         @negative_dependents = Incremental.invert(@missing)
@@ -845,7 +941,8 @@ module Rigor
           param_table: marshal_safe_param_table,
           effect_collections: marshal_safe_effect_collections,
           effects_identity: @effects_identity,
-          run_level_rows: @run_level_rows
+          run_level_rows: @run_level_rows,
+          effect_plugin_digest: @effect_plugin_digest
         )
       end
 
@@ -857,6 +954,7 @@ module Rigor
       def reset_effect_state
         @effect_collections = {}
         @effects_identity = nil
+        @effect_plugin_digest = nil
       end
 
       # The state this session carries ACROSS processes in the snapshot rather than deriving each run: the
@@ -947,6 +1045,7 @@ module Rigor
       # multiple edits: the analyzed set gets fresh diagnostics + digests + dependency edges, removed files
       # are evicted from every map, and the analyzed-file list advances to `current`.
       def absorb(runner, current, analyze_set, removed)
+        @last_runner = runner # ADR-88 WD1 — the post-hoc fact-surface fingerprint reads this prepared registry.
         removed.each { |path| forget(path) }
         @analyzed = current
         # ADR-85 WD2 — the recheck's discovery folded the restored bundles and refreshed them (changed files
@@ -980,6 +1079,7 @@ module Rigor
         @effect_collections.reject! { |path, _| analyzed.include?(path) }
         @effect_collections.merge!(runner.effect_collections_by_path)
         @effects_identity = current_effects_identity
+        @effect_plugin_digest = effect_plugin_digest_of(runner)
       end
 
       # ADR-89 WD2 — replace the behavioural summaries of every re-analyzed file with THIS run's harvest: drop
@@ -1075,7 +1175,8 @@ module Rigor
       # appeared `"ClassName#method"` to the negative-dependency key it would satisfy (`toplevel:foo` for a
       # top-level def, `method:C#m` otherwise), then unions the recorded negative-dependents of those keys.
       # Issue #1120 — plus the consumers of any refinement name the edit moved ({#refinement_affected}). Issue #1367 —
-      # and every file whose last result holds a `global.*` diagnostic ({#global_write_reporters}).
+      # and every file whose last result holds a `global.*` diagnostic ({#global_write_reporters}). Issue #1459 — and
+      # the consumers of any method name a file started or stopped defining ({#defined_name_affected}).
       def negative_affected(changed, removed, new_fingerprints, new_class_decls, new_constant_decls, summary = nil)
         appeared_methods = Incremental.appeared_symbols(changed, @symbol_fingerprints, new_fingerprints)
         # Issue #639 — a class DISAPPEARING satisfies the `class:` kind too, now that a resolved bare
@@ -1093,7 +1194,7 @@ 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) |
-          global_write_reporters
+          defined_name_affected(changed + removed, summary) | global_write_reporters
       end
 
       # The negative keys a class-declaration diff fires: `class:<last segment>` for a class name, and (issue #1820)
@@ -1121,14 +1222,30 @@ module Rigor
         Incremental.negative_closure(names.map { |name| "refinement:#{name}" }, @negative_dependents)
       end
 
+      # Issue #1459 — the consumers whose answer asked whether the program defines a method name anywhere, for each
+      # name a file in `paths` started or stopped defining. The before-state is each file's seed bundle, the
+      # after-state the scan's per-file name sets. Unlike the appeared-symbol diff, it sees a name an `attr_*`,
+      # `alias` or `define_method` adds, and one that vanishes, which brings a declined reading back.
+      def defined_name_affected(paths, summary)
+        after = (summary && summary[:defined_method_names]) || {}
+        before = paths.to_h do |path|
+          bundle = @seed_bundles[path]
+          [path, bundle && Inference::ScopeIndexer.defined_method_names(bundle)]
+        end
+        names = Incremental.changed_defined_names(paths, before, after)
+        return Set.new if names.empty?
+
+        Incremental.negative_closure(names.map { |name| "defines:#{name}" }, @negative_dependents)
+      end
+
       # The qualified class/module names declared in the pre-parsed `index` (shared with
       # {#symbol_fingerprints_from_index}, so the changed set is parsed once). `{ path => Set<class name> }`.
       def class_declarations_from_index(index)
         return {} if index.nil?
 
         result = Hash.new { |hash, key| hash[key] = Set.new }
-        index[:class_sources].each do |class_name, files|
-          files.each { |file| result[file] << class_name }
+        [index[:class_sources], index[:singleton_class_sources] || {}].each do |sources|
+          sources.each { |class_name, files| files.each { |file| result[file] << class_name } }
         end
         Incremental.add_superclass_edges(result, index[:class_sources], index[:superclasses])
         result.transform_values(&:freeze).freeze
@@ -1269,10 +1386,60 @@ module Rigor
         Runner.new(
           configuration: @configuration, cache_store: @cache_store, environment: @environment,
           plugin_requirer: @plugin_requirer, seed_bundles: @seed_bundles, collect_seed_bundles: true,
-          workers: @workers, buffer: @buffer, **
+          workers: @workers, buffer: @buffer, explain: @explain, on_file_indexed: @on_file_indexed, **
         )
       end
 
+      # The forced targets present in `current`, and the recheck's analyse set with them joined to the closure.
+      def forced_analyze_set(affected, current)
+        forced = @force_targets & current.to_set
+        [forced, (affected | forced) & current]
+      end
+
+      # What the session serves a narrowed run for the files it does not analyse: their cached per-file rows (#1524),
+      # and (#1898) their effect collections, so the run closes its effect graph over the whole project.
+      def served_state(reused)
+        { served_per_file_diagnostics: @cache.slice(*reused),
+          served_effect_collections: @effect_collections.slice(*reused) }
+      end
+
+      # Issue #1898 — the plugin effect-fact digest a run's collections were stamped under. A plugin writes its
+      # attributions and edges into a file's collection when the file is collected, and what it contributes can
+      # follow project state no file digest sees (rigor-activejob reads `config.active_job.queue_adapter`), so a
+      # served collection is current only while this digest is. nil when collection is off.
+      def effect_plugin_digest_of(runner)
+        @configuration.effects_enabled? ? runner.effect_plugin_facts.digest : nil
+      end
+
+      # Whether `runner` judged envelopes over served collections stamped under a different plugin effect-fact
+      # digest, or an unknown one. The comparison waits for the run because the plugins load inside it.
+      def served_effects_stale?(runner, reused)
+        return false if reused.empty? || @effect_collections.empty?
+
+        effect_plugin_digest_of(runner) != @effect_plugin_digest
+      end
+
+      # The answer {#recheck} gives when {#served_effects_stale?}: a full baseline, reported as a recheck that
+      # re-analysed every file. {#run_incremental} reads `rebaselined` so it neither runs a second baseline
+      # nor reports the run as warm.
+      def rebaseline_recheck(changed, added, removed)
+        diagnostics = baseline
+        recheck_result(diagnostics, [changed, added, removed],
+                       affected: @analyzed.to_set, reused: Set.new, runner: @last_runner, rebaselined: true)
+      end
+
+      # A {Recheck} over `deltas` (`[changed, added, removed]`), counting `runner`'s template units.
+      def recheck_result(diagnostics, deltas, affected:, reused:, runner:, rebaselined: false)
+        changed, added, removed = deltas.map(&:to_set)
+        Recheck.new(diagnostics: diagnostics, changed: changed, added: added, removed: removed, affected: affected,
+                    reused: reused, templates: runner.template_unit_paths.size, rebaselined: rebaselined)
+      end
+
+      # A recheck that forces targets analyses in this process, so the index callback reaches them.
+      def forced_target_options(forced)
+        forced.empty? ? {} : { workers: 0 }
+      end
+
       # Run the runner over the session's explicit paths (or, when none were given, the configuration's
       # `paths:` via `Runner#run`'s default).
       def run_runner(runner)

data/lib/rigor/analysis/path_expansion.rb

@@ -14,10 +14,10 @@ module Rigor
       module_function
 
       # The `.rb` files an ordinary (non-buffer) check over `paths` would analyze.
-      def ruby_files(paths, exclude_patterns)
+      def ruby_files(paths, exclude_patterns, base: Dir.pwd)
         Array(paths).flat_map do |path|
           if File.directory?(path)
-            directory_files(path, exclude_patterns)
+            directory_files(path, exclude_patterns, base: base)
           elsif File.file?(path) && path.end_with?(".rb")
             [path]
           else
@@ -26,16 +26,72 @@ module Rigor
         end
       end
 
-      def directory_files(dir, exclude_patterns)
-        reject_excluded(Dir.glob(File.join(dir, RUBY_GLOB)), exclude_patterns)
+      def directory_files(dir, exclude_patterns, base: Dir.pwd)
+        reject_excluded(Dir.glob(File.join(dir, RUBY_GLOB)), exclude_patterns, base: base)
       end
 
       # `exclude_patterns` are matched with `File.fnmatch?` WITHOUT `FNM_PATHNAME`, so `**`/`*` span separators
       # (the patterns behave like substring globs) — the exact semantics the Runner's directory glob applies.
-      def reject_excluded(file_list, exclude_patterns)
+      #
+      # #1576 — a RELATIVE pattern (a leading `./` is ignored) is matched against the file's path relative to
+      # `base` (the config file's directory, or the working directory with no config), so the same file is
+      # excluded whether `paths:` (absolute) or an argument (relative) named it.
+      #
+      # Two spellings are tried. The LOGICAL one (the path as given, against the logical base) counts only when
+      # the file lies inside the base; it is what lets a symlinked `lib` match `lib/gen/**`. The REALPATH one
+      # (realpath of the file against realpath of the base) is the only one used for a file outside the base, and
+      # it also catches a base or file spelled through a different symlink root (macOS `/tmp` vs `/private/tmp`).
+      # Neither shows a directory name above the base: a file outside it comes out as `../…`, so `**/tmp/**`
+      # cannot exclude a project merely located under a `tmp/`, while `**/vendor/bundle/**` still reaches
+      # `../other/vendor/bundle/x.rb`. The pattern is also tried against `/<relative>`, because without
+      # `FNM_PATHNAME` the unanchored `**/tmp/**` needs a leading `/` to match a top-level `tmp/x.rb` (and `*`
+      # never matches a leading `.`, as in `../other`). A pattern starting with `.` therefore also matches files
+      # outside the base. An ABSOLUTE pattern is matched only against the absolute path (logical, then real).
+      def reject_excluded(file_list, exclude_patterns, base: Dir.pwd)
         return file_list if exclude_patterns.empty?
 
-        file_list.reject { |path| exclude_patterns.any? { |pattern| File.fnmatch?(pattern, path) } }
+        absolute_patterns, relative_patterns = exclude_patterns.partition { |pattern| pattern.start_with?("/") }
+        relative_patterns = relative_patterns.map { |pattern| pattern.sub(%r{\A(?:\./+)+}, "") }
+        logical_base = File.absolute_path(base)
+        context = { cwd: Dir.pwd, base: logical_base, real_base: real_directory(logical_base), real_dirs: {} }
+        file_list.reject { |path| excluded?(path, absolute_patterns, relative_patterns, context) }
+      end
+
+      def excluded?(path, absolute_patterns, relative_patterns, context)
+        logical = File.absolute_path(path, context.fetch(:cwd))
+        base = context.fetch(:base)
+        inside = logical.start_with?("#{base}/")
+        return true if inside && matches_relative?(relative_patterns, logical.byteslice((base.bytesize + 1)..))
+        return true if absolute_patterns.any? { |pattern| File.fnmatch?(pattern, logical) }
+
+        real = real_file(logical, context.fetch(:real_dirs))
+        return false if real == logical && inside && context.fetch(:real_base) == base
+
+        matches_relative?(relative_patterns, relative_path(real, context.fetch(:real_base))) ||
+          (real != logical && absolute_patterns.any? { |pattern| File.fnmatch?(pattern, real) })
+      end
+
+      def relative_path(absolute, base)
+        return absolute.byteslice((base.bytesize + 1)..) if absolute.start_with?("#{base}/")
+
+        Pathname.new(absolute).relative_path_from(Pathname.new(base)).to_s
+      end
+
+      def matches_relative?(patterns, relative)
+        candidates = [relative, "/#{relative}"]
+        patterns.any? { |pattern| candidates.any? { |candidate| File.fnmatch?(pattern, candidate) } }
+      end
+
+      def real_directory(dir)
+        File.realpath(dir)
+      rescue SystemCallError
+        File.absolute_path(dir)
+      end
+
+      def real_file(absolute, real_dirs)
+        dir = File.dirname(absolute)
+        real_dir = real_dirs[dir] ||= real_directory(dir)
+        File.join(real_dir, File.basename(absolute))
       end
     end
   end