rigortype 0.4.1 → 0.4.2

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

@@ -36,6 +36,8 @@ module Rigor
         #   that stood down against a colliding generic arity (#610), as
         #   `[path, class_name, existing_arity, incoming_arity, existing_file]` tuples. Defaults to none so
         #   a caller that snapshots nothing of the kind need not say so.
+        # @param vendored_standdowns_snapshot — issue #1713 — reader returning what each required-feature-gated
+        #   vendored directory left out (`Environment::RbsLoader#vendored_standdowns`). Defaults to none.
         # @param env_build_failure_snapshot — reader returning the total RBS env-build failure tuple
         #   (`[error_class, first_error_line, conflicting_buffer_names]`) or nil when the env built.
         # @param definition_build_failures_snapshot — issue #696 — reader returning the per-class
@@ -55,7 +57,7 @@ module Rigor
                        quarantined_signatures_snapshot:, env_build_failure_snapshot:,
                        definition_build_failures_snapshot:, hkt_scan_failure_snapshot:,
                        conformance_results_snapshot:, signature_standdowns_snapshot: -> { [] },
-                       pooled_run_disclosures: -> { [] })
+                       vendored_standdowns_snapshot: -> { [] }, pooled_run_disclosures: -> { [] })
           @configuration = configuration
           @rbs_extended_reporter = rbs_extended_reporter
           @boundary_cross_reporter = boundary_cross_reporter
@@ -68,6 +70,7 @@ module Rigor
           @synthesized_namespaces_snapshot_reader = synthesized_namespaces_snapshot
           @quarantined_signatures_snapshot_reader = quarantined_signatures_snapshot
           @signature_standdowns_snapshot_reader = signature_standdowns_snapshot
+          @vendored_standdowns_snapshot_reader = vendored_standdowns_snapshot
           @env_build_failure_snapshot_reader = env_build_failure_snapshot
           @definition_build_failures_snapshot_reader = definition_build_failures_snapshot
           @hkt_scan_failure_snapshot_reader = hkt_scan_failure_snapshot
@@ -437,11 +440,23 @@ module Rigor
           standdowns.map { |entry| build_rbs_plugin_signature_stood_down_diagnostic(entry) }
         end
 
-        # The two `:info` notices that close the `rbs.coverage.*` ladder, in this order: the namespace
-        # synthesis first, then the stand-down (#610) — the outcome that AVOIDED a definition-build failure
-        # and so the quietest row on it. One method so the runner's assembly reads them as one slot.
+        # Issue #1713 — the other outcome that avoided a definition-build failure: a required-feature-gated
+        # vendored directory (`data/vendored_gem_sigs/prime/`) left out what another signature source already
+        # declares — a member, a whole type, or, when nothing narrower built, the directory. One `:info` per
+        # directory, naming the declarations that stood down and the files that displaced them.
+        def rbs_vendored_signature_stood_down_diagnostics
+          standdowns = vendored_standdowns_snapshot
+          return [] if standdowns.nil? || standdowns.empty?
+
+          standdowns.map { |entry| build_rbs_vendored_signature_stood_down_diagnostic(entry) }
+        end
+
+        # The `:info` notices that close the `rbs.coverage.*` ladder, in this order: the namespace synthesis
+        # first, then the stand-downs (#610, #1713) — the outcomes that AVOIDED a definition-build failure and so
+        # the quietest rows on it. One method so the runner's assembly reads them as one slot.
         def rbs_coverage_notice_diagnostics
-          rbs_synthesized_namespace_diagnostics + rbs_plugin_signature_stood_down_diagnostics
+          rbs_synthesized_namespace_diagnostics + rbs_plugin_signature_stood_down_diagnostics +
+            rbs_vendored_signature_stood_down_diagnostics
         end
 
         # Maps the per-run `rigor:v1:conforms-to` scan results into diagnostics (spec: `rbs-extended.md` §
@@ -769,6 +784,69 @@ module Rigor
           )
         end
 
+        def build_rbs_vendored_signature_stood_down_diagnostic(entry)
+          dir, declarations, whole = entry
+          Diagnostic.new(
+            path: ".rigor.yml",
+            line: 1,
+            column: 1,
+            message: vendored_standdown_message(dir, declarations, whole),
+            severity: :info,
+            rule: "rbs.coverage.vendored-signature-stood-down",
+            source_family: :builtin
+          )
+        end
+
+        def vendored_standdown_message(dir, declarations, whole)
+          subject = "Rigor's vendored `#{dir}` signatures (loaded because the project requires `#{dir}` or lists " \
+                    "it under `libraries:`)"
+          return vendored_whole_standdown_message(subject, dir, declarations) if whole
+
+          vendored_partial_standdown_message(subject, declarations)
+        end
+
+        # One sentence per kind of stand-down present ({Environment::GatedSignaturePlan.standdowns}' reasons).
+        VENDORED_STANDDOWN_SENTENCES = {
+          "member" => "left out %<count>d method declaration(s) another signature source also makes, since two " \
+                      "declarations of one method fail the class's definition build, and uses the other " \
+                      "source's: %<list>s.",
+          "type" => "stood %<count>d type(s) down whole, keeping only the types nested in them, because another " \
+                    "source declares each with a different kind (class or module) or generic arity, or the type " \
+                    "failed to build beside that source's declaration: %<list>s.",
+          "open" => "kept %<count>d type(s) without their superclass, because each failed to build beside the " \
+                    "other signatures although no other source declares it; calls they no longer answer read " \
+                    "untyped rather than undefined: %<list>s."
+        }.freeze
+        private_constant :VENDORED_STANDDOWN_SENTENCES
+
+        def vendored_partial_standdown_message(subject, declarations)
+          sentences = VENDORED_STANDDOWN_SENTENCES.filter_map do |reason, template|
+            group = declarations.select { |entry| (entry[2] || "member") == reason }
+            next if group.empty?
+
+            format(template, count: group.size, list: sampled(vendored_standdown_labels(group), 5))
+          end
+          "#{subject} loaded without some of their declarations. Rigor #{sentences.join(' Rigor ')} The rest of the " \
+            "vendored signatures still load. Nothing to fix unless the other declaration is an outdated copy; " \
+            "removing it brings the vendored one back."
+        end
+
+        def vendored_whole_standdown_message(subject, dir, declarations)
+          labels = vendored_standdown_labels(declarations)
+          clashes = labels.empty? ? "" : " Declarations it clashed with: #{sampled(labels, 5)}."
+          "#{subject} stood down " \
+            "entirely: a type they declare failed to build beside the other signature sources even with the " \
+            "clashing declarations left out, so calls into `#{dir}`'s API resolve only against what those " \
+            "sources declare.#{clashes}"
+        end
+
+        def vendored_standdown_labels(declarations)
+          declarations.map do |declaration, cause_file|
+            cause = cause_file.nil? ? "" : " (#{relative_signature_path(cause_file.to_s)})"
+            "`#{declaration}`#{cause}"
+          end
+        end
+
         def displacing_source_phrase(existing_file)
           return "another loaded signature source" if existing_file.nil?
 
@@ -1196,6 +1274,10 @@ module Rigor
           @signature_standdowns_snapshot_reader.call
         end
 
+        def vendored_standdowns_snapshot
+          @vendored_standdowns_snapshot_reader.call
+        end
+
         def env_build_failure_snapshot
           @env_build_failure_snapshot_reader.call
         end

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

@@ -45,7 +45,8 @@ module Rigor
                        snapshots:, plugin_registry:, dependency_source_index:,
                        synthetic_method_index:, project_patched_methods:,
                        analyze_file:, project_scope_seed: -> { {} }, record_dependencies: false,
-                       restored_run_level_rows: nil, template_units: -> { TemplateUnits.empty })
+                       restored_run_level_rows: nil, template_units: -> { TemplateUnits.empty },
+                       feature_sources: -> { {} })
           @configuration = configuration
           @cache_store = cache_store
           @explain = explain
@@ -67,6 +68,7 @@ module Rigor
           @collected_run_disclosures = {}
           @collect_stats = collect_stats
           @buffer = buffer
+          @feature_sources = feature_sources
           @environment_override = environment_override
           @rbs_extended_reporter = rbs_extended_reporter
           @boundary_cross_reporter = boundary_cross_reporter
@@ -208,7 +210,7 @@ module Rigor
 
             env = resolve_sequential_environment(source_files: project_files)
           end
-          snapshot_project_signature_state(signature_state_environment(resolve))
+          snapshot_project_signature_state(signature_state_environment(resolve, project_files))
           snapshot_effect_annotation_carrier(
             annotation_carrier_environment(resolve, in_hand: !env.nil?)&.rbs_loader
           )
@@ -220,11 +222,21 @@ module Rigor
           record_hkt_scan_failure(hkt_scan_outcome(resolve.call))
         end
 
-        # Issue #794 — the signature-state snapshot's own gates, asked BEFORE an environment exists. Both
-        # answers are loader-free (the configuration and the plugin registry), and with neither gate open
-        # {#snapshot_project_signature_state} writes the same empty state a nil environment gives it.
-        def signature_state_environment(resolve)
-          plugin_signature_paths? || project_signature_paths? ? resolve.call : nil
+        # Issue #794 — the signature-state snapshot's own gates, asked BEFORE an environment exists. Every
+        # answer is loader-free (the configuration, the plugin registry and, issue #1713, the required-feature
+        # scan), and with no gate open {#snapshot_project_signature_state} writes the same empty state a nil
+        # environment gives it.
+        def signature_state_environment(resolve, project_files)
+          gated = plugin_signature_paths? || project_signature_paths? || vendored_features_requested?(project_files)
+          gated ? resolve.call : nil
+        end
+
+        # Issue #1713 — whether this run activates a required-feature-gated vendored directory, whose stand-down
+        # {#snapshot_project_signature_state} reports: the scan every build of this run gates on, or the
+        # feature named under `libraries:`.
+        def vendored_features_requested?(project_files)
+          features = project_files.nil? || project_files.empty? ? [] : required_features_for(project_files)
+          !Environment::RequiredFeatures.tokens(features, @configuration.libraries).empty?
         end
 
         # Issue #794 — the same, for the #441 carrier. The carrier is a filter over the loader's
@@ -344,6 +356,10 @@ module Rigor
           # no such plugin reads nothing off its loader here, as before.
           @snapshots.signature_standdowns =
             plugin_signature_paths? ? signature_standdowns_for(environment&.rbs_loader) : []
+          # Issue #1713 — NOT behind the `signature_paths:` gate either: what displaces a vendored declaration may
+          # be a gem's or a collection's copy. The loader answers without building its env when no gated
+          # directory is active.
+          @snapshots.vendored_standdowns = vendored_standdowns_for(environment&.rbs_loader)
           unless project_signature_paths?
             @snapshots.synthesized_namespaces = []
             @snapshots.quarantined_signatures = []
@@ -459,7 +475,22 @@ module Rigor
             **ProjectEnvironment.dependency_discovery_options(@configuration),
             synthetic_method_index: synthetic_method_index,
             project_patched_methods: project_patched_methods,
-            source_files: source_files
+            source_files: source_files,
+            required_features: required_features_for(source_files)
+          )
+        end
+
+        # Issue #1700 — the {Environment::RequiredFeatures} this run's environments gate on: the configured paths
+        # plus `source_files`, whichever files the run checks, with an editor buffer or an in-memory source read
+        # in place of its file. Taken once per file list and handed to every build (the sequential one, the
+        # pool's prewarm and each worker), so they agree and a pool does not re-read the project per worker.
+        def required_features_for(source_files)
+          key = source_files.map(&:to_s)
+          return @required_features if @required_features_key == key
+
+          @required_features_key = key
+          @required_features = Ractor.make_shareable(
+            Environment::RequiredFeatures.for_configuration(@configuration, key, sources: @feature_sources.call)
           )
         end
 
@@ -575,9 +606,10 @@ module Rigor
           # a frozen Array<String>; cheaply shareable. Issue #793 — it IS the full project now
           # (`source_files`), not the analyzed subset this comment always described.
           shareable_source_files = source_files.map { |path| path.to_s.dup.freeze }.freeze
+          features = required_features_for(source_files)
 
           pool = Array.new(@workers) do
-            Ractor.new(configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems) do |configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems| # rubocop:disable Layout/LineLength
+            Ractor.new(configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems, features) do |configuration, cache_root, blueprints, explain, shareable_source_files, locked_gems, features| # rubocop:disable Layout/LineLength
               cache_store = cache_root ? Rigor::Cache::Store.new(root: cache_root) : nil
               session = Rigor::Analysis::WorkerSession.new(
                 configuration: configuration,
@@ -585,7 +617,8 @@ module Rigor
                 plugin_blueprints: blueprints,
                 explain: explain,
                 source_files: shareable_source_files,
-                locked_gems: locked_gems
+                locked_gems: locked_gems,
+                required_features: features
               )
               main = Ractor.main
               main.send([:prepare, session.prepare_diagnostics])
@@ -713,7 +746,8 @@ module Rigor
             project_scope_seed: project_scope_seed,
             source_files: source_files,
             record_dependencies: @record_dependencies,
-            template_units: template_units
+            template_units: template_units,
+            required_features: required_features_for(source_files)
           )
           # Force the full RBS load on the parent so children copy-on-write inherit a warm Environment
           # rather than each rebuilding it after the fork.
@@ -890,6 +924,7 @@ module Rigor
             plugin_registry: plugin_registry,
             source_files: source_files,
             locked_gems: locked_gems,
+            required_features: required_features_for(source_files),
             **ProjectEnvironment.dependency_discovery_options(@configuration)
           )
           warm_env.rbs_loader&.prewarm
@@ -1094,6 +1129,10 @@ module Rigor
           loader.signature_standdowns
         end
 
+        def vendored_standdowns_for(loader)
+          loader.respond_to?(:vendored_standdowns) ? loader.vendored_standdowns : []
+        end
+
         def plugin_registry
           @plugin_registry_reader.call
         end

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

@@ -575,6 +575,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 +642,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 }
         end
+        Incremental.add_superclass_edges(result, @project_discovered_class_sources, @project_discovered_superclasses)
         result.transform_values(&:freeze).freeze
       end
 
@@ -2005,7 +2016,8 @@ 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 }
         )
         @diagnostic_aggregator = DiagnosticAggregator.new(
           configuration: @configuration,
@@ -2020,6 +2032,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 },
@@ -2295,13 +2308,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
@@ -2603,7 +2633,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
@@ -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/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
@@ -270,8 +271,18 @@ 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 = Environment::RequiredFeatures.for_configuration(
+          configuration, Analysis::PathExpansion.ruby_files(roots, configuration.exclude_patterns)
+        )
+        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
@@ -286,6 +297,17 @@ module Rigor
         nil
       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"

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 --------------------------------------------------

data/lib/rigor/cli/check_command.rb

@@ -685,9 +685,10 @@ module Rigor
         # ADR-103 WD15 — captured before `DEFAULTS.merge` below folds "no `effects:` key" and "`effects:
         # false`" into the same value; see `Configuration.load`'s identical capture.
         effects_key_present = data.key?("effects")
+        target_ruby_key_present = data.key?("target_ruby")
         data = data.dup
         data["plugins"] = inject_treat_all_as_inline_rbs(Array(data["plugins"]))
-        Configuration.new(Configuration::DEFAULTS.merge(data), effects_key_present)
+        Configuration.new(Configuration::DEFAULTS.merge(data), effects_key_present, target_ruby_key_present)
       end
 
       # ADR-50 § WD2 — applies the `--bleeding-edge[=ids]` / `--no-bleeding-edge` CLI selection over the configured

data/lib/rigor/cli/trace_command.rb

@@ -69,7 +69,12 @@ module Rigor
       def execute(file:, options:)
         configuration = Configuration.load(options.fetch(:config))
         source = File.read(file, encoding: Encoding::UTF_8)
+        # Prism parses the ORIGINAL bytes, so a `# -*- coding: -*-` file is read in its own encoding. Only the text the
+        # renderer sees is scrubbed: the colouriser and line splitter raise on a byte invalid in UTF-8 (a comment,
+        # `__END__` data, a non-UTF-8 file).
+        # 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)
 
         events = record_events(parse_result.value, file, configuration)

data/lib/rigor/cli/type_of_command.rb

@@ -87,7 +87,7 @@ module Rigor
       # file is parsed and scope-indexed once, however many positions land in it.
       def execute(targets:, options:, buffer: nil)
         configuration = Configuration.load(options.fetch(:config))
-        environment = project_environment(targets.map(&:file).uniq, configuration)
+        environment = project_environment(targets.map(&:file).uniq, configuration, buffer)
         base_scope = Scope.empty(environment: environment)
 
         results_by_target = Array.new(targets.length)
@@ -218,8 +218,10 @@ module Rigor
       # closes). The probed file is threaded as the synthesizer's `source_files:`. Project-RBS auto-detection
       # roots at CWD today; future work will walk parent directories to find the enclosing `Gemfile`/`*.gemspec`
       # so probes against files outside the current process's CWD still see the right `sig/` tree.
-      def project_environment(files, configuration)
-        ProjectEnvironment.build(configuration: configuration, source_files: files)
+      # Issue #1700 — an editor buffer is scanned for required features in place of the file it stands for.
+      def project_environment(files, configuration, buffer = nil)
+        ProjectEnvironment.build(configuration: configuration, source_files: files,
+                                 feature_sources: ProjectEnvironment.buffer_sources(buffer))
       end
 
       def file_exists?(file)