rigortype 0.1.3 → 0.1.5

data/lib/rigor/inference/scope_indexer.rb

@@ -57,9 +57,19 @@ module Rigor
         # `Scope#with_local` / `#with_fact` / `#with_self_type`
         # propagates it across every derived scope.
         declared_types, discovered_classes = build_declaration_artifacts(root)
+        # Merge the indexer's findings on top of whatever the
+        # base scope already carries so callers that seed
+        # cross-file class knowledge (e.g. the ADR-14
+        # `SigGen::ObservationCollector` pre-walking project
+        # `lib/` before scanning `spec/`) keep their seeds
+        # alongside the per-file declarations the indexer
+        # itself discovers. Indexer-found entries win on
+        # collision — same-file declarations are the most
+        # specific authority.
+        merged_classes = default_scope.discovered_classes.merge(discovered_classes)
         seeded_scope = default_scope
                        .with_declared_types(declared_types)
-                       .with_discovered_classes(discovered_classes)
+                       .with_discovered_classes(merged_classes)
 
         # Slice 7 phase 2. Pre-pass over every class/module body
         # to collect the per-class ivar accumulator. Seeded after
@@ -300,7 +310,7 @@ module Rigor
         accumulator.freeze
       end
 
-      def walk_constant_writes(node, qualified_prefix, default_scope, accumulator) # rubocop:disable Metrics/CyclomaticComplexity
+      def walk_constant_writes(node, qualified_prefix, default_scope, accumulator)
         return unless node.is_a?(Prism::Node)
 
         case node
@@ -348,7 +358,7 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
       def walk_methods(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -385,7 +395,7 @@ module Rigor
           walk_methods(child, qualified_prefix, in_singleton_class, accumulator)
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
       # v0.1.2 — when a `Const = Data.define(*sym) do ... end`
       # / `Const = Struct.new(*sym) do ... end` constant write
@@ -430,7 +440,6 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def walk_def_nodes(node, qualified_prefix, in_singleton_class, accumulator)
         return unless node.is_a?(Prism::Node)
 
@@ -462,8 +471,6 @@ module Rigor
           walk_def_nodes(child, qualified_prefix, in_singleton_class, accumulator)
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-
       # v0.0.3 A — sentinel key under which `record_def_node`
       # files DefNodes that live outside any class / module
       # body (top-level helpers, `def`s nested inside DSL
@@ -646,7 +653,6 @@ module Rigor
 
       # Builds a map `{class_name => {new_name_sym => old_name_sym}}` by
       # walking the tree for `AliasMethodNode` nodes inside class bodies.
-      # rubocop:disable Metrics/CyclomaticComplexity
       def collect_class_alias_map(node, qualified_prefix, accumulator)
         return accumulator unless node.is_a?(Prism::Node)
 
@@ -667,7 +673,6 @@ module Rigor
         node.compact_child_nodes.each { |child| collect_class_alias_map(child, qualified_prefix, accumulator) }
         accumulator
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
 
       def record_alias_map_entry(alias_node, qualified_prefix, accumulator)
         return if qualified_prefix.empty?

data/lib/rigor/inference/statement_evaluator.rb

@@ -889,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?
@@ -967,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])
@@ -1034,7 +1034,7 @@ module Rigor
         end
       end
 
-      def resolve_call_method(call_node, current_scope) # rubocop:disable Metrics/PerceivedComplexity
+      def resolve_call_method(call_node, current_scope)
         receiver_node = call_node.receiver
         receiver_type =
           if receiver_node
@@ -1120,7 +1120,7 @@ module Rigor
         end
       end
 
-      def lookup_post_return_arg(call_node, method_def, target_name) # rubocop:disable Metrics/CyclomaticComplexity
+      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
@@ -1394,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)
@@ -1501,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
@@ -1607,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
@@ -1629,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/inference/synthetic_method.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    # ADR-16 Tier C output — one synthetic method declared by a
+    # plugin's `Plugin::Macro::HeredocTemplate` entry, after the
+    # pre-pass has interpolated the call-site literal symbol into
+    # the template name. Stored in {SyntheticMethodIndex} and
+    # consulted by {MethodDispatcher} below the RBS dispatch tier.
+    #
+    # Per ADR-16 § WD13 (cost-bounded best-effort): the v0.1.x
+    # delivery commitment is the floor — method names emit; their
+    # return types degrade to `Dynamic[T]` until slice 6
+    # (precision promotion) routes the recorded `return_type`
+    # string through ADR-13's `Plugin::TypeNodeResolver` chain.
+    # The string is preserved so the ceiling slice can resolve it
+    # without re-walking.
+    #
+    # The `provenance` Hash carries debug / `--explain` metadata:
+    # plugin id, the template's call shape, and the source
+    # location of the originating DSL call. Surfaced through the
+    # dispatcher's `macro.tier_c.*` provenance markers.
+    class SyntheticMethod
+      INSTANCE = :instance
+      SINGLETON = :singleton
+      VALID_KINDS = [INSTANCE, SINGLETON].freeze
+
+      attr_reader :class_name, :method_name, :return_type, :kind, :provenance
+
+      def initialize(class_name:, method_name:, return_type:, kind: INSTANCE, provenance: {})
+        validate!(class_name, method_name, return_type, kind, provenance)
+        @class_name = class_name.dup.freeze
+        @method_name = method_name.to_sym
+        @return_type = return_type.dup.freeze
+        @kind = kind
+        @provenance = provenance.transform_keys(&:to_sym).transform_values do |v|
+          v.is_a?(String) ? v.dup.freeze : v
+        end.freeze
+        freeze
+      end
+
+      def instance? = kind == INSTANCE
+      def singleton? = kind == SINGLETON
+
+      def to_h
+        {
+          "class_name" => class_name,
+          "method_name" => method_name.to_s,
+          "return_type" => return_type,
+          "kind" => kind.to_s,
+          "provenance" => provenance.transform_keys(&:to_s)
+        }
+      end
+
+      def ==(other)
+        other.is_a?(SyntheticMethod) && to_h == other.to_h
+      end
+      alias eql? ==
+
+      def hash
+        to_h.hash
+      end
+
+      private
+
+      def validate!(class_name, method_name, return_type, kind, provenance)
+        unless class_name.is_a?(String) && !class_name.empty?
+          raise ArgumentError, "SyntheticMethod#class_name must be non-empty String, got #{class_name.inspect}"
+        end
+        unless method_name.is_a?(Symbol) || (method_name.is_a?(String) && !method_name.empty?)
+          raise ArgumentError, "SyntheticMethod#method_name must be Symbol/non-empty String, got #{method_name.inspect}"
+        end
+        unless return_type.is_a?(String) && !return_type.empty?
+          raise ArgumentError, "SyntheticMethod#return_type must be non-empty String, got #{return_type.inspect}"
+        end
+        unless VALID_KINDS.include?(kind)
+          raise ArgumentError, "SyntheticMethod#kind must be one of #{VALID_KINDS.inspect}, got #{kind.inspect}"
+        end
+
+        return if provenance.is_a?(Hash)
+
+        raise ArgumentError, "SyntheticMethod#provenance must be a Hash, got #{provenance.inspect}"
+      end
+    end
+  end
+end

data/lib/rigor/inference/synthetic_method_index.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "synthetic_method"
+
+module Rigor
+  module Inference
+    # Frozen, Ractor-shareable lookup table for the synthetic
+    # methods emitted by ADR-16 Tier C declarations during a
+    # single `Analysis::Runner#run`. Constructed by the pre-pass
+    # scanner (see {SyntheticMethodScanner}) and consulted by
+    # {MethodDispatcher} below `RbsDispatch.try_dispatch` (per WD13:
+    # user-authored RBS overrides substrate synthesis).
+    #
+    # The index is keyed by `(class_name, method_name, kind)`. A
+    # single key may resolve to multiple {SyntheticMethod} records
+    # if two plugins emit the same name (e.g. `rigor-dry-struct`
+    # and a hypothetical `rigor-dry-struct-extras` both registering
+    # the same attribute). Per ADR-16 WD11 / the WD-discussion in
+    # `## Open questions` the dispatcher uses first-wins by
+    # registration order; this index preserves that order in
+    # `lookup`'s return.
+    #
+    # ## Slice 2b — return-type precision posture
+    #
+    # The recorded `SyntheticMethod#return_type` is a String
+    # (e.g. `"ActiveStorage::Attached::One"`), preserved verbatim
+    # from the manifest's emit table. Slice 2b's engine wiring
+    # treats every match as returning `Dynamic[T]` per WD13's
+    # floor — the recorded string is the input to a later slice's
+    # precision promotion via ADR-13's `Plugin::TypeNodeResolver`.
+    class SyntheticMethodIndex
+      attr_reader :entries
+
+      def initialize(entries: [])
+        unless entries.is_a?(Array) && entries.all?(SyntheticMethod)
+          raise ArgumentError,
+                "SyntheticMethodIndex#entries must be an Array of SyntheticMethod, got #{entries.inspect}"
+        end
+
+        @entries = Ractor.make_shareable(entries.dup)
+        @by_instance = Ractor.make_shareable(bucket(entries, SyntheticMethod::INSTANCE))
+        @by_singleton = Ractor.make_shareable(bucket(entries, SyntheticMethod::SINGLETON))
+        freeze
+      end
+
+      def empty?
+        entries.empty?
+      end
+
+      # Returns an Array of matching {SyntheticMethod} records in
+      # plugin-registration order. Empty Array when no plugin has
+      # declared a Tier C entry that interpolates to this name.
+      def lookup_instance(class_name, method_name)
+        @by_instance.fetch([class_name, method_name.to_sym], EMPTY_ROW)
+      end
+
+      def lookup_singleton(class_name, method_name)
+        @by_singleton.fetch([class_name, method_name.to_sym], EMPTY_ROW)
+      end
+
+      def to_h
+        { "entries" => entries.map(&:to_h) }
+      end
+
+      EMPTY_ROW = [].freeze
+
+      def bucket(entries, kind)
+        h = {}
+        entries.each do |entry|
+          next unless entry.kind == kind
+
+          key = [entry.class_name, entry.method_name]
+          (h[key] ||= []) << entry
+        end
+        h.each_value(&:freeze).freeze
+      end
+      private :bucket
+
+      EMPTY = new(entries: []).freeze
+    end
+  end
+end