rigortype 0.1.3 → 0.1.4

data/lib/rigor/analysis/fact_store.rb

@@ -18,7 +18,7 @@ module Rigor
         relational
       ].freeze
 
-      Target = Data.define(:kind, :name) do
+      class Target < Data.define(:kind, :name)
         def self.local(name)
           new(kind: :local, name: name.to_sym)
         end
@@ -28,7 +28,7 @@ module Rigor
         end
       end
 
-      Fact = Data.define(:bucket, :target, :predicate, :payload, :polarity, :stability) do
+      class Fact < Data.define(:bucket, :target, :predicate, :payload, :polarity, :stability)
         def initialize(bucket:, target:, predicate:, payload: nil, polarity: :positive, stability: :local_binding)
           bucket = bucket.to_sym
           raise ArgumentError, "unknown fact bucket #{bucket.inspect}" unless BUCKETS.include?(bucket)
@@ -125,8 +125,16 @@ module Rigor
         unique.freeze
       end
 
+      # `fact.target` is `Target | Array[Target]` per the carrier
+      # contract. Branching with an early return on the `Array`
+      # arm lets type narrowing collapse the post-return value to
+      # the bare `Target` case, so the wrapped tuple is `[Target]`
+      # and the union of return paths is exactly `Array[Target]`.
       def fact_targets(fact)
-        Array(fact.target)
+        target = fact.target
+        return target if target.is_a?(Array)
+
+        [target]
       end
     end
   end

data/lib/rigor/analysis/rule_catalog.rb

@@ -31,8 +31,8 @@ module Rigor
     #   from `Configuration::SeverityProfile::PROFILES`.
     # - `since` — first version the rule shipped in.
     module RuleCatalog # rubocop:disable Metrics/ModuleLength
-      Entry = Data.define(:id, :summary, :fires_when, :does_not_fire_when,
-                          :suppression, :severity_authored, :severity_by_profile, :since) do
+      class Entry < Data.define(:id, :summary, :fires_when, :does_not_fire_when,
+                                :suppression, :severity_authored, :severity_by_profile, :since)
         def aliases
           CheckRules::LEGACY_RULE_ALIASES.select { |_legacy, canonical| canonical == id }.keys
         end

data/lib/rigor/analysis/runner.rb

@@ -6,6 +6,7 @@ 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"
@@ -22,7 +23,8 @@ module Rigor
       RUBY_GLOB = "**/*.rb"
       DEFAULT_CACHE_ROOT = ".rigor/cache"
 
-      attr_reader :cache_store, :plugin_registry, :dependency_source_index
+      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
@@ -42,6 +44,8 @@ module Rigor
         @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
@@ -66,12 +70,16 @@ module Rigor
           signature_paths: @configuration.signature_paths,
           cache_store: @cache_store,
           plugin_registry: @plugin_registry,
-          dependency_source_index: @dependency_source_index
+          dependency_source_index: @dependency_source_index,
+          rbs_extended_reporter: @rbs_extended_reporter,
+          boundary_cross_reporter: @boundary_cross_reporter
         )
         expansion = expand_paths(paths)
 
         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
@@ -296,6 +304,109 @@ module Rigor
         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
@@ -453,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,