rigortype 0.4.4 → 0.4.6

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

@@ -11,6 +11,8 @@ require_relative "../project_scan"
 require_relative "../worker_session"
 require_relative "../template_units"
 require_relative "../template_unit_collector"
+require_relative "../../project_environment"
+require_relative "scan_environment"
 
 module Rigor
   module Analysis
@@ -100,7 +102,7 @@ module Rigor
           synthetic_method_index = Inference::SyntheticMethodScanner.scan(
             plugin_registry: plugin_registry,
             paths: expansion.fetch(:files),
-            environment: nil,
+            environment: scan_environment(plugin_registry, dependency_source_index, expansion),
             fact_store: shared_fact_store(plugin_registry),
             buffer: @buffer
           )
@@ -135,7 +137,9 @@ module Rigor
         # collectors walk the tree, and the AST is dropped before the next file (peak RSS stays flat).
         def discover(expansion:)
           build_discovery(
-            Inference::ScopeIndexer.discovered_project_index_for_paths(expansion.fetch(:files), buffer: @buffer)
+            Inference::ScopeIndexer.discovered_project_index_for_paths(
+              expansion.fetch(:files), buffer: @buffer, uncertain: uncertain_paths(expansion)
+            )
           )
         end
 
@@ -145,11 +149,18 @@ module Rigor
         # (`seed_bundles` empty) this is `#discover` plus a fresh bundle set — the discovery index is identical.
         def discover_from_bundles(expansion:, seed_bundles:)
           index = Inference::ScopeIndexer.discovered_project_index_incremental(
-            expansion.fetch(:files), seed_bundles: seed_bundles, buffer: @buffer
+            expansion.fetch(:files), seed_bundles: seed_bundles, buffer: @buffer, uncertain: uncertain_paths(expansion)
           )
           [build_discovery(index), index.fetch(:bundles)]
         end
 
+        # Issue #2021 — the files only the `require_relative` walk added ({Runner#required_outside_paths}): their
+        # declarations resolve constants and their methods exist, but every method contribution is `possible`, so no
+        # return type, arity or visibility is read from them.
+        def uncertain_paths(expansion)
+          expansion.fetch(:uncertain, Inference::ScopeIndexer::EMPTY_PATH_SET)
+        end
+
         # Builds the {Discovery} bundle from a `{ classes:, def_index: }` index hash (shared by the plain and
         # seed-bundle discovery paths).
         def build_discovery(index)
@@ -294,6 +305,37 @@ module Rigor
 
         private
 
+        # Issue #476 — the environment the Tier B (trait registry) half of the synthetic-method scan reads, or
+        # nil when no loaded plugin registers a trait registry (the scan then has no use for one, and Tier C's
+        # template and nested-class lanes behave exactly as they did). The view is lazy ({ScanEnvironment}): it
+        # builds an {Environment} on the first question a matching call site asks. That environment is built
+        # WITHOUT `synthetic_method_index:` — the index is this scan's output and only the run's real
+        # environment stores it; the loader never reads it — and without the diagnostic reporters, which the
+        # run's real environment attaches (a second set here would double-report). Every input that decides
+        # what the loader resolves (libraries, signature paths, plugin signatures, the bundle / collection
+        # axes, required features) is the one the real build passes, so the module a trait names resolves to
+        # the same RBS the dispatcher later promotes against.
+        def scan_environment(plugin_registry, dependency_source_index, expansion)
+          return nil if plugin_registry.nil? || plugin_registry.empty?
+          return nil unless plugin_registry.plugins.any? { |plugin| plugin.manifest.trait_registries.any? }
+
+          files = expansion.fetch(:files)
+          ScanEnvironment.new do
+            Environment.for_project(
+              libraries: @configuration.libraries,
+              signature_paths: @configuration.signature_paths,
+              cache_store: @cache_store,
+              plugin_registry: plugin_registry,
+              dependency_source_index: dependency_source_index,
+              source_files: files,
+              required_features: ProjectEnvironment.required_features(
+                @configuration, files, sources: ProjectEnvironment.buffer_sources(@buffer)
+              ),
+              **ProjectEnvironment.dependency_discovery_options(@configuration)
+            )
+          end
+        end
+
         def trust_refusals(registry, baseline)
           registry.plugins.filter_map do |plugin|
             summary = plugin.io_boundary.refusal_summary

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Analysis
+    class Runner
+      # Issue #476 — the read-only, lazily built view of the project's RBS universe that the ADR-16 Tier B
+      # (trait registry) half of {Inference::SyntheticMethodScanner} reads.
+      #
+      # The scanner needs exactly two answers from an environment: `#rbs_loader` (to explode a trait module such
+      # as `Devise::Models::Recoverable` into its instance-method names) and `#class_ordering` (to decide
+      # whether a project class descends from an RBS-known `receiver_constraint` such as
+      # `ActiveRecord::Base`). Neither reads the synthetic-method index — `Environment.for_project` only stores
+      # that index, the RBS loader never consults it — so the chicken-and-egg the issue describes (the env
+      # consumes the scan's output) does not reach the loader: the view builds an environment WITHOUT the
+      # index, the scan runs against it, and the run's real environment is built afterwards WITH the index.
+      #
+      # The build is deferred to the first question. A scan whose trait registries never match a call site
+      # (no `devise` call in any class body) never asks, so it never pays the environment build. The build is
+      # fail-soft: a raise leaves the view answering "unknown", which is what the nil environment answered
+      # before — Tier B emits nothing rather than aborting the pre-pass.
+      class ScanEnvironment
+        # @param builder — called at most once, returns the {Rigor::Environment} (without a synthetic index).
+        def initialize(&builder)
+          @builder = builder
+          @built = false
+          @environment = nil
+        end
+
+        def rbs_loader
+          environment&.rbs_loader
+        end
+
+        def class_ordering(lhs, rhs)
+          env = environment
+          env.nil? ? :unknown : env.class_ordering(lhs, rhs)
+        end
+
+        private
+
+        def environment
+          return @environment if @built
+
+          @built = true
+          @environment = @builder.call
+        rescue StandardError
+          @environment = nil
+        end
+      end
+    end
+  end
+end