rigortype 0.1.2 → 0.1.4

data/lib/rigor/analysis/runner.rb

@@ -6,12 +6,14 @@ require_relative "../environment"
 require_relative "../scope"
 require_relative "../cache/store"
 require_relative "../plugin"
+require_relative "../rbs_extended/reporter"
 require_relative "../reflection"
 require_relative "../type/combinator"
 require_relative "../inference/coverage_scanner"
 require_relative "../inference/scope_indexer"
 require_relative "../inference/method_dispatcher/file_folding"
 require_relative "check_rules"
+require_relative "dependency_source_inference"
 require_relative "diagnostic"
 require_relative "result"
 
@@ -21,7 +23,8 @@ module Rigor
       RUBY_GLOB = "**/*.rb"
       DEFAULT_CACHE_ROOT = ".rigor/cache"
 
-      attr_reader :cache_store, :plugin_registry
+      attr_reader :cache_store, :plugin_registry, :dependency_source_index,
+                  :rbs_extended_reporter, :boundary_cross_reporter
 
       # @param configuration [Rigor::Configuration]
       # @param explain [Boolean] surface fail-soft fallback events
@@ -40,6 +43,9 @@ module Rigor
         @cache_store = cache_store
         @plugin_requirer = plugin_requirer
         @plugin_registry = Plugin::Registry::EMPTY
+        @dependency_source_index = DependencySourceInference::Index::EMPTY
+        @rbs_extended_reporter = RbsExtended::Reporter.new
+        @boundary_cross_reporter = DependencySourceInference::BoundaryCrossReporter.new
       end
 
       # Walks every Ruby file under `paths`, parses it, builds a
@@ -58,22 +64,41 @@ module Rigor
         return Result.new(diagnostics: [target_ruby_error]) if target_ruby_error
 
         @plugin_registry = load_plugins
+        @dependency_source_index = DependencySourceInference::Builder.build(@configuration.dependencies)
         environment = Environment.for_project(
           libraries: @configuration.libraries,
           signature_paths: @configuration.signature_paths,
           cache_store: @cache_store,
-          plugin_registry: @plugin_registry
+          plugin_registry: @plugin_registry,
+          dependency_source_index: @dependency_source_index,
+          rbs_extended_reporter: @rbs_extended_reporter,
+          boundary_cross_reporter: @boundary_cross_reporter
         )
         expansion = expand_paths(paths)
 
-        diagnostics = plugin_load_diagnostics
-        diagnostics += plugin_prepare_diagnostics
-        diagnostics += expansion.fetch(:errors)
+        diagnostics = pre_file_diagnostics(expansion)
         diagnostics += expansion.fetch(:files).flat_map { |path| analyze_file(path, environment) }
+        diagnostics += rbs_extended_reporter_diagnostics
+        diagnostics += boundary_cross_diagnostics
 
         Result.new(diagnostics: apply_severity_profile(diagnostics))
       end
 
+      # Pre-file diagnostic streams that fire once per run rather
+      # than per analyzed file: plugin load / prepare envelopes,
+      # the ADR-10 dependency-source resolution surface, and the
+      # `expand_paths` errors for `paths:` entries that don't
+      # exist or aren't `.rb`. Aggregated here so `#run` stays
+      # under the ABC budget.
+      def pre_file_diagnostics(expansion)
+        plugin_load_diagnostics +
+          plugin_prepare_diagnostics +
+          dependency_source_diagnostics +
+          dependency_source_budget_diagnostics +
+          dependency_source_config_conflict_diagnostics +
+          expansion.fetch(:errors)
+      end
+
       # `target_ruby` flows through to Prism's `version:` option.
       # Prism enforces the supported range and raises
       # `ArgumentError` for versions it does not recognise. Run a
@@ -207,6 +232,181 @@ module Rigor
         end
       end
 
+      # ADR-10 § "Diagnostic prefix family" — surfaces gems
+      # listed in `dependencies.source_inference` that RubyGems
+      # could not resolve. The run continues; the gem simply
+      # contributes nothing this session, mirroring the
+      # plugin-load error envelope. Authored `:warning` because
+      # an unresolvable gem usually means a typo or a missing
+      # `bundle install` rather than a project-blocking problem;
+      # the severity profile still re-stamps it.
+      def dependency_source_diagnostics
+        @dependency_source_index.unresolvable.map do |entry|
+          Diagnostic.new(
+            path: ".rigor.yml",
+            line: 1,
+            column: 1,
+            message: "dependencies.source_inference[].gem #{entry.gem_name.inspect} could not be " \
+                     "resolved (#{entry.reason}); skipping",
+            severity: :warning,
+            rule: "dynamic.dependency-source.gem-not-found",
+            source_family: :builtin
+          )
+        end
+      end
+
+      # ADR-10 § "Budget interaction" / slice 4 — emits one
+      # `:warning` per gem whose Walker run hit the
+      # `dependencies.budget_per_gem` cap. The cap is a Walker-
+      # side guard rail (slice 4 picks the (α) semantics from
+      # ADR-10 WD4: harvesting stops, the dispatcher behaves
+      # exactly as before for unrecorded methods). The
+      # diagnostic names the gem and points the user at the
+      # three remediations: ship RBS, reduce `mode:` from
+      # `full` to `when_missing`, or de-list the gem.
+      # ADR-10 § "config-conflict diagnostic" / 5d — surfaces
+      # `Configuration::Dependencies` warnings accumulated
+      # during `from_h` deduplication of the `includes:`-chain
+      # source_inference array. Each warning describes a
+      # per-gem mode conflict that the merge resolved
+      # right-wins; the user sees one diagnostic per conflict.
+      # `:warning` matches the user's "warn but don't block"
+      # preference per the design discussion.
+      def dependency_source_config_conflict_diagnostics
+        @configuration.dependencies.warnings.map do |message|
+          Diagnostic.new(
+            path: ".rigor.yml",
+            line: 1,
+            column: 1,
+            message: message,
+            severity: :warning,
+            rule: "dynamic.dependency-source.config-conflict",
+            source_family: :builtin
+          )
+        end
+      end
+
+      def dependency_source_budget_diagnostics
+        budget = @configuration.dependencies.budget_per_gem
+        @dependency_source_index.budget_exceeded.map do |gem_name|
+          Diagnostic.new(
+            path: ".rigor.yml",
+            line: 1,
+            column: 1,
+            message: "dependencies.source_inference[].gem #{gem_name.inspect} exceeded the per-gem " \
+                     "catalog cap (#{budget} method definitions); the remaining methods fall back " \
+                     "to the existing RBS-or-Dynamic[top] boundary. Ship RBS for the gem, set " \
+                     "`mode: when_missing` instead of `full`, or de-list the gem.",
+            severity: :warning,
+            rule: "dynamic.dependency-source.budget-exceeded",
+            source_family: :builtin
+          )
+        end
+      end
+
+      # ADR-13 slice 3b — drains the per-run
+      # {RbsExtended::Reporter} into one diagnostic per accumulated
+      # event:
+      #
+      # - `dynamic.rbs-extended.unresolved` for every annotation
+      #   payload the parser could not turn into a {Rigor::Type}.
+      #   Surfaces typos and references to plugin-supplied names
+      #   the project did not enable.
+      # - `dynamic.shape.lossy-projection` for every shape-projection
+      #   type function (`pick_of`, …) applied to a carrier that
+      #   loses precision (anything other than `HashShape` / `Tuple`).
+      #
+      # Both are authored `:info`; the severity profile re-stamps
+      # them per project taste. Path / line / column come from the
+      # annotation's `RBS::Location` when available, falling back
+      # to `.rigor.yml`-style file-level attribution otherwise.
+      def rbs_extended_reporter_diagnostics
+        return [] if @rbs_extended_reporter.empty?
+
+        unresolved = @rbs_extended_reporter.unresolved_payloads.map do |entry|
+          build_reporter_diagnostic(
+            entry.source_location,
+            rule: "dynamic.rbs-extended.unresolved",
+            message: "`RBS::Extended` directive payload could not be resolved: " \
+                     "#{entry.payload.inspect}. Check for typos or enable a plugin " \
+                     "that contributes the referenced type vocabulary."
+          )
+        end
+
+        lossy = @rbs_extended_reporter.lossy_projections.map do |entry|
+          build_reporter_diagnostic(
+            entry.source_location,
+            rule: "dynamic.shape.lossy-projection",
+            message: "Shape projection `#{entry.head}` applied to a carrier without a " \
+                     "literal shape; the projection degrades to the input type. Author " \
+                     "a `HashShape` / `Tuple` carrier or accept the unchanged result."
+          )
+        end
+
+        unresolved + lossy
+      end
+
+      # ADR-10 slice 5c — drains the per-run
+      # {DependencySourceInference::BoundaryCrossReporter} into
+      # `dynamic.dependency-source.boundary-cross` `:info`
+      # diagnostics. Each event flags a call site where RBS
+      # dispatch produced a concrete answer AND a `mode: :full`
+      # opt-in gem's source catalog ALSO contains an entry for
+      # the same `(class_name, method_name)` — i.e., both
+      # contracts have an opinion. RBS still wins on the
+      # dispatch result; the diagnostic is purely advisory so
+      # the user can verify the two contracts haven't drifted.
+      #
+      # Severity profile re-stamps the rule per project taste.
+      # The diagnostic carries no `path` / `line` / `column`
+      # because the crossing is per-method-per-gem, not
+      # per-call-site — the diagnostic anchors at `.rigor.yml`
+      # like the other `dependency-source.*` diagnostics that
+      # report on opt-in configuration.
+      def boundary_cross_diagnostics
+        return [] if @boundary_cross_reporter.empty?
+
+        @boundary_cross_reporter.entries.map do |entry|
+          Diagnostic.new(
+            path: ".rigor.yml", 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 " \
+                     "has not drifted from its RBS contract.",
+            severity: :info,
+            rule: "dynamic.dependency-source.boundary-cross",
+            source_family: :builtin
+          )
+        end
+      end
+
+      def build_reporter_diagnostic(source_location, rule:, message:)
+        path, line, column = location_fields(source_location)
+        Diagnostic.new(
+          path: path, line: line, column: column,
+          message: message, severity: :info, rule: rule, source_family: :builtin
+        )
+      end
+
+      def location_fields(source_location)
+        return [".rigor.yml", 1, 1] if source_location.nil?
+
+        path = location_path(source_location)
+        line = source_location.respond_to?(:start_line) ? source_location.start_line : 1
+        column = source_location.respond_to?(:start_column) ? source_location.start_column + 1 : 1
+        [path, line, column]
+      rescue StandardError
+        [".rigor.yml", 1, 1]
+      end
+
+      def location_path(source_location)
+        buffer = source_location.respond_to?(:buffer) ? source_location.buffer : nil
+        return ".rigor.yml" if buffer.nil? || !buffer.respond_to?(:name)
+
+        name = buffer.name.to_s
+        name.empty? ? ".rigor.yml" : name
+      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
@@ -364,7 +564,7 @@ module Rigor
         parse_result = Prism.parse_file(path, version: @configuration.target_ruby)
         return parse_diagnostics(path, parse_result) unless parse_result.errors.empty?
 
-        scope = Scope.empty(environment: environment)
+        scope = Scope.empty(environment: environment, source_path: path)
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)
         diagnostics = CheckRules.diagnose(
           path: path,