rigortype 0.4.1 → 0.4.3

data/lib/rigor/analysis/runner/run_snapshots.rb

@@ -16,7 +16,8 @@ module Rigor
       # back-reference cycle.
       class RunSnapshots
         attr_accessor :class_decl_paths, :signature_paths,
-                      :synthesized_namespaces, :quarantined_signatures, :signature_standdowns, :conformance_results,
+                      :synthesized_namespaces, :quarantined_signatures, :signature_standdowns, :vendored_standdowns,
+                      :conformance_results,
                       :env_build_failure, :definition_build_failures, :hkt_scan_failure,
                       :effect_annotation_carrier
 
@@ -32,12 +33,15 @@ module Rigor
         # `signature_standdowns` (#610) is the quarantine slot's twin for the plugin-contributed files that
         # stood down against a colliding generic arity: a list, assigned once from the loader as
         # `quarantined_signatures` is, and derived from the final env so a cache HIT carries it too.
+        # `vendored_standdowns` (#1713) is the same shape of slot for what a required-feature-gated vendored
+        # directory left out because another signature source declares it.
         def initialize
           @class_decl_paths = {}.freeze
           @signature_paths = [].freeze
           @synthesized_namespaces = [].freeze
           @quarantined_signatures = [].freeze
           @signature_standdowns = [].freeze
+          @vendored_standdowns = [].freeze
           @conformance_results = [].freeze
           @env_build_failure = nil
           @definition_build_failures = [].freeze
@@ -53,6 +57,7 @@ module Rigor
           @synthesized_namespaces = []
           @quarantined_signatures = []
           @signature_standdowns = []
+          @vendored_standdowns = []
           @conformance_results = []
           @env_build_failure = nil
           @definition_build_failures = []

data/lib/rigor/analysis/runner.rb

@@ -297,8 +297,13 @@ module Rigor
                      record_dependencies: false, record_self_calls: false, analyze_only: nil,
                      seed_bundles: nil, collect_seed_bundles: false, param_inferred_types: nil,
                      discovery_seed: nil, no_tolerated_effects: false,
-                     restored_run_level_rows: nil, served_per_file_diagnostics: nil)
+                     restored_run_level_rows: nil, served_per_file_diagnostics: nil, on_file_indexed: nil)
         @configuration = configuration
+        # ADR-113 WD2 — `rigor lens` reads a target's seeded index here: called with `(path, parse_result, scope,
+        # index)` for every file this process indexes, after its rules ran and inside the run window, so the reader
+        # sees what `check` saw. A pooled file is indexed in a worker and never reaches it; the incremental session
+        # analyses forced targets with `workers: 0` for that reason.
+        @on_file_indexed = on_file_indexed
         # Issues #796 / #794 — the previous full run's run-level rows, supplied only by
         # {IncrementalSession} on a narrowed run; see {PoolCoordinator#replay_restored_run_level_rows}.
         @restored_run_level_rows = restored_run_level_rows
@@ -431,6 +436,7 @@ module Rigor
         # Issue #1367 — the project's `Inference::GlobalWriteCensus`, which the `global.*` write rules read.
         @project_discovered_global_write_census = Set.new.freeze
         @project_discovered_class_sources = {}.freeze
+        @project_singleton_class_sources = {}.freeze
         # Issue #644 — the cross-file VALUE-constant publication table (`{qualified name => Type::Constant}`,
         # literal writes only) and its per-name write attribution. The first seeds `in_source_constants` on
         # every per-file scope so `FOO = :sym` in one file reads as `:sym` in another; the second seeds
@@ -575,6 +581,12 @@ module Rigor
         @in_memory_sources = nil
       end
 
+      # Issue #1700 — the sources the required-feature scan reads in place of a file on disk: an in-memory
+      # source ({#run_source}) and an editor buffer (`--tmp-file` read for its `--instead-of` path).
+      def required_feature_sources
+        (@in_memory_sources || {}).merge(ProjectEnvironment.buffer_sources(@buffer))
+      end
+
       # ADR-46 — the project file set that a run over `paths` would analyze, computed by globbing only (no
       # RBS environment build), so the incremental fingerprint can be derived cheaply on the warm path
       # before deciding whether to build the env at all.
@@ -636,11 +648,16 @@ module Rigor
       # detect a class that *appeared* in an edit so a subclass whose ancestor was previously undefined
       # (and so recorded a negative class edge) is re-checked. Inverts the project class-source attribution
       # (class → declaring files).
+      #
+      # Issue #1820 — each file's set also holds a `[class, superclass as written]` pair for every class it declares
+      # with a superclass, so a subclass appearing or vanishing re-checks the consumers that enumerated the parent's
+      # subclasses (`subclass_of:<last segment>`).
       def class_declarations
         result = Hash.new { |hash, key| hash[key] = Set.new }
-        @project_discovered_class_sources.each do |class_name, files|
-          files.each { |file| result[file] << class_name }
+        [@project_discovered_class_sources, @project_singleton_class_sources].each do |sources|
+          sources.each { |class_name, files| files.each { |file| result[file] << class_name } }
         end
+        Incremental.add_superclass_edges(result, @project_discovered_class_sources, @project_discovered_superclasses)
         result.transform_values(&:freeze).freeze
       end
 
@@ -1737,6 +1754,8 @@ module Rigor
         @project_discovered_prepends = discovery.discovered_prepends
         @project_discovered_extends = discovery.discovered_extends
         @project_unpositioned_mixins = discovery.unpositioned_mixins
+        # Issue #1752 — the files that open `class << Const`, read only by {#class_declarations}.
+        @project_singleton_class_sources = discovery.singleton_class_sources
       end
 
       # Internal: builds the deferred cross-file discovery tables at most once per run and adopts them.
@@ -1793,10 +1812,8 @@ module Rigor
       # the pre-pass then saw two writers for every constant a file declares and withheld its publication (#644),
       # and every file was a discovered-not-analysed dependency of the run's cache entry.
       #
-      # The widening decision itself still compares the paths as spelled. `exclude:` patterns match a path as it
-      # is spelled, so until #1576 is fixed the configured absolute `lib` can discover files the argument `lib`
-      # excludes (a relative `lib/gen/**` pattern never matches `/abs/lib/gen/x.rb`), and treating the two as the
-      # same root would drop those files from discovery.
+      # The widening decision itself compares the paths as spelled. `exclude:` patterns apply to both spellings
+      # alike (#1576), so the configured absolute `lib` and the argument `lib` exclude the same files.
       def project_discovery_expansion(paths, expansion)
         return nil unless widen_discovery_to_project?(paths)
 
@@ -2005,7 +2022,9 @@ module Rigor
           project_scope_seed: -> { project_scope_seed_tables },
           template_units: -> { template_units },
           analyze_file: ->(path, environment) { analyze_file(path, environment) },
-          restored_run_level_rows: @restored_run_level_rows
+          restored_run_level_rows: @restored_run_level_rows,
+          feature_sources: -> { required_feature_sources },
+          plugin_prepare: -> { @pre_passes.prepare_throwaway_registry }
         )
         @diagnostic_aggregator = DiagnosticAggregator.new(
           configuration: @configuration,
@@ -2020,6 +2039,7 @@ module Rigor
           synthesized_namespaces_snapshot: -> { @snapshots.synthesized_namespaces },
           quarantined_signatures_snapshot: -> { @snapshots.quarantined_signatures },
           signature_standdowns_snapshot: -> { @snapshots.signature_standdowns },
+          vendored_standdowns_snapshot: -> { @snapshots.vendored_standdowns },
           env_build_failure_snapshot: -> { @snapshots.env_build_failure },
           definition_build_failures_snapshot: -> { @snapshots.definition_build_failures },
           hkt_scan_failure_snapshot: -> { @snapshots.hkt_scan_failure },
@@ -2050,7 +2070,8 @@ module Rigor
         )
         RunStats.new(
           wall_seconds: Process.clock_gettime(Process::CLOCK_MONOTONIC) - wall_started_at,
-          peak_rss_bytes: RunStats.peak_rss_bytes,
+          # Issue #1529 — read lazily on the summary's first use, so a run that prints none never forks for it.
+          peak_rss_probe: RunStats::CURRENT_PROCESS_PEAK_RSS,
           # #392 — the template units count too: they are files this run parsed and typed, and a stats line
           # that omitted them would under-report exactly the work a views-heavy project added.
           target_files: expansion.fetch(:files).size + template_units.paths.size,
@@ -2163,7 +2184,8 @@ module Rigor
         bad = []
         Array(paths).each do |path|
           if File.directory?(path)
-            files.concat(PathExpansion.directory_files(path, @configuration.exclude_patterns))
+            files.concat(PathExpansion.directory_files(path, @configuration.exclude_patterns,
+                                                       base: @configuration.exclude_base))
           # Editor-mode bypass: the buffer's logical path is treated as a real `.rb` file regardless of
           # on-disk presence — `parse_source` reads bytes from the buffer's physical path. Common case: LSP
           # client editing a brand-new file.
@@ -2295,13 +2317,30 @@ module Rigor
       # global-write census (the `global.*` write rules); the issue #992 envelopes ride {#seed_paired_tables}. Split
       # out of {#project_scope_seed_tables} to keep it under the complexity budget.
       def seed_call_surface_tables(tables)
-        tables[:discovered_refinements] = @project_discovered_refinements unless @project_discovered_refinements.empty?
+        refinements = seed_refinements(tables)
+        tables[:discovered_refinements] = refinements unless refinements.nil? || refinements.empty?
         # Issue #1367 — read by the `global.*` write rules.
         return if @project_discovered_global_write_census.empty?
 
         tables[:discovered_global_write_census] = @project_discovered_global_write_census
       end
 
+      # Issue #1672 — the project's refinements (this run's discovery, else an opt-in `discovery_seed:` base's)
+      # unioned with the opt-in gems' ({DependencySourceInference::Index#refinements}). The gem half comes from
+      # the pre-passes every run takes, warm or cold, so a file re-analysed warm is seeded what a cold run seeds.
+      # The seed is rebuilt per file, so the union is kept while its two inputs are the same objects.
+      def seed_refinements(tables)
+        project = @project_discovered_refinements
+        project = tables[:discovered_refinements] if project.empty?
+        gems = @dependency_source_index.refinements
+        memo = @seed_refinements
+        return memo[2] if memo && memo[0].equal?(project) && memo[1].equal?(gems)
+
+        merged = Inference::ScopeIndexer.merge_refinement_tables(project, gems)
+        @seed_refinements = [project, gems, merged]
+        merged
+      end
+
       # The three mixin tables: the ADR-24 instance-side `include` map, its issue #1123 `prepend` twin
       # (which carries the instance-ancestor order the include table's set-shaped value cannot), and the
       # #898 singleton-side `extend` table. Grouped here because they are read as one picture of a class's
@@ -2561,10 +2600,11 @@ module Rigor
         # the rule is active or `record_self_calls:` opted in.
         index = nil
         self_call_record = with_self_call_recording(path) do
-          index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
+          index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope, widen_clauses: true)
         end
         self_call_misses = self_call_record ? self_call_record.calls : []
         diagnostics = rule_and_plugin_diagnostics(path, parse_result, scope, index, self_call_misses)
+        notify_file_indexed(path, parse_result, scope, index)
         diagnostics + explain_diagnostics(path, parse_result.value, scope)
       rescue Errno::ENOENT => e
         [
@@ -2588,6 +2628,14 @@ module Rigor
         ]
       end
 
+      # ADR-113 WD2 — the `on_file_indexed` observer. It reads; an error inside it never changes this file's
+      # diagnostics, so it is contained here rather than reaching {#analyze_file_body}'s crash row.
+      def notify_file_indexed(path, parse_result, scope, index)
+        @on_file_indexed&.call(path, parse_result, scope, index)
+      rescue StandardError
+        nil
+      end
+
       # ADR-53 B4 — the built-in node collectors and the plugin node rules share ONE traversal of the file.
       # The collectors are built here (they need the completed `index`) and populated by the converged
       # plugin walk; `node_results` carries the per-plugin node-rule output. Both the built-in `diagnose`
@@ -2603,7 +2651,8 @@ module Rigor
           self_call_misses: self_call_misses,
           comments: parse_result.comments,
           disabled_rules: @configuration.disabled_rules,
-          node_collectors: node_collectors
+          node_collectors: node_collectors,
+          stated_runtime_ruby: @configuration.stated_runtime_ruby
         )
         diagnostics + plugin_emitted_diagnostics(path, root, scope, node_results)
       end

data/lib/rigor/analysis/worker_session.rb

@@ -86,7 +86,7 @@ module Rigor
                      plugin_blueprints: [], explain: false, buffer: nil,
                      synthetic_method_index: nil, project_patched_methods: nil,
                      project_scope_seed: {}, source_files: [], record_dependencies: false,
-                     template_units: nil, locked_gems: nil)
+                     template_units: nil, locked_gems: nil, required_features: nil)
         @configuration = configuration
         @cache_store = cache_store
         @explain = explain
@@ -119,7 +119,9 @@ module Rigor
         # RubyGems module state a non-main Ractor may not touch, so a Ractor worker that resolved it here got
         # `Ractor::IsolationError` and an empty map — no gem `sig/` directories, no ADR-72 overlays. nil (the
         # fork backend and every other caller) resolves inside `Environment.for_project` exactly as before.
-        @locked_gems = locked_gems
+        # Issue #1700 — `required_features` is the coordinator's scan ({Runner::PoolCoordinator#required_features_for});
+        # nil scans `source_files` inside `Environment.for_project`.
+        @environment_inputs = { locked_gems: locked_gems, required_features: required_features }.freeze
 
         # NOTE: `Inference::MethodDispatcher::FileFolding.fold_platform_specific_paths` is process-global
         # state. Writing it from a non-main Ractor would raise `Ractor::IsolationError`, so the session does
@@ -153,7 +155,7 @@ module Rigor
           synthetic_method_index: @synthetic_method_index,
           project_patched_methods: @project_patched_methods,
           source_files: @source_files,
-          locked_gems: @locked_gems
+          **@environment_inputs
         )
         @prepare_diagnostics = run_plugin_prepare.freeze
       end
@@ -226,7 +228,7 @@ module Rigor
         scope = @template_units.seed(
           seed_project_scope(Scope.empty(environment: @environment, source_path: path)), path
         )
-        index = Inference::ScopeIndexer.index(root, default_scope: scope)
+        index = Inference::ScopeIndexer.index(root, default_scope: scope, widen_clauses: true)
         # ADR-53 B4 — built-in collectors + plugin node rules share one walk.
         node_collectors = CheckRules.build_node_collectors(path, index, root)
         node_results = node_rule_results_by_plugin(path, root, scope, node_collectors, index)
@@ -236,7 +238,8 @@ module Rigor
           scope_index: index,
           comments: parse_result.comments,
           disabled_rules: @configuration.disabled_rules,
-          node_collectors: node_collectors
+          node_collectors: node_collectors,
+          stated_runtime_ruby: @configuration.stated_runtime_ruby
         )
         diagnostics += plugin_emitted_diagnostics(path, root, scope, node_results)
         diagnostics + explain_diagnostics(path, parse_result.value, scope)

data/lib/rigor/cache/engine_source.rb

@@ -59,6 +59,19 @@ module Rigor
       # `apps/` and `tool/` are not loaded by an analysis and stay out.
       SOURCE_DIRECTORIES = %w[lib plugins].freeze
 
+      # Engine DATA the analysis reads at runtime, relative to the gem root (issue #1492). A data edit moves
+      # diagnostics as surely as a `lib/` edit, yet the caches that key only on `signature_paths` plus this
+      # digest (the `--incremental` snapshot fingerprint, `Protection::MutationCache`) see nothing else.
+      #
+      # - YAML: `data/builtins` (`MethodCatalog::DATA_ROOT`) and `data/effects` (`Effects::Catalog`,
+      #   `Effects::Registry`).
+      # - RBS: every `.rbs` under `data/` (`core_overlay`, `vendored_gem_sigs`, `capability_roles`,
+      #   `gem_overlay`) plus each bundled plugin's `plugins/*/sig`. `RbsDescriptor` digests the same files
+      #   into the run-result and env caches, but those are the only two consumers that do.
+      #
+      # Tooling-only trees (`data/oss-sweep`) are not read by an analysis and stay out.
+      DATA_GLOBS = %w[data/builtins/**/*.yml data/effects/**/*.yml data/**/*.rbs plugins/*/sig/**/*.rbs].freeze
+
       # The one directory whose absence means "this is not an engine tree". `plugins/` may legitimately be
       # missing (a slimmed install contributes nothing); a missing `lib/` would silently shrink the digest
       # to whatever else happened to be there, which is exactly the weakening this module forbids.
@@ -153,8 +166,9 @@ module Rigor
         !File.exist?(File.join(root, ".git"))
       end
 
-      # A SHA-256 over every engine `.rb` file: its ROOT-RELATIVE path (so the digest survives moving or
-      # re-cloning the checkout) followed by its bytes, in sorted path order.
+      # A SHA-256 over every engine `.rb` file and {DATA_GLOBS} data file: its ROOT-RELATIVE
+      # path (so the digest survives moving or re-cloning the checkout) followed by its bytes, in sorted path
+      # order.
       #
       # The walk itself is not memoised — {.process_identity} is where a production caller gets the
       # once-per-process value, and this stays the computation so a spec can point it at another tree.
@@ -178,12 +192,12 @@ module Rigor
         raise Unavailable, "engine source under #{root} could not be read: #{e.message}"
       end
 
-      # Sorted absolute paths of every engine `.rb` file, across the directories that exist.
+      # Sorted, de-duplicated absolute paths of every engine `.rb` file and {DATA_GLOBS} data file, across
+      # the directories that exist. `plugins/*/sig/**/*.rbs` overlaps nothing else but is de-duplicated anyway.
       def source_files(root)
-        SOURCE_DIRECTORIES.flat_map do |relative|
-          directory = File.join(root, relative)
-          File.directory?(directory) ? Dir.glob(File.join(directory, "**", "*.rb")) : []
-        end.sort
+        sources = SOURCE_DIRECTORIES.flat_map { |relative| Dir.glob(File.join(root, relative, "**", "*.rb")) }
+        data = DATA_GLOBS.flat_map { |pattern| Dir.glob(File.join(root, pattern)) }
+        (sources + data).uniq.sort
       end
     end
   end

data/lib/rigor/cache/incremental_snapshot.rb

@@ -9,6 +9,7 @@ require_relative "store"
 require_relative "../analysis/shadow_harness"
 require_relative "../analysis/run_cache_key"
 require_relative "../environment"
+require_relative "../analysis/path_expansion"
 
 module Rigor
   module Cache
@@ -259,7 +260,11 @@ module Rigor
       # {EngineSource.process_identity} closes it, and answers nil for a version-pinned tree — which adds no
       # part, so a released gem's fingerprint is byte-identical to the pre-#289 one and its warm snapshots
       # survive the upgrade untouched.
-      def self.fingerprint(configuration:, roots:)
+      #
+      # Issue #1533 — `explain:` is the run's `--explain` flag. It adds `:info` rows to the per-file diagnostics
+      # the snapshot caches, so a snapshot written without it holds none and one written with it holds rows a
+      # plain run must not print. No part for the default, so every plain run's fingerprint is as it was.
+      def self.fingerprint(configuration:, roots:, explain: false)
         bundler_lock, collection_lock = Analysis::RunCacheKey.resolved_lockfile_paths(configuration)
         parts = [
           "engine:#{Rigor::VERSION}:#{SCHEMA}",
@@ -270,12 +275,19 @@ module Rigor
           "sig:#{digest_signature_paths(project_sig_roots(configuration))}",
           "pre_eval:#{digest_pre_eval(configuration.pre_eval)}"
         ]
+        parts.concat(dependency_source_parts(configuration))
         identity = EngineSource.process_identity
         parts << "engine-source:#{identity}" if identity
+        # Issue #1700 — the gated vendored signatures the run's source activates. A file that gains or drops a
+        # `require "prime"` changes the environment every other file was analysed against, which no per-file
+        # dependency edge records, so the whole snapshot goes. Scanned over the configured paths plus the roots'
+        # files, the set the run's environment scans; no part when nothing is required, so every other
+        # project's fingerprint is as it was.
+        features = required_features(configuration, roots)
+        parts << "required-features:#{features.join(',')}" unless features.empty?
         # ADR-116 WD5 — the snapshot's per-file rows and seed bundles are only as checked as the run that
         # wrote them ({Inference::DeclarationWalk::Shadow}); nil with the harness off adds no part.
-        shadow = Analysis::ShadowHarness.cache_identity
-        parts << "shadow-harness:#{shadow}" if shadow
+        parts.concat(run_mode_parts(explain))
         Digest::SHA256.hexdigest(parts.join("\x00"))
       rescue StandardError
         # {EngineSource::Unavailable} lands here too, and nil is the answer it requires rather than one it
@@ -286,12 +298,38 @@ module Rigor
         nil
       end
 
+      def self.required_features(configuration, roots)
+        files = Analysis::PathExpansion.ruby_files(roots, configuration.exclude_patterns,
+                                                   base: configuration.exclude_base)
+        Environment::RequiredFeatures.for_configuration(configuration, files)
+      end
+
+      # ADR-10 slice 3, issue #1814 — the walked gems' versions: their method catalogue, their refinement table and the
+      # constants they bind reach every file's checks, and the lockfile digest above does not cover a project with none.
+      # No part for a project that lists no gem, so its fingerprint is what it was.
+      def self.dependency_source_parts(configuration)
+        rows = Analysis::RunCacheKey.dependency_source_entries(configuration).map do |row|
+          [row.gem_name, row.gem_version, row.mode]
+        end
+        rows.empty? ? [] : ["dependency-source:#{rows.sort.inspect}"]
+      end
+      private_class_method :dependency_source_parts
+
       def self.digest_file_if_present(path)
         path = path&.to_s
         path && File.file?(path) ? Digest::SHA256.file(path).hexdigest : "absent"
       end
       private_class_method :digest_file_if_present
 
+      # The parts naming how the run was asked to behave rather than what it reads: the ADR-116 WD5 shadow harness
+      # (the snapshot's rows are only as checked as the run that wrote them; nil with the harness off) and
+      # `--explain` (#1533).
+      def self.run_mode_parts(explain)
+        shadow = Analysis::ShadowHarness.cache_identity
+        [("shadow-harness:#{shadow}" if shadow), ("explain:true" if explain)].compact
+      end
+      private_class_method :run_mode_parts
+
       # Content-digest every `pre_eval:` file in configuration order, so an edit to one invalidates the snapshot
       # even when it lies outside the analysed paths. A missing file digests as "absent", so creating it counts too.
       def self.digest_pre_eval(paths)
@@ -324,8 +362,20 @@ module Rigor
       end
       private_class_method :digest_signature_paths
 
-      def initialize(root:)
-        @path = File.join(root.to_s, "incremental", "snapshot.bin")
+      # Issue #1867 — one snapshot FILE per fingerprint mode. A run whose fingerprint carries run-mode parts
+      # (`--explain`, the ADR-116 shadow harness) keeps its own file so it neither reads nor overwrites the
+      # plain run's warm snapshot, and the reverse. The plain file name is unchanged. The fingerprint still
+      # carries the mode parts, so the files never cross-serve.
+      def initialize(root:, explain: false)
+        @path = File.join(root.to_s, "incremental", self.class.file_name(explain: explain))
+      end
+
+      # `snapshot.bin` for a plain run; `snapshot-<mode digest>.bin` when {run_mode_parts} is non-empty.
+      def self.file_name(explain: false)
+        parts = run_mode_parts(explain)
+        return "snapshot.bin" if parts.empty?
+
+        "snapshot-#{Digest::SHA256.hexdigest(parts.join("\x00"))[0, 12]}.bin"
       end
 
       attr_reader :path

data/lib/rigor/cli/annotate_command.rb

@@ -100,7 +100,12 @@ module Rigor
         # in `#annotate` raise `invalid byte sequence in US-ASCII`. Ruby source is UTF-8 by convention (the parser's own
         # assumption absent a magic comment).
         source = File.read(file, mode: "r:bom|utf-8")
+        # Prism parses the ORIGINAL bytes, so a `# -*- coding: -*-` file is read in its own encoding. Only the text the
+        # line-wise regexps below see is scrubbed: a byte invalid in UTF-8 (a comment, `__END__` data, a non-UTF-8
+        # file) would make them raise.
+        # Scrubbing is byte-for-byte (`?` per bad byte), so Prism's positions still address it.
         parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
+        source = source.scrub { |bytes| "?" * bytes.bytesize } unless source.valid_encoding?
         return 1 if parse_errors?(parse_result, file)
 
         # `converged_loop_recording` re-records fixpoint-tracked loop bodies from their converged (post-writeback)

data/lib/rigor/cli/baseline_command.rb

@@ -126,8 +126,10 @@ module Rigor
 
       def collect_diagnostics(configuration, _options)
         cache_store = Cache::Store.new(root: configuration.cache_path)
-        # IMPORTANT: do NOT activate the existing baseline when generating a fresh one — otherwise the new file records
-        # the post-filter (silenced) diagnostic set, which is empty after a successful first run.
+        # The generating run is the loaded configuration with `baseline:` off (#1777): every other key shapes the
+        # diagnostic set `rigor check` reports, so it must shape the recorded one too. The baseline filter itself is
+        # applied CLI-side by `check` (`CheckCommand#apply_baseline_filter`), never by the runner; clearing it here is
+        # defensive.
         configuration_for_generation = override_configuration_baseline_off(configuration)
         runner = Analysis::Runner.new(
           configuration: configuration_for_generation,
@@ -137,23 +139,10 @@ module Rigor
         runner.run(configuration_for_generation.paths).diagnostics
       end
 
+      # The loaded configuration with only `baseline` disabled (#1777): any other key can change the
+      # diagnostic set, and the baseline must record the set `rigor check` will then report.
       def override_configuration_baseline_off(configuration)
-        # Synthesise a new Configuration with `baseline` explicitly disabled. The original Configuration is frozen-ish
-        # so we round-trip through the constructor with an override hash.
-        defaults = Configuration::DEFAULTS.merge(
-          "paths" => configuration.paths,
-          "exclude" => configuration.exclude_patterns,
-          "plugins" => configuration.plugins,
-          "disable" => configuration.disabled_rules,
-          "libraries" => configuration.libraries,
-          "signature_paths" => configuration.signature_paths,
-          "pre_eval" => configuration.pre_eval,
-          "severity_profile" => configuration.severity_profile.to_s,
-          "severity_overrides" => configuration.severity_overrides,
-          "baseline" => false,
-          "cache" => { "path" => configuration.cache_path }
-        )
-        Configuration.new(defaults)
+        configuration.without_baseline
       end
 
       # ---- dump --------------------------------------------------