rigortype 0.1.16 → 0.1.17

data/lib/rigor/inference/expression_typer.rb

@@ -4,6 +4,7 @@ require "prism"
 
 require_relative "../type"
 require_relative "../ast"
+require_relative "../analysis/self_call_resolution_recorder"
 require_relative "block_parameter_binder"
 require_relative "budget_trace"
 require_relative "fallback"
@@ -111,7 +112,7 @@ module Rigor
         Prism::GlobalVariableOperatorWriteNode => :type_of_assignment_write,
         Prism::GlobalVariableOrWriteNode => :type_of_assignment_write,
         Prism::GlobalVariableAndWriteNode => :type_of_assignment_write,
-        # Compound writes that share the .value rvalue protocol
+        # Compound writes that share the `.value` rvalue accessor
         Prism::LocalVariableOperatorWriteNode => :type_of_assignment_write,
         Prism::LocalVariableOrWriteNode => :type_of_assignment_write,
         Prism::LocalVariableAndWriteNode => :type_of_assignment_write,
@@ -443,8 +444,12 @@ module Rigor
         candidates = []
         while prefix && !prefix.empty?
           candidates << "#{prefix}::#{name}"
-          prefix = prefix.rpartition("::").first
-          prefix = nil if prefix.empty?
+          # Strip the last `::` segment without `rpartition`'s throwaway
+          # 3-element array + extra substrings (this loop is the sole
+          # caller of the `String#rpartition` allocation seen in the
+          # profile): `rindex` + slice gives the same prefix, or nil.
+          idx = prefix.rindex("::")
+          prefix = idx ? prefix[0, idx] : nil
         end
         candidates << name
         candidates
@@ -1260,9 +1265,64 @@ module Rigor
         # MUST NOT record a tracer event.
         return dynamic_top if receiver.is_a?(Type::Dynamic)
 
+        # ADR-24 slice 4a — this is the engine choke-point where an
+        # implicit-self call has exhausted every resolution tier (RBS
+        # dispatch + user-class ancestor walk) and falls through to
+        # `Dynamic[top]`. When the slice-4 recorder is active, capture the
+        # miss so a later slice's closed-class gate can flag it. Off by
+        # default: `active?` is a plain integer read.
+        record_unresolved_self_call(node, receiver) if Analysis::SelfCallResolutionRecorder.active?
+
         fallback_for(node, family: :prism)
       end
 
+      # ADR-24 slice 4a — records an unresolved *implicit-self* call (no
+      # explicit receiver) whose `self` types to a concrete user class.
+      # Explicit-receiver misses are out of scope (the existing
+      # `call.undefined-method` rule already owns receiver-typed dispatch);
+      # a non-`Nominal` self (top-level / DSL-block `self`, or a `Dynamic`
+      # self) is skipped so the gradual guarantee is never touched here.
+      def record_unresolved_self_call(node, receiver)
+        return unless node.receiver.nil?
+        return unless receiver.is_a?(Type::Nominal)
+        return if self_call_method_known?(receiver.class_name, node.name)
+
+        location = node.message_loc || node.location
+        Analysis::SelfCallResolutionRecorder.record(
+          class_name: receiver.class_name,
+          method_name: node.name,
+          node: node,
+          path: scope.source_path,
+          line: location&.start_line,
+          column: location ? location.start_column + 1 : nil
+        )
+      end
+
+      # The recorder must capture *existence* misses, not type misses.
+      # Reaching the choke-point means RBS dispatch produced no result, but
+      # a project method can still EXIST without an inferable return type —
+      # a `module_function` sibling whose body the engine can't fully type,
+      # an `attr_reader` / `define_method` / `Data.define` member. Recording
+      # those would reproduce the 135 false positives of slice-4 attempt 1.
+      # So skip any name the engine's own existence signals already know:
+      # a `def` resolvable through the ancestor walk, or an own-class entry
+      # in the discovered-methods table (`def` / `attr_*` / `define_method`
+      # / alias). This reuses the engine's real resolution — the
+      # "collect, don't recompute" lesson — so only a name that exists
+      # nowhere a project signal can see reaches the recorder.
+      # `module_function` records its defs as `:singleton` (an implicit-self
+      # call inside such a method dispatches to the module's singleton
+      # method), while ordinary instance methods record `:instance`. The
+      # recorder cannot tell the two contexts apart from the call node, so
+      # existence under EITHER kind suppresses recording — the FP-safe
+      # choice, since either means the method genuinely exists.
+      def self_call_method_known?(class_name, method_name)
+        return true if resolve_user_def_through_ancestors(class_name, method_name)
+
+        scope.discovered_method?(class_name, method_name, :instance) ||
+          scope.discovered_method?(class_name, method_name, :singleton)
+      end
+
       # v0.0.2 #5 — re-types the body of a user-defined
       # instance method with the call site's argument types
       # bound to the method's parameters. Used as a
@@ -1349,7 +1409,44 @@ module Rigor
       ANCESTOR_WALK_LIMIT = 100
       private_constant :ANCESTOR_WALK_LIMIT
 
+      CLASS_GRAPH_CACHE_KEY = :__rigor_class_graph_cache__
+      private_constant :CLASS_GRAPH_CACHE_KEY
+
+      # Run-scoped memo for the static class-graph resolvers below. They
+      # are pure functions of the *frozen* project index trio
+      # (`discovered_def_nodes` / `discovered_superclasses` /
+      # `discovered_includes`) — `user_def_for` / `superclass_of` /
+      # `includes_of` read nothing else, and never touch the current
+      # scope's locals or narrowings — so a result computed for one
+      # `(class, method)` is valid for every `Scope` that shares those
+      # tables. `ExpressionTyper` is rebuilt per `Scope#type_of`, so the
+      # memo lives on `Thread.current` rather than on `self`. It is keyed
+      # by the *identity* of the three frozen tables (nested
+      # `compare_by_identity` stores): a new analysis generation, or any
+      # `Scope` that swaps an index via `with_discovered_*`, transparently
+      # lands in a fresh bucket while everything sharing the tables shares
+      # the memo. Steady-state cost is three identity-keyed hash reads and
+      # zero allocation — the `||=` chains only allocate on the first miss
+      # of a generation. (Pool mode forks per worker, so the
+      # `Thread.current` store is process-local and never crosses a
+      # project boundary.)
+      def class_graph_buckets
+        store = (Thread.current[CLASS_GRAPH_CACHE_KEY] ||= {}.compare_by_identity)
+        by_def = (store[scope.discovered_def_nodes] ||= {}.compare_by_identity)
+        by_super = (by_def[scope.discovered_superclasses] ||= {}.compare_by_identity)
+        by_super[scope.discovered_includes] ||= { name: {}, user_def: {} }
+      end
+
       def resolve_user_def_through_ancestors(class_name, method_name)
+        cache = class_graph_buckets[:user_def]
+        table = (cache[class_name.to_s] ||= {})
+        key = method_name.to_sym
+        return table[key] if table.key?(key)
+
+        table[key] = compute_user_def_through_ancestors(class_name, method_name)
+      end
+
+      def compute_user_def_through_ancestors(class_name, method_name)
         queue = [class_name.to_s]
         seen = {}
         visited = 0
@@ -1398,6 +1495,14 @@ module Rigor
       # no candidate names a discovered user class (e.g. the
       # superclass is an RBS-known or third-party class).
       def resolve_ancestor_class_name(subclass_qualified, raw_superclass)
+        by_subclass = (class_graph_buckets[:name][subclass_qualified] ||= {})
+        return by_subclass[raw_superclass] if by_subclass.key?(raw_superclass)
+
+        by_subclass[raw_superclass] =
+          compute_ancestor_class_name(subclass_qualified, raw_superclass)
+      end
+
+      def compute_ancestor_class_name(subclass_qualified, raw_superclass)
         segments = subclass_qualified.split("::")
         (segments.length - 1).downto(0) do |i|
           candidate = (segments[0, i] + [raw_superclass]).join("::")
@@ -1466,23 +1571,38 @@ module Rigor
         return nil unless params.nil? || user_method_param_shape_simple?(params)
         return nil unless required.size == arg_types.size
 
-        fresh = Scope.empty(environment: scope.environment)
-                     .with_declared_types(scope.declared_types)
-                     .with_discovered_classes(scope.discovered_classes)
-                     .with_in_source_constants(scope.in_source_constants)
-                     .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_def_nodes(scope.discovered_def_nodes)
-                     .with_discovered_superclasses(scope.discovered_superclasses)
-                     .with_discovered_includes(scope.discovered_includes)
-                     .with_self_type(receiver)
-
-        required.each_with_index do |param, index|
-          fresh = fresh.with_local(param.name, arg_types[index])
-        end
-        fresh
+        # Bind required positionals by index. The body scope starts from an
+        # empty fact store and narrowing set, so `with_local`'s fact /
+        # narrowing invalidations would be no-ops here — build the locals
+        # table directly (matching `with_local`'s `name.to_sym` key).
+        locals = {}
+        required.each_with_index { |param, index| locals[param.name.to_sym] = arg_types[index] }
+
+        # Construct the body scope in a SINGLE allocation. The previous
+        # `Scope.empty.with_*.with_*…` chain allocated a fresh frozen Scope
+        # per field — ~12 throwaway Scopes to build one body scope, run per
+        # user-method-call inference, which made these `with_*` the dominant
+        # `Scope#rebuild` source. Each field here is a plain inherited
+        # reference (the project-wide indexes + self_type); every unset
+        # field defaults to the same empty binding the old chain left it at,
+        # so the result is identical (ADR-44).
+        Scope.new(
+          environment: scope.environment,
+          locals: locals.freeze,
+          self_type: receiver,
+          declared_types: scope.declared_types,
+          discovered_classes: scope.discovered_classes,
+          in_source_constants: scope.in_source_constants,
+          class_ivars: scope.class_ivars,
+          class_cvars: scope.class_cvars,
+          program_globals: scope.program_globals,
+          discovered_methods: scope.discovered_methods,
+          discovered_def_nodes: scope.discovered_def_nodes,
+          discovered_def_sources: scope.discovered_def_sources,
+          discovered_superclasses: scope.discovered_superclasses,
+          discovered_includes: scope.discovered_includes,
+          discovered_class_sources: scope.discovered_class_sources
+        )
       end
 
       # First iteration accepts only required positional

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)