rigortype 0.2.9 → 0.3.0

data/lib/rigor/inference/parameter_inference_collector.rb

@@ -150,6 +150,11 @@ module Rigor
         # 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)
@@ -264,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?
 

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,