rigortype 0.1.16 → 0.1.18

data/lib/rigor/inference/builtins/numeric_catalog.rb

@@ -1,104 +1,32 @@
 # frozen_string_literal: true
 
-require "yaml"
+require_relative "method_catalog"
 
 module Rigor
   module Inference
     module Builtins
-      # Read-only loader for the Numeric/Integer/Float built-in method
-      # catalog at `data/builtins/ruby_core/numeric.yml`. The catalog is
-      # produced offline by `tool/extract_numeric_catalog.rb` from the
-      # CRuby reference checkout under `references/ruby` plus the RBS
-      # core signatures under `references/rbs`.
+      # `Numeric` family catalog (Integer, Float, Rational, Complex,
+      # Numeric). Singleton — load once, consult during dispatch.
       #
-      # The loader is the runtime bridge: callers ask "is `Integer#+`
-      # safe to invoke during constant folding?" and the answer comes
-      # straight from the offline classification (`leaf`, `trivial`,
-      # `leaf_when_numeric` are foldable; everything else is not).
+      # The catalog is produced offline by `tool/extract_builtin_catalog.rb`
+      # from the CRuby reference checkout under `references/ruby` plus the
+      # RBS core signatures under `references/rbs`. The loader is the
+      # runtime bridge: callers ask "is `Integer#+` safe to invoke during
+      # constant folding?" and the answer comes straight from the offline
+      # classification (`leaf` / `trivial` / `leaf_when_numeric` are
+      # foldable; everything else is not).
       #
-      # The catalog is loaded lazily on first access and memoised for
-      # the lifetime of the process. If the file is missing (e.g. in a
-      # bare gem install where the consumer opted out of shipping data
-      # files, or in a development checkout that has not yet generated
-      # the catalog) the loader degrades to an empty catalog so calls
-      # uniformly return `false` and the rest of the dispatcher
-      # continues with its hand-rolled allow lists.
-      module NumericCatalog
-        # Purity tags from the catalog that are safe for the analyzer
-        # to invoke against concrete literal receivers/arguments.
-        # `leaf_when_numeric` is included because `ConstantFolding`
-        # only lets it through when every argument is itself a
-        # `Constant<Numeric>` or `IntegerRange` — exactly the gate
-        # the catalog tag is named for.
-        FOLDABLE_PURITIES = Set["leaf", "trivial", "leaf_when_numeric"].freeze
-
-        EMPTY_CATALOG = { "classes" => {} }.freeze
-        private_constant :EMPTY_CATALOG
-
-        # Path resolved relative to this file. The catalog ships under
-        # `data/builtins/ruby_core/numeric.yml` at the gem root.
-        CATALOG_PATH = File.expand_path(
-          "../../../../data/builtins/ruby_core/numeric.yml",
-          __dir__
-        )
-        private_constant :CATALOG_PATH
-
-        class << self
-          # @param class_name [String] e.g. "Integer", "Float"
-          # @param selector [Symbol, String]
-          # @param kind [Symbol] :instance (default) or :singleton
-          # @return [Boolean]
-          def safe_for_folding?(class_name, selector, kind: :instance)
-            entry = method_entry(class_name, selector, kind: kind)
-            return false unless entry
-
-            FOLDABLE_PURITIES.include?(entry["purity"])
-          end
-
-          # @return [Hash, nil] catalog entry for the given method, or
-          #   nil when the method is not registered.
-          def method_entry(class_name, selector, kind: :instance)
-            klass = catalog.dig("classes", class_name.to_s)
-            return nil unless klass
-
-            bucket_key = kind == :singleton ? "singleton_methods" : "instance_methods"
-            klass.dig(bucket_key, selector.to_s)
-          end
-
-          # Used by tests to drop the cached catalog so a different
-          # path or content can be exercised. Production code MUST
-          # NOT call this during normal operation.
-          #
-          # ADR-15 Phase 4b.x — reset re-loads eagerly so the
-          # singleton-class `@catalog` ivar stays populated, and
-          # the loaded Hash is deep-shared via `Ractor.make_shareable`
-          # so a worker Ractor reading the ivar via `catalog.dig(...)`
-          # does not trip `Ractor::IsolationError`. Plain `.freeze`
-          # is insufficient: YAML parses to a nested Hash/Array/String
-          # graph and only the outer Hash would be frozen.
-          def reset!
-            @catalog = Ractor.make_shareable(load_catalog)
-          end
-
-          private
-
-          attr_reader :catalog
-
-          def load_catalog
-            return EMPTY_CATALOG unless File.exist?(CATALOG_PATH)
-
-            data = YAML.safe_load_file(CATALOG_PATH, permitted_classes: [Symbol])
-            data.is_a?(Hash) ? data : EMPTY_CATALOG
-          rescue Psych::SyntaxError
-            EMPTY_CATALOG
-          end
-        end
-
-        # ADR-15 Phase 4b.x — eager-load on the main Ractor at
-        # module-load time so worker Ractors only READ the
-        # populated singleton-class `@catalog` ivar.
-        reset!
-      end
+      # No mutation blocklist is needed. The numeric classes expose no
+      # foldable bang or indirect-mutator method that the static C
+      # classifier mis-attributes (every `:leaf` numeric method is a pure
+      # value computation), so the generic `MethodCatalog` loader — shared
+      # with the eighteen other per-class catalogs — covers it directly.
+      # This previously hand-rolled its own `safe_for_folding?` /
+      # `method_entry` / `load_catalog` copy of `MethodCatalog`; folding
+      # it onto the shared loader also picks up alias resolution (e.g.
+      # `Integer#magnitude` → `abs`, `Integer#inspect` → `to_s`), which the
+      # old bespoke loader silently dropped.
+      NUMERIC_CATALOG = MethodCatalog.for_topic("numeric")
     end
   end
 end

data/lib/rigor/inference/builtins/pathname_catalog.rb

@@ -16,11 +16,8 @@ module Rigor
       # helper that triggered the false positive (see
       # `string_catalog.rb`, `array_catalog.rb`, `time_catalog.rb`
       # for the canonical shape).
-      PATHNAME_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/pathname.yml",
-          __dir__
-        ),
+      PATHNAME_CATALOG = MethodCatalog.for_topic(
+        "pathname",
         mutating_selectors: {
           "Pathname" => Set[
           # initialize_copy is blocklisted by convention so a

data/lib/rigor/inference/builtins/proc_catalog.rb

@@ -31,11 +31,8 @@ module Rigor
       # `#source_location`, `#name`, `#owner`, `#receiver`) remain
       # foldable; the RBS tier still resolves return types for
       # the blocklisted methods so callers do not lose precision.
-      PROC_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/proc.yml",
-          __dir__
-        ),
+      PROC_CATALOG = MethodCatalog.for_topic(
+        "proc",
         mutating_selectors: {
           "Proc" => Set[
             # `#call` / `#[]` / `#===` / `#yield` invoke the proc

data/lib/rigor/inference/builtins/random_catalog.rb

@@ -21,11 +21,8 @@ module Rigor
       # functionally pure they would produce a misleading constant
       # at fold time. The whole class is conservative-by-default
       # at the catalog tier; precision flows through the RBS layer.
-      RANDOM_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/random.yml",
-          __dir__
-        ),
+      RANDOM_CATALOG = MethodCatalog.for_topic(
+        "random",
         mutating_selectors: {
           "Random" => Set[
             # `rand_random` -> `random_real` / `random_ulong_limited`

data/lib/rigor/inference/builtins/range_catalog.rb

@@ -15,11 +15,8 @@ module Rigor
       # routes through a helper the block/yield regex does not
       # recognise, so the classifier mis-flags them as `:leaf`
       # despite yielding to a block.
-      RANGE_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/range.yml",
-          __dir__
-        ),
+      RANGE_CATALOG = MethodCatalog.for_topic(
+        "range",
         mutating_selectors: {
           "Range" => Set[
             # `range_initialize` / `range_initialize_copy` write

data/lib/rigor/inference/builtins/rational_catalog.rb

@@ -22,11 +22,8 @@ module Rigor
       # hypothetical future `Constant<Rational>` carrier cannot
       # fold an aliasing copy through the catalog and surface a
       # shared mutable handle.
-      RATIONAL_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/rational.yml",
-          __dir__
-        ),
+      RATIONAL_CATALOG = MethodCatalog.for_topic(
+        "rational",
         mutating_selectors: {
           "Rational" => Set[
             :initialize_copy

data/lib/rigor/inference/builtins/re_catalog.rb

@@ -38,11 +38,8 @@ module Rigor
       # signatures already widen the answer enough to keep the
       # behaviour sound; revisit if the dispatcher ever grows a
       # singleton-aware catalog path.
-      REGEXP_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/re.yml",
-          __dir__
-        ),
+      REGEXP_CATALOG = MethodCatalog.for_topic(
+        "re",
         mutating_selectors: {
           "Regexp" => Set[
             # Defensive: aliasing-copy semantics already covered

data/lib/rigor/inference/builtins/set_catalog.rb

@@ -19,11 +19,8 @@ module Rigor
       # (`set_iter`, `RETURN_SIZED_ENUMERATOR`) and its identity-
       # mode and reset paths drive into helpers the regex classifier
       # does not yet recognise as block-yielding or mutating.
-      SET_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/set.yml",
-          __dir__
-        ),
+      SET_CATALOG = MethodCatalog.for_topic(
+        "set",
         mutating_selectors: {
           "Set" => Set[
             # Indirect mutators classified `:leaf` because the C

data/lib/rigor/inference/builtins/string_catalog.rb

@@ -15,11 +15,8 @@ module Rigor
       # mutation primitives). Adding to the blocklist is the
       # corrective surface for false positives until the
       # classifier learns the helper functions.
-      STRING_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/string.yml",
-          __dir__
-        ),
+      STRING_CATALOG = MethodCatalog.for_topic(
+        "string",
         mutating_selectors: {
           "String" => Set[
             :replace, :initialize, :initialize_copy, :clear, :<<, :concat, :insert,

data/lib/rigor/inference/builtins/struct_catalog.rb

@@ -23,11 +23,8 @@ module Rigor
       # member but the answer depends on the subclass's member
       # definition, which the catalog does not see, so we blocklist
       # it defensively.
-      STRUCT_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/struct.yml",
-          __dir__
-        ),
+      STRUCT_CATALOG = MethodCatalog.for_topic(
+        "struct",
         mutating_selectors: {
           "Struct" => Set[
             # Defensive: aliasing-copy semantics on a hypothetical

data/lib/rigor/inference/builtins/time_catalog.rb

@@ -29,11 +29,8 @@ module Rigor
       # The blocklist captures the false-positive `:leaf` entries
       # whose helper functions the regex classifier did not
       # recognise as mutators.
-      TIME_CATALOG = MethodCatalog.new(
-        path: File.expand_path(
-          "../../../../data/builtins/ruby_core/time.yml",
-          __dir__
-        ),
+      TIME_CATALOG = MethodCatalog.for_topic(
+        "time",
         mutating_selectors: {
           "Time" => Set[
             # `time_init_copy` writes the `timew` and `vtm` slots on

data/lib/rigor/inference/expression_typer.rb

@@ -4,9 +4,11 @@ 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"
+require_relative "flow_tracer"
 require_relative "indexed_narrowing"
 require_relative "macro_block_self_type"
 require_relative "method_dispatcher"
@@ -111,7 +113,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,
@@ -218,6 +220,15 @@ module Rigor
       end
 
       def type_of(node)
+        return untraced_type_of(node) unless FlowTracer.active?
+
+        # `rigor trace` — bracket the recursion with enter/result events.
+        # The tracer is observational only: the inferred type flows
+        # through unchanged (see FlowTracer's contract).
+        FlowTracer.trace_node(node) { untraced_type_of(node) }
+      end
+
+      def untraced_type_of(node)
         # Slice A-declarations. ScopeIndexer pre-fills
         # `scope.declared_types` for declaration-position nodes
         # (`module Foo` / `class Bar` headers) with the qualified
@@ -443,8 +454,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
@@ -663,26 +678,17 @@ module Rigor
       end
 
       # Returns `:truthy`, `:falsey`, or `nil` for an arbitrary
-      # predicate expression under three-valued logic. Uses the
-      # same {Narrowing} probe as `StatementEvaluator#eval_if`:
-      # the predicate is truthy when its falsey fragment is `Bot`,
-      # falsey when its truthy fragment is `Bot`. So
-      # `Nominal[Integer]` (always truthy in Ruby), `Constant[nil]`,
-      # and `Constant[false]` fold one branch; `Union[true, false]`,
-      # `Dynamic[T]`, and `Top` keep both branches live.
+      # predicate expression under three-valued logic.
+      # {Narrowing.predicate_certainty} owns the judgment (the same
+      # one `StatementEvaluator#live_branch_for_if` reads on the
+      # scope side): `Nominal[Integer]` (always truthy in Ruby),
+      # `Constant[nil]`, and `Constant[false]` fold one branch;
+      # `Union[true, false]`, `Dynamic[T]`, and `Top` keep both
+      # branches live.
       def constant_predicate_polarity(predicate)
         return nil if predicate.nil?
 
-        type = type_of(predicate)
-        return nil if type.nil? || type.is_a?(Type::Bot)
-
-        truthy_bot = Narrowing.narrow_truthy(type).is_a?(Type::Bot)
-        falsey_bot = Narrowing.narrow_falsey(type).is_a?(Type::Bot)
-
-        return :falsey if truthy_bot && !falsey_bot
-        return :truthy if !truthy_bot && falsey_bot
-
-        nil
+        Narrowing.predicate_certainty(type_of(predicate))
       end
 
       def type_of_else(node)
@@ -813,29 +819,14 @@ module Rigor
       # `:maybe` — the existing union fallback handles them.
       def case_when_pattern_certainty(subject_type, pattern_node)
         class_name = build_constant_path_name(pattern_node)
-        return class_pattern_certainty(subject_type, class_name) if class_name
+        return Narrowing.class_pattern_certainty(subject_type, class_name, environment: scope.environment) if class_name
 
         literal = literal_pattern_value(pattern_node)
-        return literal_pattern_certainty(subject_type, literal[:value]) if literal
-
-        :maybe
-      end
-
-      def class_pattern_certainty(subject_type, class_name)
-        env = scope.environment
-        truthy_bot = Narrowing.narrow_class(subject_type, class_name, environment: env).is_a?(Type::Bot)
-        falsey_bot = Narrowing.narrow_not_class(subject_type, class_name, environment: env).is_a?(Type::Bot)
-
-        return :no if truthy_bot && !falsey_bot
-        return :yes if !truthy_bot && falsey_bot
+        return Narrowing.value_pattern_certainty(subject_type, literal[:value]) if literal
 
         :maybe
       end
 
-      VALUE_EQUALITY_CLASSES = [Integer, Float, Rational, Complex, String, Symbol,
-                                TrueClass, FalseClass, NilClass].freeze
-      private_constant :VALUE_EQUALITY_CLASSES
-
       # Returns `{ value: v }` when `pattern_node` types to a
       # `Constant[v]` of a value-equality-safe class (so `===`
       # reduces to `==`), else nil. Wrapped in a hash so a literal
@@ -844,18 +835,11 @@ module Rigor
       def literal_pattern_value(pattern_node)
         type = type_of(pattern_node)
         return nil unless type.is_a?(Type::Constant)
-        return nil unless VALUE_EQUALITY_CLASSES.any? { |klass| type.value.is_a?(klass) }
+        return nil unless Narrowing::VALUE_EQUALITY_CLASSES.any? { |klass| type.value.is_a?(klass) }
 
         { value: type.value }
       end
 
-      def literal_pattern_certainty(subject_type, pattern_value)
-        return :maybe unless subject_type.is_a?(Type::Constant)
-        return :maybe unless VALUE_EQUALITY_CLASSES.any? { |klass| subject_type.value.is_a?(klass) }
-
-        pattern_value == subject_type.value ? :yes : :no
-      end
-
       # `when` clauses for `case` and `in` clauses for `case ... in` have
       # the same body shape; we reuse one handler for both Prism node
       # classes.
@@ -1260,9 +1244,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 +1388,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 +1474,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("::")
@@ -1460,29 +1544,31 @@ module Rigor
       # nil when the parameter shape is too complex for the
       # first-iteration binder (rest args, keyword args,
       # block params, etc.).
-      def build_user_method_body_scope(def_node, receiver, arg_types) # rubocop:disable Metrics/AbcSize
+      def build_user_method_body_scope(def_node, receiver, arg_types)
         params = def_node.parameters
         required = params&.requireds || []
         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, run per user-method-call inference (ADR-44). The
+        # discovery index is inherited whole by reference (ADR-53 Track A);
+        # the hand-copied per-field list this replaces had silently dropped
+        # `data_member_layouts` and `discovered_method_visibilities`.
+        Scope.new(
+          environment: scope.environment,
+          locals: locals.freeze,
+          self_type: receiver,
+          discovery: scope.discovery
+        )
       end
 
       # First iteration accepts only required positional