rigortype 0.2.8 → 0.3.0

data/lib/rigor/inference/narrowing.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "../reflection"
+require_relative "../source/constant_path"
 require_relative "../type"
 require_relative "../environment"
 require_relative "../rbs_extended"
@@ -41,7 +42,13 @@ module Rigor
       TRUSTED_EQUALITY_LITERAL_CLASSES = [String, Symbol, Integer, TrueClass, FalseClass, NilClass].freeze
       SINGLETON_LITERAL_CLASSES = [TrueClass, FalseClass, NilClass].freeze
       ClassNarrowingContext = Data.define(:exact, :polarity, :environment)
-      private_constant :TRUSTED_EQUALITY_LITERAL_CLASSES, :SINGLETON_LITERAL_CLASSES, :ClassNarrowingContext
+      # A recognised `=~` regex pattern operand: the pattern `source` string and whether it was
+      # compiled in extended (`//x`) mode. Extraction from a literal `RegularExpressionNode` and from
+      # a value-pinned `Constant[Regexp]` share this carrier so the participation walk and the
+      # extended-mode bail read one shape.
+      RegexMatchPattern = Data.define(:source, :extended)
+      private_constant :TRUSTED_EQUALITY_LITERAL_CLASSES, :SINGLETON_LITERAL_CLASSES, :ClassNarrowingContext,
+                       :RegexMatchPattern
 
       module_function
 
@@ -873,6 +880,15 @@ module Rigor
             string_predicate_result = analyse_string_predicate(node, scope)
             return apply_safe_nav_non_nil(node, scope, string_predicate_result) if string_predicate_result
 
+            # A predicate whose RBS says it always returns `false` for one union arm cannot have
+            # been called on that arm when it answered truthily. `NilClass#present?: () -> false`
+            # (ActiveSupport) is the motivating case: `if login.present?` must narrow `String | nil`
+            # to `String`, and nothing else in the catalogue does it — `present?` is a gem method the
+            # engine must not hardcode, and `rigor:v1:predicate-if-true` facts never reach a union
+            # receiver.
+            polarity_result = analyse_union_predicate_polarity(node, scope)
+            return polarity_result if polarity_result
+
             # A safe-navigation call (`v&.foo`) whose result is truthy proves the receiver was
             # non-nil — `&.` returns `nil` when the receiver is nil, so a truthy outcome can
             # only come from a non-nil receiver. Narrow the receiver on the truthy edge even
@@ -953,8 +969,8 @@ module Rigor
         end
 
         def simple_dispatch_name?(name)
-          %i[nil? ! is_a? kind_of? instance_of? == != === =~ key? has_key? empty? any? none?
-             respond_to?].include?(name)
+          %i[nil? ! is_a? kind_of? instance_of? == != === =~ match? key? has_key? empty? any?
+             none? respond_to?].include?(name)
         end
 
         def dispatch_call_simple(node, scope, name)
@@ -965,6 +981,7 @@ module Rigor
           when :==, :!= then analyse_equality_predicate(node, scope, equality: name)
           when :=== then analyse_case_equality_predicate(node, scope)
           when :=~ then analyse_regex_match_predicate(node, scope)
+          when :match? then analyse_whole_regex_match_predicate(node, scope)
           when :key?, :has_key? then analyse_key_presence_predicate(node, scope)
           when :empty?, :any?, :none? then analyse_array_emptiness_predicate(node, scope, name)
           when :respond_to? then analyse_respond_to_predicate(node, scope)
@@ -1190,30 +1207,123 @@ module Rigor
         # - Falsey edge (`=~` returned nil — no match): `$~` and every numbered / back-reference
         #   global bound to `Constant<nil>`.
         #
-        # Returns nil (no narrowing) when the receiver / argument pair does not include a
-        # `RegularExpressionNode` literal we can count.
+        # Returns nil (no narrowing) when the receiver / argument pair does not resolve to exactly one
+        # regex pattern we can count (see {#regex_match_pattern}).
         def analyse_regex_match_predicate(node, scope)
           return nil if node.arguments.nil?
           return nil unless node.arguments.arguments.size == 1
 
-          regex_node = regex_match_literal(node.receiver, node.arguments.arguments.first)
-          return nil if regex_node.nil?
+          arg = node.arguments.arguments.first
+          pattern = regex_match_pattern(node.receiver, arg, scope)
+          return nil if pattern.nil?
+          # Extended mode (`//x`) lets the pattern carry free whitespace and `#` comments, and a
+          # comment may contain a literal `(` — which the light char-scan walker would miscount as a
+          # capturing group, shifting `$N` indices and narrowing the wrong global. That is a
+          # false-negative-class misnarrowing, so bail rather than risk it. The literal path shares
+          # this bail: `RegularExpressionNode` carries the same latent miscount.
+          return nil if pattern.extended
+
+          unconditional = unconditional_capture_groups(pattern.source)
+          truthy, falsey = regex_match_predicate_scopes(scope, unconditional)
+          # #164 — layer whole-receiver refinement onto the truthy edge without disturbing the
+          # match-global logic above. A successful `str =~ /\A\d+\z/` proves the WHOLE string
+          # matched, so the string operand narrows to the imported refinement the anchored pattern
+          # names. The falsey edge is untouched: a failed match proves nothing about the shape.
+          truthy = apply_whole_receiver_refinement(truthy, node.receiver, arg, pattern.source, scope)
+          [truthy, falsey]
+        end
+
+        # `str.match?(/\A\d+\z/)` — `String#match?` is a pure boolean predicate whose truthy edge
+        # proves a property of the ENTIRE receiver. When the argument is a fully `\A…\z`-anchored
+        # single-char-class pattern recognised by {RegexRefinement.for_whole_pattern}, narrow the
+        # receiver local to the matching imported refinement on the truthy edge; the falsey edge
+        # passes through unchanged (failing one pattern proves nothing about the string's shape).
+        # A non-literal / unanchored / `\Z` / line-anchored / `//x` pattern falls through to no
+        # narrowing.
+        def analyse_whole_regex_match_predicate(node, scope)
+          return nil unless node.receiver.is_a?(Prism::LocalVariableReadNode)
+          return nil if node.arguments.nil? || node.arguments.arguments.size != 1
+
+          pattern = regex_operand_pattern(node.arguments.arguments.first, scope)
+          return nil unless pattern.is_a?(RegexMatchPattern)
+          return nil if pattern.extended
 
-          unconditional = unconditional_capture_groups(regex_node.unescaped)
-          regex_match_predicate_scopes(scope, unconditional)
+          refinement = ::Rigor::Builtins::RegexRefinement.for_whole_pattern(pattern.source)
+          return nil if refinement.nil?
+
+          local_name = node.receiver.name
+          return nil if scope.local(local_name).nil?
+
+          [scope.with_local(local_name, refinement), scope]
         end
 
-        def regex_match_literal(left, right)
-          return left if left.is_a?(Prism::RegularExpressionNode)
-          return right if right.is_a?(Prism::RegularExpressionNode)
+        # Narrows the string operand of a `=~` predicate to a whole-receiver refinement when the
+        # regex source is a recognised `\A…\z`-anchored pattern. Returns the (possibly unchanged)
+        # truthy scope; the falsey edge is never touched by this layer.
+        def apply_whole_receiver_refinement(truthy, receiver, arg, source, scope)
+          refinement = ::Rigor::Builtins::RegexRefinement.for_whole_pattern(source)
+          return truthy if refinement.nil?
 
-          nil
+          # `regex_match_pattern` already resolved the regex operand from a literal or a
+          # `Constant[Regexp]` constant read — never a bare local — so the string subject is
+          # unambiguously the local-read operand, if either operand is one.
+          subject = [receiver, arg].find { |operand| operand.is_a?(Prism::LocalVariableReadNode) }
+          return truthy if subject.nil? || scope.local(subject.name).nil?
+
+          truthy.with_local(subject.name, refinement)
+        end
+
+        # Recognises the regex pattern operand of a `=~` predicate. An operand resolves to a regex when
+        # it is either a syntactic `RegularExpressionNode` literal OR a constant read whose type is a
+        # value-pinned `Constant[Regexp]` (`RE = /.../` and `RE = Regexp.new(...)` both fold to the
+        # carrier in the whole-program constant pre-pass). Returns a single {RegexMatchPattern}, or nil
+        # (no narrowing) when NEITHER operand resolves to a regex, when BOTH do (`/a/ =~ /b/` — no
+        # string subject to bind), or when a constant operand is ambiguous — typed as a `Union` from a
+        # twice-assigned constant, where no single source can be pinned.
+        def regex_match_pattern(left, right, scope)
+          left_pattern = regex_operand_pattern(left, scope)
+          right_pattern = regex_operand_pattern(right, scope)
+          return nil if left_pattern == :ambiguous || right_pattern == :ambiguous
+
+          patterns = [left_pattern, right_pattern].grep(RegexMatchPattern)
+          patterns.size == 1 ? patterns.first : nil
+        end
+
+        # Classifies one `=~` operand: a {RegexMatchPattern} when it resolves to a regex (literal or
+        # `Constant[Regexp]`), `:ambiguous` when a constant operand types as a `Union` (a twice-assigned
+        # constant), or nil when the operand is not a regex at all.
+        def regex_operand_pattern(node, scope)
+          case node
+          when Prism::RegularExpressionNode
+            RegexMatchPattern.new(source: node.unescaped, extended: node.extended?)
+          when Prism::ConstantReadNode, Prism::ConstantPathNode
+            regex_operand_from_constant(node, scope)
+          end
         end
 
-        # Curated set of back-reference globals bound by every
-        # `=~`. Numbered references (`$1..$N`) are handled
-        # separately because N depends on the regex source.
-        REGEX_MATCH_GLOBALS = %i[$~ $& $` $' $+].freeze
+        # Resolves a constant-reference operand to a regex pattern via the shared lexical-constant
+        # resolution (`Reflection.resolve_constant_type`). `Regexp#options` gives the real
+        # extended-mode flag; `Regexp#source` the pattern. Returns `:ambiguous` for a `Union`-typed
+        # constant so the caller bails, and nil when the constant does not resolve to a `Constant[Regexp]`.
+        def regex_operand_from_constant(node, scope)
+          name = Source::ConstantPath.qualified_name_or_nil(node)
+          return nil if name.nil?
+
+          type = Reflection.resolve_constant_type(name, scope: scope)
+          return :ambiguous if type.is_a?(Type::Union)
+          return nil unless type.is_a?(Type::Constant)
+
+          value = type.value
+          return nil unless value.is_a?(Regexp)
+
+          RegexMatchPattern.new(source: value.source, extended: value.options.anybits?(Regexp::EXTENDED))
+        end
+
+        # Curated set of match globals bound non-nil on every successful `=~` regardless of grouping:
+        # `$~` (the MatchData), `$&` (whole match), `` $` `` (pre-match), `$'` (post-match). Numbered
+        # references (`$1..$N`) and `$+` (the last matched group) are handled separately because they
+        # depend on the regex source — `$+` is gated on the same participation set as `$N` (#177).
+        REGEX_MATCH_GLOBALS = %i[$~ $& $` $'].freeze
         private_constant :REGEX_MATCH_GLOBALS
 
         # `unconditional` is the Set of 1-based numbered-capture indices whose group is
@@ -1242,6 +1352,15 @@ module Rigor
             truthy = truthy.with_global(name, string_t)
             falsey = falsey.with_global(name, nil_t)
           end
+          # `$+` is the LAST matched group, so it is nil on a successful match whose groups are all
+          # optional (`"b" =~ /(a)?b/` matches yet leaves `$+` nil) or absent (no capture group). It
+          # narrows to `String` only when some group is guaranteed to participate — the same
+          # participation gate `$N` uses (#177). With no unconditional group it is left unbound on both
+          # edges (fall through to the RBS `String?` default), exactly as an optional `$N` is.
+          unless unconditional.empty?
+            truthy = truthy.with_global(:$+, string_t)
+            falsey = falsey.with_global(:$+, nil_t)
+          end
           [truthy, falsey]
         end
 
@@ -2352,6 +2471,115 @@ module Rigor
           end
         end
 
+        # The three value-pinned classes a union arm can name whose instances are the single
+        # value itself. Their finality is what makes the polarity rule below sound: no subclass
+        # can override the predicate, because there is no subclass.
+        POLARITY_ARM_CLASSES = { nil => "NilClass", true => "TrueClass", false => "FalseClass" }.freeze
+        private_constant :POLARITY_ARM_CLASSES
+
+        # Drops union arms a zero-argument predicate's own signature rules out on each edge.
+        #
+        # `if x.present?` with `x: String | nil` must see `String` in the body. Rigor could not:
+        # `present?` is an ActiveSupport method (so the engine must not join the hardcoded
+        # `nil?` / `empty?` catalogue with it), and `resolve_rbs_extended_method` hands a union
+        # receiver no `rigor:v1:predicate-if-true` facts, so annotating the RBS would not help
+        # either. But the answer is already written down: the bundled ActiveSupport signature
+        # declares `NilClass#present?: () -> false`, and a method that always returns `false` for
+        # `nil` cannot have answered truthily on a `nil` receiver.
+        #
+        # Soundness rests on the arm being a value-pinned `nil` / `true` / `false`. For an
+        # ordinary `Nominal[Foo]` arm the static type admits Foo's subclasses, any of which may
+        # override the predicate and return the other polarity; the three classes here have no
+        # subclasses, so the declared return is the runtime return.
+        #
+        # Safe navigation is excluded: `x&.blank?` yields `nil` (falsey) for a nil receiver
+        # rather than `NilClass#blank?`'s declared `true`, so the falsey edge would wrongly drop
+        # the nil arm. `analyse_safe_nav_receiver` below handles that shape's truthy edge.
+        #
+        # Returns `[truthy_scope, falsey_scope]`, or nil when no arm is ruled out, when an edge
+        # would be emptied, or when the receiver has no scope binding to narrow.
+        def analyse_union_predicate_polarity(node, scope)
+          return nil if node.safe_navigation? || !argument_free?(node)
+          return nil unless node.name.end_with?("?")
+
+          receiver_type = receiver_binding_type(node.receiver, scope)
+          return nil unless receiver_type.is_a?(Type::Union)
+
+          truthy, falsey = partition_arms_by_polarity(receiver_type.members, node.name, scope)
+          return nil if truthy.size == receiver_type.members.size && falsey.size == receiver_type.members.size
+          return nil if truthy.empty? || falsey.empty?
+
+          [
+            narrow_receiver_binding(node.receiver, scope, Type::Combinator.union(*truthy)),
+            narrow_receiver_binding(node.receiver, scope, Type::Combinator.union(*falsey))
+          ]
+        end
+
+        # Splits `members` into the arms that survive the truthy edge and those that survive the
+        # falsey edge. An arm whose polarity is unknown survives both.
+        def partition_arms_by_polarity(members, method_name, scope)
+          truthy = []
+          falsey = []
+          members.each do |arm|
+            case arm_predicate_polarity(arm, method_name, scope)
+            when :always_false then falsey << arm
+            when :always_true then truthy << arm
+            else
+              truthy << arm
+              falsey << arm
+            end
+          end
+          [truthy, falsey]
+        end
+
+        # `:always_false` / `:always_true` when every RBS overload of `method_name` on the arm's
+        # class returns that literal; nil for any other arm, signature, or lookup failure.
+        def arm_predicate_polarity(arm, method_name, scope)
+          returns = arm_predicate_return_types(arm, method_name, scope)
+          return nil if returns.nil? || returns.empty?
+          return :always_false if returns.all? { |type| literal_boolean?(type, false) }
+          return :always_true if returns.all? { |type| literal_boolean?(type, true) }
+
+          nil
+        end
+
+        # Declared return type of every RBS overload of `method_name` on the arm's class, or nil
+        # when the arm is not one of the three value-pinned classes or the lookup fails.
+        def arm_predicate_return_types(arm, method_name, scope)
+          return nil unless arm.is_a?(Type::Constant)
+
+          class_name = POLARITY_ARM_CLASSES[arm.value]
+          return nil if class_name.nil?
+
+          definition = Rigor::Reflection.instance_method_definition(class_name, method_name, scope: scope)
+          definition&.method_types&.map { |method_type| method_type.type.return_type }
+        rescue StandardError
+          nil
+        end
+
+        def literal_boolean?(rbs_type, value)
+          rbs_type.is_a?(RBS::Types::Literal) && rbs_type.literal == value
+        end
+
+        # The four receiver shapes with a scope binding the edges can rebind, mirroring
+        # `apply_self_fact`. A method chain or arbitrary expression has none, so it reads nil and
+        # the caller declines.
+        def receiver_binding_type(receiver, scope)
+          case receiver
+          when Prism::LocalVariableReadNode then scope.local(receiver.name)
+          when Prism::InstanceVariableReadNode then scope.ivar(receiver.name)
+          when Prism::SelfNode then scope.self_type
+          end
+        end
+
+        def narrow_receiver_binding(receiver, scope, narrowed)
+          case receiver
+          when Prism::LocalVariableReadNode then scope.with_local(receiver.name, narrowed)
+          when Prism::InstanceVariableReadNode then scope.with_ivar(receiver.name, narrowed)
+          when Prism::SelfNode then scope.with_self_type(narrowed)
+          end
+        end
+
         # Narrows a safe-navigation call's receiver (`v&.foo`) to its non-nil fragment on the
         # truthy edge, returning `[truthy, falsey]` or nil when nothing applies (not safe-nav,
         # opaque receiver, or already non-nil). Used standalone for a bare `v&.foo` truthy edge

data/lib/rigor/inference/parameter_inference_collector.rb

@@ -3,6 +3,7 @@
 require "prism"
 
 require_relative "scope_indexer"
+require_relative "fork_map"
 require_relative "../source/node_walker"
 
 module Rigor
@@ -120,15 +121,20 @@ module Rigor
       # @param target_ruby [String, nil] Prism parse target.
       # @param max_rounds [Integer] the WD5 fixpoint cap (1 = single-level).
       # @return [Hash{[String,Symbol,Symbol] => Hash{Symbol => Rigor::Type}}] frozen.
-      def self.collect(files:, environment:, target_ruby: nil, max_rounds: DEFAULT_ROUNDS)
-        new(files: files, environment: environment, target_ruby: target_ruby, max_rounds: max_rounds).collect
+      def self.collect(files:, environment:, target_ruby: nil, max_rounds: DEFAULT_ROUNDS, workers: 0)
+        new(files: files, environment: environment, target_ruby: target_ruby,
+            max_rounds: max_rounds, workers: workers).collect
       end
 
-      def initialize(files:, environment:, target_ruby: nil, max_rounds: DEFAULT_ROUNDS)
+      def initialize(files:, environment:, target_ruby: nil, max_rounds: DEFAULT_ROUNDS, workers: 0)
         @files = files
         @environment = environment
         @target_ruby = target_ruby
         @max_rounds = max_rounds
+        # P3-10 — fork-parallelism for the per-round re-typing (the dominant coverage-protection cost). A
+        # round's per-file typing is independent; contributions merge associatively (see {#merge_round}), so
+        # forking over file slices is byte-identical to the sequential pass. 0/1 → sequential.
+        @workers = workers
         # Reset per round (see {#run_round}). `[[class, method, kind], param_sym]` => [Type] of
         # observed concrete arguments (a default-block Hash, not a `{}` literal, so the
         # analyzer types its reads generically — {#finalize}), plus the ids widened to
@@ -139,7 +145,16 @@ module Rigor
 
       def collect
         parsed = parse_all
+        # Force the full RBS load on the parent so forked round-workers copy-on-write inherit a warm
+        # environment instead of each rebuilding it (mirrors the check / scan fork pools). A no-op on the
+        # sequential path.
+        @environment.rbs_loader&.prewarm if ForkMap.parallel?([@workers, parsed.size].min)
         discovery = discovery_seed_tables
+        # The union of every method name any discovered `def` declares. A call whose name is absent cannot
+        # bind in `resolve_callee`, so {#record_call} short-circuits it before typing its receiver (an
+        # on-demand dispatch for an otherwise-unresolved call). ~73% of call sites in a Rails app name a
+        # method no user def declares; a pure negative filter, so the resolved table is byte-identical.
+        @user_method_names = user_method_names(discovery)
         table = EMPTY
         @max_rounds.times do
           rounded = run_round(parsed, discovery, table)
@@ -164,18 +179,51 @@ module Rigor
       end
 
       # One fixpoint round: re-type every file with `seed_table` (the previous round's inferred
-      # parameters) seeded, collecting the next round's table.
+      # parameters) seeded, collecting the next round's table. The per-file typing is fork-mapped over
+      # `@workers` (byte-identical to sequential — see {#merge_round}); each slice returns a marshalable
+      # `[observations, poisoned]` contribution the parent merges in slice order.
       def run_round(parsed, discovery_tables, seed_table)
+        seed_scope = build_seed_scope(discovery_tables, seed_table)
+        contributions = ForkMap.call(items: parsed, workers: @workers) do |slice|
+          accumulate_slice(slice, seed_scope)
+        end
+        merge_round(contributions)
+      end
+
+      # Types every call in one contiguous file slice, returning a marshalable contribution: the per-`id`
+      # observed argument types (default proc stripped for `Marshal`) and the poisoned-`id` list. Uses the
+      # per-process observation ivars, so a forked worker and the sequential single-slice call share this
+      # exact code.
+      def accumulate_slice(parsed_slice, seed_scope)
         @type_observations = Hash.new { |hash, id| hash[id] = [] }
         @poisoned_params = Set.new
-        seed_scope = build_seed_scope(discovery_tables, seed_table)
-        parsed.each do |path, ast|
+        parsed_slice.each do |path, ast|
           index = ScopeIndexer.index(ast, default_scope: seed_scope.with_source_path(path))
           Source::NodeWalker.each(ast) do |node|
             record_call(node, index) if node.is_a?(Prism::CallNode)
           end
         end
-        finalize
+        # Copy into a plain Hash, dropping the default proc — a Marshal-unfriendly proc the fork worker
+        # would otherwise fail to dump. (`.to_h` returns self here, keeping the proc, so copy explicitly.)
+        observations = @type_observations.each_with_object({}) { |(id, types), plain| plain[id] = types }
+        [observations, @poisoned_params.to_a]
+      end
+
+      # Merges the per-slice contributions into the round's table. Associative and order-preserving, so the
+      # result is identical to a sequential single-slice run: a parameter is poisoned if ANY slice poisoned
+      # it, its observations are the file-order concatenation across slices, and the {MAX_CALL_SITE_TYPES}
+      # cap re-applies over the merged total (a per-slice sub-cap can undercount, so the parent enforces the
+      # real cap — the same "poisoned" outcome the sequential mid-stream cap reaches).
+      def merge_round(contributions)
+        poisoned = contributions.each_with_object(Set.new) { |(_obs, pois), set| set.merge(pois) }
+        observations = {}
+        contributions.each do |(obs, _pois)|
+          obs.each do |id, types|
+            (observations[id] ||= []).concat(types) unless poisoned.include?(id)
+          end
+        end
+        observations.each { |id, types| poisoned << id if types.length > MAX_CALL_SITE_TYPES }
+        finalize(observations, poisoned)
       end
 
       # A scope carrying the cross-file discovery index (so `Foo.new` receivers and
@@ -221,7 +269,17 @@ module Rigor
       }.freeze
       private_constant :DISCOVERY_FIELD
 
+      # Built once over the whole project and inherited by the fork workers via copy-on-write; a frozen Set
+      # for O(1) membership in the {#record_call} hot loop.
+      def user_method_names(discovery)
+        tables = [discovery[:discovered_def_nodes], discovery[:discovered_singleton_def_nodes]].compact
+        tables.flat_map { |table| table.values.flat_map(&:keys) }.to_set.freeze
+      end
+
       def record_call(call_node, index)
+        # See {#collect}: a name no discovered def declares cannot resolve, so skip without typing anything.
+        return unless @user_method_names.include?(call_node.name)
+
         args = positional_args(call_node)
         return if args.nil?
 
@@ -343,13 +401,15 @@ module Rigor
         @type_observations.delete(id)
       end
 
-      def finalize
+      # Builds the round's frozen `[class, method, kind] => {param => Type}` table from the merged
+      # observations and poisoned set.
+      def finalize(merged_observations, poisoned)
         # `result` is a default-block Hash (not a `{}` literal) so the analyzer types its reads
         # generically rather than folding the empty shape — the nesting writes stay plain
         # assignments, no literal-fold conditions.
         result = Hash.new { |hash, key| hash[key] = {} }
-        @type_observations.each do |id, observations|
-          next if @poisoned_params.include?(id)
+        merged_observations.each do |id, observations|
+          next if poisoned.include?(id)
           next if observations.empty?
 
           union = Type::Combinator.union(*observations)

data/lib/rigor/inference/project_patched_scanner.rb

@@ -5,6 +5,7 @@ require "prism"
 require_relative "project_patched_methods"
 require_relative "../analysis/dependency_source_inference/return_type_heuristic"
 require_relative "../source/constant_path"
+require_relative "../source/node_children"
 
 module Rigor
   module Inference
@@ -141,7 +142,7 @@ module Rigor
       private_class_method :walk_node
 
       def walk_children(node, qualified_prefix, in_singleton_class, source_path, entries)
-        node.compact_child_nodes.each do |child|
+        node.rigor_each_child do |child|
           walk_node(child, qualified_prefix, in_singleton_class, source_path, entries)
         end
       end

data/lib/rigor/inference/rbs_type_translator.rb

@@ -48,7 +48,14 @@ module Rigor
         RBS::Types::Bases::Self => :translate_self,
         RBS::Types::Bases::Instance => :translate_instance,
         RBS::Types::Bases::Class => :translate_untyped,
-        RBS::Types::Bases::Void => :translate_untyped,
+        # `void` is the top type, not `untyped`: RBS defines the two as the same type ("They are all
+        # equivalent for the type system; they are all *top type*" — rbs `docs/syntax.md`), with `void`
+        # carrying only a hint that the value should not be used. Mapping it to `untyped` made Rigor looser
+        # than the toolchain it reads — `Dynamic[top]` is consistent with everything at a gradual boundary,
+        # where `top` demands proof — so a caller could silently depend on a return whose author declared
+        # "don't rely on this". See ADR-92 WD2; `special-types.md` § `void` (a distinct carrier + a value-use
+        # diagnostic) remains unimplemented and marked.
+        RBS::Types::Bases::Void => :translate_top,
         RBS::Types::Optional => :translate_optional,
         RBS::Types::Union => :translate_union,
         RBS::Types::Literal => :translate_literal,