rigortype 0.2.7 → 0.2.8

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

@@ -12,23 +12,19 @@ require_relative "../project_scan"
 module Rigor
   module Analysis
     class Runner
-      # Owns every project-wide pre-pass that runs once per run before
-      # per-file analysis: plugin load + `#prepare`, the ADR-10
-      # dependency-source index, the ADR-16 synthetic-method scanner,
-      # the ADR-17 project-patched (`pre_eval:`) scanner, cross-file
-      # class discovery, and the ADR-24 def-node + visibility index.
-      # Also owns the {ProjectScan} snapshot adopt / build paths the LSP
-      # uses.
+      # Owns every project-wide pre-pass that runs once per run before per-file analysis: plugin load +
+      # `#prepare`, the ADR-10 dependency-source index, the ADR-16 synthetic-method scanner, the ADR-17
+      # project-patched (`pre_eval:`) scanner, cross-file class discovery, and the ADR-24 def-node +
+      # visibility index. Also owns the {ProjectScan} snapshot adopt / build paths the LSP uses.
       #
-      # The collaborator produces a frozen {Result} bundle; the {Runner}
-      # assigns each slot onto its own ivar surface, preserving the exact
-      # assignment order and timing the inline body had. The `pool_mode`
-      # predicate is injected (it keys on `@workers` / `@buffer`, owned by
-      # the Runner) so this collaborator never calls back into it.
+      # The collaborator produces a frozen {Result} bundle; the {Runner} assigns each slot onto its own
+      # ivar surface, preserving the exact assignment order and timing the inline body had. The `pool_mode`
+      # predicate is injected (it keys on `@workers` / `@buffer`, owned by the Runner) so this collaborator
+      # never calls back into it.
       class ProjectPrePasses
-        # Frozen bundle of the project-wide state the pre-passes produce.
-        # Mirrors the ivars `run_project_pre_passes` / `adopt_prebuilt`
-        # set on the {Runner}, in the same order they were assigned.
+        # Frozen bundle of the project-wide state the pre-passes produce. Mirrors the ivars
+        # `run_project_pre_passes` / `adopt_prebuilt` set on the {Runner}, in the same order they were
+        # assigned.
         Result = Data.define(
           :plugin_registry,
           :dependency_source_index,
@@ -62,29 +58,23 @@ module Rigor
           @pool_mode_reader = pool_mode
         end
 
-        # Internal: drives every project-wide pre-pass and returns the
-        # results bundled in {Result} in the order the downstream `#run`
-        # body expects. Extracted so `#prepare_project_scan` and the
+        # Internal: drives every project-wide pre-pass and returns the results bundled in {Result} in the
+        # order the downstream `#run` body expects. Extracted so `#prepare_project_scan` and the
         # prebuilt-less `#run` path share one implementation.
         def run(expansion:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
           plugin_registry = load_plugins
           dependency_source_index = DependencySourceInference::Builder.build(@configuration.dependencies)
-          # ADR-18 slice 3 — plugin prepare MUST run before the
-          # synthetic-method scanner so cross-plugin facts
-          # (`:dry_type_aliases` etc.) are already published when
-          # the scanner resolves Tier C `returns_from_arg:`
-          # lookups. The diagnostics produced by prepare are
-          # captured here so `pre_file_diagnostics` can re-emit
-          # them in the existing order without invoking prepare
-          # twice. Pool mode still re-runs prepare per worker
-          # (workers don't see this early invocation), preserving
+          # ADR-18 slice 3 — plugin prepare MUST run before the synthetic-method scanner so cross-plugin
+          # facts (`:dry_type_aliases` etc.) are already published when the scanner resolves Tier C
+          # `returns_from_arg:` lookups. The diagnostics produced by prepare are captured here so
+          # `pre_file_diagnostics` can re-emit them in the existing order without invoking prepare twice.
+          # Pool mode still re-runs prepare per worker (workers don't see this early invocation), preserving
           # the existing Phase 4b contract.
           cached_plugin_prepare_diagnostics =
             pool_mode? ? [] : plugin_prepare_diagnostics(plugin_registry)
-          # ADR-16 slice 2b — Tier C pre-pass. Built once per run
-          # against the resolved file set + the loaded plugin
-          # registry's `heredoc_templates` so synthetic methods are
-          # visible cross-file when per-file inference dispatches.
+          # ADR-16 slice 2b — Tier C pre-pass. Built once per run against the resolved file set + the loaded
+          # plugin registry's `heredoc_templates` so synthetic methods are visible cross-file when per-file
+          # inference dispatches.
           synthetic_method_index = Inference::SyntheticMethodScanner.scan(
             plugin_registry: plugin_registry,
             paths: expansion.fetch(:files),
@@ -92,36 +82,27 @@ module Rigor
             fact_store: shared_fact_store(plugin_registry),
             buffer: @buffer
           )
-          # ADR-17 slice 2 — pre-eval pre-pass. Built once per run
-          # from the `pre_eval:` entries that exist on disk
-          # (slice-1's `pre-eval.file-not-found` `:error` already
-          # surfaced any missing entries; the scanner skips them
-          # here). The resulting {ProjectPatchedMethods} registry
-          # is consulted by the dispatcher tier between plugins
-          # and dependency-source inference so project-side
-          # patches resolve cross-file.
+          # ADR-17 slice 2 — pre-eval pre-pass. Built once per run from the `pre_eval:` entries that exist
+          # on disk (slice-1's `pre-eval.file-not-found` `:error` already surfaced any missing entries; the
+          # scanner skips them here). The resulting {ProjectPatchedMethods} registry is consulted by the
+          # dispatcher tier between plugins and dependency-source inference so project-side patches resolve
+          # cross-file.
           existing_pre_eval = @configuration.pre_eval.select { |path| File.file?(path) }
           pre_eval_outcome = Inference::ProjectPatchedScanner.scan(existing_pre_eval, buffer: @buffer)
           project_patched_methods = pre_eval_outcome.registry
           pre_eval_diagnostics_from_scanner = pre_eval_outcome.diagnostics
-          # Cross-file class discovery — walks every project file
-          # for `class Foo` / `module Bar` declarations so a
-          # `Foo.method_call` receiver in one file resolves a
-          # `class Foo` declared in a sibling file. Without this
-          # pre-pass each file's `discovered_classes` was per-file
-          # only, and lexical lookup fell back to stdlib `::Foo`
-          # for any user class shadowing a stdlib name (e.g.
-          # `Google::Cloud::Storage::File`). Cost is one extra
-          # parse pass over the project; small projects pay
-          # tens of ms, larger projects ~1s. Future optimisation
-          # can share parses with the existing scanner passes.
+          # Cross-file class discovery — walks every project file for `class Foo` / `module Bar`
+          # declarations so a `Foo.method_call` receiver in one file resolves a `class Foo` declared in a
+          # sibling file. Without this pre-pass each file's `discovered_classes` was per-file only, and
+          # lexical lookup fell back to stdlib `::Foo` for any user class shadowing a stdlib name (e.g.
+          # `Google::Cloud::Storage::File`). Cost is one extra parse pass over the project; small projects
+          # pay tens of ms, larger projects ~1s. Future optimisation can share parses with the existing
+          # scanner passes.
           discovered_classes =
             Inference::ScopeIndexer.discovered_classes_for_paths(expansion.fetch(:files), buffer: @buffer)
-          # ADR-24 slice 2 — cross-file def-node + class->superclass
-          # index so an implicit-self call inside a subclass
-          # resolves a superclass `def` declared in a sibling
-          # file. One extra parse pass over the project; shares
-          # the cost profile of the class-discovery pass above.
+          # ADR-24 slice 2 — cross-file def-node + class->superclass index so an implicit-self call inside a
+          # subclass resolves a superclass `def` declared in a sibling file. One extra parse pass over the
+          # project; shares the cost profile of the class-discovery pass above.
           def_index =
             Inference::ScopeIndexer.discovered_def_index_for_paths(expansion.fetch(:files), buffer: @buffer)
           Result.new(
@@ -145,11 +126,9 @@ module Rigor
           )
         end
 
-        # Builds the LSP-facing {ProjectScan} snapshot from a fresh
-        # pre-pass run. The runner adopts `result` onto its ivars first
-        # so the same registry object that ran `#prepare` (and so the
-        # populated `services.fact_store`) is the one the snapshot
-        # carries.
+        # Builds the LSP-facing {ProjectScan} snapshot from a fresh pre-pass run. The runner adopts `result`
+        # onto its ivars first so the same registry object that ran `#prepare` (and so the populated
+        # `services.fact_store`) is the one the snapshot carries.
         def build_project_scan(result)
           ProjectScan.new(
             plugin_registry: result.plugin_registry,
@@ -161,12 +140,10 @@ module Rigor
           )
         end
 
-        # Translates a prebuilt {ProjectScan} snapshot supplied to
-        # `Runner.new(prebuilt: ...)` into a {Result} the runner adopts
-        # the same way it adopts a fresh pre-pass run. The discovery
-        # tables are not part of the snapshot (the LSP path seeds an
-        # empty project scope), so they stay at their frozen-empty
-        # constructor defaults.
+        # Translates a prebuilt {ProjectScan} snapshot supplied to `Runner.new(prebuilt: ...)` into a
+        # {Result} the runner adopts the same way it adopts a fresh pre-pass run. The discovery tables are
+        # not part of the snapshot (the LSP path seeds an empty project scope), so they stay at their
+        # frozen-empty constructor defaults.
         def adopt_prebuilt(scan)
           Result.new(
             plugin_registry: scan.plugin_registry,
@@ -189,11 +166,9 @@ module Rigor
           )
         end
 
-        # Returns the per-run shared `Plugin::FactStore` instance.
-        # All loaded plugins share this store through their
-        # respective `Plugin::Services` (the same instance is
-        # threaded by `Plugin::Loader.load`). Returns `nil` when
-        # no plugins are loaded.
+        # Returns the per-run shared `Plugin::FactStore` instance. All loaded plugins share this store
+        # through their respective `Plugin::Services` (the same instance is threaded by
+        # `Plugin::Loader.load`). Returns `nil` when no plugins are loaded.
         def shared_fact_store(plugin_registry)
           return nil if plugin_registry.nil? || plugin_registry.empty?
 
@@ -206,13 +181,11 @@ module Rigor
           @pool_mode_reader.call
         end
 
-        # Loads project-configured plugins through {Rigor::Plugin::Loader}
-        # and returns the resulting {Rigor::Plugin::Registry}. Loader
-        # failures are isolated: each surfaces as a `:plugin_loader`
-        # diagnostic on the run's `Result` rather than aborting the
-        # analysis. Plugins that load successfully but contribute no
-        # protocol hooks are inert in slice 1; later v0.1.0 slices
-        # wire the contribution merger through this registry.
+        # Loads project-configured plugins through {Rigor::Plugin::Loader} and returns the resulting
+        # {Rigor::Plugin::Registry}. Loader failures are isolated: each surfaces as a `:plugin_loader`
+        # diagnostic on the run's `Result` rather than aborting the analysis. Plugins that load successfully
+        # but contribute no protocol hooks are inert in slice 1; later v0.1.0 slices wire the contribution
+        # merger through this registry.
         def load_plugins
           return Plugin::Registry::EMPTY if @configuration.plugins.empty?
 
@@ -230,14 +203,11 @@ 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`.
-        # Slice 2 keeps `network_policy` `:disabled` — the only value
-        # the configuration accepts today.
+        # 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`. Slice 2 keeps `network_policy` `:disabled`
+        # — the only value the configuration accepts today.
         def build_trust_policy
           trusted_gems = @configuration.plugins.map { |entry| trusted_gem_name(entry) }.uniq
           roots = [Dir.pwd]
@@ -272,18 +242,14 @@ module Rigor
           nil
         end
 
-        # ADR-9 slice 3 — invokes every loaded plugin's `#prepare`
-        # hook once per run, after the loader's `#init` pass and
-        # before per-file iteration. Plugins publish facts here
-        # for cross-plugin consumption via the shared
-        # `services.fact_store`. Failures isolate as
-        # `:plugin_loader runtime-error` diagnostics, mirroring the
-        # `#diagnostics_for_file` raise envelope in
+        # ADR-9 slice 3 — invokes every loaded plugin's `#prepare` hook once per run, after the loader's
+        # `#init` pass and before per-file iteration. Plugins publish facts here for cross-plugin
+        # consumption via the shared `services.fact_store`. Failures isolate as `:plugin_loader
+        # runtime-error` diagnostics, mirroring the `#diagnostics_for_file` raise envelope in
         # `plugin_runtime_error_diagnostic`.
         #
-        # `Plugin::Loader` returns plugins in topological order by
-        # `manifest(consumes:)` (ADR-9 slice 5), so producers
-        # always run before consumers.
+        # `Plugin::Loader` returns plugins in topological order by `manifest(consumes:)` (ADR-9 slice 5), so
+        # producers always run before consumers.
         def plugin_prepare_diagnostics(plugin_registry)
           return [] if plugin_registry.empty?
 

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

@@ -3,27 +3,22 @@
 module Rigor
   module Analysis
     class Runner
-      # Mutable per-run holder for the four end-of-pass snapshots that
-      # the analysis paths compute as a side effect and the rest of the
-      # run reads back: the RBS `class_decl_paths` / `signature_paths`
-      # tables (consumed by {RunStats}), the synthesized-namespace name
-      # list, and the `conforms-to` scan results (consumed by the
-      # diagnostic aggregator).
+      # Mutable per-run holder for the four end-of-pass snapshots that the analysis paths compute as a side
+      # effect and the rest of the run reads back: the RBS `class_decl_paths` / `signature_paths` tables
+      # (consumed by {RunStats}), the synthesized-namespace name list, and the `conforms-to` scan results
+      # (consumed by the diagnostic aggregator).
       #
-      # The snapshots are written by whichever analysis path ran
-      # ({PoolCoordinator} sequential / fork-pool / fallback) and read by
-      # the {Runner} and {DiagnosticAggregator}. A shared mutable holder
-      # keeps the write/read timing bit-for-bit with the original inline
-      # ivars (the same pattern the reporter accumulators use) while
-      # letting the writer and readers live in separate objects without a
+      # The snapshots are written by whichever analysis path ran ({PoolCoordinator} sequential / fork-pool /
+      # fallback) and read by the {Runner} and {DiagnosticAggregator}. A shared mutable holder keeps the
+      # write/read timing bit-for-bit with the original inline ivars (the same pattern the reporter
+      # accumulators use) while letting the writer and readers live in separate objects without a
       # back-reference cycle.
       class RunSnapshots
         attr_accessor :class_decl_paths, :signature_paths,
                       :synthesized_namespaces, :conformance_results
 
-        # Constructor defaults match the {Runner} constructor: the
-        # pre-seed values `build_run_stats` / `pre_file_diagnostics` read
-        # before the first analysis path runs are frozen empties.
+        # Constructor defaults match the {Runner} constructor: the pre-seed values `build_run_stats` /
+        # `pre_file_diagnostics` read before the first analysis path runs are frozen empties.
         def initialize
           @class_decl_paths = {}.freeze
           @signature_paths = [].freeze
@@ -31,9 +26,8 @@ module Rigor
           @conformance_results = [].freeze
         end
 
-        # Per-`#run` reset. Mirrors the original `#run` body, which reset
-        # these to NON-frozen empties (distinct from the frozen
-        # constructor defaults) at the top of each run.
+        # Per-`#run` reset. Mirrors the original `#run` body, which reset these to NON-frozen empties (distinct
+        # from the frozen constructor defaults) at the top of each run.
         def reset_for_run
           @class_decl_paths = {}.freeze
           @signature_paths = []