rigortype 0.4.7 → 0.4.8

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

@@ -4,6 +4,7 @@ require "tmpdir"
 
 require_relative "../../environment"
 require_relative "../../runtime/jit"
+require_relative "../../type_of_memo"
 
 module Rigor
   module Analysis
@@ -164,10 +165,13 @@ module Rigor
         # `exit!` skips `at_exit` / stdio flush; the payload is already durable on disk by then.
         def run_fork_worker(slice, out_path)
           Runtime::Jit.rearm_after_fork
+          TypeOfMemo.forked
           results = slice.to_h { |binding, index| [index, run_one(binding)] }
           File.binwrite(out_path, Marshal.dump(results))
+          TypeOfMemo.write_report
           exit!(0)
         rescue StandardError
+          TypeOfMemo.write_report
           exit!(1)
         end
 

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

@@ -8,25 +8,25 @@ module Rigor
       # The declaration, not the method: this is a fact about what the author wrote, and the fix is on
       # that line. A `.rbs` position is the right answer here even though its sibling deliberately avoids
       # one (the `rbs_extended.unsatisfied-conformance` precedent) — there is no Ruby `def` that could
-      # carry the typo. A value written in configuration has no location at all and lands at
-      # `.rigor.yml:1`, the `rbs.coverage.quarantined-signature` precedent.
+      # carry the typo. A value written in configuration has no location at all and lands at the loaded
+      # configuration file's `1:1` (`.rigor.yml` when none was loaded — #2742), the
+      # `rbs.coverage.quarantined-signature` precedent.
       # A declaration's `location` is already the position a reader can open, `.rbs` and rbs-inline
       # alike: the synthesized-buffer line is re-anchored onto the Ruby file where the envelope is
       # built ({Rigor::Effects::InlineAnchor}, #432), so this module only has to split it. Doing the
       # re-anchoring here as well used to be the fix, and it could not tell two identically-spelled
       # annotations in one file apart — every finding in it landed on the first.
       module DeclarationPosition
-        CONFIG_PATH = ".rigor.yml"
-
         module_function
 
+        # @param config_path — the path a config-value finding lands at ({Rigor::Configuration#config_display_path}).
         # @return the path and the one-based line of the finding
-        def of(finding)
+        def of(finding, config_path)
           location = finding.location
-          return [CONFIG_PATH, 1] if location.nil?
+          return [config_path, 1] if location.nil?
 
           path, _, raw_line = location.rpartition(":")
-          return [CONFIG_PATH, 1] if path.empty?
+          return [config_path, 1] if path.empty?
 
           line = raw_line.to_i
           [path, line.positive? ? line : 1]

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

@@ -3,6 +3,7 @@
 require_relative "../check_rules/rule_ids"
 require_relative "../crash_signature"
 require_relative "../diagnostic"
+require_relative "../run_cache_key"
 require_relative "../severity_stamp"
 
 module Rigor
@@ -99,6 +100,7 @@ module Rigor
             dependency_source_budget_diagnostics +
             dependency_source_config_conflict_diagnostics +
             rbs_coverage_diagnostics +
+            rbs_collection_setup_hint_diagnostics +
             rbs_inline_annotation_hint_diagnostics(expansion) +
             expansion.fetch(:errors)
         end
@@ -115,7 +117,7 @@ module Rigor
             next if File.file?(path)
 
             Diagnostic.new(
-              path: ".rigor.yml", line: 1, column: 1,
+              path: @configuration.config_display_path, line: 1, column: 1,
               message: "pre_eval entry not found: #{path.inspect}. " \
                        "Pre-evaluation requires the file to exist on disk; remove the entry " \
                        "or create the file before re-running analysis.",
@@ -163,7 +165,7 @@ module Rigor
         def plugin_load_diagnostics
           plugin_registry.load_errors.map do |error|
             Diagnostic.new(
-              path: ".rigor.yml",
+              path: @configuration.config_display_path,
               line: 1,
               column: 1,
               message: plugin_load_error_message(error),
@@ -192,7 +194,7 @@ module Rigor
         def dependency_source_diagnostics
           dependency_source_index.unresolvable.map do |entry|
             Diagnostic.new(
-              path: ".rigor.yml",
+              path: @configuration.config_display_path,
               line: 1,
               column: 1,
               message: "dependencies.source_inference[].gem #{entry.gem_name.inspect} could not be " \
@@ -217,7 +219,7 @@ module Rigor
         def dependency_source_config_conflict_diagnostics
           @configuration.dependencies.warnings.map do |message|
             Diagnostic.new(
-              path: ".rigor.yml",
+              path: @configuration.config_display_path,
               line: 1,
               column: 1,
               message: message,
@@ -232,7 +234,7 @@ module Rigor
           budget = @configuration.dependencies.budget_per_gem
           dependency_source_index.budget_exceeded.map do |gem_name|
             Diagnostic.new(
-              path: ".rigor.yml",
+              path: @configuration.config_display_path,
               line: 1,
               column: 1,
               message: "dependencies.source_inference[].gem #{gem_name.inspect} exceeded the per-gem " \
@@ -248,7 +250,8 @@ module Rigor
 
         # O4 Layer 3 slice 3 — graceful-degradation coverage report. When the project has a `Gemfile.lock`
         # (slice 1) and one or more locked gems are not covered by ANY of the four RBS resolution paths
-        # (`DEFAULT_LIBRARIES`, `data/vendored_gem_sigs/`, slice-1 bundle-shipped `sig/`, slice-2
+        # (the resolved library list — `DEFAULT_LIBRARIES` + `libraries:` + the collection lockfile's stdlib
+        # entries, `data/vendored_gem_sigs/`, slice-1 bundle-shipped `sig/`, slice-2
         # `rbs_collection.lock.yaml`), emit a single `:info` diagnostic summarising the uncovered set so the
         # user can act on it (run `rbs collection install`, opt the gem into `dependencies.source_inference:`,
         # or accept the `Dynamic[T]` fallback).
@@ -279,7 +282,7 @@ module Rigor
           )
           rows = Environment::RbsCoverageReport.classify(
             locked_gems: locked,
-            default_libraries: Environment::DEFAULT_LIBRARIES,
+            default_libraries: resolved_default_libraries,
             bundle_sig_paths: bundle_sig_paths,
             rbs_collection_paths: collection_paths
           )
@@ -289,6 +292,55 @@ module Rigor
           [build_rbs_coverage_missing_diagnostic(missing)]
         end
 
+        # Issue #3030 — one `:info` when the run found no `rbs_collection.lock.yaml` but the directory looks set up for
+        # one ({Environment::RbsCollectionDiscovery.missing_lockfile_hint}): the dependency RBS a collection would
+        # load is absent, and Rigor does not resolve it from `manifest.yaml` or a gemspec itself.
+        def rbs_collection_setup_hint_diagnostics
+          # The run-result key and the `--incremental` fingerprint carry the same answer ({RunCacheKey}).
+          hint = RunCacheKey.collection_setup_hint(@configuration)
+          return [] if hint.nil?
+
+          [build_rbs_collection_setup_hint_diagnostic(hint)]
+        end
+
+        RBS_COLLECTION_SETUP_STEPS = {
+          collection_test_dir: "This looks like a gem_rbs_collection test directory: run the collection's " \
+                               "`bin/test` setup for this gem first (it writes the lockfile and " \
+                               "`.gem_rbs_collection/`), then run Rigor here again.",
+          collection_config: "An `rbs_collection.yaml` is here: run `rbs collection install` to write the " \
+                             "lockfile, then run Rigor again."
+        }.freeze
+        private_constant :RBS_COLLECTION_SETUP_STEPS
+
+        def build_rbs_collection_setup_hint_diagnostic(hint)
+          Diagnostic.new(
+            path: @configuration.config_display_path,
+            line: 1,
+            column: 1,
+            message: "No `rbs_collection.lock.yaml` was found, so no `rbs collection` RBS was loaded: the signatures " \
+                     "of this directory's gem dependencies are absent and calls into them read `Dynamic[top]`. " \
+                     "#{RBS_COLLECTION_SETUP_STEPS.fetch(hint)}",
+            severity: :info,
+            rule: "rbs.coverage.collection-not-installed",
+            source_family: :builtin
+          )
+        end
+
+        # Issue #2962 — the library list is {Environment::BaseLibraries.resolve}'s, the same merge
+        # `Environment.for_project` loads, so a gem covered through `libraries:` or a lockfile stdlib
+        # entry is not reported missing. Only the names the environment loads count ({LibraryProbe.loadable}): a
+        # locked gem named there that RBS has no library for is still missing.
+        def resolved_default_libraries
+          resolved = Environment::BaseLibraries.resolve(
+            @configuration.libraries,
+            rbs_collection_lockfile: @configuration.rbs_collection_lockfile,
+            rbs_collection_auto_detect: @configuration.rbs_collection_auto_detect,
+            root: Dir.pwd
+          )
+          LibraryProbe.loadable(resolved)
+        end
+        private :resolved_default_libraries
+
         # Issue #2441 — the same project-own set `Environment.for_project` skips the collection copy of.
         def project_own_gem_names(locked)
           Environment::ProjectPathGems.names(
@@ -345,7 +397,7 @@ module Rigor
 
         def build_rbs_inline_unsynthesized_diagnostic(sample_path)
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "Inline rbs-inline annotations (`# @rbs …`, `#: <type>`) are present in your project " \
@@ -575,7 +627,7 @@ module Rigor
           sample = quarantined.first(sample_size).map { |path, _first_line| relative_signature_path(path) }
           suffix = quarantined.size > sample_size ? ", and #{quarantined.size - sample_size} more" : ""
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "#{quarantined.size} RBS file(s) under `signature_paths:` were SKIPPED " \
@@ -598,7 +650,7 @@ module Rigor
           suffix = files.size > sample_size ? ", and #{files.size - sample_size} more" : ""
           conflicts = sample.empty? ? "" : " Conflicting signature file(s): #{sample.join(', ')}#{suffix}."
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "The RBS environment failed to build (#{error_class}): #{first_line}.#{conflicts} " \
@@ -637,7 +689,7 @@ module Rigor
           files = failures.flat_map { |failure| Array(failure[3]) }
                           .map { |name| signature_source_label(name.to_s) }.uniq.sort
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "#{failures.size} RBS class definition(s) failed to build: " \
@@ -834,7 +886,7 @@ module Rigor
           frame_clause = relative_frame ? " at #{relative_frame}" : ""
           raised = "(#{error_class}): #{first_line}#{frame_clause}."
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: stage == :overlay ? hkt_overlay_failed_message(raised) : hkt_scan_failed_message(raised),
@@ -889,7 +941,7 @@ module Rigor
           sample = synthesized.first(sample_size)
           suffix = synthesized.size > sample_size ? ", and #{synthesized.size - sample_size} more" : ""
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "#{synthesized.size} RBS namespace(s) under `signature_paths:` are " \
@@ -908,7 +960,7 @@ module Rigor
           path, class_name, existing_arity, incoming_arity, existing_file = entry
           displaced_by = displacing_source_phrase(existing_file)
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "`#{relative_signature_path(path.to_s)}` (a signature file a plugin contributes) declares " \
@@ -937,7 +989,7 @@ module Rigor
             "`#{declaration}`#{cause}"
           end
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "`#{relative_signature_path(path.to_s)}` (a signature file a plugin contributes) loaded without " \
@@ -956,7 +1008,7 @@ module Rigor
         def build_rbs_vendored_signature_stood_down_diagnostic(entry)
           dir, declarations, whole = entry
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: vendored_standdown_message(dir, declarations, whole),
@@ -1035,7 +1087,7 @@ module Rigor
           sample = missing.first(sample_size).map(&:gem_name)
           suffix = missing.size > sample_size ? ", and #{missing.size - sample_size} more" : ""
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "#{missing.size} gem(s) in Gemfile.lock have no RBS available: " \
@@ -1201,7 +1253,7 @@ module Rigor
 
           @boundary_cross_reporter.entries.map do |entry|
             Diagnostic.new(
-              path: ".rigor.yml", line: 1, column: 1,
+              path: @configuration.config_display_path, line: 1, column: 1,
               message: "`#{entry.class_name}##{entry.method_name}` is contributed by both " \
                        "RBS (#{entry.rbs_display}) and the `mode: :full` opt-in gem " \
                        "`#{entry.gem_name}`. RBS wins on dispatch; verify the gem source " \
@@ -1328,7 +1380,7 @@ module Rigor
 
         def run_disclosure_diagnostic(record)
           Diagnostic.new(
-            path: ".rigor.yml", line: 1, column: 1,
+            path: @configuration.config_display_path, line: 1, column: 1,
             message: record.fetch(:message),
             severity: record.fetch(:severity),
             rule: record.fetch(:rule),
@@ -1371,7 +1423,7 @@ module Rigor
         def plugin_trust_refusal_diagnostic(plugin, summary)
           plugin_id = plugin.manifest.id
           Diagnostic.new(
-            path: ".rigor.yml", line: 1, column: 1,
+            path: @configuration.config_display_path, line: 1, column: 1,
             message: "plugin #{plugin_id.inspect} had #{summary[:count]} read(s) refused by the trust " \
                      "policy; first refused path: #{summary[:first_path].inspect}, outside read root " \
                      "#{summary[:nearest_root].inspect}. Spell the path the way that read root spells it " \

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

@@ -52,11 +52,6 @@ module Rigor
         LISKOV_RULE = CheckRules::RULE_EFFECT_LISKOV_WIDENED
         UNKNOWN_LABEL_RULE = CheckRules::RULE_EFFECT_UNKNOWN_LABEL
 
-        # Where a diagnostic about a configuration value is positioned when the loader cannot say
-        # which line the key was written on — the `rbs.coverage.quarantined-signature` precedent.
-        CONFIG_PATH = ".rigor.yml"
-        private_constant :CONFIG_PATH
-
         RUBY_EXTENSION = ".rb"
         private_constant :RUBY_EXTENSION
 
@@ -222,7 +217,7 @@ module Rigor
         end
 
         def position_of(finding)
-          DeclarationPosition.of(finding)
+          DeclarationPosition.of(finding, @configuration.config_display_path)
         end
 
         # The vocabulary an unknown label is judged against: the shipped registry plus whatever
@@ -299,7 +294,7 @@ module Rigor
 
         def build_diagnostic(finding)
           Diagnostic.new(
-            path: finding.path || unit_source_path(finding.key) || ".rigor.yml",
+            path: finding.path || unit_source_path(finding.key) || @configuration.config_display_path,
             line: finding.line,
             column: 1,
             message: message_for(finding),
@@ -323,7 +318,7 @@ module Rigor
 
         def build_liskov_diagnostic(finding)
           Diagnostic.new(
-            path: finding.path || CONFIG_PATH,
+            path: finding.path || @configuration.config_display_path,
             line: finding.line,
             column: 1,
             message: EnvelopeMessages.liskov(finding),

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

@@ -10,6 +10,7 @@ require_relative "../run_stats"
 require_relative "../../effects/signature_sources"
 require_relative "../../rbs_extended/conformance_checker"
 require_relative "../../runtime/jit"
+require_relative "../../type_of_memo"
 require_relative "../../cache/engine_source"
 require_relative "run_level_facts"
 require_relative "worker_payload"
@@ -198,6 +199,18 @@ module Rigor
           @buffer.nil?
         end
 
+        # ADR-130 WD2/WD5 — `RbsTypeTranslator.with_interface_erasure` and `RbsDispatch.without_interface_dispatch`
+        # are per-thread switches, which a Ractor worker would not see: a pooled run under either would analyse with
+        # the default engine and pass as the erasure baseline or the dispatch-off mode.
+        def refuse_pool_under_interface_switches
+          if Rigor::Inference::RbsTypeTranslator.interface_erasure?
+            raise ArgumentError, "RbsTypeTranslator.with_interface_erasure supports only a sequential run (workers: 0)"
+          end
+          return if Rigor::Inference::MethodDispatcher::RbsDispatch.interface_dispatch?
+
+          raise ArgumentError, "RbsDispatch.without_interface_dispatch supports only a sequential run (workers: 0)"
+        end
+
         # ADR-15 Phase 4b — routes per-file analysis to either the sequential coordinator-side Environment
         # (legacy path, default) or a Ractor worker pool built around {WorkerSession} (opt-in via
         # `workers:`). The sequential path is bit-for-bit unchanged from v0.1.4 / earlier; the pool path is
@@ -225,6 +238,7 @@ module Rigor
           source_files = project_files || files
           result =
             if pool_mode?
+              refuse_pool_under_interface_switches
               dispatch_pool(files, source_files: source_files)
             else
               environment ||= resolve_sequential_environment(source_files: source_files)
@@ -483,8 +497,8 @@ module Rigor
         # runner's fresh per-run reporter pair attached so dispatcher events route to THIS runner's
         # diagnostics) when present; otherwise builds a fresh Environment per-call via
         # {#build_runner_environment} — preserving the pre-override behaviour bit-for-bit.
-        def resolve_sequential_environment(source_files: [])
-          return build_runner_environment(source_files: source_files) unless @environment_override
+        def resolve_sequential_environment(source_files: [], eager: true)
+          return build_runner_environment(source_files: source_files, eager: eager) unless @environment_override
 
           @environment_override.attach_reporters!(
             rbs_extended_reporter: @rbs_extended_reporter,
@@ -546,8 +560,9 @@ module Rigor
         # loaded plugin's `source_rbs_synthesizer` callable per project source file at env-build time.
         # Defaults to `[]` for callers that don't have a file list yet (e.g. pre-pass-only build paths); in
         # that case no synthesised RBS is contributed.
-        def build_runner_environment(source_files: [])
+        def build_runner_environment(source_files: [], eager: true)
           Environment.for_project(
+            eager: eager,
             libraries: @configuration.libraries,
             signature_paths: @configuration.signature_paths,
             cache_store: @cache_store,
@@ -719,6 +734,9 @@ module Rigor
               # so the worker's own table is the only place a disclosure exists, and it is complete only
               # once the worker has finished its files.
               main.send([:done, Rigor::Analysis::Runner::WorkerPayload.harvest(session)])
+              # `Ractor#send` answers the Ractor; the worker's own value is unread (`join` only), and G3 reads a
+              # messaging call as an address only while its value is discarded.
+              nil
             end
           end
 
@@ -933,12 +951,15 @@ module Rigor
           # mode is opted into for large projects, so a slice reliably outlasts the remainder; a small-project
           # worker finishes first and stays at no-YJIT parity, exactly as the sequential path would.
           Runtime::Jit.rearm_after_fork
+          TypeOfMemo.forked
           results = slice.to_h { |path| [path, session.analyze(path)] }
           # ADR-103 WD13 — the effects slot is filled only on a collecting run.
           payload = WorkerPayload.harvest(session, results: results, record_effects: @record_effects)
           File.binwrite(out_path, Marshal.dump(payload))
+          TypeOfMemo.write_report
           exit!(0)
         rescue StandardError
+          TypeOfMemo.write_report
           exit!(1)
         end
 
@@ -986,7 +1007,7 @@ module Rigor
         # process — so they say so the same way, naming which backend it was (#414).
         def pool_degraded_diagnostic(count, backend)
           Diagnostic.new(
-            path: ".rigor.yml", line: 1, column: 1,
+            path: @configuration.config_display_path, line: 1, column: 1,
             message: "#{backend} pool degraded: #{count} file(s) re-analysed in-process " \
                      "after a worker exited abnormally",
             severity: :warning, rule: "pool-degraded", source_family: :builtin
@@ -1069,7 +1090,7 @@ module Rigor
           harvest_stats { environment }
           diagnostics.unshift(
             Diagnostic.new(
-              path: ".rigor.yml", line: 1, column: 1,
+              path: @configuration.config_display_path, line: 1, column: 1,
               message: "pool mode degraded to sequential: #{reason}",
               severity: :warning, rule: "pool-degraded", source_family: :builtin
             )

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

@@ -375,43 +375,10 @@ module Rigor
           end
         end
 
-        # Builds the {Rigor::Plugin::TrustPolicy} for this run. Trusted gems are the gem-name half of every
-        # entry in `Configuration#plugins`. Allowed read roots default to the project root (CWD), the
-        # project's signature_paths, and each trusted gem's `Gem::Specification#full_gem_path`, plus any
-        # extras the user listed under `plugins_io.allowed_paths`. `network_policy` is `plugins_io.network`
-        # (`:disabled` or `:allowlist`).
+        # The run's {Rigor::Plugin::TrustPolicy}: {Rigor::Plugin::TrustPolicy.for_configuration} is the single
+        # derivation `rigor check`, pooled workers and `rigor unused`'s plugin roots share (#2586).
         def build_trust_policy
-          trusted_gems = @configuration.plugins.map { |entry| trusted_gem_name(entry) }.uniq
-          roots = [Dir.pwd]
-          Array(@configuration.signature_paths).each { |sp| roots << File.absolute_path(sp) }
-          trusted_gems.each do |gem_name|
-            path = trusted_gem_root(gem_name)
-            roots << path if path
-          end
-          @configuration.plugins_io_allowed_paths.each { |p| roots << File.absolute_path(p) }
-
-          Plugin::TrustPolicy.new(
-            trusted_gems: trusted_gems,
-            allowed_read_roots: roots,
-            network_policy: @configuration.plugins_io_network,
-            allowed_url_hosts: @configuration.plugins_io_allowed_url_hosts
-          )
-        end
-
-        def trusted_gem_name(entry)
-          case entry
-          when String then entry
-          when Hash then entry["gem"] || entry["id"]
-          end
-        end
-
-        def trusted_gem_root(gem_name)
-          return nil if gem_name.nil? || gem_name.empty?
-
-          spec = Gem.loaded_specs[gem_name]
-          spec&.full_gem_path
-        rescue StandardError
-          nil
+          Plugin::TrustPolicy.for_configuration(@configuration)
         end
 
         # ADR-9 slice 3 — invokes every loaded plugin's `#prepare` hook once per run, after the loader's
@@ -438,7 +405,7 @@ module Rigor
         def plugin_prepare_error_diagnostic(plugin, error)
           plugin_id = safe_plugin_id(plugin)
           Diagnostic.new(
-            path: ".rigor.yml",
+            path: @configuration.config_display_path,
             line: 1,
             column: 1,
             message: "plugin #{plugin_id.inspect} raised during prepare: " \