rigortype 0.0.8 → 0.1.0

data/lib/rigor/plugin/registry.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # Read-side query API over the plugins loaded for a single
+    # `Analysis::Runner.run`. Constructed by
+    # {Rigor::Plugin::Loader.load} and exposed downstream so the
+    # contribution merger (slice 3) and diagnostic provenance
+    # (slice 5) can iterate over loaded plugin instances in
+    # deterministic order.
+    #
+    # The registry is read-only after construction; ordering is
+    # the order in which {Rigor::Plugin::Loader} resolved
+    # configuration entries, which is project-config order with
+    # plugin-id alphabetical as the tie-breaker.
+    class Registry
+      attr_reader :plugins, :load_errors
+
+      # @param plugins [Array<Rigor::Plugin::Base>] instantiated
+      #   plugin instances in deterministic order.
+      # @param load_errors [Array<Rigor::Plugin::LoadError>] failures
+      #   surfaced during loading. Each error is also turned into a
+      #   diagnostic by the runner.
+      def initialize(plugins: [], load_errors: [])
+        @plugins = plugins.dup.freeze
+        @load_errors = load_errors.dup.freeze
+        freeze
+      end
+
+      def find(id)
+        id_s = id.to_s
+        plugins.find { |plugin| plugin.manifest.id == id_s }
+      end
+
+      def ids
+        plugins.map { |plugin| plugin.manifest.id }
+      end
+
+      def empty?
+        plugins.empty?
+      end
+
+      def any_load_errors?
+        !load_errors.empty?
+      end
+
+      EMPTY = new.freeze
+    end
+  end
+end

data/lib/rigor/plugin/services.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # Dependency-injection container handed to every plugin's
+    # {Rigor::Plugin::Base#init} method. Plugins read from the
+    # container; they MUST NOT mutate it. The container is
+    # constructed once per `Analysis::Runner.run` and destroyed
+    # at the end of the run.
+    #
+    # ADR-2 § "Registration, Configuration, and Caching" reserves
+    # this surface for "constructor injection for analyzer
+    # services such as reflection providers, type factories,
+    # loggers, and configuration readers". Slice 1 wires four
+    # of those:
+    #
+    # - `reflection`: the {Rigor::Reflection} read-side facade.
+    # - `type`: the {Rigor::Type::Combinator} factory module.
+    # - `configuration`: the project's {Rigor::Configuration}.
+    # - `cache_store`: the {Rigor::Cache::Store} the run is using
+    #   (or `nil` when caching is disabled). Slice 6 wires
+    #   plugin-side cache producers through this entry.
+    #
+    # Loggers are not yet a public surface in the core analyzer;
+    # they will be added when the diagnostics formatter grows a
+    # progress channel.
+    #
+    # Slice 2 (Plugin trust / I/O policy) extends the container
+    # with `trust_policy` and a per-plugin `io_boundary_for(plugin_id)`
+    # factory. Plugins should reach for the boundary rather than
+    # 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.
+    class Services
+      attr_reader :reflection, :type, :configuration, :cache_store, :trust_policy
+
+      def initialize(reflection:, type:, configuration:, cache_store: nil, trust_policy: nil)
+        @reflection = reflection
+        @type = type
+        @configuration = configuration
+        @cache_store = cache_store
+        @trust_policy = trust_policy || default_trust_policy
+        freeze
+      end
+
+      # Returns a fresh {IoBoundary} bound to `plugin_id` and the
+      # current `trust_policy`. The boundary accumulates per-plugin
+      # cache descriptor entries; the loader / contribution merger
+      # constructs one boundary per plugin per run.
+      def io_boundary_for(plugin_id)
+        IoBoundary.new(policy: @trust_policy, plugin_id: plugin_id)
+      end
+
+      private
+
+      def default_trust_policy
+        TrustPolicy.new(
+          trusted_gems: [],
+          allowed_read_roots: [Dir.pwd],
+          network_policy: :disabled
+        )
+      end
+    end
+  end
+end

data/lib/rigor/plugin/trust_policy.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    # Declarative trust / I/O policy for the active plugin set.
+    # Pinned by [ADR-2 § "Plugin Trust and I/O Policy"](../../../docs/adr/2-extension-api.md):
+    # plugins are *trusted Ruby gems selected by the user, their
+    # Gemfile, or project configuration*; this class is the
+    # programmatic surface that documents that trust and lets the
+    # analyzer enforce read scope + network disablement at the
+    # documented edges.
+    #
+    # The policy is **not a sandbox.** A plugin that uses raw
+    # `File.read` or `Net::HTTP` bypasses the policy — ADR-2
+    # explicitly chooses documentation over forced isolation. The
+    # contract is: when plugins go through {Rigor::Plugin::IoBoundary}
+    # (the analyzer-side helper service slice 2 introduces), the
+    # boundary checks against this policy and feeds compliant reads
+    # into the cache descriptor for invalidation. Slices 3-6 wire
+    # plugin contributions through the boundary so the policy is
+    # the actual mechanism, not just paperwork.
+    #
+    # ## Fields
+    #
+    # - `trusted_gems`: gem names the user has authorised. Derived
+    #   from the `plugins:` section of `.rigor.yml` plus any gems
+    #   they reach transitively. Used today for documentation and
+    #   future trust diagnostics.
+    # - `allowed_read_roots`: absolute paths plugin code may read
+    #   from through the {IoBoundary}. The default set covers the
+    #   project root, the project's `signature_paths`, the active
+    #   `Gemfile.lock`, and each trusted gem's
+    #   `Gem::Specification#full_gem_path`. The user extends this
+    #   with `.rigor.yml`'s `plugins_io.allowed_paths:`.
+    # - `network_policy`: `:disabled` in slice 2; the only value
+    #   accepted today. Plugin {IoBoundary#open_url} always raises
+    #   while the policy is `:disabled`.
+    class TrustPolicy
+      VALID_NETWORK_POLICIES = %i[disabled].freeze
+
+      attr_reader :trusted_gems, :allowed_read_roots, :network_policy
+
+      def initialize(trusted_gems: [], allowed_read_roots: [], network_policy: :disabled)
+        validate_network_policy!(network_policy)
+
+        @trusted_gems = trusted_gems.map { |g| g.to_s.dup.freeze }.uniq.sort.freeze
+        @allowed_read_roots = allowed_read_roots
+                              .map { |path| File.expand_path(path).freeze }
+                              .uniq
+                              .sort
+                              .freeze
+        @network_policy = network_policy
+        freeze
+      end
+
+      # @param path [String]
+      # @return [Boolean] true when the absolute path falls inside
+      #   any allowed read root. Symlinks are resolved through
+      #   `File.expand_path` only (no `realpath`); plugins with
+      #   adversarial intent are out of scope per ADR-2.
+      def allow_read?(path)
+        absolute = File.expand_path(path.to_s)
+        @allowed_read_roots.any? { |root| inside?(absolute, root) }
+      end
+
+      def network_allowed?
+        @network_policy != :disabled
+      end
+
+      def gem_trusted?(name)
+        @trusted_gems.include?(name.to_s)
+      end
+
+      def to_h
+        {
+          "trusted_gems" => trusted_gems,
+          "allowed_read_roots" => allowed_read_roots,
+          "network_policy" => network_policy.to_s
+        }
+      end
+
+      private
+
+      def validate_network_policy!(policy)
+        return if VALID_NETWORK_POLICIES.include?(policy)
+
+        raise ArgumentError,
+              "TrustPolicy network_policy must be one of #{VALID_NETWORK_POLICIES.inspect}, got #{policy.inspect}"
+      end
+
+      def inside?(absolute, root)
+        return true if absolute == root
+
+        prefix = "#{root}#{File::SEPARATOR}"
+        absolute.start_with?(prefix)
+      end
+    end
+  end
+end

data/lib/rigor/plugin.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "plugin/manifest"
+require_relative "plugin/access_denied_error"
+require_relative "plugin/trust_policy"
+require_relative "plugin/io_boundary"
+require_relative "plugin/services"
+require_relative "plugin/base"
+require_relative "plugin/registry"
+require_relative "plugin/load_error"
+
+module Rigor
+  module Plugin
+    @registered = {}
+    @mutex = Mutex.new
+
+    class << self
+      def register(plugin_class)
+        unless plugin_class.is_a?(Class) && plugin_class < Base
+          raise ArgumentError,
+                "Rigor::Plugin.register expects a subclass of Rigor::Plugin::Base, got #{plugin_class.inspect}"
+        end
+
+        manifest = plugin_class.manifest # rigor:disable undefined-method
+        @mutex.synchronize do
+          existing = @registered[manifest.id]
+          if existing && existing != plugin_class
+            raise LoadError.new(
+              "plugin id #{manifest.id.inspect} already registered to #{existing}, " \
+              "cannot re-register to #{plugin_class}",
+              plugin_ref: manifest.id
+            )
+          end
+
+          @registered[manifest.id] = plugin_class
+        end
+        plugin_class
+      end
+
+      def registered_for(id)
+        @mutex.synchronize { @registered[id.to_s] }
+      end
+
+      def registered
+        @mutex.synchronize { @registered.dup.freeze }
+      end
+
+      def unregister!(id = nil)
+        @mutex.synchronize do
+          if id.nil?
+            @registered.clear
+          else
+            @registered.delete(id.to_s)
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "plugin/loader"

data/lib/rigor/rbs_extended.rb

@@ -2,6 +2,7 @@
 
 require_relative "type"
 require_relative "builtins/imported_refinements"
+require_relative "flow_contribution"
 
 module Rigor
   # Slice 7 phase 15 — first-preview reader for the
@@ -63,6 +64,23 @@ module Rigor
       def falsey_only? = edge == :falsey_only
       def negative? = negative == true
       def refinement? = !refinement_type.nil?
+
+      # ADR-7 § "Slice 4-A" canonical translation. Lifts the
+      # parser-side carrier into a `Rigor::FlowContribution::Fact`
+      # that the merger and plugin contribution stream consume
+      # uniformly. `class_name` lifts to `Nominal[<class>]`;
+      # `refinement_type` is already a `Rigor::Type` and passes
+      # through. The `edge` field doesn't survive the conversion —
+      # the slot it lands in (truthy_facts / falsey_facts / ...)
+      # encodes that.
+      def to_fact
+        FlowContribution::Fact.new(
+          target_kind: target_kind,
+          target_name: target_name,
+          type: refinement_type || Rigor::Type::Combinator.nominal_of(class_name),
+          negative: negative == true
+        )
+      end
     end
 
     # Returned for `assert` / `assert-if-true` /
@@ -86,6 +104,21 @@ module Rigor
       def if_falsey_return? = condition == :if_falsey_return
       def negative? = negative == true
       def refinement? = !refinement_type.nil?
+
+      # ADR-7 § "Slice 4-A" canonical translation. Same shape as
+      # `PredicateEffect#to_fact`; the `condition` field
+      # (`:always` / `:if_truthy_return` / `:if_falsey_return`)
+      # routes which slot the resulting fact lands in at the
+      # `read_flow_contribution` boundary, but does not surface
+      # on the Fact itself.
+      def to_fact
+        FlowContribution::Fact.new(
+          target_kind: target_kind,
+          target_name: target_name,
+          type: refinement_type || Rigor::Type::Combinator.nominal_of(class_name),
+          negative: negative == true
+        )
+      end
     end
 
     module_function
@@ -410,5 +443,75 @@ module Rigor
 
       ParamOverride.new(param_name: match[:param].to_sym, type: type)
     end
+
+    # The shared {Rigor::FlowContribution::Provenance} for every
+    # bundle this module produces. `source_family: :rbs_extended`
+    # so consumers (today the documentation surface; v0.1.0 the
+    # plugin contribution merger) can attribute facts back to the
+    # RBS::Extended layer.
+    RBS_EXTENDED_PROVENANCE = FlowContribution::Provenance.new(
+      source_family: :rbs_extended,
+      plugin_id: nil,
+      node: nil,
+      descriptor: nil
+    ).freeze
+
+    # Rolls up every recognised RBS::Extended directive on
+    # `method_def` into a single {Rigor::FlowContribution} with
+    # the canonical {Rigor::FlowContribution::Fact} payload (see
+    # ADR-7 § "Slice 4-A"):
+    #
+    # - `predicate-if-true`        → `truthy_facts`
+    # - `predicate-if-false`       → `falsey_facts`
+    # - `assert`                   → `post_return_facts`
+    # - `assert-if-true`           → `truthy_facts`
+    # - `assert-if-false`          → `falsey_facts`
+    # - `return:` override         → `return_type` (`Rigor::Type`)
+    #
+    # Param overrides are intentionally NOT included — they refine
+    # the call's signature contract rather than its flow facts and
+    # do not fit ADR-2 § "Flow Contribution Bundle" slot semantics.
+    # Callers that care about parameter contracts keep using
+    # {.read_param_type_overrides} / {.param_type_override_map}.
+    #
+    # Returns `nil` when the method carries no recognised
+    # contribution directives (callers can skip the merge step
+    # without iterating an empty bundle).
+    def read_flow_contribution(method_def)
+      return nil if method_def.nil?
+
+      predicate_effects = read_predicate_effects(method_def)
+      assert_effects = read_assert_effects(method_def)
+      return_override = read_return_type_override(method_def)
+      return nil if predicate_effects.empty? && assert_effects.empty? && return_override.nil?
+
+      build_flow_contribution(predicate_effects, assert_effects, return_override)
+    end
+
+    def build_flow_contribution(predicate_effects, assert_effects, return_override) # rubocop:disable Metrics/CyclomaticComplexity
+      truthy = predicate_effects.select(&:truthy_only?).map(&:to_fact)
+      falsey = predicate_effects.select(&:falsey_only?).map(&:to_fact)
+      post_return = []
+
+      assert_effects.each do |effect|
+        case effect.condition
+        when :if_truthy_return then truthy << effect.to_fact
+        when :if_falsey_return then falsey << effect.to_fact
+        else post_return << effect.to_fact
+        end
+      end
+
+      FlowContribution.new(
+        return_type: return_override,
+        truthy_facts: nilable_slot(truthy),
+        falsey_facts: nilable_slot(falsey),
+        post_return_facts: nilable_slot(post_return),
+        provenance: RBS_EXTENDED_PROVENANCE
+      )
+    end
+
+    def nilable_slot(facts)
+      facts.empty? ? nil : facts
+    end
   end
 end

data/lib/rigor/reflection.rb

@@ -147,7 +147,7 @@ module Rigor
       return nil if loader.nil?
 
       loader.instance_definition(class_name.to_s)
-    rescue StandardError
+    rescue ::RBS::BaseError
       nil
     end
 
@@ -157,7 +157,7 @@ module Rigor
       return nil if loader.nil?
 
       loader.singleton_definition(class_name.to_s)
-    rescue StandardError
+    rescue ::RBS::BaseError
       nil
     end
 

data/lib/rigor/type/combinator.rb

@@ -149,14 +149,40 @@ module Rigor
         Refined.new(nominal_of("String"), :lowercase)
       end
 
+      # Complement of `lowercase-string`: a `String` with at least
+      # one non-lowercase character (i.e. `v != v.downcase`).
+      # Registered as the paired complement of
+      # `:lowercase` in {Refined::COMPLEMENT_PAIRS} so
+      # `~lowercase-string` narrows to this carrier instead of
+      # falling back to `Difference[String, lowercase-string]`.
+      def non_lowercase_string
+        Refined.new(nominal_of("String"), :not_lowercase)
+      end
+
       def uppercase_string
         Refined.new(nominal_of("String"), :uppercase)
       end
 
+      # Complement of `uppercase-string`: a `String` with at least
+      # one non-uppercase character. Paired with `:uppercase` in
+      # {Refined::COMPLEMENT_PAIRS}.
+      def non_uppercase_string
+        Refined.new(nominal_of("String"), :not_uppercase)
+      end
+
       def numeric_string
         Refined.new(nominal_of("String"), :numeric)
       end
 
+      # Complement of `numeric-string`: a `String` that is not
+      # accepted by Rigor's Ruby numeric-string predicate
+      # (contains at least one non-digit, has a malformed numeric
+      # form, etc.). Paired with `:numeric` in
+      # {Refined::COMPLEMENT_PAIRS}.
+      def non_numeric_string
+        Refined.new(nominal_of("String"), :not_numeric)
+      end
+
       def decimal_int_string
         Refined.new(nominal_of("String"), :decimal_int)
       end
@@ -169,6 +195,52 @@ module Rigor
         Refined.new(nominal_of("String"), :hex_int)
       end
 
+      # `literal-string` — a `String` that is statically known to
+      # come from a source-code literal (or a composition of
+      # literals). v0.0.9 tracks this flow through interpolation
+      # `"#{...}"`, leaving propagation through `+` / `<<` to a
+      # later slice. Every `Constant<String>` is implicitly
+      # literal-string-compatible; the carrier exists for cases
+      # where the concrete value is unknown but literal-ness has
+      # been established (an RBS::Extended `return: literal-string`
+      # annotation, or interpolation over literal-bearing parts).
+      def literal_string
+        Refined.new(nominal_of("String"), :literal_string)
+      end
+
+      # `non-empty-literal-string` = `non-empty-string ∩ literal-string`.
+      # Composes the point-removal half (`Difference[String, ""]`)
+      # with the predicate-subset half. Both members erase to
+      # `String`.
+      def non_empty_literal_string
+        intersection(non_empty_string, literal_string)
+      end
+
+      # Recognises the carriers that participate in literal-string
+      # flow tracking: any `Constant<String>` (constants are literal
+      # by construction), the `literal-string` Refined carrier, an
+      # `Intersection` containing `literal-string`, or a `Union`
+      # whose every member qualifies. Used by
+      # `ExpressionTyper#type_of_interpolated_string` and the
+      # `LiteralStringFolding` dispatcher tier so propagation
+      # through interpolation and `+`/`*` composition stays
+      # consistent.
+      def literal_string_compatible?(type)
+        case type
+        when Constant then type.value.is_a?(String)
+        when Refined then literal_string_carrier?(type)
+        when Intersection then type.members.any? { |m| literal_string_compatible?(m) }
+        when Union then type.members.all? { |m| literal_string_compatible?(m) }
+        else false
+        end
+      end
+
+      def literal_string_carrier?(refined)
+        refined.predicate_id == :literal_string &&
+          refined.base.is_a?(Nominal) &&
+          refined.base.class_name == "String"
+      end
+
       # Normalised intersection. Flattens nested Intersections,
       # drops `Top` members, collapses to `Bot` if any member is
       # `Bot`, deduplicates structurally-equal members, sorts the

data/lib/rigor/type/refined.rb

@@ -141,11 +141,24 @@ module Rigor
 
       PREDICATES = {
         lowercase: ->(v) { v.is_a?(String) && v == v.downcase },
+        not_lowercase: ->(v) { v.is_a?(String) && v != v.downcase },
         uppercase: ->(v) { v.is_a?(String) && v == v.upcase },
+        not_uppercase: ->(v) { v.is_a?(String) && v != v.upcase },
         numeric: ->(v) { v.is_a?(String) && NUMERIC_STRING_PATTERN.match?(v) },
+        not_numeric: ->(v) { v.is_a?(String) && !NUMERIC_STRING_PATTERN.match?(v) },
         decimal_int: ->(v) { v.is_a?(String) && DECIMAL_INT_STRING_PATTERN.match?(v) },
         octal_int: ->(v) { v.is_a?(String) && OCTAL_INT_STRING_PATTERN.match?(v) },
-        hex_int: ->(v) { v.is_a?(String) && HEX_INT_STRING_PATTERN.match?(v) }
+        hex_int: ->(v) { v.is_a?(String) && HEX_INT_STRING_PATTERN.match?(v) },
+        # `literal-string` is a flow-tracked predicate, not a value-
+        # level predicate: a String is literal-string when it is
+        # known to come from a source-code literal (or composition
+        # of literals). Every concrete `Constant<String>` is
+        # already literal by construction, so the inspection
+        # recogniser returns true for any String — the property is
+        # really tracked in the flow analysis (interpolation,
+        # concatenation, RBS::Extended `return: literal-string`)
+        # rather than recovered by inspecting an arbitrary string.
+        literal_string: ->(v) { v.is_a?(String) }
       }.freeze
 
       # Maps `[base_class_name, predicate_id]` pairs to their
@@ -154,14 +167,49 @@ module Rigor
       # to the operator form.
       CANONICAL_NAMES = {
         ["String", :lowercase] => "lowercase-string",
+        ["String", :not_lowercase] => "non-lowercase-string",
         ["String", :uppercase] => "uppercase-string",
+        ["String", :not_uppercase] => "non-uppercase-string",
         ["String", :numeric] => "numeric-string",
+        ["String", :not_numeric] => "non-numeric-string",
         ["String", :decimal_int] => "decimal-int-string",
         ["String", :octal_int] => "octal-int-string",
-        ["String", :hex_int] => "hex-int-string"
+        ["String", :hex_int] => "hex-int-string",
+        ["String", :literal_string] => "literal-string"
       }.freeze
       private_constant :CANONICAL_NAMES
 
+      # Bidirectional `predicate_id ↔ complement_predicate_id`
+      # registry. `~Refined[base, p]` narrows to
+      # `Refined[base, COMPLEMENT_PAIRS[p]]` when the part is the
+      # refinement's base — the precise carrier the spec promises
+      # under the `~T` operator. Predicates without a registered
+      # complement fall back to the imprecise but sound
+      # `Difference[part, refined]` carrier from the existing
+      # narrowing rule.
+      #
+      # Adding a new pair here is an additive change: register the
+      # complement predicate in {PREDICATES}, give it a kebab-case
+      # canonical name in {CANONICAL_NAMES}, and add the bidirectional
+      # entry below. No call site needs to know about the new pair —
+      # `complement_refined` consults this map and routes through
+      # the registered complement automatically.
+      COMPLEMENT_PAIRS = {
+        lowercase: :not_lowercase,
+        not_lowercase: :lowercase,
+        uppercase: :not_uppercase,
+        not_uppercase: :uppercase,
+        numeric: :not_numeric,
+        not_numeric: :numeric
+      }.freeze
+      private_constant :COMPLEMENT_PAIRS
+
+      # @return [Symbol, nil] the registered complement predicate
+      #   id, or nil when no pair is registered for this predicate.
+      def complement_predicate_id
+        COMPLEMENT_PAIRS[predicate_id]
+      end
+
       private
 
       def canonical_name

data/lib/rigor/version.rb

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

data/lib/rigor.rb

@@ -2,6 +2,7 @@
 
 require_relative "rigor/version"
 require_relative "rigor/configuration"
+require_relative "rigor/configuration/severity_profile"
 require_relative "rigor/trinary"
 require_relative "rigor/type"
 require_relative "rigor/ast"
@@ -21,7 +22,19 @@ require_relative "rigor/scope"
 require_relative "rigor/reflection"
 require_relative "rigor/cache/descriptor"
 require_relative "rigor/cache/store"
+require_relative "rigor/cache/rbs_descriptor"
 require_relative "rigor/cache/rbs_constant_table"
+require_relative "rigor/cache/rbs_known_class_names"
+require_relative "rigor/cache/rbs_class_ancestor_table"
+require_relative "rigor/cache/rbs_class_type_param_names"
+require_relative "rigor/cache/rbs_environment"
+require_relative "rigor/cache/rbs_instance_definitions"
+require_relative "rigor/flow_contribution"
+require_relative "rigor/flow_contribution/fact"
+require_relative "rigor/flow_contribution/conflict"
+require_relative "rigor/flow_contribution/merge_result"
+require_relative "rigor/flow_contribution/merger"
+require_relative "rigor/plugin"
 require_relative "rigor/source"
 require_relative "rigor/inference/scope_indexer"
 require_relative "rigor/inference/coverage_scanner"

data/sig/rigor/environment.rbs

@@ -32,19 +32,25 @@ module Rigor
     class RbsLoader
       attr_reader libraries: Array[String]
       attr_reader signature_paths: Array[String | _ToPath]
+      attr_reader cache_store: untyped?
 
       def self.default: () -> RbsLoader
       def self.reset_default!: () -> void
+      def self.build_env_for: (libraries: Array[String], signature_paths: Array[String | _ToPath]) -> untyped
 
-      def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath]) -> void
+      def initialize: (?libraries: Array[String], ?signature_paths: Array[String | _ToPath], ?cache_store: untyped?) -> void
       def class_known?: (String | Symbol name) -> bool
       def instance_definition: (String | Symbol class_name) -> untyped?
       def instance_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
+      def uncached_instance_definition: (String | Symbol class_name) -> untyped?
       def singleton_definition: (String | Symbol class_name) -> untyped?
       def singleton_method: (class_name: String | Symbol, method_name: String | Symbol) -> untyped?
+      def uncached_singleton_definition: (String | Symbol class_name) -> untyped?
       def class_type_param_names: (String | Symbol class_name) -> Array[Symbol]
       def class_ordering: (String | Symbol lhs, String | Symbol rhs) -> ordering
       def constant_type: (String name) -> Type::t?
+      def constant_names: () -> Array[String]
+      def each_known_class_name: () { (String name) -> void } -> untyped
     end
 
     class RbsHierarchy

data/sig/rigor/inference.rbs

@@ -86,6 +86,7 @@ module Rigor
       def self?.narrow_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
       def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
       def self?.narrow_not_refinement: (Type::t current_type, Type::t refinement_type) -> Type::t
+      def self?.narrow_for_fact: (Type::t current, untyped fact, untyped environment) -> Type::t
       def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
       def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
       def self?.analyse: (untyped node, Scope scope) -> untyped

data/sig/rigor/rbs_extended.rbs

@@ -43,6 +43,8 @@ module Rigor
     def self?.read_return_type_override: (untyped method_def) -> Type::t?
     def self?.parse_return_type_override: (String string) -> Type::t?
 
+    def self?.read_flow_contribution: (untyped method_def) -> untyped?
+
     class ParamOverride
       attr_reader param_name: Symbol
       attr_reader type: Type::t