rigortype 0.2.1 → 0.2.3

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

@@ -51,7 +51,15 @@ module Rigor
         NUMERIC_BINARY = Set[
           :+, :-, :*, :/, :%, :**, :&, :|, :^, :<<, :>>,
           :<, :<=, :>, :>=, :==, :!=, :<=>,
-          :gcd, :lcm, :fdiv, :quo, :ceildiv, :[]
+          :gcd, :lcm, :fdiv, :quo, :ceildiv, :[],
+          # Integer bit-test predicates (`(self & mask) <=> mask|0`). The
+          # catalog marks them `:dispatch` only because a non-Integer mask
+          # would route through `to_int`; a concrete Integer literal never
+          # does, so the fold is pure here — the sibling of the already-folded
+          # bit-reference `:[]`. Integer-only, but Float-safe to list: a Float
+          # receiver has no such method, so `invoke_binary` rescues the
+          # `NoMethodError` to nil and the RBS tier answers.
+          :allbits?, :anybits?, :nobits?
         ].freeze
         STRING_BINARY  = Set[
           :+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>,
@@ -86,6 +94,17 @@ module Rigor
         # delegates to operand `==`); ordering is undefined for Complex.
         COMPLEX_BINARY = Set[:+, :-, :*, :/, :**].freeze
 
+        # `Set#&` and its alias `Set#intersection` are leaf-pure for a
+        # concrete Set operand exactly like their siblings `|` / `-` / `^`
+        # (all `:leaf` in the catalog), but the catalog flags
+        # `set_i_intersection`'s C body `block_dependent` — it drives Set's
+        # own internal iterator — so the catalog tier declines and the
+        # intersection alone fails to fold. A concrete Set argument's `each`
+        # is the pure core method, so the fold is sound; the hand-rolled
+        # allow-list is the right tool, mirroring the bit-test predicates.
+        # (The other binary set ops keep folding through the catalog.)
+        SET_BINARY = Set[:&, :intersection].freeze
+
         # v0.0.3 C — pure unary catalogue. Each method must:
         # - take zero arguments,
         # - have no side effects,
@@ -130,6 +149,19 @@ module Rigor
           :abs, :magnitude, :floor, :ceil, :round, :truncate,
           :next_float, :prev_float,
           :to_s, :to_i, :to_int, :to_f, :to_r, :rationalize,
+          # `numerator` / `denominator` expose the rational
+          # decomposition of the float (`2.5.numerator → 5`,
+          # `.denominator → 2`) — pure arithmetic, the Float siblings
+          # of the already-folded Rational accessors. The non-finite
+          # edges stay sound: `Infinity.numerator → Infinity` /
+          # `.denominator → 1` fold to the same value Ruby returns, and
+          # `NaN.numerator → NaN` is declined by `foldable_constant_value?`.
+          :numerator, :denominator,
+          # `arg` / `angle` / `phase` (aliases) return the complex
+          # argument of the real number: `0` for `self >= 0`, `Math::PI`
+          # for `self < 0`. Pure sign test, deterministic; a NaN
+          # receiver yields NaN which `foldable_constant_value?` declines.
+          :arg, :angle, :phase,
           :inspect, :-@, :+@
         ].freeze
         STRING_UNARY = Set[
@@ -138,7 +170,12 @@ module Rigor
           :empty?, :strip, :lstrip, :rstrip, :chomp, :chop, :squeeze,
           :to_s, :to_str, :to_sym, :intern,
           :to_i, :to_f, :ord, :chr, :hex, :oct, :succ, :next,
-          :sum, :inspect
+          :sum, :inspect,
+          # `shellescape` is the String-receiver twin of the already-folded
+          # `Shellwords.escape` — deterministic shell-quoting, no global
+          # state. The `shellwords` library is loaded process-wide via
+          # `shellwords_folding`, so the method is always defined here.
+          :shellescape
         ].freeze
         SYMBOL_UNARY = Set[
           :to_s, :to_sym, :to_proc, :length, :size,
@@ -386,26 +423,8 @@ module Rigor
         end
 
         def try_fold_unary_set(receiver_values, method_name)
-          range_lift = try_fold_range_constant_unary(receiver_values, method_name)
-          return range_lift if range_lift
-
-          string_lift = try_fold_string_array_unary(receiver_values, method_name)
-          return string_lift if string_lift
-
-          pathname_lift = try_fold_pathname_unary(receiver_values, method_name)
-          return pathname_lift if pathname_lift
-
-          regexp_lift = try_fold_regexp_array_unary(receiver_values, method_name)
-          return regexp_lift if regexp_lift
-
-          set_lift = try_fold_set_array_unary(receiver_values, method_name)
-          return set_lift if set_lift
-
-          integer_lift = try_fold_integer_array_unary(receiver_values, method_name)
-          return integer_lift if integer_lift
-
-          numeric_lift = try_fold_numeric_array_unary(receiver_values, method_name)
-          return numeric_lift if numeric_lift
+          special = try_fold_unary_special(receiver_values, method_name)
+          return special if special
 
           # Type-level allow check on every receiver. If one member's
           # type does not have the method in its allow list (e.g.
@@ -420,6 +439,23 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values)
         end
+
+        # The carrier-specific unary lifts — Range-to-Tuple, the
+        # Array-returning String / Pathname / Regexp / Set / Integer /
+        # Numeric folds — that produce a precise structural type before
+        # the generic scalar `invoke_unary` path. The first match wins;
+        # nil means none applied and the caller falls through to the
+        # scalar allow-list path.
+        def try_fold_unary_special(receiver_values, method_name)
+          try_fold_range_constant_unary(receiver_values, method_name) ||
+            try_fold_string_array_unary(receiver_values, method_name) ||
+            try_fold_pathname_unary(receiver_values, method_name) ||
+            try_fold_pathname_array_unary(receiver_values, method_name) ||
+            try_fold_regexp_array_unary(receiver_values, method_name) ||
+            try_fold_set_array_unary(receiver_values, method_name) ||
+            try_fold_integer_array_unary(receiver_values, method_name) ||
+            try_fold_numeric_array_unary(receiver_values, method_name)
+        end
         # v0.0.7 — `Constant<Range>#to_a` and the no-arg
         # `first` / `last` / `min` / `max` short-circuit through a
         # Range-specific arm that catalog dispatch cannot reach:
@@ -436,10 +472,13 @@ module Rigor
         RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax,
                                  :sum].freeze
         # 1-arg head/tail projections on a `Constant<Range>`. `first(n)` /
-        # `take(n)` return the first `n` elements, `last(n)` the final `n` —
-        # each lifts to a per-position `Tuple[Constant[Integer]…]`. The
-        # no-arg `first` / `last` stay on the unary path (single Integer).
-        RANGE_FOLD_BINARY_METHODS = Set[:first, :last, :take].freeze
+        # `take(n)` return the first `n` elements, `last(n)` the final `n`,
+        # and `min(n)` / `max(n)` the n smallest / largest (for an ascending
+        # integer range `min(n) == first(n)` and `max(n) == last(n).reverse`)
+        # — each lifts to a per-position `Tuple[Constant[Integer]…]`. The
+        # no-arg `first` / `last` / `min` / `max` stay on the unary path
+        # (single Integer endpoint).
+        RANGE_FOLD_BINARY_METHODS = Set[:first, :last, :take, :min, :max].freeze
         RANGE_TO_A_LIMIT = 16
         private_constant :RANGE_FOLD_METHODS, :RANGE_FOLD_BINARY_METHODS, :RANGE_TO_A_LIMIT
 
@@ -518,17 +557,31 @@ module Rigor
 
         def range_take_tuple(range, method_name, count)
           return nil unless count.is_a?(Integer) && !count.negative?
-          # `first(n)`/`last(n)`/`take(n)` materialise at most `min(n, size)`
-          # elements; cap that count so a huge `n` (or range) never blows up
-          # the Constant. `Range#size` is O(1) for integer endpoints.
+          # `first(n)`/`last(n)`/`take(n)`/`min(n)`/`max(n)` materialise at
+          # most `min(n, size)` elements; cap that count so a huge `n` (or
+          # range) never blows up the Constant. `Range#size` and the head/
+          # tail projections are O(n) for integer endpoints (no full
+          # materialisation).
           return nil if [count, range.size].min > RANGE_TO_A_LIMIT
 
-          values = method_name == :last ? range.last(count) : range.first(count)
+          values = range_head_tail(range, method_name, count)
           return Type::Combinator.tuple_of if values.empty?
 
           Type::Combinator.tuple_of(*values.map { |v| Type::Combinator.constant_of(v) })
         end
 
+        # The n elements a head/tail projection selects, in Ruby's order.
+        # For an ascending integer range `min(n)` is the leading `n`
+        # (`first(n)`) and `max(n)` the trailing `n` reversed (descending),
+        # so neither needs the full sort `Array#min`/`#max` would do.
+        def range_head_tail(range, method_name, count)
+          case method_name
+          when :last then range.last(count)
+          when :max  then range.last(count).reverse
+          else            range.first(count) # :first, :take, :min
+          end
+        end
+
         def try_fold_binary_set(receiver_values, method_name, arg_values)
           range_lift = try_fold_range_constant_binary(receiver_values, method_name, arg_values)
           return range_lift if range_lift
@@ -559,7 +612,13 @@ module Rigor
         # bounded for long strings. (`codepoints` yields per-character
         # Integer codepoints, the sibling of the byte-valued `bytes`;
         # `grapheme_clusters` is the extended-grapheme sibling of `chars`.)
-        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :codepoints, :grapheme_clusters, :lines, :split].freeze
+        # `shellsplit` is the String-receiver twin of the already-folded
+        # `Shellwords.split` — lifts the token Array to a Tuple. Raises
+        # `ArgumentError` on unmatched quotes, which `try_fold_string_array_unary`
+        # rescues to nil (RBS tier widens). `shellwords` is loaded process-wide
+        # via `shellwords_folding`.
+        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :codepoints, :grapheme_clusters,
+                                         :lines, :split, :shellsplit].freeze
         # `partition` / `rpartition` always return a fixed 3-element
         # `[head, separator, tail]` Array whose members are substrings of
         # the receiver (bounded by the input), so they lift to a precise
@@ -623,10 +682,26 @@ module Rigor
         ].freeze
         PATHNAME_PURE_BINARY = Set[
           :+, :join, :sub_ext, :<=>, :==, :eql?, :===,
-          :relative_path_from
+          :relative_path_from,
+          # `/` is the exact alias of `+` (`def /(other) = self + other`),
+          # the idiomatic path-join operator (`dir / "file"`). `basename`'s
+          # 1-arg suffix-stripping form (`path.basename(".rb")` → the stem)
+          # is the binary sibling of the already-folded no-arg `basename` —
+          # both are pure `@path` string manipulation, no filesystem read.
+          :/, :basename
         ].freeze
         private_constant :PATHNAME_PURE_UNARY, :PATHNAME_PURE_BINARY
 
+        # `Constant<Pathname>#split` returns the fixed 2-element
+        # `[dirname, basename]` pair (both Pathname), the path-string
+        # split of `File.split`. Lifted to `Tuple[Constant[Pathname],
+        # Constant[Pathname]]`. Filesystem-independent — reads only
+        # `@path` — so it is deterministic at fold time, the
+        # Array-returning sibling of the scalar `basename` / `dirname`
+        # folds (which `try_fold_pathname_unary` already covers).
+        PATHNAME_ARRAY_UNARY_METHODS = Set[:split].freeze
+        private_constant :PATHNAME_ARRAY_UNARY_METHODS
+
         def try_fold_pathname_unary(receiver_values, method_name)
           return nil unless PATHNAME_PURE_UNARY.include?(method_name)
           return nil unless receiver_values.size == 1
@@ -659,6 +734,22 @@ module Rigor
           nil
         end
 
+        # `Constant<Pathname>#split` — lift the `[dirname, basename]`
+        # Pathname pair to a Tuple[Constant[Pathname], Constant[Pathname]].
+        # Pure path-string manipulation (no filesystem read); both
+        # elements are Pathname, a foldable Constant class.
+        def try_fold_pathname_array_unary(receiver_values, method_name)
+          return nil unless PATHNAME_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Pathname)
+
+          lift_array_result(receiver.split)
+        rescue StandardError
+          nil
+        end
+
         def try_fold_string_array_unary(receiver_values, method_name)
           return nil unless STRING_ARRAY_UNARY_METHODS.include?(method_name)
           return nil unless receiver_values.size == 1
@@ -1500,6 +1591,7 @@ module Rigor
           when nil            then NIL_BINARY
           when Rational       then RATIONAL_BINARY
           when Complex        then COMPLEX_BINARY
+          when ::Set          then SET_BINARY
           else                     Set.new
           end
         end

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

@@ -88,6 +88,7 @@ module Rigor
           to_h: :tuple_to_h,
           zip: :tuple_zip,
           :[] => :tuple_index,
+          slice: :tuple_index,
           fetch: :tuple_index,
           dig: :tuple_dig,
           values_at: :tuple_values_at,
@@ -842,7 +843,10 @@ module Rigor
 
           # `tuple.min` / `tuple.max` — fold when every element is
           # a `Constant` whose values share a Ruby-comparable
-          # domain. Empty tuples fold to `Constant[nil]`.
+          # domain. Empty tuples fold to `Constant[nil]`. The 1-arg
+          # `min(n)` / `max(n)` form folds to a `Tuple` of the n
+          # edge-most values in Ruby's order (`min(n)` ascending,
+          # `max(n)` descending) — the n-arg sibling of `first(n)`.
           def tuple_min(tuple, _method_name, args)
             tuple_minmax(tuple, args, :min)
           end
@@ -852,7 +856,7 @@ module Rigor
           end
 
           def tuple_minmax(tuple, args, edge)
-            return nil unless args.empty?
+            return tuple_minmax_n(tuple, args.first, edge) unless args.empty?
             return Type::Combinator.constant_of(nil) if tuple.elements.empty?
 
             values = constant_values(tuple.elements)
@@ -864,6 +868,25 @@ module Rigor
             nil
           end
 
+          # `tuple.min(n)` / `tuple.max(n)` — a `Tuple` of the n
+          # edge-most element values, delegating to Ruby's
+          # `Array#min` / `#max` for the ordering. Declines on a
+          # non-static / negative count or non-Constant elements.
+          # The result is bounded by the tuple's known arity, so no
+          # extra size cap is needed.
+          def tuple_minmax_n(tuple, arg, edge)
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Integer)
+            return nil if arg.value.negative?
+
+            values = constant_values(tuple.elements)
+            return nil if values.nil?
+
+            picked = values.public_send(edge, arg.value)
+            Type::Combinator.tuple_of(*picked.map { |v| Type::Combinator.constant_of(v) })
+          rescue StandardError
+            nil
+          end
+
           # `tuple.minmax` — the `[min, max]` pair as a 2-slot
           # `Tuple[Constant[min], Constant[max]]`, mirroring the
           # `Range#minmax` fold. Every element must be a `Constant`
@@ -1201,6 +1224,13 @@ module Rigor
           # indices still fall through because the same handler serves
           # `fetch`, while statically nil slices can be represented
           # precisely for `[]`.
+          # `[]` and its exact alias `slice` share the index / Range /
+          # start-length folding. `fetch` routes here too but stays
+          # integer-index-only: the Range and start-length branches gate
+          # on this selector set, which `fetch` is deliberately not in.
+          SLICE_SELECTORS = Set[:[], :slice].freeze
+          private_constant :SLICE_SELECTORS
+
           def tuple_index(tuple, method_name, args)
             case args.size
             when 1 then tuple_single_index(tuple, method_name, args.first)
@@ -1211,17 +1241,18 @@ module Rigor
           def tuple_single_index(tuple, method_name, arg)
             return nil unless arg.is_a?(Type::Constant)
 
-            return tuple_range_slice(tuple, arg.value) if method_name == :[] && arg.value.is_a?(Range)
-            return nil unless arg.value.is_a?(Integer)
+            value = arg.value
+            return tuple_range_slice(tuple, value) if SLICE_SELECTORS.include?(method_name) && value.is_a?(Range)
+            return nil unless value.is_a?(Integer)
 
-            idx = normalise_index(arg.value, tuple.elements.size)
+            idx = normalise_index(value, tuple.elements.size)
             return nil unless idx
 
             tuple.elements[idx]
           end
 
           def tuple_start_length_slice(tuple, method_name, args)
-            return nil unless method_name == :[]
+            return nil unless SLICE_SELECTORS.include?(method_name)
 
             start, length = args
             return nil unless start.is_a?(Type::Constant) && length.is_a?(Type::Constant)

data/lib/rigor/inference/scope_indexer.rb

@@ -118,10 +118,12 @@ module Rigor
         # table to suppress false positives for methods the
         # user has defined but no RBS sig describes. Merged
         # UNDER the cross-file pre-pass seed; details: merge_project_method_indexes.
-        discovered_methods = deep_merge_class_methods(
-          default_scope.discovered_methods, build_discovered_methods(root)
-        )
-        seeded_scope = seeded_scope.with_discovery(seeded_scope.discovery.with(discovered_methods: discovered_methods))
+        # One combined descent yields both the discovered-methods existence
+        # table and the instance def-node table — see
+        # {#build_methods_and_def_nodes}. `seed_discovered_methods` seeds the
+        # former onto the scope and returns the def-node table for
+        # `merge_project_method_indexes` below.
+        seeded_scope, file_def_nodes = seed_discovered_methods(seeded_scope, default_scope, root)
 
         # v0.0.2 #5 + ADR-24 slice 2 — record per-instance-method
         # def nodes, the class -> superclass map, and the
@@ -134,7 +136,7 @@ module Rigor
         # table. Seeded inside `merge_project_method_indexes` so the
         # per-file visibilities merge OVER the cross-file project seed
         # rather than overwriting it.
-        seeded_scope = merge_project_method_indexes(seeded_scope, default_scope, root)
+        seeded_scope = merge_project_method_indexes(seeded_scope, default_scope, root, file_def_nodes)
 
         table = {}.compare_by_identity
         table.default = seeded_scope
@@ -160,6 +162,19 @@ module Rigor
         table
       end
 
+      # Runs the combined methods/def-nodes descent (one walk of the file),
+      # seeds the discovered-methods existence table onto `seeded_scope`
+      # (merged UNDER the cross-file pre-pass seed `default_scope` carries),
+      # and returns `[scope, file_def_nodes]` so the caller can thread the
+      # def-node table into {#merge_project_method_indexes} without walking
+      # the file a second time.
+      def seed_discovered_methods(seeded_scope, default_scope, root)
+        file_methods, file_def_nodes = build_methods_and_def_nodes(root)
+        discovered_methods = deep_merge_class_methods(default_scope.discovered_methods, file_methods)
+        scope = seeded_scope.with_discovery(seeded_scope.discovery.with(discovered_methods: discovered_methods))
+        [scope, file_def_nodes]
+      end
+
       # ADR-48 Struct slice 3 — installs the top-level fold-safe-local set
       # ({Inference::StructFoldSafety}). Struct member layouts of constant
       # receivers are resolved through the side-table the seeded scope carries.
@@ -179,9 +194,9 @@ module Rigor
       # `discovered_def_index_for_paths` seed carried on
       # `default_scope` — same-file declarations win per entry,
       # the cross-file seed supplies sibling-file ancestors.
-      def merge_project_method_indexes(seeded_scope, default_scope, root)
+      def merge_project_method_indexes(seeded_scope, default_scope, root, file_def_nodes)
         def_nodes = default_scope.discovered_def_nodes.merge(
-          build_discovered_def_nodes(root)
+          file_def_nodes
         ) { |_class, cross_file, per_file| cross_file.merge(per_file) }
         singleton_def_nodes = default_scope.discovered_singleton_def_nodes.merge(
           build_discovered_singleton_def_nodes(root)
@@ -1406,16 +1421,29 @@ module Rigor
         Type::Combinator.singleton_of(full)
       end
 
-      # Slice 7 phase 12 — in-source method discovery pre-pass.
-      # Walks every class/module body and records the methods
-      # introduced via `Prism::DefNode` (instance + singleton)
-      # and via recognised `define_method(:name) { ... }` calls.
-      # The returned table maps qualified class name to a
-      # `Hash[Symbol, :instance | :singleton]`.
-      def build_discovered_methods(root)
-        accumulator = {}
-        walk_methods(root, [], false, accumulator)
-        accumulator.transform_values(&:freeze).freeze
+      # Slice 7 phase 12 — in-source method discovery pre-pass, fused with
+      # the instance-method def-node pre-pass (v0.0.2 #5). One descent
+      # produces BOTH tables the per-file `index` and the cross-file
+      # pre-pass each need together:
+      #
+      #   - `methods`   : `{class_name => {method => :instance | :singleton}}`
+      #     for every `def` / `define_method(:name)` / `attr_*` / `alias` /
+      #     Data/Struct-member reader (the undefined-method existence table).
+      #   - `def_nodes` : `{class_name => {method => Prism::DefNode}}` for
+      #     every instance-side `def` (the inter-procedural return-inference
+      #     table; singleton defs and `define_method` are intentionally
+      #     skipped — `record_def_node` filters them).
+      #
+      # `walk_methods` and `walk_def_nodes` had byte-identical class /
+      # module / singleton / meta-block descents (both stop at `DefNode`),
+      # so a single combined walk records both accumulators at once instead
+      # of traversing every file twice.
+      def build_methods_and_def_nodes(root)
+        methods = {}
+        def_nodes = {}
+        walk_methods_and_def_nodes(root, [], false, methods, def_nodes)
+        apply_alias_def_nodes(root, def_nodes)
+        [methods.transform_values(&:freeze).freeze, def_nodes.transform_values(&:freeze).freeze]
       end
 
       # Merges two `class_name => { method => kind }` tables, unioning
@@ -1431,7 +1459,14 @@ module Rigor
       end
 
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
-      def walk_methods(node, qualified_prefix, in_singleton_class, accumulator)
+      # Combined `walk_methods` + `walk_def_nodes` descent. The two walks
+      # had identical class / module / singleton-class / meta-block
+      # traversals and both stopped at `DefNode`; the only divergences are
+      # leaf actions (recorded into the right accumulator) and the original
+      # `walk_methods` returning at `AliasMethodNode` (its symbol-only
+      # children carry no def / class node, so not descending them is
+      # byte-identical for `def_nodes` too). See {#build_methods_and_def_nodes}.
+      def walk_methods_and_def_nodes(node, qualified_prefix, in_singleton_class, methods_acc, def_nodes_acc)
         return unless node.is_a?(Prism::Node)
 
         case node
@@ -1439,40 +1474,40 @@ module Rigor
           name = Source::ConstantPath.qualified_name(node.constant_path)
           if name
             child_prefix = qualified_prefix + [name]
-            record_meta_superclass_members(node, child_prefix, accumulator) if node.is_a?(Prism::ClassNode)
-            walk_methods(node.body, child_prefix, false, accumulator) if node.body
+            record_meta_superclass_members(node, child_prefix, methods_acc) if node.is_a?(Prism::ClassNode)
+            walk_methods_and_def_nodes(node.body, child_prefix, false, methods_acc, def_nodes_acc) if node.body
             return
           end
         when Prism::SingletonClassNode
           if node.body
             singleton_prefix = singleton_class_prefix(node, qualified_prefix)
             if singleton_prefix
-              walk_methods(node.body, singleton_prefix, true, accumulator)
+              walk_methods_and_def_nodes(node.body, singleton_prefix, true, methods_acc, def_nodes_acc)
               return
             end
           end
         when Prism::ConstantWriteNode
           if meta_new_block_body(node)
             child_prefix = qualified_prefix + [node.name.to_s]
-            walk_methods(meta_new_block_body(node), child_prefix, false, accumulator)
+            walk_methods_and_def_nodes(meta_new_block_body(node), child_prefix, false, methods_acc, def_nodes_acc)
             return
           end
         when Prism::DefNode
-          record_def_method(node, qualified_prefix, in_singleton_class, accumulator)
+          record_def_method(node, qualified_prefix, in_singleton_class, methods_acc)
+          record_def_node(node, qualified_prefix, in_singleton_class, def_nodes_acc)
           return
         when Prism::AliasMethodNode
-          record_alias_method(node, qualified_prefix, in_singleton_class, accumulator)
+          record_alias_method(node, qualified_prefix, in_singleton_class, methods_acc)
           return
         when Prism::CallNode
-          record_define_method(node, qualified_prefix, in_singleton_class, accumulator) if node.name == :define_method
+          record_define_method(node, qualified_prefix, in_singleton_class, methods_acc) if node.name == :define_method
           if ATTR_MACROS.include?(node.name)
-            record_attr_methods(node, qualified_prefix, in_singleton_class,
-                                accumulator)
+            record_attr_methods(node, qualified_prefix, in_singleton_class, methods_acc)
           end
         end
 
         node.compact_child_nodes.each do |child|
-          walk_methods(child, qualified_prefix, in_singleton_class, accumulator)
+          walk_methods_and_def_nodes(child, qualified_prefix, in_singleton_class, methods_acc, def_nodes_acc)
         end
       end
 
@@ -1606,57 +1641,6 @@ module Rigor
         end
       end
 
-      # v0.0.2 #5 — instance-side def-node recording. Walks
-      # class bodies the same way as `build_discovered_methods`
-      # but records the actual `Prism::DefNode` for each
-      # **instance** method so `ExpressionTyper` can re-type
-      # the body at the call site for inter-procedural return
-      # inference. Singleton methods and `define_method` calls
-      # are intentionally skipped: the inference path needs a
-      # statically introspectable body, and singleton dispatch
-      # has its own complications (Class / Module ancestry)
-      # the first-iteration rule does not yet model.
-      def build_discovered_def_nodes(root)
-        accumulator = {}
-        walk_def_nodes(root, [], false, accumulator)
-        apply_alias_def_nodes(root, accumulator)
-        accumulator.transform_values(&:freeze).freeze
-      end
-
-      def walk_def_nodes(node, qualified_prefix, in_singleton_class, accumulator)
-        return unless node.is_a?(Prism::Node)
-
-        case node
-        when Prism::ClassNode, Prism::ModuleNode
-          name = Source::ConstantPath.qualified_name(node.constant_path)
-          if name
-            child_prefix = qualified_prefix + [name]
-            walk_def_nodes(node.body, child_prefix, false, accumulator) if node.body
-            return
-          end
-        when Prism::SingletonClassNode
-          if node.body
-            singleton_prefix = singleton_class_prefix(node, qualified_prefix)
-            if singleton_prefix
-              walk_def_nodes(node.body, singleton_prefix, true, accumulator)
-              return
-            end
-          end
-        when Prism::ConstantWriteNode
-          if meta_new_block_body(node)
-            child_prefix = qualified_prefix + [node.name.to_s]
-            walk_def_nodes(meta_new_block_body(node), child_prefix, false, accumulator)
-            return
-          end
-        when Prism::DefNode
-          record_def_node(node, qualified_prefix, in_singleton_class, accumulator)
-          return
-        end
-
-        node.compact_child_nodes.each do |child|
-          walk_def_nodes(child, qualified_prefix, in_singleton_class, accumulator)
-        end
-      end
       # v0.0.3 A — sentinel key under which `record_def_node`
       # files DefNodes that live outside any class / module
       # body (top-level helpers, `def`s nested inside DSL
@@ -2385,7 +2369,13 @@ module Rigor
       # the override-visibility-reduced rule can read an ancestor's
       # visibility declared in a sibling file.
       def accumulate_project_index(acc, path, root)
-        merge_discovered_defs(acc[:def_nodes], acc[:def_sources], path, root)
+        # One combined descent yields both the methods existence table and
+        # the def-node table; the latter is also consumed by
+        # `record_class_sources`, so a def-dense file is walked once here
+        # instead of three times (methods + def-nodes ×2). See
+        # {#build_methods_and_def_nodes}.
+        file_methods, file_def_nodes = build_methods_and_def_nodes(root)
+        merge_discovered_defs(acc[:def_nodes], acc[:def_sources], path, file_def_nodes)
         build_discovered_singleton_def_nodes(root).each do |class_name, methods|
           (acc[:singleton_def_nodes][class_name] ||= {}).merge!(methods)
         end
@@ -2395,20 +2385,28 @@ module Rigor
         includes.each do |class_name, mods|
           acc[:includes][class_name] = ((acc[:includes][class_name] || []) + mods).uniq
         end
-        record_class_sources(acc[:class_sources], path, root, superclasses, includes)
-        merge_class_keyed_index_tables(acc, root)
+        record_class_sources(acc[:class_sources], path, root, superclasses, includes, file_def_nodes)
+        merge_class_keyed_index_tables(acc, root, file_methods)
+        merge_member_layout_tables(acc, root)
+      end
+
+      # Folds one file's Data + Struct member-layout tables into the
+      # cross-file accumulator (kept out of {#accumulate_project_index} to
+      # hold its ABC budget).
+      def merge_member_layout_tables(acc, root)
         acc[:data_member_layouts].merge!(build_data_member_layouts(root))
         acc[:struct_member_layouts].merge!(build_struct_member_layouts(root))
       end
 
       # Folds the per-class method-visibility and method-existence tables of
       # one file into the cross-file accumulator (kept out of
-      # {#accumulate_project_index} to hold its ABC budget).
-      def merge_class_keyed_index_tables(acc, root)
+      # {#accumulate_project_index} to hold its ABC budget). `file_methods`
+      # is the existence table from the combined methods/def-nodes descent.
+      def merge_class_keyed_index_tables(acc, root, file_methods)
         build_discovered_method_visibilities(root).each do |class_name, table|
           (acc[:method_visibilities][class_name] ||= {}).merge!(table)
         end
-        build_discovered_methods(root).each do |class_name, table|
+        file_methods.each do |class_name, table|
           (acc[:methods][class_name] ||= {}).merge!(table)
         end
       end
@@ -2423,13 +2421,13 @@ module Rigor
       # dependency recording (ADR-46). The class-declaration walk
       # (`collect_class_decls`) catches bodyless / def-less reopenings the
       # other three builders miss.
-      def record_class_sources(class_sources, path, root, superclasses, includes)
+      def record_class_sources(class_sources, path, root, superclasses, includes, file_def_nodes)
         names = Set.new
         collect_class_decls(root, [], decls = {})
         names.merge(decls.keys)
         names.merge(superclasses.keys)
         names.merge(includes.keys)
-        names.merge(build_discovered_def_nodes(root).keys)
+        names.merge(file_def_nodes.keys)
         names.each { |name| (class_sources[name] ||= Set.new) << path }
       end
 
@@ -2438,8 +2436,8 @@ module Rigor
       # seen `"path:line"` definition site in `def_sources` (ADR-17 —
       # the un-registered-project-patch signal `call.undefined-method`
       # and `rigor triage` key on).
-      def merge_discovered_defs(def_nodes, def_sources, path, root)
-        build_discovered_def_nodes(root).each do |class_name, methods|
+      def merge_discovered_defs(def_nodes, def_sources, path, file_def_nodes)
+        file_def_nodes.each do |class_name, methods|
           (def_nodes[class_name] ||= {}).merge!(methods)
           sources = (def_sources[class_name] ||= {})
           methods.each do |method_name, def_node|

data/lib/rigor/plugin/isolation.rb

@@ -12,13 +12,13 @@ module Rigor
     # `exe/rigor` launcher maps `.rigor.yml`'s `plugins_isolation:` onto it
     # before re-exec). Three backends behind one interface:
     #
-    # - `none` (**default**) — load into the main space and call directly.
-    #   Lowest cost; no isolation. Fine for the common case because the
-    #   invoked library is trusted + pure.
+    # - `none` — load into the main space and call directly.
+    #   Lowest cost; no isolation. Used as the fallback where fork is
+    #   unavailable; fine because the invoked library is trusted + pure.
     # - `ruby_box` — call inside a {Box} (`Ruby::Box`, `RUBY_BOX=1`). Isolates
     #   core-class monkey-patches + lets gem versions coexist, but a native
     #   crash in the boxed work still takes the process down (in-process).
-    # - `process` — call in a forked worker ({Process}); returns data over a
+    # - `process` (**default**) — call in a forked worker ({Process}); returns data over a
     #   pipe. The strongest: a child crash (even `SIGSEGV`) is contained —
     #   the parent survives and declines. Higher cost (fork + IPC).
     #
@@ -73,7 +73,7 @@ module Rigor
       end
 
       # `none` — load the trusted library into the main space and call it
-      # directly. No isolation; lowest cost; the current default behaviour.
+      # directly. No isolation; lowest cost; the fork-unavailable fallback.
       module Direct
         module_function