rigortype 0.1.2 → 0.1.4

data/lib/rigor/inference/statement_evaluator.rb

@@ -785,6 +785,7 @@ module Rigor
         evaluate_block_if_present(node)
         post_scope = record_closure_escape_if_any(node)
         post_scope = apply_rbs_extended_assertions(node, post_scope)
+        post_scope = apply_plugin_assertions(node, post_scope)
         post_scope = apply_rspec_matcher_narrowing(node, post_scope)
         [call_type, post_scope]
       end
@@ -888,7 +889,7 @@ module Rigor
       # or nil otherwise. Centralised so each per-matcher
       # decoder can short-circuit on a non-matching outer
       # call.
-      def rspec_expectation_target(call_node) # rubocop:disable Metrics/CyclomaticComplexity
+      def rspec_expectation_target(call_node)
         receiver = call_node.receiver
         return nil unless receiver.is_a?(Prism::CallNode) && receiver.name == :expect
         return nil unless receiver.receiver.nil?
@@ -966,7 +967,7 @@ module Rigor
         method_def = resolve_call_method(call_node, current_scope)
         return current_scope if method_def.nil?
 
-        contribution = RbsExtended.read_flow_contribution(method_def)
+        contribution = RbsExtended.read_flow_contribution(method_def, environment: current_scope.environment)
         return current_scope if contribution.nil?
 
         result = Rigor::FlowContribution::Merger.merge([contribution])
@@ -978,7 +979,62 @@ module Rigor
         end
       end
 
-      def resolve_call_method(call_node, current_scope) # rubocop:disable Metrics/PerceivedComplexity
+      # ADR-7 § "Slice 4-A" / T.bind priority slice 2 — applies
+      # the post-return facts plugin contributions produce. This
+      # is the sibling of {apply_rbs_extended_assertions}: the
+      # carrier (`Rigor::FlowContribution::Fact`) and the
+      # downstream narrowing path (`apply_post_return_fact` →
+      # `apply_self_post_return_fact`) are the same; only the
+      # *source* of the bundle changes (RBS::Extended vs the
+      # registered plugins' `flow_contribution_for`).
+      #
+      # `:self`-targeted facts narrow `scope.self_type` for the
+      # surrounding scope. In a block body, the surrounding
+      # scope is the block's own scope, so the narrowing applies
+      # to the rest of the block — exactly the contract Sorbet's
+      # `T.bind(self, T)` commits to.
+      #
+      # `:parameter`-targeted facts only land when the called
+      # method has an authoritative RBS sig (via
+      # `resolve_call_method`); plugins recognising their own
+      # synthetic call shapes (e.g. `T.assert_type!`) have no
+      # method_def and the parameter facts silently skip — the
+      # plugin's own diagnostics_for_file path covers those
+      # cases. The full plugin-side parameter-targeting story
+      # (PHPStan-style Type-Specifying Extensions on
+      # plugin-recognised calls) lives behind a follow-up slice
+      # that introduces `:local` / `:argument_at` target kinds.
+      def apply_plugin_assertions(call_node, current_scope)
+        registry = current_scope.environment&.plugin_registry
+        return current_scope if registry.nil? || registry.empty?
+
+        contributions = collect_plugin_contributions(registry, call_node, current_scope)
+        return current_scope if contributions.empty?
+
+        result = Rigor::FlowContribution::Merger.merge(contributions)
+        post_return = result.post_return_facts
+        return current_scope if post_return.empty?
+
+        method_def = resolve_call_method(call_node, current_scope)
+        post_return.reduce(current_scope) do |scope_acc, fact|
+          apply_post_return_fact(fact, call_node, scope_acc, method_def)
+        end
+      end
+
+      # Walks the registry and collects each plugin's
+      # `flow_contribution_for` result, swallowing per-plugin
+      # exceptions so a buggy plugin can't abort the assertion
+      # path. Mirrors `MethodDispatcher.collect_plugin_contributions`
+      # exactly — the two paths consume the same hook.
+      def collect_plugin_contributions(registry, call_node, current_scope)
+        registry.plugins.filter_map do |plugin|
+          plugin.flow_contribution_for(call_node: call_node, scope: current_scope)
+        rescue StandardError
+          nil
+        end
+      end
+
+      def resolve_call_method(call_node, current_scope)
         receiver_node = call_node.receiver
         receiver_type =
           if receiver_node
@@ -1065,6 +1121,14 @@ module Rigor
       end
 
       def lookup_post_return_arg(call_node, method_def, target_name)
+        # Plugin-source contributions arrive without an
+        # authoritative method_def (the plugin recognised the
+        # call shape directly). Parameter-targeting falls back
+        # to "no narrow" in that case — the wider plugin-side
+        # parameter mapping (`:local` / `:argument_at`) is a
+        # follow-up slice.
+        return nil if method_def.nil?
+
         arguments = call_node.arguments&.arguments || []
         method_def.method_types.each do |mt|
           params = mt.type.required_positionals + mt.type.optional_positionals
@@ -1330,6 +1394,8 @@ module Rigor
              .with_class_ivars(scope.class_ivars)
              .with_class_cvars(scope.class_cvars)
              .with_program_globals(scope.program_globals)
+             .with_discovered_methods(scope.discovered_methods)
+             .with_discovered_method_visibilities(scope.discovered_method_visibilities)
       end
 
       def singleton_def?(def_node)
@@ -1437,7 +1503,7 @@ module Rigor
       EXIT_CALL_NAMES = %i[raise throw exit abort fail].freeze
       private_constant :EXIT_CALL_NAMES
 
-      def branch_unconditionally_exits?(node) # rubocop:disable Metrics/CyclomaticComplexity
+      def branch_unconditionally_exits?(node)
         return false if node.nil?
 
         case node
@@ -1543,7 +1609,6 @@ module Rigor
       # Returns an array of `[Symbol, Rigor::Type]` pairs for every
       # variable captured by `pattern`. Unrecognised pattern nodes
       # contribute no bindings (fail-soft).
-      # rubocop:disable Metrics/CyclomaticComplexity
       def collect_in_pattern_bindings(subject, pattern, scope)
         case pattern
         when Prism::CapturePatternNode
@@ -1565,7 +1630,6 @@ module Rigor
           []
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def collect_array_pattern_bindings(pattern, scope)
         bindings = [*pattern.requireds, *pattern.posts].flat_map do |elem|

data/lib/rigor/plugin/io_boundary.rb

@@ -137,7 +137,6 @@ module Rigor
     # to the same `#get(url, timeout:, max_bytes:)` shape so the
     # tests don't require network access.
     class DefaultHttpClient
-      # rubocop:disable Metrics/MethodLength
       def get(url, timeout:, max_bytes:)
         require "net/http"
         require "uri"
@@ -169,7 +168,6 @@ module Rigor
         end
         body
       end
-      # rubocop:enable Metrics/MethodLength
     end
   end
 end

data/lib/rigor/plugin/loader.rb

@@ -81,7 +81,7 @@ module Rigor
       #   "rigor-rails"
       #   { "gem" => "rigor-rails", "id" => "rails", "config" => {...} }
       #   { gem: "rigor-rails", id: "rails", config: {...} }
-      def normalise_entry(raw, index) # rubocop:disable Metrics/CyclomaticComplexity
+      def normalise_entry(raw, index)
         case raw
         when String
           { gem: raw, id: nil, config: {} }
@@ -136,7 +136,7 @@ module Rigor
         )
       end
 
-      def lookup_plugin_class!(entry, newly_registered) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      def lookup_plugin_class!(entry, newly_registered)
         if entry[:id]
           plugin_class = Plugin.registered_for(entry[:id])
           unless plugin_class

data/lib/rigor/plugin/manifest.rb

@@ -11,7 +11,7 @@ module Rigor
     # The fields are pinned by ADR-2 § "Registration, Configuration,
     # and Caching"; the v0.1.0 plugin contract surface treats this
     # struct as the public manifest shape.
-    class Manifest # rubocop:disable Metrics/ClassLength
+    class Manifest
       # Same regex {Rigor::Cache::Store::VALID_PRODUCER_ID} uses,
       # so plugin ids round-trip through cache producer ids and
       # `plugin.<id>.<rule>` diagnostic identifiers without escape.
@@ -31,32 +31,38 @@ module Rigor
       # topological sort + missing-producer detection (slice 5);
       # slice 4 carries the declarations on the manifest but the
       # loader does not yet enforce them.
-      Consumption = Data.define(:plugin_id, :name, :optional) do
+      class Consumption < Data.define(:plugin_id, :name, :optional)
         def initialize(plugin_id:, name:, optional: false)
           super(plugin_id: plugin_id.to_s, name: name.to_sym, optional: optional ? true : false)
         end
       end
 
-      attr_reader :id, :version, :description, :protocols, :config_schema, :produces, :consumes
+      attr_reader :id, :version, :description, :protocols, :config_schema, :produces, :consumes,
+                  :owns_receivers, :type_node_resolvers
 
       def initialize( # rubocop:disable Metrics/ParameterLists
         id:, version:,
         description: nil, protocols: [], config_schema: {},
-        produces: [], consumes: []
+        produces: [], consumes: [], owns_receivers: [], type_node_resolvers: []
       )
         validate_id!(id)
         validate_version!(version)
         validate_protocols!(protocols)
         validate_config_schema!(config_schema)
         validate_produces!(produces)
+        validate_owns_receivers!(owns_receivers)
+        validate_type_node_resolvers!(type_node_resolvers)
 
-        assign_fields(id, version, description, protocols, config_schema, produces, consumes)
+        assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
+                      type_node_resolvers)
         freeze
       end
 
       private
 
-      def assign_fields(id, version, description, protocols, config_schema, produces, consumes) # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/ParameterLists
+      def assign_fields(id, version, description, protocols, config_schema, produces, consumes, owns_receivers,
+                        type_node_resolvers)
         @id = id.dup.freeze
         @version = version.dup.freeze
         @description = description.nil? ? nil : description.to_s.dup.freeze
@@ -64,7 +70,10 @@ module Rigor
         @config_schema = config_schema.to_h { |k, v| [k.to_s.dup.freeze, v.to_sym] }.freeze
         @produces = produces.map(&:to_sym).freeze
         @consumes = coerce_consumes(consumes)
+        @owns_receivers = owns_receivers.map { |c| c.to_s.dup.freeze }.freeze
+        @type_node_resolvers = type_node_resolvers.dup.freeze
       end
+      # rubocop:enable Metrics/ParameterLists
 
       public
 
@@ -99,7 +108,9 @@ module Rigor
           "protocols" => protocols.map(&:to_s),
           "config_schema" => config_schema.to_h { |k, v| [k, v.to_s] },
           "produces" => produces.map(&:to_s),
-          "consumes" => consumes.map { |c| consumption_hash(c) }
+          "consumes" => consumes.map { |c| consumption_hash(c) },
+          "owns_receivers" => owns_receivers,
+          "type_node_resolvers" => type_node_resolvers.map { |r| r.class.name }
         }
       end
 
@@ -166,6 +177,37 @@ module Rigor
         raise ArgumentError, "plugin manifest produces must be an Array of Symbol/String, got #{produces.inspect}"
       end
 
+      # ADR-10 5a — `owns_receivers:` declares the class names
+      # this plugin claims sole ownership of. The dispatcher's
+      # dependency-source-inference tier consults this list
+      # before consulting its own catalog: receivers owned by a
+      # registered plugin (directly or via subclass) decline,
+      # so plugin contributions stay authoritative for those
+      # types.
+      def validate_owns_receivers!(owns_receivers)
+        return if owns_receivers.is_a?(Array) && owns_receivers.all? { |c| c.is_a?(String) && !c.empty? }
+
+        raise ArgumentError,
+              "plugin manifest owns_receivers must be an Array of non-empty String, " \
+              "got #{owns_receivers.inspect}"
+      end
+
+      # ADR-13 slice 2 — `type_node_resolvers:` declares the
+      # plugin-supplied `TypeNodeResolver` instances the parser
+      # consults (in slice 3) when an RBS::Extended payload's
+      # named- or generic-type head misses the built-in registry.
+      # Slice 2 carries the declarations on the manifest and the
+      # registry exposes them in registration order; the parser
+      # integration that actually drives the chain lands in
+      # slice 3.
+      def validate_type_node_resolvers!(resolvers)
+        return if resolvers.is_a?(Array) && resolvers.all?(TypeNodeResolver)
+
+        raise ArgumentError,
+              "plugin manifest type_node_resolvers must be an Array of " \
+              "Rigor::Plugin::TypeNodeResolver instances, got #{resolvers.inspect}"
+      end
+
       def coerce_consumes(consumes)
         unless consumes.is_a?(Array)
           raise ArgumentError, "plugin manifest consumes must be an Array, got #{consumes.inspect}"

data/lib/rigor/plugin/registry.rb

@@ -44,6 +44,17 @@ module Rigor
         !load_errors.empty?
       end
 
+      # ADR-13 slice 2 — flat ordered list of every loaded
+      # plugin's manifest-declared {TypeNodeResolver} instances,
+      # in plugin registration order. Slice 3 wires this into
+      # the parser's resolver chain; until then the method is a
+      # read-side aggregator only. The first non-nil
+      # `#resolve(node, scope)` return wins per ADR-13 WD3 / WD5
+      # — registration order is the user's lever.
+      def type_node_resolvers
+        plugins.flat_map { |plugin| plugin.manifest.type_node_resolvers }
+      end
+
       EMPTY = new.freeze
     end
   end

data/lib/rigor/plugin/services.rb

@@ -42,7 +42,7 @@ module Rigor
     class Services
       attr_reader :reflection, :type, :configuration, :cache_store, :trust_policy, :fact_store
 
-      def initialize( # rubocop:disable Metrics/ParameterLists
+      def initialize(
         reflection:, type:, configuration:,
         cache_store: nil, trust_policy: nil, fact_store: nil
       )

data/lib/rigor/plugin/type_node_resolver.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # Plugin-supplied resolver for custom named / generic type
+    # vocabulary in RBS::Extended payloads. ADR-13 § "Decision".
+    #
+    # Subclasses override {#resolve} to return a
+    # {Rigor::Type::Base} when the node matches the vocabulary
+    # the resolver covers, or `nil` to fall through to the next
+    # resolver in the chain (and finally to the built-in / RBS
+    # fallback). The base implementation returns `nil` so an
+    # unimplemented subclass is a safe no-op.
+    #
+    # Resolvers are registered through their plugin's manifest
+    # under the `type_node_resolvers:` slot:
+    #
+    #   class RigorTypescriptUtilityTypes < Rigor::Plugin::Base
+    #     manifest(
+    #       id: "typescript-utility-types",
+    #       version: "0.1.0",
+    #       type_node_resolvers: [Resolvers::Pick.new,
+    #                             Resolvers::Omit.new]
+    #     )
+    #   end
+    #
+    # Slice 2 of the ADR-13 envelope (this file) ships the base
+    # class + manifest hook + registry aggregation. The parser-
+    # side wiring that actually consults the resolver chain
+    # arrives in slice 3, when {Rigor::TypeNode::NameScope} and
+    # the dispatcher between {Rigor::Builtins::ImportedRefinements::Parser}
+    # and the chain land. Until then resolvers can be unit-tested
+    # in isolation but never run for a real `%a{rigor:v1:...}`
+    # payload.
+    #
+    # Resolvers SHOULD be stateless and re-entrant; the registry
+    # builds the chain once per `Analysis::Runner.run` and may
+    # consult any resolver multiple times for the same node.
+    class TypeNodeResolver
+      # @param node [Rigor::TypeNode::Identifier, Rigor::TypeNode::Generic]
+      #   the parser-emitted node the chain is asking about.
+      # @param scope [Rigor::TypeNode::NameScope] companion
+      #   value object (slice 3); slice 2 invocations MAY pass
+      #   `nil` because the chain doesn't exist yet.
+      # @return [Rigor::Type::Base, nil] resolved type, or `nil`
+      #   to fall through.
+      def resolve(node, scope) # rubocop:disable Lint/UnusedMethodArgument
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/plugin.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "plugin/type_node_resolver"
 require_relative "plugin/manifest"
 require_relative "plugin/access_denied_error"
 require_relative "plugin/trust_policy"

data/lib/rigor/rbs_extended/reporter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Rigor
+  module RbsExtended
+    # ADR-13 slice 3b — per-run accumulator for `RBS::Extended`
+    # diagnostic events that the parser / resolver cannot surface
+    # at the point of failure (the parsers are fail-soft, returning
+    # `nil` so call sites fall back to the RBS-declared type).
+    #
+    # Owns two event streams:
+    #
+    # - `#unresolved_payloads` — `rigor:v1:*` directive payloads
+    #   the resolver could not turn into a {Rigor::Type}. Surface
+    #   as `dynamic.rbs-extended.unresolved` `:info` diagnostics.
+    # - `#lossy_projections` — shape-projection type functions
+    #   (`pick_of` / `omit_of` / `partial_of` / `required_of` /
+    #   `readonly_of`) applied to a carrier that does not preserve
+    #   shape information (anything other than `Type::HashShape`
+    #   / `Type::Tuple`). Surface as
+    #   `dynamic.shape.lossy-projection` `:info` diagnostics.
+    #
+    # Mutable through the run; consumed once by
+    # {Rigor::Analysis::Runner} at end-of-run. Each event is
+    # deduplicated by `(payload, source_location)` for unresolved
+    # and `(head, source_location)` for lossy-projection so a
+    # single annotation read from many call sites yields one
+    # diagnostic.
+    #
+    # The reporter is intentionally thread-safe via a coarse
+    # `Mutex` because the inference engine may read the same
+    # method definition from multiple files in parallel; the
+    # critical sections are short (Array#include? + Array#<<) so
+    # the lock contention is negligible.
+    class Reporter
+      UnresolvedEntry = Data.define(:payload, :source_location)
+      LossyProjectionEntry = Data.define(:head, :source_location)
+
+      def initialize
+        @unresolved_payloads = []
+        @lossy_projections = []
+        @mutex = Mutex.new
+      end
+
+      # @return [Array<UnresolvedEntry>] frozen snapshot of the
+      #   accumulated unresolved-payload events.
+      def unresolved_payloads
+        @mutex.synchronize { @unresolved_payloads.dup.freeze }
+      end
+
+      # @return [Array<LossyProjectionEntry>] frozen snapshot of
+      #   the accumulated lossy-projection events.
+      def lossy_projections
+        @mutex.synchronize { @lossy_projections.dup.freeze }
+      end
+
+      # Records a `dynamic.rbs-extended.unresolved` event. The
+      # `source_location` argument is the {RBS::Location} attached
+      # to the source annotation (or `nil` when the caller doesn't
+      # have one — the diagnostic falls back to a generic
+      # location in that case).
+      def record_unresolved(payload:, source_location: nil)
+        entry = UnresolvedEntry.new(payload: payload.to_s, source_location: source_location)
+        @mutex.synchronize do
+          return if @unresolved_payloads.include?(entry)
+
+          @unresolved_payloads << entry
+        end
+      end
+
+      # Records a `dynamic.shape.lossy-projection` event for one
+      # of the five shape-projection heads. `head` MUST be a
+      # String (`"pick_of"`, `"omit_of"`, …); the diagnostic
+      # message identifies which projection degraded.
+      def record_lossy_projection(head:, source_location: nil)
+        entry = LossyProjectionEntry.new(head: head.to_s, source_location: source_location)
+        @mutex.synchronize do
+          return if @lossy_projections.include?(entry)
+
+          @lossy_projections << entry
+        end
+      end
+
+      # True when no events have accumulated. Used by callers
+      # that want to skip the diagnostic-emission pass entirely
+      # on the common no-event path.
+      def empty?
+        @mutex.synchronize { @unresolved_payloads.empty? && @lossy_projections.empty? }
+      end
+    end
+  end
+end