rigortype 0.1.16 → 0.1.18

data/lib/rigor/inference/method_dispatcher/uri_folding.rb

@@ -2,6 +2,7 @@
 
 require "uri"
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -40,24 +41,23 @@ module Rigor
         module_function
 
         # @return [Rigor::Type, nil] folded result, or nil to defer.
-        def try_dispatch(receiver:, method_name:, args:)
-          return nil unless dispatch_target?(receiver)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
+          return nil unless SingletonFolding.receiver?(receiver, "URI")
           return nil unless URI_COMPONENT_METHODS.include?(method_name)
 
           fold_uri_call(method_name, args)
         end
 
-        def dispatch_target?(receiver)
-          receiver.is_a?(Type::Singleton) && receiver.class_name == "URI"
-        end
-
         def fold_uri_call(method_name, args)
           return nil unless args.size == 1
 
-          arg = args.first
-          return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+          str = SingletonFolding.constant_string(args.first)
+          return nil if str.nil?
 
-          Type::Combinator.constant_of(URI.public_send(method_name, arg.value))
+          Type::Combinator.constant_of(URI.public_send(method_name, str))
         rescue StandardError
           nil
         end

data/lib/rigor/inference/method_dispatcher.rb

@@ -6,9 +6,12 @@ require_relative "../flow_contribution"
 require_relative "../flow_contribution/merger"
 require_relative "../builtins/hkt_builtins"
 require_relative "../builtins/static_return_refinements"
+require_relative "flow_tracer"
+require_relative "method_dispatcher/call_context"
 require_relative "method_dispatcher/constant_folding"
 require_relative "method_dispatcher/literal_string_folding"
 require_relative "method_dispatcher/shape_dispatch"
+require_relative "method_dispatcher/data_folding"
 require_relative "method_dispatcher/rbs_dispatch"
 require_relative "method_dispatcher/iterator_dispatch"
 require_relative "method_dispatcher/block_folding"
@@ -71,19 +74,45 @@ module Rigor
       # @param environment [Rigor::Environment, nil] required for
       #   RBS-backed dispatch; when nil only constant folding can fire.
       # @return [Rigor::Type, nil] inferred result type, or `nil` for "no rule".
-      def dispatch(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def dispatch(receiver_type:, method_name:, arg_types:,
                    block_type: nil, environment: nil,
                    call_node: nil, scope: nil)
+        result = resolve(
+          receiver_type: receiver_type, method_name: method_name, arg_types: arg_types,
+          block_type: block_type, environment: environment,
+          call_node: call_node, scope: scope
+        )
+        # `rigor trace` — record the dispatch outcome (resolved type, or
+        # the fail-soft `nil` the caller widens to `Dynamic[Top]`).
+        if FlowTracer.active?
+          FlowTracer.dispatch(
+            receiver: receiver_type, method_name: method_name, args: arg_types,
+            result: result, location: call_node&.location
+          )
+        end
+        result
+      end
+
+      def resolve(receiver_type:, method_name:, arg_types:, # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+                  block_type: nil, environment: nil,
+                  call_node: nil, scope: nil)
         return nil if receiver_type.nil?
 
-        bound_method_result = MethodFolding.try_backward(
+        # Build the call context once and thread it — unchanged —
+        # through every tier (`_DispatchTier#try_dispatch`). The
+        # dispatcher's own private fallback tiers still read the
+        # positional locals below; only the tier modules consume the
+        # context object.
+        context = CallContext.build(
           receiver: receiver_type, method_name: method_name, args: arg_types,
           block_type: block_type, environment: environment,
           call_node: call_node, scope: scope
         )
+
+        bound_method_result = MethodFolding.try_backward(context)
         return bound_method_result if bound_method_result
 
-        precise = dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type)
+        precise = dispatch_precise_tiers(context)
         return precise if precise
 
         # v0.1.1 Track 2 slice 7 — plugin return-type contribution
@@ -123,10 +152,7 @@ module Rigor
         static_refinement = try_static_refinement(receiver_type, method_name, arg_types)
         return static_refinement if static_refinement
 
-        rbs_result = RbsDispatch.try_dispatch(
-          receiver: receiver_type, method_name: method_name, args: arg_types,
-          environment: environment, block_type: block_type, scope: scope
-        )
+        rbs_result = RbsDispatch.try_dispatch(context)
         if rbs_result
           record_boundary_cross_if_applicable(receiver_type, method_name, rbs_result, environment)
           return rbs_result
@@ -211,7 +237,7 @@ module Rigor
         # introspection (`attr_reader`, `private`, ...) on
         # user classes without requiring the user to author
         # their own RBS.
-        try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type, call_node)
+        try_user_class_fallback(receiver_type, environment, call_node, context)
       end
 
       # v0.1.3 — discovered-method dispatch tier. `scope` carries
@@ -292,12 +318,12 @@ module Rigor
       end
 
       # ADR-2 § "Flow Contribution Bundle" / v0.1.1 Track 2
-      # slice 7. Walks every loaded plugin's
-      # `#flow_contribution_for(call_node:, scope:)` hook,
-      # collects the non-nil `FlowContribution` bundles, merges
-      # them through `FlowContribution::Merger`, and returns
-      # the merged `return_type` slot (or nil when no plugin
-      # contributed a return type).
+      # slice 7; ADR-52 WD3 — consults each loaded plugin's gated
+      # `dynamic_return` rules, wraps the contributed types as
+      # `FlowContribution` bundles, merges them through
+      # `FlowContribution::Merger`, and returns the merged
+      # `return_type` slot (or nil when no plugin contributed a
+      # return type).
       #
       # Plugins whose hook raises have their contribution
       # silently dropped for this call so the dispatch chain
@@ -467,8 +493,10 @@ module Rigor
 
         module_type = Type::Combinator.nominal_of(module_name)
         RbsDispatch.try_dispatch(
-          receiver: module_type, method_name: method_name, args: arg_types,
-          environment: environment, block_type: block_type
+          CallContext.build(
+            receiver: module_type, method_name: method_name, args: arg_types,
+            environment: environment, block_type: block_type
+          )
         )
       end
 
@@ -635,23 +663,15 @@ module Rigor
         Type::Combinator.untyped
       end
 
+      # ADR-52 WD1 — the per-dispatch plugins × owns_receivers ×
+      # `class_ordering` walk moved into the compiled contribution
+      # table: the union is built once per registry (almost always
+      # empty → O(1) false) and per-class verdicts memoise per run.
       def plugin_owns_receiver?(class_name, environment)
         registry = environment&.plugin_registry
         return false if registry.nil? || registry.empty?
 
-        registry.plugins.any? do |plugin|
-          owns = plugin.manifest.owns_receivers # rigor:disable undefined-method
-          owns.any? { |owner| receiver_matches_owner?(class_name, owner, environment) }
-        end
-      end
-
-      def receiver_matches_owner?(class_name, owner, environment)
-        return true if class_name == owner
-
-        ordering = environment.class_ordering(class_name, owner)
-        %i[equal subclass].include?(ordering)
-      rescue StandardError
-        false
+        registry.contribution_index.owns_receiver?(class_name, environment)
       end
 
       def dep_source_class_name(receiver_type)
@@ -660,22 +680,66 @@ module Rigor
         end
       end
 
-      # ADR-37 slice 2 — gathers each plugin's return-type contribution
-      # from BOTH the narrow `dynamic_return` DSL (receiver-gated, wrapped
-      # as a return-only `FlowContribution`) and the legacy
-      # `flow_contribution_for` escape valve, so migrated and unmigrated
-      # plugins compose through the same merger.
+      # ADR-37 slice 2 / ADR-52 WD3 — gathers each plugin's return-type
+      # contribution from the gated `dynamic_return` DSL, wrapped as a
+      # return-only `FlowContribution` for the shared merger. (The legacy
+      # ungated `flow_contribution_for` escape valve was deleted once its
+      # five users migrated.)
+      EMPTY_CONTRIBUTIONS = [].freeze
+      private_constant :EMPTY_CONTRIBUTIONS
+
+      # Collects every plugin's flow / dynamic-return contribution for one
+      # call site. Two prunings keep this off the hot path on plugin-heavy
+      # projects (it was the #1 allocation site and a top CPU cost):
+      #
+      # 1. Only the plugins that *structurally* implement a per-call path
+      #    are visited — `registry.contribution_index.for_method_dispatch`
+      #    is the registry-ordered subset declaring a `dynamic_return`.
+      #    Iterating the subset in registry order, and gating each path by
+      #    membership, yields the exact same contributions in the same
+      #    order as visiting every plugin would (a skipped plugin's call
+      #    returns nil/[] anyway). The receiver-class ancestry match still
+      #    happens per dispatch inside `dynamic_return_type`.
+      # 2. Contributions accumulate lazily — allocate only when one
+      #    actually appears, and share a frozen empty array otherwise. The
+      #    caller treats the result as read-only (`.empty?` / `Merger.merge`).
+      # 3. ADR-52 WD1 — method-name gates compiled at registry build. The
+      #    global gate makes the common "no plugin cares about this call"
+      #    case a single Set probe; the per-plugin gate skips a plugin
+      #    whose `dynamic_return` rules are all `methods:`-gated on other
+      #    names. A pruned consultation could only have returned nil, so
+      #    contribution order and content are unchanged.
       def collect_plugin_contributions(registry, call_node, scope, receiver_type)
-        registry.plugins.flat_map do |plugin|
-          contributions = []
-          legacy = plugin.flow_contribution_for(call_node: call_node, scope: scope)
-          contributions << legacy if legacy.is_a?(FlowContribution)
+        index = registry.contribution_index
+        relevant = index.for_method_dispatch
+        return EMPTY_CONTRIBUTIONS if relevant.empty?
+
+        # `call_node` is not always a CallNode — the `&:symbol` block
+        # path dispatches with the `Prism::BlockArgumentNode` itself
+        # (`ExpressionTyper#symbol_block_return_type`). A bare `.name`
+        # here raised, and the raise was silently absorbed by
+        # `block_return_type_for`'s rescue, nil-ing the block type and
+        # flipping `select(&:p)`-style calls onto their no-block
+        # Enumerator overloads (caught by the GitLab corpus gate).
+        name = call_node.respond_to?(:name) ? call_node.name : nil
+        return EMPTY_CONTRIBUTIONS unless index.dispatch_candidate?(name)
+
+        collect_gated_contributions(index, relevant, name, call_node, scope, receiver_type)
+      end
+
+      # The post-gate walk, in registry order — the same order the
+      # ungated walk used.
+      def collect_gated_contributions(index, relevant, name, call_node, scope, receiver_type)
+        result = nil
+        relevant.each do |plugin|
+          next unless index.dynamic_candidate_for?(plugin, name)
+
           dynamic = plugin.dynamic_return_type(call_node: call_node, scope: scope, receiver_type: receiver_type)
-          contributions << FlowContribution.new(return_type: dynamic) if dynamic
-          contributions
+          (result ||= []) << FlowContribution.new(return_type: dynamic) if dynamic
         rescue StandardError
-          []
+          next
         end
+        result || EMPTY_CONTRIBUTIONS
       end
 
       # Runs the precision tiers (constant fold, shape dispatch,
@@ -690,37 +754,80 @@ module Rigor
       # its rules apply only to block-taking calls, so the cheaper
       # arity-based fold tiers above it filter out the common
       # cases first. When `block_type` is nil the tier is a no-op.
-      def dispatch_precise_tiers(receiver_type, method_name, arg_types, block_type = nil)
-        meta_result = try_meta_introspection(receiver_type, method_name, arg_types)
+      # The precise-tier folders, consulted in order via the uniform
+      # `_DispatchTier` interface (`try_dispatch(CallContext) -> Type?`).
+      # Order is significant: ConstantFolding's exact-value folds win
+      # first, the eight stdlib singleton folders sit in the middle (each
+      # gates on a distinct `Singleton` receiver, so their relative order
+      # is immaterial), and BlockFolding runs last because its rules only
+      # apply to block-taking calls — the cheaper arity folds above it
+      # filter the common cases first. Adding a precise tier is a
+      # one-line append here rather than another link in a hand-written
+      # `||` ladder.
+      PRECISE_TIERS_HEAD = Ractor.make_shareable([
+        ConstantFolding, LiteralStringFolding, ShapeDispatch
+      ].freeze)
+      private_constant :PRECISE_TIERS_HEAD
+
+      # ADR-53 re-review follow-up (gate-by-held-key applied to the
+      # built-in tiers): the eight stdlib singleton folders are mutually
+      # exclusive — each fires only on `Singleton[<its class>]`, the
+      # first check in every `try_dispatch` — so at most one can match a
+      # given receiver and their relative trial order was never
+      # observable. Compiling them into a class-name table turns eight
+      # no-op trials per call into one Hash read, skipped entirely when
+      # the receiver is not a `Singleton` (the overwhelmingly common
+      # case). The table sits where the eight sat in the old flat list:
+      # after ShapeDispatch, before KernelDispatch.
+      STDLIB_SINGLETON_FOLDERS = Ractor.make_shareable({
+        "File" => FileFolding,
+        "Shellwords" => ShellwordsFolding,
+        "Math" => MathFolding,
+        "Time" => TimeFolding,
+        "Regexp" => RegexpFolding,
+        "CGI" => CGIFolding,
+        "URI" => URIFolding,
+        "Set" => SetFolding
+      }.freeze)
+      private_constant :STDLIB_SINGLETON_FOLDERS
+
+      PRECISE_TIERS_TAIL = Ractor.make_shareable([
+        KernelDispatch, MethodFolding, BlockFolding
+      ].freeze)
+      private_constant :PRECISE_TIERS_TAIL
+
+      def dispatch_precise_tiers(context)
+        # ADR-48 — Data value folding runs ahead of meta-introspection:
+        # `meta_new` intercepts every `Singleton[*].new` (returning
+        # `Nominal`), which would mask a `Data` class's precise instance.
+        # The tier only fires on Data receivers (a `Data.define`, a
+        # `DataClass`/`DataInstance`, or a `Singleton` with a recorded
+        # member layout), so it never shadows meta's Array/Set/Range lifts.
+        data_result = DataFolding.try_dispatch(context)
+        return data_result if data_result
+
+        meta_result = try_meta_introspection(context.receiver, context.method_name, context.args)
         return meta_result if meta_result
 
-        ConstantFolding.try_fold(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          LiteralStringFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          ShapeDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          dispatch_stdlib_module_tiers(receiver_type, method_name, arg_types) ||
-          KernelDispatch.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          MethodFolding.try_forward(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          BlockFolding.try_fold(
-            receiver: receiver_type, method_name: method_name, args: arg_types, block_type: block_type
-          )
-      end
+        PRECISE_TIERS_HEAD.each do |tier|
+          result = tier.try_dispatch(context)
+          return result if result
+        end
+
+        receiver = context.receiver
+        if receiver.is_a?(Type::Singleton) && (folder = STDLIB_SINGLETON_FOLDERS[receiver.class_name])
+          result = folder.try_dispatch(context)
+          return result if result
+        end
 
-      # Stdlib module singleton-folding tiers: File, Shellwords, Math,
-      # Time, Regexp, CGI, URI, Set. Extracted from
-      # `dispatch_precise_tiers` to keep the parent method within the
-      # cyclomatic-complexity limit.
-      def dispatch_stdlib_module_tiers(receiver_type, method_name, arg_types)
-        FileFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          ShellwordsFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          MathFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          TimeFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          RegexpFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          CGIFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          URIFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types) ||
-          SetFolding.try_dispatch(receiver: receiver_type, method_name: method_name, args: arg_types)
+        PRECISE_TIERS_TAIL.each do |tier|
+          result = tier.try_dispatch(context)
+          return result if result
+        end
+        nil
       end
 
-      def try_user_class_fallback(receiver_type, method_name, arg_types, environment, block_type, call_node = nil)
+      def try_user_class_fallback(receiver_type, environment, call_node, context)
         return nil if environment.nil?
 
         fallback_receiver = user_class_fallback_receiver(receiver_type, environment)
@@ -745,13 +852,12 @@ module Rigor
         # self / `self.`-receiver calls (`puts`, `raise`, `require`)
         # keep resolving — those are the fallback's intended targets.
         RbsDispatch.try_dispatch(
-          receiver: fallback_receiver,
-          method_name: method_name,
-          args: arg_types,
-          environment: environment,
-          block_type: block_type,
-          self_type_override: receiver_type,
-          public_only: explicit_non_self_receiver?(call_node)
+          context.with(
+            receiver: fallback_receiver,
+            self_type_override: receiver_type,
+            public_only: explicit_non_self_receiver?(call_node),
+            call_node: nil, scope: nil
+          )
         )
       end
 
@@ -1093,19 +1199,14 @@ module Rigor
       def expected_block_param_types(receiver_type:, method_name:, arg_types:, environment: nil)
         return [] if receiver_type.nil?
 
-        iterator_result = IteratorDispatch.block_param_types(
-          receiver: receiver_type,
-          method_name: method_name,
-          args: arg_types
+        context = CallContext.build(
+          receiver: receiver_type, method_name: method_name,
+          args: arg_types, environment: environment
         )
+        iterator_result = IteratorDispatch.block_param_types(context)
         return iterator_result if iterator_result
 
-        RbsDispatch.block_param_types(
-          receiver: receiver_type,
-          method_name: method_name,
-          args: arg_types,
-          environment: environment
-        )
+        RbsDispatch.block_param_types(context)
       end
     end
   end