Extract OverloadSet class to cache overload comparison results

mame · mame · commit 79fc821b354d · 2026-03-02T22:27:13.000+09:00
diff --git a/lib/typeprof/core/ast/sig_decl.rb b/lib/typeprof/core/ast/sig_decl.rb
@@ -193,16 +193,16 @@ def initialize(raw_decl, lenv)
         @mid_code_range = lenv.code_range_from_node(raw_decl.location[:name])
         @singleton = raw_decl.singleton?
         @instance = raw_decl.instance?
-        @method_types = raw_decl.overloads.map do |overload|
+        @method_types = OverloadSet.new(raw_decl.overloads.map do |overload|
           method_type = overload.method_type
           AST.create_rbs_func_type(method_type, method_type.type_params, method_type.block, lenv)
-        end
+        end)
         @overloading = raw_decl.overloading
       end
 
       attr_reader :mid, :singleton, :instance, :method_types, :overloading, :mid_code_range
 
-      def subnodes = { method_types: }
+      def subnodes = { method_types: @method_types.to_a }
       def attrs = { mid:, mid_code_range:, singleton:, instance:, overloading: }
 
       def mname_code_range(_name) = @mid_code_range
@@ -346,6 +346,7 @@ def initialize(raw_decl, lenv)
           location: raw_decl.type.location
         )
         @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
+        @method_types = OverloadSet.new([@method_type])
       end
 
       attr_reader :mid, :method_type
@@ -354,7 +355,7 @@ def subnodes = { method_type: }
       def attrs = { mid: }
 
       def install0(genv)
-        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, [@method_type], false)
+        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, @method_types, false)
         Source.new
       end
     end
@@ -381,6 +382,7 @@ def initialize(raw_decl, lenv)
           location: raw_decl.type.location
         )
         @method_type = AST.create_rbs_func_type(rbs_method_type, [], nil, lenv)
+        @method_types = OverloadSet.new([@method_type])
       end
 
       attr_reader :mid, :method_type
@@ -389,7 +391,7 @@ def subnodes = { method_type: }
       def attrs = { mid: }
 
       def install0(genv)
-        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, [@method_type], false)
+        @changes.add_method_decl_box(genv, @lenv.cref.cpath, false, @mid, @method_types, false)
         Source.new
       end
     end
diff --git a/lib/typeprof/core/graph/box.rb b/lib/typeprof/core/graph/box.rb
@@ -99,6 +99,141 @@ def run0(genv, changes)
     end
   end
 
+  class OverloadSet
+    include Enumerable
+
+    def initialize(method_types)
+      @method_types = method_types
+    end
+
+    def each(&blk) = @method_types.each(&blk)
+    def map(&blk)  = @method_types.map(&blk)
+    def first      = @method_types.first
+    def size       = @method_types.size
+    def to_a       = @method_types
+
+    # lazy cache: combination(2) for all-pair comparison
+    def overloads_differ_in_args?
+      return @overloads_differ_in_args if defined?(@overloads_differ_in_args)
+      @overloads_differ_in_args = !@method_types.combination(2).all? { |a, b|
+        positionals_match?(a, b) && keywords_match?(a, b)
+      }
+    end
+
+    def overloads_differ_at_top_level?
+      return @overloads_differ_at_top_level if defined?(@overloads_differ_at_top_level)
+      @overloads_differ_at_top_level = !@method_types.combination(2).all? { |a, b|
+        positionals_match_shallow?(a, b) && keywords_match_shallow?(a, b)
+      }
+    end
+
+    private
+
+    # Check if two method types have structurally identical positional
+    # parameter types (req, opt, rest).
+    def positionals_match?(mt1, mt2)
+      return false unless mt1.req_positionals.size == mt2.req_positionals.size
+      return false unless mt1.opt_positionals.size == mt2.opt_positionals.size
+      return false unless mt1.rest_positionals.nil? == mt2.rest_positionals.nil?
+      mt1.req_positionals.zip(mt2.req_positionals).all? {|a, b| sig_types_match?(a, b) } &&
+        mt1.opt_positionals.zip(mt2.opt_positionals).all? {|a, b| sig_types_match?(a, b) } &&
+        (mt1.rest_positionals.nil? || sig_types_match?(mt1.rest_positionals, mt2.rest_positionals))
+    end
+
+    # Check if two method types have identical positional parameter
+    # types at the top level (ignoring type parameter contents).
+    def positionals_match_shallow?(mt1, mt2)
+      return false unless mt1.req_positionals.size == mt2.req_positionals.size
+      return false unless mt1.opt_positionals.size == mt2.opt_positionals.size
+      return false unless mt1.rest_positionals.nil? == mt2.rest_positionals.nil?
+      mt1.req_positionals.zip(mt2.req_positionals).all? {|a, b| sig_types_match_shallow?(a, b) } &&
+        mt1.opt_positionals.zip(mt2.opt_positionals).all? {|a, b| sig_types_match_shallow?(a, b) } &&
+        (mt1.rest_positionals.nil? || sig_types_match_shallow?(mt1.rest_positionals, mt2.rest_positionals))
+    end
+
+    # Check if two method types have structurally identical keyword
+    # parameter types (req, opt, rest).
+    def keywords_match?(mt1, mt2)
+      return false unless mt1.req_keyword_keys == mt2.req_keyword_keys
+      return false unless mt1.opt_keyword_keys == mt2.opt_keyword_keys
+      return false unless mt1.rest_keywords.nil? == mt2.rest_keywords.nil?
+      mt1.req_keyword_values.zip(mt2.req_keyword_values).all? {|a, b| sig_types_match?(a, b) } &&
+        mt1.opt_keyword_values.zip(mt2.opt_keyword_values).all? {|a, b| sig_types_match?(a, b) } &&
+        (mt1.rest_keywords.nil? || sig_types_match?(mt1.rest_keywords, mt2.rest_keywords))
+    end
+
+    # Shallow version: compare keyword keys and structure, but use
+    # shallow type comparison for values.
+    def keywords_match_shallow?(mt1, mt2)
+      return false unless mt1.req_keyword_keys == mt2.req_keyword_keys
+      return false unless mt1.opt_keyword_keys == mt2.opt_keyword_keys
+      return false unless mt1.rest_keywords.nil? == mt2.rest_keywords.nil?
+      mt1.req_keyword_values.zip(mt2.req_keyword_values).all? {|a, b| sig_types_match_shallow?(a, b) } &&
+        mt1.opt_keyword_values.zip(mt2.opt_keyword_values).all? {|a, b| sig_types_match_shallow?(a, b) } &&
+        (mt1.rest_keywords.nil? || sig_types_match_shallow?(mt1.rest_keywords, mt2.rest_keywords))
+    end
+
+    # Structural equality check for two SigTyNode objects.
+    def sig_types_match?(a, b)
+      return false unless a.class == b.class
+      case a
+      when AST::SigTyInstanceNode, AST::SigTyInterfaceNode
+        a.cpath == b.cpath &&
+          a.args.size == b.args.size &&
+          a.args.zip(b.args).all? {|x, y| sig_types_match?(x, y) }
+      when AST::SigTySingletonNode
+        a.cpath == b.cpath
+      when AST::SigTyTupleNode, AST::SigTyUnionNode, AST::SigTyIntersectionNode
+        a.types.size == b.types.size &&
+          a.types.zip(b.types).all? {|x, y| sig_types_match?(x, y) }
+      when AST::SigTyRecordNode
+        a.fields.size == b.fields.size &&
+          a.fields.all? {|k, v| b.fields[k] && sig_types_match?(v, b.fields[k]) }
+      when AST::SigTyOptionalNode, AST::SigTyProcNode
+        sig_types_match?(a.type, b.type)
+      when AST::SigTyVarNode
+        a.var == b.var
+      when AST::SigTyLiteralNode
+        a.lit == b.lit
+      when AST::SigTyAliasNode
+        a.cpath == b.cpath && a.name == b.name &&
+          a.args.size == b.args.size &&
+          a.args.zip(b.args).all? {|x, y| sig_types_match?(x, y) }
+      else
+        true # Leaf types (bool, nil, self, void, untyped, etc.)
+      end
+    end
+
+    # Shallow structural equality: compare only the top-level type
+    # identity without recursing into type parameters.
+    def sig_types_match_shallow?(a, b)
+      return false unless a.class == b.class
+      case a
+      when AST::SigTyInstanceNode, AST::SigTyInterfaceNode
+        a.cpath == b.cpath
+      when AST::SigTySingletonNode
+        a.cpath == b.cpath
+      when AST::SigTyTupleNode
+        a.types.size == b.types.size
+      when AST::SigTyUnionNode, AST::SigTyIntersectionNode
+        a.types.size == b.types.size &&
+          a.types.zip(b.types).all? {|x, y| sig_types_match_shallow?(x, y) }
+      when AST::SigTyRecordNode
+        a.fields.keys.sort == b.fields.keys.sort
+      when AST::SigTyOptionalNode, AST::SigTyProcNode
+        true
+      when AST::SigTyVarNode
+        a.var == b.var
+      when AST::SigTyLiteralNode
+        a.lit == b.lit
+      when AST::SigTyAliasNode
+        a.cpath == b.cpath && a.name == b.name
+      else
+        true
+      end
+    end
+  end
+
   class MethodDeclBox < Box
     def initialize(node, genv, cpath, singleton, mid, method_types, overloading)
       super(node)
@@ -274,17 +409,35 @@ def resolve_overloads(changes, genv, node, param_map, a_args, ret, &blk)
       # cyclic cases and avoids false "failed to resolve overloads"
       # diagnostics for untyped arguments.
       #
-      # Top-level empty vertices are always uninformative. For type
-      # parameter vertices (e.g., Array[T], Hash[K,V], tuples), we
-      # only recurse when overloads differ in their positional or keyword
-      # parameter types -- otherwise empty type params (like those of
-      # `{}`) cannot cause oscillation and should not trigger bail-out.
-      overloads_differ = !@method_types.each_cons(2).all? {|mt1, mt2|
-        positionals_match?(mt1, mt2) && keywords_match?(mt1, mt2)
-      }
-      has_uninformative_args = if overloads_differ
-        a_args.positionals.any? {|vtx| vertex_uninformative?(genv, vtx) } ||
-          (a_args.keywords && vertex_uninformative?(genv, a_args.keywords))
+      # We check at two levels:
+      # 1. Top-level empty vertices are always uninformative.
+      # 2. Empty type parameter vertices (e.g., Array[T] where T is
+      #    empty) are only uninformative when overloads differ solely
+      #    in their type parameters (e.g., Array[Integer] vs
+      #    Array[String]). When overloads differ at the top level
+      #    (e.g., Integer vs Float), the type parameter contents are
+      #    irrelevant for overload selection and should not trigger
+      #    bail-out.
+      has_uninformative_args = if @method_types.overloads_differ_in_args?
+        # Check whether overloads also differ at the top level (e.g.,
+        # Integer vs Float) or only in their type parameters (e.g.,
+        # Array[Integer] vs Array[String]).
+        if @method_types.overloads_differ_at_top_level?
+          # Overloads are distinguished by top-level types.
+          # Only top-level empty vertices matter; empty type parameters
+          # are irrelevant for overload selection.
+          # However, splatted arguments have their elements extracted
+          # during matching, so also check splat element vertices.
+          a_args.positionals.any? {|vtx| vtx.types.empty? } ||
+            splat_elements_uninformative?(genv, a_args) ||
+            (a_args.keywords && a_args.keywords.types.empty?)
+        else
+          # Overloads differ only in type parameters (e.g.,
+          # Array[Integer] vs Array[String]). Empty type parameter
+          # vertices can cause oscillation, so check recursively.
+          a_args.positionals.any? {|vtx| vertex_uninformative?(genv, vtx) } ||
+            (a_args.keywords && vertex_uninformative?(genv, a_args.keywords))
+        end
       else
         a_args.positionals.any? {|vtx| vtx.types.empty? } ||
           (a_args.keywords && a_args.keywords.types.empty?)
@@ -310,6 +463,23 @@ def resolve_overloads(changes, genv, node, param_map, a_args, ret, &blk)
       end
     end
 
+    # Check if any splatted argument has an Array element vertex
+    # that is empty. Splat expansion extracts elements during
+    # overload matching, so empty element types can cause oscillation
+    # even when the top-level Array type is present.
+    def splat_elements_uninformative?(genv, a_args)
+      a_args.positionals.each_with_index do |vtx, i|
+        next unless a_args.splat_flags[i]
+        vtx.each_type do |ty|
+          base = ty.base_type(genv)
+          if base.is_a?(Type::Instance) && base.mod == genv.mod_ary && base.args[0]
+            return true if base.args[0].types.empty?
+          end
+        end
+      end
+      false
+    end
+
     def vertex_uninformative?(genv, vtx, depth = 0)
       return true if vtx.types.empty?
       return false if depth > 3
@@ -363,59 +533,6 @@ def rest_keyword_args_typecheck?(genv, changes, keywords_vtx, method_type, param
       true
     end
 
-    # Check if two method types have structurally identical positional
-    # parameter types (req, opt, rest).
-    def positionals_match?(mt1, mt2)
-      return false unless mt1.req_positionals.size == mt2.req_positionals.size
-      return false unless mt1.opt_positionals.size == mt2.opt_positionals.size
-      return false unless mt1.rest_positionals.nil? == mt2.rest_positionals.nil?
-      mt1.req_positionals.zip(mt2.req_positionals).all? {|a, b| sig_types_match?(a, b) } &&
-        mt1.opt_positionals.zip(mt2.opt_positionals).all? {|a, b| sig_types_match?(a, b) } &&
-        (mt1.rest_positionals.nil? || sig_types_match?(mt1.rest_positionals, mt2.rest_positionals))
-    end
-
-    # Check if two method types have structurally identical keyword
-    # parameter types (req, opt, rest).
-    def keywords_match?(mt1, mt2)
-      return false unless mt1.req_keyword_keys == mt2.req_keyword_keys
-      return false unless mt1.opt_keyword_keys == mt2.opt_keyword_keys
-      return false unless mt1.rest_keywords.nil? == mt2.rest_keywords.nil?
-      mt1.req_keyword_values.zip(mt2.req_keyword_values).all? {|a, b| sig_types_match?(a, b) } &&
-        mt1.opt_keyword_values.zip(mt2.opt_keyword_values).all? {|a, b| sig_types_match?(a, b) } &&
-        (mt1.rest_keywords.nil? || sig_types_match?(mt1.rest_keywords, mt2.rest_keywords))
-    end
-
-    # Structural equality check for two SigTyNode objects.
-    def sig_types_match?(a, b)
-      return false unless a.class == b.class
-      case a
-      when AST::SigTyInstanceNode, AST::SigTyInterfaceNode
-        a.cpath == b.cpath &&
-          a.args.size == b.args.size &&
-          a.args.zip(b.args).all? {|x, y| sig_types_match?(x, y) }
-      when AST::SigTySingletonNode
-        a.cpath == b.cpath
-      when AST::SigTyTupleNode, AST::SigTyUnionNode, AST::SigTyIntersectionNode
-        a.types.size == b.types.size &&
-          a.types.zip(b.types).all? {|x, y| sig_types_match?(x, y) }
-      when AST::SigTyRecordNode
-        a.fields.size == b.fields.size &&
-          a.fields.all? {|k, v| b.fields[k] && sig_types_match?(v, b.fields[k]) }
-      when AST::SigTyOptionalNode, AST::SigTyProcNode
-        sig_types_match?(a.type, b.type)
-      when AST::SigTyVarNode
-        a.var == b.var
-      when AST::SigTyLiteralNode
-        a.lit == b.lit
-      when AST::SigTyAliasNode
-        a.cpath == b.cpath && a.name == b.name &&
-          a.args.size == b.args.size &&
-          a.args.zip(b.args).all? {|x, y| sig_types_match?(x, y) }
-      else
-        true # Leaf types (bool, nil, self, void, untyped, etc.)
-      end
-    end
-
     def show
       @method_types.map do |method_type|
         args = []
