rigortype 0.1.0 → 0.1.1

data/lib/rigor/plugin/base.rb

@@ -111,6 +111,49 @@ module Rigor
         nil
       end
 
+      # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
+      # slice 7 — per-call return-type contribution hook. When
+      # the inference engine dispatches a `Prism::CallNode` and
+      # neither the precision tiers nor RBS resolve a result,
+      # `MethodDispatcher` consults each loaded plugin via this
+      # hook ahead of `RbsDispatch`. Plugins that override the
+      # default return a {Rigor::FlowContribution} bundle whose
+      # `return_type` slot pins the call site's result type.
+      #
+      # Default returns nil — plugins that don't refine return
+      # types skip the override. Failures are isolated: a hook
+      # that raises gets its contribution dropped silently for
+      # this call so the rest of the dispatch chain continues.
+      def flow_contribution_for(call_node:, scope:) # rubocop:disable Lint/UnusedMethodArgument
+        nil
+      end
+
+      # ADR-9 slice 3 — per-run preparation hook. The runner
+      # invokes `#prepare(services)` on every loaded plugin once
+      # per `Analysis::Runner.run`, after `#init` has run on every
+      # plugin and before any `#diagnostics_for_file` call.
+      # Plugins use this hook to compute and publish facts other
+      # plugins consume:
+      #
+      #   def prepare(services)
+      #     services.fact_store.publish(
+      #       plugin_id: manifest.id, name: :model_index, value: model_index
+      #     )
+      #   end
+      #
+      # Default no-op so plugins without facts to publish leave
+      # `#prepare` unimplemented. Failures isolate as
+      # `:plugin_loader runtime-error` diagnostics; a plugin that
+      # raises in `#prepare` has its facts considered un-published
+      # and downstream consumers see `nil` from `fact_store.read`.
+      #
+      # Slice 3 calls plugins in registration order. ADR-9 slice 5
+      # introduces topological ordering by `consumes:` so producers
+      # always run before consumers.
+      def prepare(services) # rubocop:disable Lint/UnusedMethodArgument
+        nil
+      end
+
       # ADR-7 § "Slice 5-A" — per-file diagnostic emission hook.
       # Override in plugin subclasses to return an array of
       # `Rigor::Analysis::Diagnostic` rows for the analysed file.

data/lib/rigor/plugin/fact_store.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # Per-run cross-plugin fact store. ADR-9 § "Plugin::FactStore".
+    #
+    # A plugin publishes typed `(plugin_id, name) -> value` tuples
+    # in its `Plugin::Base#prepare(services)` hook (slice 3); other
+    # plugins read them in `#diagnostics_for_file` via
+    # `services.fact_store.read(plugin_id:, name:)`. The store is
+    # constructed fresh at the start of every `Analysis::Runner.run`
+    # and discarded at the end — caching the underlying expensive
+    # computation is the producer's job (`Plugin::Base.producer`);
+    # the FactStore just publishes a *reference* to that
+    # already-cached result.
+    #
+    # `(plugin_id, name)` is a unique key. A second `publish` with
+    # the same value is a no-op (`==` comparison); a second
+    # `publish` with a different value raises {Conflict}. Since
+    # `plugin_id` namespaces the key, a real conflict only happens
+    # when a single plugin publishes twice with differing values —
+    # the conflict signals a plugin-author bug, never a load-time
+    # interaction between unrelated plugins.
+    class FactStore
+      Fact = Data.define(:plugin_id, :name, :value)
+
+      class Conflict < StandardError
+        attr_reader :plugin_id, :name, :existing, :incoming
+
+        def initialize(plugin_id:, name:, existing:, incoming:)
+          @plugin_id = plugin_id
+          @name = name
+          @existing = existing
+          @incoming = incoming
+          super(
+            "fact store conflict: plugin #{plugin_id.inspect} published " \
+            "two different values for #{name.inspect} " \
+            "(existing: #{existing.inspect}, incoming: #{incoming.inspect})"
+          )
+        end
+      end
+
+      def initialize
+        @facts = {}
+        @mutex = Mutex.new
+      end
+
+      # Writes a `(plugin_id, name) -> value` triple. Idempotent if
+      # the same value is published twice (`==`); raises
+      # {Conflict} if the values differ.
+      #
+      # @param plugin_id [String] producing plugin's manifest id.
+      # @param name [Symbol, String] fact name (canonicalised to
+      #   Symbol for lookup).
+      # @param value [Object] frozen-shape value object the
+      #   producer chose to publish. The value is stored as-is.
+      def publish(plugin_id:, name:, value:)
+        plugin_id = plugin_id.to_s
+        name = name.to_sym
+        @mutex.synchronize do
+          existing = @facts[[plugin_id, name]]
+          if existing && existing.value != value
+            raise Conflict.new(plugin_id: plugin_id, name: name, existing: existing.value, incoming: value)
+          end
+
+          @facts[[plugin_id, name]] = Fact.new(plugin_id: plugin_id, name: name, value: value)
+        end
+        nil
+      end
+
+      # @return [Object, nil] the published value, or `nil` when no
+      #   fact is registered. Reads do NOT establish a dependency —
+      #   `manifest(consumes:)` (slice 4) is the dependency
+      #   declaration mechanism.
+      def read(plugin_id:, name:)
+        fact = @mutex.synchronize { @facts[[plugin_id.to_s, name.to_sym]] }
+        fact&.value
+      end
+
+      # @return [Boolean] whether a fact is registered.
+      def published?(plugin_id:, name:)
+        @mutex.synchronize { @facts.key?([plugin_id.to_s, name.to_sym]) }
+      end
+
+      # @yield [Fact] every published fact in publication order.
+      def each_fact(&)
+        snapshot = @mutex.synchronize { @facts.values }
+        snapshot.each(&)
+      end
+    end
+  end
+end

data/lib/rigor/plugin/load_error.rb

@@ -11,12 +11,24 @@ module Rigor
     # to be isolated at the analyzer boundary; this class is the
     # carrier for that contract on the loading side.
     class LoadError < StandardError
-      attr_reader :plugin_ref, :cause_class
+      attr_reader :plugin_ref, :cause_class, :reason
 
-      def initialize(message, plugin_ref:, cause: nil)
+      # ADR-9 slice 5 introduces two new reason codes alongside the
+      # implicit "load failure" used for require / configuration /
+      # init failures:
+      #
+      #   - `:missing-producer` — a non-optional `manifest(consumes:)`
+      #     entry names a `(plugin_id, name)` no loaded plugin
+      #     produces.
+      #   - `:dependency-cycle` — the consumes graph forms a cycle.
+      #
+      # Older callers omit `reason:` and the field defaults to nil
+      # (the legacy "load failure" envelope).
+      def initialize(message, plugin_ref:, cause: nil, reason: nil)
         super(message)
         @plugin_ref = plugin_ref
         @cause_class = cause&.class
+        @reason = reason&.to_sym
       end
     end
   end

data/lib/rigor/plugin/loader.rb

@@ -63,6 +63,15 @@ module Rigor
           end
         end
 
+        # ADR-9 slice 5 — topological sort by `manifest(consumes:)`
+        # so producers run before consumers, plus early
+        # `missing-producer` validation. Cycles surface as
+        # `dependency-cycle` LoadErrors. When validation fails, the
+        # offending plugin(s) drop from the returned plugins list
+        # and the LoadError surfaces alongside any earlier failure.
+        plugins, sort_errors = topo_sort_plugins(plugins)
+        load_errors.concat(sort_errors)
+
         Registry.new(plugins: plugins, load_errors: load_errors)
       end
 
@@ -186,6 +195,113 @@ module Rigor
       rescue StandardError
         plugin_class.to_s
       end
+
+      # ADR-9 slice 5 — topological sort of plugins by their
+      # `manifest(consumes:)` declarations. Returns `[sorted_plugins,
+      # load_errors]`. Determinism: when no dependency relation
+      # forces an order, plugins are visited alphabetically by
+      # manifest id. A non-optional consume of a `(plugin_id, name)`
+      # whose producer is missing emits a `:missing-producer`
+      # LoadError and drops the consumer; cycles emit a
+      # `:dependency-cycle` LoadError naming the offending chain.
+      def topo_sort_plugins(plugins)
+        # If no plugin opts into the cross-plugin API the loader's
+        # legacy configuration-order contract is preserved
+        # unchanged. Topo sort and missing-producer validation only
+        # run when at least one plugin declares `consumes:`.
+        return [plugins, []] unless plugins.any? { |p| p.manifest.consumes.any? }
+
+        index = plugins.to_h { |plugin| [plugin.manifest.id, plugin] }
+        errors = validate_missing_producers(plugins, index)
+        sortable = plugins.reject { |p| errors.any? { |e| e.plugin_ref == p.manifest.id } }
+        config_order = plugins.each_with_index.to_h { |plugin, i| [plugin.manifest.id, i] }
+
+        sort_in_topo_order(sortable, index, errors, config_order)
+      end
+
+      def validate_missing_producers(plugins, index)
+        errors = []
+        plugins.each do |plugin|
+          plugin.manifest.consumes.each do |consume|
+            next if consume.optional
+            next if index.key?(consume.plugin_id) && producer_provides?(index[consume.plugin_id], consume.name)
+
+            errors << LoadError.new(
+              "plugin #{plugin.manifest.id.inspect} consumes " \
+              "#{consume.plugin_id.inspect}/#{consume.name} but no loaded plugin " \
+              "with that id declares `produces: [#{consume.name.inspect}]`",
+              plugin_ref: plugin.manifest.id,
+              reason: :"missing-producer"
+            )
+          end
+        end
+        errors
+      end
+
+      def producer_provides?(producer, name)
+        producer.manifest.produces.include?(name)
+      end
+
+      # Kahn's algorithm with `Configuration#plugins`-order
+      # tie-break. Edges go from producer -> consumer (producer
+      # must visit first). When two plugins are simultaneously
+      # ready, the configuration-order index decides the visit
+      # order — preserves the v0.1.0 legacy contract for plugins
+      # without dependencies.
+      def sort_in_topo_order(plugins, index, errors, config_order)
+        in_degree, forward = build_consumes_graph(plugins, index, errors)
+        ordered, cycle_errors = kahn_walk(plugins, in_degree, forward, config_order)
+        [ordered, errors + cycle_errors]
+      end
+
+      def build_consumes_graph(plugins, index, errors)
+        in_degree = Hash.new(0)
+        forward = Hash.new { |h, k| h[k] = [] }
+        plugins.each do |consumer|
+          consumer.manifest.consumes.each do |consume|
+            next unless index.key?(consume.plugin_id)
+            next if errors.any? { |e| e.plugin_ref == consume.plugin_id }
+
+            forward[consume.plugin_id] << consumer.manifest.id
+            in_degree[consumer.manifest.id] += 1
+          end
+        end
+        [in_degree, forward]
+      end
+
+      def kahn_walk(plugins, in_degree, forward, config_order)
+        order = ->(plugin) { config_order.fetch(plugin.manifest.id, Float::INFINITY) }
+        ready = plugins.select { |p| in_degree[p.manifest.id].zero? }.sort_by(&order)
+        result = kahn_collect(plugins, in_degree, forward, ready, order)
+
+        return [result, []] if result.size == plugins.size
+
+        cycled = plugins - result
+        [result, [dependency_cycle_error(cycled)]]
+      end
+
+      def kahn_collect(plugins, in_degree, forward, ready, order)
+        result = []
+        until ready.empty?
+          plugin = ready.shift
+          result << plugin
+          forward[plugin.manifest.id].each do |consumer_id|
+            in_degree[consumer_id] -= 1
+            ready << plugins.find { |p| p.manifest.id == consumer_id } if in_degree[consumer_id].zero?
+          end
+          ready.sort_by!(&order)
+        end
+        result
+      end
+
+      def dependency_cycle_error(cycled)
+        ids = cycled.map { |p| p.manifest.id }.sort
+        LoadError.new(
+          "plugin dependency cycle through `manifest(consumes:)`: #{ids.inspect}",
+          plugin_ref: ids.first,
+          reason: :"dependency-cycle"
+        )
+      end
     end
   end
 end

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
+    class Manifest # rubocop:disable Metrics/ClassLength
       # 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.
@@ -23,23 +23,51 @@ module Rigor
       # the v0.1.0 protocol slices need them.
       VALID_VALUE_KINDS = %i[string boolean integer array hash any].freeze
 
-      attr_reader :id, :version, :description, :protocols, :config_schema
+      # ADR-9 slice 4 — declared cross-plugin fact dependencies.
+      # `produces:` lists the names this plugin publishes through
+      # its `#prepare(services)` hook. `consumes:` lists the
+      # `(plugin_id, name)` pairs this plugin reads from
+      # `services.fact_store`. The loader uses both for
+      # 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
+        def initialize(plugin_id:, name:, optional: false)
+          super(plugin_id: plugin_id.to_s, name: name.to_sym, optional: optional ? true : false)
+        end
+      end
 
-      def initialize(id:, version:, description: nil, protocols: [], config_schema: {})
+      attr_reader :id, :version, :description, :protocols, :config_schema, :produces, :consumes
+
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        id:, version:,
+        description: nil, protocols: [], config_schema: {},
+        produces: [], consumes: []
+      )
         validate_id!(id)
         validate_version!(version)
         validate_protocols!(protocols)
         validate_config_schema!(config_schema)
+        validate_produces!(produces)
+
+        assign_fields(id, version, description, protocols, config_schema, produces, consumes)
+        freeze
+      end
+
+      private
 
+      def assign_fields(id, version, description, protocols, config_schema, produces, consumes) # rubocop:disable Metrics/ParameterLists
         @id = id.dup.freeze
         @version = version.dup.freeze
         @description = description.nil? ? nil : description.to_s.dup.freeze
         @protocols = protocols.map(&:to_sym).freeze
         @config_schema = config_schema.to_h { |k, v| [k.to_s.dup.freeze, v.to_sym] }.freeze
-
-        freeze
+        @produces = produces.map(&:to_sym).freeze
+        @consumes = coerce_consumes(consumes)
       end
 
+      public
+
       # Validates the user-supplied plugin config block against this
       # manifest's `config_schema`. Returns an array of human-readable
       # error strings (empty when the config is valid). Slice 1 checks
@@ -69,7 +97,9 @@ module Rigor
           "version" => version,
           "description" => description,
           "protocols" => protocols.map(&:to_s),
-          "config_schema" => config_schema.to_h { |k, v| [k, v.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) }
         }
       end
 
@@ -129,6 +159,45 @@ module Rigor
         else false
         end
       end
+
+      def validate_produces!(produces)
+        return if produces.is_a?(Array) && produces.all? { |p| p.is_a?(Symbol) || p.is_a?(String) }
+
+        raise ArgumentError, "plugin manifest produces must be an Array of Symbol/String, got #{produces.inspect}"
+      end
+
+      def coerce_consumes(consumes)
+        unless consumes.is_a?(Array)
+          raise ArgumentError, "plugin manifest consumes must be an Array, got #{consumes.inspect}"
+        end
+
+        consumes.map { |entry| coerce_consumption(entry) }.freeze
+      end
+
+      def coerce_consumption(entry)
+        case entry
+        when Consumption then entry
+        when Hash then build_consumption_from_hash(entry)
+        else raise ArgumentError,
+                   "plugin manifest consumes entry must be a Hash or Consumption, got #{entry.inspect}"
+        end
+      end
+
+      def consumption_hash(consumption)
+        { "plugin_id" => consumption.plugin_id, "name" => consumption.name.to_s, "optional" => consumption.optional }
+      end
+
+      def build_consumption_from_hash(entry)
+        plugin_id = entry[:plugin_id] || entry["plugin_id"]
+        name = entry[:name] || entry["name"]
+        optional = entry.key?(:optional) ? entry[:optional] : entry["optional"]
+        if plugin_id.nil? || name.nil?
+          raise ArgumentError,
+                "plugin manifest consumes entry missing plugin_id/name: #{entry.inspect}"
+        end
+
+        Consumption.new(plugin_id: plugin_id, name: name, optional: optional || false)
+      end
     end
   end
 end

data/lib/rigor/plugin/services.rb

@@ -31,15 +31,27 @@ module Rigor
     # raw `File.read` so reads stay within the trusted scope and
     # feed cache invalidation; ADR-2 § "Plugin Trust and I/O
     # Policy" documents the trust model the boundary enforces.
+    #
+    # ADR-9 slice 2 adds `fact_store`: the per-run cross-plugin
+    # `Plugin::FactStore`. Producer plugins publish their facts
+    # in `#prepare(services)` (slice 3); consumer plugins read in
+    # `#diagnostics_for_file` via `services.fact_store.read(...)`.
+    # A fresh `FactStore` instance is constructed per Services
+    # when none is supplied — the runner threads its own instance
+    # in once slice 3 wires `#prepare` invocation.
     class Services
-      attr_reader :reflection, :type, :configuration, :cache_store, :trust_policy
+      attr_reader :reflection, :type, :configuration, :cache_store, :trust_policy, :fact_store
 
-      def initialize(reflection:, type:, configuration:, cache_store: nil, trust_policy: nil)
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        reflection:, type:, configuration:,
+        cache_store: nil, trust_policy: nil, fact_store: nil
+      )
         @reflection = reflection
         @type = type
         @configuration = configuration
         @cache_store = cache_store
         @trust_policy = trust_policy || default_trust_policy
+        @fact_store = fact_store || FactStore.new
         freeze
       end
 

data/lib/rigor/plugin.rb

@@ -4,6 +4,7 @@ require_relative "plugin/manifest"
 require_relative "plugin/access_denied_error"
 require_relative "plugin/trust_policy"
 require_relative "plugin/io_boundary"
+require_relative "plugin/fact_store"
 require_relative "plugin/services"
 require_relative "plugin/base"
 require_relative "plugin/registry"

data/lib/rigor/trinary.rb

@@ -58,7 +58,7 @@ module Rigor
       case value
       when :yes then self.class.no
       when :no then self.class.yes
-      when :maybe then self.class.maybe
+      else self.class.maybe
       end
     end
 

data/lib/rigor/type/integer_range.rb

@@ -66,12 +66,16 @@ module Rigor
       # `:neg_infinity` directly with an `Integer`.
       def lower
         m = min
-        m.is_a?(Symbol) ? -Float::INFINITY : m
+        return m if m.is_a?(Integer)
+
+        -Float::INFINITY
       end
 
       def upper
         m = max
-        m.is_a?(Symbol) ? Float::INFINITY : m
+        return m if m.is_a?(Integer)
+
+        Float::INFINITY
       end
 
       ALIAS_NAMES = {

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/sig/rigor/environment.rbs

@@ -6,11 +6,12 @@ module Rigor
 
     attr_reader class_registry: ClassRegistry
     attr_reader rbs_loader: RbsLoader?
+    attr_reader plugin_registry: untyped?
 
     def self.default: () -> Environment
-    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?) -> Environment
+    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?) -> Environment
 
-    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?) -> void
+    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?) -> void
     def nominal_for_name: (String | Symbol name) -> Type::Nominal?
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?
     def constant_for_name: (String | Symbol name) -> Type::t?

data/sig/rigor.rbs

@@ -64,8 +64,14 @@ module Rigor
     class Runner
       RUBY_GLOB: String
       DEFAULT_CACHE_ROOT: String
-      attr_reader cache_store: Rigor::Cache::Store?
-      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: Rigor::Cache::Store?) -> void
+      # `Rigor::Cache::Store` itself is not yet sig-covered (the
+      # cache namespace is in `UNSIGNED_NAMESPACES` per
+      # `spec/rigor/public_api_drift_spec.rb`), so reference it as
+      # `untyped` until the full Cache::Store sig lands. Steep
+      # otherwise raises `RBS::UnknownTypeName` for the named type.
+      attr_reader cache_store: untyped
+      attr_reader plugin_registry: untyped
+      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped) -> void
       def run: (?Array[String] paths) -> Result
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Rigor contributors
@@ -191,6 +191,7 @@ files:
 - lib/rigor/ast.rb
 - lib/rigor/ast/type_node.rb
 - lib/rigor/builtins/imported_refinements.rb
+- lib/rigor/builtins/regex_refinement.rb
 - lib/rigor/cache/descriptor.rb
 - lib/rigor/cache/rbs_class_ancestor_table.rb
 - lib/rigor/cache/rbs_class_type_param_names.rb
@@ -265,6 +266,7 @@ files:
 - lib/rigor/plugin.rb
 - lib/rigor/plugin/access_denied_error.rb
 - lib/rigor/plugin/base.rb
+- lib/rigor/plugin/fact_store.rb
 - lib/rigor/plugin/io_boundary.rb
 - lib/rigor/plugin/load_error.rb
 - lib/rigor/plugin/loader.rb