rigortype 0.1.16 → 0.1.18

data/lib/rigor/inference/flow_tracer.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    # Thread-local event recorder behind `rigor trace`: while a block runs
+    # under {record}, the inference engine emits a flat, ordered event
+    # stream describing HOW it typed the program — expression enter/result
+    # pairs, scope binds, union formation, and method-dispatch outcomes.
+    # The CLI replays that stream as a terminal animation (or dumps it as
+    # JSON); the engine itself never reads the events back, so recording
+    # is purely observational and MUST NOT change any inferred type.
+    #
+    # Modelled on {Analysis::DependencyRecorder}: thread-local state, a
+    # module-level activation count so the disabled fast path ({active?})
+    # is a plain integer read, and a frozen snapshot for consumers. The
+    # instrumented hot paths (`ExpressionTyper#type_of`,
+    # `Scope#with_local`, `Type::Combinator.union`,
+    # `MethodDispatcher.dispatch`) each guard their emit behind {active?},
+    # so a normal (non-tracing) run pays one integer comparison.
+    module FlowTracer
+      KEY = :__rigor_flow_tracer__
+      private_constant :KEY
+
+      # One animation-relevant moment.
+      #
+      # kind     :enter | :result | :bind | :union | :dispatch
+      # depth    expression-recursion depth at emit time (0 = statement level)
+      # location frozen Hash with :start_line/:start_column/:end_line/
+      #          :end_column/:start_offset/:end_offset, or nil. Events
+      #          without a node of their own (:bind, :union) inherit the
+      #          innermost in-flight expression node's location so the
+      #          replayer can still highlight the source being evaluated.
+      # stack    frozen Array of short node-class names, outermost first
+      # data     frozen kind-specific Hash (types pre-rendered as Strings
+      #          via `describe(:short)` so events serialise to JSON as-is)
+      Event = Data.define(:kind, :depth, :location, :stack, :data)
+
+      # Mutable per-thread accumulator; only ever touched by the thread
+      # that activated it, so no locking is needed on the emit path.
+      class Recorder
+        attr_reader :events
+
+        def initialize
+          @events = []
+          @stack = []
+        end
+
+        # Brackets one `ExpressionTyper#type_of` recursion: emits :enter,
+        # runs the real inference, emits :result with the inferred type,
+        # and returns the type unchanged.
+        def node(node)
+          location = location_of(node)
+          name = short_name(node.class)
+          emit(:enter, location: location, data: { node: name })
+          @stack.push(node)
+          result = nil
+          begin
+            result = yield
+          ensure
+            @stack.pop
+          end
+          emit(:result, location: location, data: { node: name, type: FlowTracer.describe(result) })
+          result
+        end
+
+        def emit(kind, location: nil, data: {})
+          @events << Event.new(
+            kind: kind,
+            depth: @stack.size,
+            location: (location || current_location)&.freeze,
+            stack: @stack.map { |n| short_name(n.class) }.freeze,
+            data: data.freeze
+          )
+        end
+
+        private
+
+        def current_location
+          location_of(@stack.last)
+        end
+
+        def location_of(node)
+          return nil unless node.respond_to?(:location) && node.location
+
+          loc = node.location
+          {
+            start_line: loc.start_line, start_column: loc.start_column,
+            end_line: loc.end_line, end_column: loc.end_column,
+            start_offset: loc.start_offset, end_offset: loc.end_offset
+          }
+        end
+
+        def short_name(klass)
+          klass.name.to_s.split("::").last
+        end
+      end
+
+      @active_count = 0
+      @mutex = Mutex.new
+
+      module_function
+
+      # Activates recording on the current thread for the duration of the
+      # block and returns the frozen event list. Nests safely; restores
+      # the previous recorder on exit.
+      def record
+        previous = Thread.current[KEY]
+        recorder = Recorder.new
+        Thread.current[KEY] = recorder
+        @mutex.synchronize { @active_count += 1 }
+        yield
+        recorder.events.freeze
+      ensure
+        Thread.current[KEY] = previous
+        @mutex.synchronize { @active_count -= 1 }
+      end
+
+      # Plain integer read (GVL-atomic) — the disabled fast path.
+      def active?
+        @active_count.positive?
+      end
+
+      # Brackets one expression-typing recursion. Falls through to the
+      # bare block when the current thread is not recording (another
+      # thread may have flipped {active?}).
+      def trace_node(node, &)
+        recorder = Thread.current[KEY]
+        return yield unless recorder
+
+        recorder.node(node, &)
+      end
+
+      # `Scope#with_local` — the moment a local enters the scope.
+      def bind(name, type)
+        Thread.current[KEY]&.emit(:bind, data: { name: name.to_s, type: describe(type) })
+      end
+
+      # `Type::Combinator.union` — the moment branch types merge
+      # (including degenerate collapses like `1 | 1 → 1`).
+      def union(members, result)
+        Thread.current[KEY]&.emit(
+          :union,
+          data: { members: members.map { |m| describe(m) }.freeze, type: describe(result) }
+        )
+      end
+
+      # `MethodDispatcher.dispatch` — resolution or the fail-soft `nil`
+      # ("no rule matched"; the caller will widen to `Dynamic[Top]`).
+      def dispatch(receiver:, method_name:, args:, result:, location: nil)
+        recorder = Thread.current[KEY]
+        return unless recorder
+
+        recorder.emit(
+          :dispatch,
+          location: location && location_hash(location),
+          data: {
+            receiver: describe(receiver), method: method_name.to_s,
+            args: args.map { |a| describe(a) }.freeze,
+            type: result && describe(result), resolved: !result.nil?
+          }
+        )
+      end
+
+      def describe(type)
+        return "nil" if type.nil?
+        return type.describe(:short) if type.respond_to?(:describe)
+
+        type.inspect
+      end
+
+      def location_hash(loc)
+        {
+          start_line: loc.start_line, start_column: loc.start_column,
+          end_line: loc.end_line, end_column: loc.end_column,
+          start_offset: loc.start_offset, end_offset: loc.end_offset
+        }
+      end
+    end
+  end
+end

data/lib/rigor/inference/macro_block_self_type.rb

@@ -51,11 +51,16 @@ module Rigor
         receiver_class_name = singleton_receiver_class_name(receiver_type)
         return nil if receiver_class_name.nil?
 
-        verb = call_node.name
-        registry.plugins.each do |plugin|
-          plugin.manifest.block_as_methods.each do |entry| # rigor:disable undefined-method
-            return instance_type_for(receiver_class_name, environment) if matches?(entry, verb, receiver_class_name,
-                                                                                   environment)
+        # ADR-52 WD1 — the verb-keyed table compiled at registry build
+        # replaces the per-call plugins × block_as_methods linear scan.
+        # Entries arrive in (plugin registration, declaration) order, so
+        # the first ancestry match below is the same entry the previous
+        # walk returned; the verb membership the old `matches?` checked
+        # is guaranteed by the table key.
+        entries = registry.contribution_index.block_entries_for(call_node.name)
+        entries.each do |entry|
+          if receiver_class_inherits_from?(receiver_class_name, entry.receiver_constraint, environment)
+            return instance_type_for(receiver_class_name, environment)
           end
         end
         nil
@@ -73,12 +78,6 @@ module Rigor
         receiver_type.class_name
       end
 
-      def matches?(entry, verb, receiver_class_name, environment)
-        return false unless entry.verbs.include?(verb)
-
-        receiver_class_inherits_from?(receiver_class_name, entry.receiver_constraint, environment)
-      end
-
       def receiver_class_inherits_from?(class_name, constraint, environment)
         return true if class_name == constraint
 

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

@@ -69,7 +69,11 @@ module Rigor
         #   the call's block. `nil` means "no block at the call site"
         #   and disqualifies every rule here.
         # @return [Rigor::Type, nil]
-        def try_fold(receiver:, method_name:, args:, block_type:)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
+          block_type = context.block_type
           return nil if receiver.nil? || block_type.nil?
 
           truthiness = constant_truthiness(block_type)

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # Immutable value object carrying everything a dispatch tier needs
+      # to fold a single call site. Built once per `MethodDispatcher.dispatch`
+      # and threaded — unchanged — through every tier, replacing the
+      # `(receiver:, method_name:, args:, …)` keyword quartet that each
+      # tier used to redeclare (several with `# rubocop:disable
+      # Metrics/ParameterLists`).
+      #
+      # Every tier satisfies one interface — `try_dispatch(CallContext) ->
+      # Rigor::Type?` (the `_DispatchTier` RBS interface). Pure tiers
+      # (the singleton folders, ConstantFolding, ShapeDispatch, …) read
+      # only `receiver` / `method_name` / `args` and ignore the rest;
+      # the RBS / backward / block-param tiers consult the wider context.
+      #
+      # Derived call sites (the user-class fallback's `public_only` RBS
+      # retry, the Tier-B origin-module redispatch) use `Data#with` to
+      # copy the base context with the few fields that differ rather than
+      # rebuilding the quartet by hand.
+      #
+      # Fields:
+      # - `receiver`            — the receiver `Rigor::Type` (nil short-circuits)
+      # - `method_name`         — the called selector (Symbol)
+      # - `args`                — positional argument `Rigor::Type`s
+      # - `block_type`          — the block's `Rigor::Type`, or nil
+      # - `environment`         — the analysis `Environment` (RBS loader, …)
+      # - `call_node`           — the Prism call node, when available
+      # - `scope`               — the enclosing `Scope` (discovered methods, …)
+      # - `self_type_override`  — receiver to attribute private dispatch to
+      # - `public_only`         — suppress private-method resolution (explicit, non-self receiver)
+      CallContext = Data.define(
+        :receiver, :method_name, :args,
+        :block_type, :environment, :call_node, :scope,
+        :self_type_override, :public_only
+      ) do
+        # Keyword factory with nil/false defaults for the optional
+        # context fields, so a caller that only has the call quartet
+        # (the common precise-tier path) need not spell out the rest.
+        #
+        # This is the single place the call-context field list is
+        # enumerated — the whole point of the value object is to absorb
+        # the wide keyword list the tiers used to each redeclare. The
+        # ParameterLists disable here retires the per-tier disables (the
+        # `RbsDispatch` quartet-plus signatures) rather than adding to
+        # them.
+        def self.build(receiver:, method_name:, args:, # rubocop:disable Metrics/ParameterLists
+                       block_type: nil, environment: nil, call_node: nil,
+                       scope: nil, self_type_override: nil, public_only: false)
+          # Positional `new` (field-definition order) avoids the keyword
+          # hash a `new(receiver:, …)` call allocates — this runs once per
+          # dispatch and was a top allocation site. Order MUST track the
+          # `Data.define` field list above.
+          new(
+            receiver, method_name, args,
+            block_type, environment, call_node, scope,
+            self_type_override, public_only
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require "cgi/util"
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -63,22 +64,21 @@ 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, "CGI")
           return nil unless CGI_ALL_ESCAPE_METHODS.include?(method_name)
 
           fold_cgi_call(method_name, args)
         end
 
-        def dispatch_target?(receiver)
-          receiver.is_a?(Type::Singleton) && receiver.class_name == "CGI"
-        end
-
         def fold_cgi_call(method_name, args)
           return nil if args.empty?
-          return nil unless args.first.is_a?(Type::Constant) && args.first.value.is_a?(String)
 
-          str = args.first.value
+          str = SingletonFolding.constant_string(args.first)
+          return nil if str.nil?
 
           if CGI_ELEMENT_ESCAPE_METHODS.include?(method_name)
             fold_cgi_element(method_name, str, args.drop(1))
@@ -94,9 +94,10 @@ module Rigor
         # must be `Constant[String]` element names.
         def fold_cgi_element(method_name, str, element_args)
           elements = element_args.map do |arg|
-            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(String)
+            value = SingletonFolding.constant_string(arg)
+            return nil if value.nil?
 
-            arg.value
+            value
           end
 
           Type::Combinator.constant_of(CGI.public_send(method_name, str, *elements))

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

@@ -57,7 +57,10 @@ module Rigor
           :+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>,
           :start_with?, :end_with?, :include?,
           :delete_prefix, :delete_suffix,
-          :match?, :index, :rindex, :center, :ljust, :rjust
+          :match?, :index, :rindex, :center, :ljust, :rjust,
+          # 1-arg pure transforms/queries whose output never exceeds the
+          # input: `delete`/`squeeze` shrink the string, `count` → Integer.
+          :delete, :count, :squeeze
         ].freeze
         SYMBOL_BINARY  = Set[:==, :!=, :<=>, :<, :<=, :>, :>=].freeze
         BOOL_BINARY    = Set[:&, :|, :^, :==, :!=, :===].freeze
@@ -98,7 +101,7 @@ module Rigor
         STRING_UNARY = Set[
           :upcase, :downcase, :capitalize, :swapcase,
           :reverse, :length, :size, :bytesize,
-          :empty?, :strip, :lstrip, :rstrip, :chomp, :chop,
+          :empty?, :strip, :lstrip, :rstrip, :chomp, :chop, :squeeze,
           :to_s, :to_str, :to_sym, :intern,
           :to_i, :to_f, :ord, :chr, :hex, :oct, :succ, :next,
           :inspect, :hash
@@ -132,7 +135,10 @@ module Rigor
         UNION_FOLD_OUTPUT_LIMIT = 8
 
         # @return [Rigor::Type::Constant, Rigor::Type::Union, Rigor::Type::IntegerRange, nil]
-        def try_fold(receiver:, method_name:, args:)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
           # v0.0.7 — `String#%` against a `Tuple` / `HashShape`
           # argument runs Ruby's format-string engine when both
           # sides are statically constant. The standard
@@ -1150,7 +1156,7 @@ module Rigor
         #
         # Resolution order:
         #
-        # 1. Primary class catalog (e.g. NumericCatalog for an
+        # 1. Primary class catalog (e.g. NUMERIC_CATALOG for an
         #    Integer receiver). When the catalog has an entry —
         #    even one classified `:dispatch` — that answer wins.
         #    The class's direct `rb_define_method` registration is
@@ -1210,8 +1216,8 @@ module Rigor
         # arm first and the catalog would consult the Date entry
         # in `DATE_CATALOG` for the wrong class.
         CATALOG_BY_CLASS = Ractor.make_shareable([
-                                                   [Integer, [Builtins::NumericCatalog, "Integer"]],
-                                                   [Float,    [Builtins::NumericCatalog, "Float"]],
+                                                   [Integer, [Builtins::NUMERIC_CATALOG, "Integer"]],
+                                                   [Float,    [Builtins::NUMERIC_CATALOG, "Float"]],
                                                    [String,   [Builtins::STRING_CATALOG, "String"]],
                                                    [Symbol,   [Builtins::STRING_CATALOG, "Symbol"]],
                                                    [Array,    [Builtins::ARRAY_CATALOG,  "Array"]],

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

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require_relative "../../type"
+require_relative "singleton_folding"
+
+module Rigor
+  module Inference
+    module MethodDispatcher
+      # ADR-48 — `Data.define` value folding. Three responsibilities, all
+      # gated on a fully-decidable shape and degrading to today's behaviour
+      # (no carrier / the `Data` nominal) the moment a premise is uncertain,
+      # so the tier is precision-additive and adds no false-positive
+      # surface:
+      #
+      # 1. `Data.define(:x, :y)` on a `Singleton[Data]` receiver with
+      #    literal-Symbol args and NO block -> `DataClass{members: [...]}`.
+      #    A block (`Data.define(:x) do ... end`) defers (slice 4 hardens
+      #    the block-body case); non-literal members (`Data.define(*names)`)
+      #    defer.
+      # 2. `.new` / `.[]` on a `DataClass` receiver -> a `DataInstance`
+      #    whose member map is built from the call's positional or keyword
+      #    arguments. An arity / key mismatch degrades to the `Data` (or the
+      #    tagged class) nominal rather than a wrong member map.
+      # 3. member reads + `[]` / `to_h` / `deconstruct` / `deconstruct_keys`
+      #    / `members` / `with` on a `DataInstance` receiver -> the precise
+      #    projected type. Unhandled methods return nil so the pipeline
+      #    projects the instance to its nominal through RbsDispatch.
+      #
+      # See docs/adr/48-data-struct-value-folding.md.
+      module DataFolding
+        module_function
+
+        # @return [Rigor::Type, nil] the folded result, or nil to defer.
+        def try_dispatch(context)
+          receiver = context.receiver
+
+          return fold_define(context) if SingletonFolding.receiver?(receiver, "Data")
+
+          case receiver
+          when Type::DataClass
+            materialize_instance(receiver.members, receiver.class_name, context)
+          when Type::DataInstance
+            fold_instance(receiver, context)
+          when Type::Singleton
+            fold_named_new(receiver, context)
+          end
+        end
+
+        # A `Data.define` value object assigned to a constant (or a
+        # `class Point < Data.define(...)` subclass) is canonicalised by the
+        # engine to `Singleton[Point]`, not a `DataClass` — so its member
+        # layout is read from the project side-table the scope indexer built
+        # (`Scope#data_member_layout`) rather than from the receiver carrier.
+        def fold_named_new(singleton, context)
+          scope = context.scope
+          return nil if scope.nil?
+
+          members = scope.data_member_layout(singleton.class_name)
+          return nil if members.nil?
+
+          materialize_instance(members, singleton.class_name, context)
+        end
+
+        # --- 1. Data.define(:x, :y) -------------------------------------
+
+        def fold_define(context)
+          return nil unless context.method_name == :define
+          # Block-form (`Data.define(:x) do ... end`) defers — slice 4.
+          return nil unless context.block_type.nil?
+
+          members = member_names_from_args(context.args)
+          return nil if members.nil? || members.empty?
+
+          Type::Combinator.data_class_of(members: members)
+        end
+
+        # The ordered Symbol member names, or nil when any argument is not
+        # a literal `Constant[Symbol]` (a splat or dynamic name).
+        def member_names_from_args(args)
+          names = args.map do |arg|
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Symbol)
+
+            arg.value
+          end
+          return nil unless names.uniq.size == names.size
+
+          names
+        end
+
+        # --- 2. Point.new(...) / Point[...] -----------------------------
+
+        def materialize_instance(members, class_name, context)
+          method_name = context.method_name
+          return nil unless %i[new []].include?(method_name)
+
+          map = member_map_for_new(members, context)
+          return degraded_instance(class_name) if map.nil?
+
+          Type::Combinator.data_instance_of(members: map, class_name: class_name)
+        end
+
+        # Builds the member -> type map from the call's arguments, honouring
+        # the keyword vs positional distinction read off the call node. nil
+        # when the arguments cannot soundly populate every member.
+        def member_map_for_new(members, context)
+          if keyword_new?(context)
+            keyword_member_map(members, context.args)
+          else
+            positional_member_map(members, context.args)
+          end
+        end
+
+        # `Point.new(x: 1, y: 2)` arrives as a single trailing `HashShape`
+        # arg whose call node is a `KeywordHashNode`. Distinguishing it from
+        # a positional hash (`Point.new({x: 1})`, a `HashNode`) needs the
+        # call node, since both type to a `HashShape`.
+        def keyword_new?(context)
+          node = context.call_node
+          return false if node.nil?
+
+          arguments = node.arguments&.arguments
+          return false if arguments.nil? || arguments.empty?
+
+          arguments.last.is_a?(Prism::KeywordHashNode)
+        end
+
+        def keyword_member_map(members, args)
+          return nil unless args.size == 1
+
+          shape = args.first
+          return nil unless shape.is_a?(Type::HashShape) && shape.closed?
+          return nil unless shape.optional_keys.empty?
+          return nil unless shape.pairs.keys.sort == members.sort
+
+          members.to_h { |name| [name, shape.pairs.fetch(name)] }
+        end
+
+        def positional_member_map(members, args)
+          return nil unless args.size == members.size
+
+          members.zip(args).to_h
+        end
+
+        # A `.new` whose arguments do not fold to a precise map still has a
+        # sound, more-precise-than-Dynamic answer: an instance of the
+        # tagged class (or the `Data` supertype).
+        def degraded_instance(class_name)
+          Type::Combinator.nominal_of(class_name || "Data")
+        end
+
+        # --- 3. inst.x / inst[...] / inst.to_h / ... --------------------
+
+        def fold_instance(instance, context)
+          method_name = context.method_name
+          args = context.args
+          members = instance.members
+
+          if members.key?(method_name) && args.empty? && !reader_overridden?(instance, method_name, context.scope)
+            return members.fetch(method_name)
+          end
+
+          case method_name
+          when :[] then instance_index(instance, args)
+          when :to_h, :to_hash then instance_to_h(instance)
+          when :deconstruct then instance_deconstruct(instance)
+          when :deconstruct_keys then instance_deconstruct_keys(instance, args)
+          when :members then instance_members(instance)
+          when :with then instance_with(instance, args)
+          end
+        end
+
+        # A `Data.define` class body (the `class Point < Data.define(:x);
+        # def x; …; end; end` subclass body, or a `Const = Data.define(:x) do
+        # def x; …; end; end` block) can redefine a member's synthesised
+        # reader. When it does, `inst.x` runs that `def`, NOT the member, so
+        # folding the read to the member type would be unsound (a downstream
+        # FP). Both named forms register the override as a real `def` node
+        # under the class name, so an entry in the project def-node table is
+        # the discriminator (the synthesised reader has no def node). The
+        # value accessors `[]` / `to_h` / `deconstruct` bypass the reader and
+        # stay foldable, so this gate is on the bare member read only.
+        def reader_overridden?(instance, method_name, scope)
+          class_name = instance.class_name
+          return false if class_name.nil? || scope.nil?
+
+          !scope.user_def_for(class_name, method_name).nil?
+        end
+
+        def instance_index(instance, args)
+          return nil unless args.size == 1
+
+          arg = args.first
+          return nil unless arg.is_a?(Type::Constant)
+
+          key = arg.value
+          case key
+          when Symbol
+            instance.members[key]
+          when Integer
+            values = instance.members.values
+            idx = key.negative? ? key + values.size : key
+            values[idx] if idx && idx >= 0 && idx < values.size
+          end
+        end
+
+        def instance_to_h(instance)
+          Type::Combinator.hash_shape_of(instance.members.dup)
+        end
+
+        def instance_deconstruct(instance)
+          Type::Combinator.tuple_of(*instance.members.values)
+        end
+
+        # `deconstruct_keys(nil)` / `deconstruct_keys([:x])` both yield a
+        # subset of the member map; the conservative, always-correct answer
+        # is the full closed member shape.
+        def instance_deconstruct_keys(instance, args)
+          return nil unless args.size <= 1
+
+          Type::Combinator.hash_shape_of(instance.members.dup)
+        end
+
+        def instance_members(instance)
+          Type::Combinator.tuple_of(*instance.member_names.map { |name| Type::Combinator.constant_of(name) })
+        end
+
+        # `Data#with(x: 9)` returns a new frozen copy with the named members
+        # overridden. Only a closed keyword `HashShape` whose keys are a
+        # subset of the members folds; anything else defers (RBS resolves
+        # `with` to `self`, returning the unchanged instance type).
+        def instance_with(instance, args)
+          return instance if args.empty?
+          return nil unless args.size == 1
+
+          shape = args.first
+          return nil unless shape.is_a?(Type::HashShape) && shape.closed?
+          return nil unless shape.optional_keys.empty?
+          return nil unless shape.pairs.keys.all? { |key| instance.members.key?(key) }
+
+          merged = instance.members.merge(shape.pairs)
+          Type::Combinator.data_instance_of(members: merged, class_name: instance.class_name)
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../type"
+require_relative "singleton_folding"
 
 module Rigor
   module Inference
@@ -90,7 +91,10 @@ module Rigor
 
         # @return [Rigor::Type, nil] folded result, or nil to defer
         #   to the next dispatcher tier.
-        def try_dispatch(receiver:, method_name:, args:)
+        def try_dispatch(context)
+          receiver = context.receiver
+          method_name = context.method_name
+          args = context.args
           return nil unless dispatch_target?(receiver)
           return nil unless FILE_PURE_CLASS_METHODS.include?(method_name)
           return nil if platform_specific_skip?(method_name)
@@ -107,7 +111,7 @@ module Rigor
         end
 
         def dispatch_target?(receiver)
-          receiver.is_a?(Type::Singleton) && receiver.class_name == "File"
+          SingletonFolding.receiver?(receiver, "File")
         end
 
         def constant_string_args(args)