typeprof 0.31.1 → 0.33.0

data/lib/typeprof/core/graph/box.rb

@@ -17,6 +17,7 @@ module TypeProf::Core
       $box_counts[self.class] -= 1
       $box_counts[Box] -= 1
       @destroyed = true
+      destroy_symbol_proc_call_boxes(genv)
       @changes.reinstall(genv) # rollback all changes
     end
 
@@ -43,6 +44,24 @@ module TypeProf::Core
       raise NotImplementedError
     end
 
+    def add_symbol_proc_call_box(_changes, genv, sym, caller_positionals, caller_keywords = nil)
+      return if caller_positionals.empty?
+
+      recv = caller_positionals.first
+      positionals = caller_positionals[1..]
+      @symbol_proc_call_boxes ||= {}
+      @symbol_proc_call_boxes[[recv, sym, *positionals, caller_keywords]] ||= begin
+        a_args = ActualArguments.new(positionals, ::Array.new(positionals.size, false), caller_keywords, nil)
+        MethodCallBox.new(@node, genv, recv, sym, a_args, false)
+      end
+    end
+
+    def destroy_symbol_proc_call_boxes(genv)
+      return unless @symbol_proc_call_boxes
+      @symbol_proc_call_boxes.each_value { |box| box.destroy(genv) }
+      @symbol_proc_call_boxes = nil
+    end
+
     def to_s
       "#{ self.class.to_s.split("::").last }#{ @id ||= $new_id += 1 }"
     end
@@ -87,7 +106,7 @@ module TypeProf::Core
         mod = genv.resolve_cpath(@node.cpath)
         if mod.type_params && !mod.type_params.empty?
           # Create a substitution map where each type parameter maps to a type variable vertex
-          subst = mod.type_params.to_h do |param|
+          subst = mod.type_params.to_h do |param, _default_ty|
             type_var_vtx = Vertex.new(@node)
             [param, type_var_vtx]
           end
@@ -99,6 +118,147 @@ module TypeProf::Core
     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
+
+    # lazy cache: overloads split into fixed-arity ones and rest-positional ones
+    def partition_by_rest_positionals
+      @partition_by_rest_positionals ||=
+        @method_types.partition {|method_type| !method_type.rest_positionals }
+    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)
@@ -123,6 +283,7 @@ module TypeProf::Core
       me = genv.resolve_method(@cpath, @singleton, @mid)
       me.remove_decl(self)
       me.add_run_all_method_call_boxes(genv)
+      destroy_symbol_proc_call_boxes(genv)
     end
 
     def match_arguments?(genv, changes, param_map, a_args, method_type)
@@ -179,14 +340,30 @@ module TypeProf::Core
         end
       end
 
+      # Check keyword arguments by inspecting the keywords vertex types
+      # directly. We avoid get_keyword_arg here because it creates a fresh
+      # Vertex each call, which would destabilize the change-set edges and
+      # cause oscillation when match_arguments? runs on every box re-eval.
+      if a_args.keywords
+        method_type.req_keyword_keys.zip(method_type.req_keyword_values) do |key, ty|
+          return false unless keyword_arg_typecheck?(genv, changes, a_args.keywords, key, ty, param_map)
+        end
+        method_type.opt_keyword_keys.zip(method_type.opt_keyword_values) do |key, ty|
+          return false unless keyword_arg_typecheck?(genv, changes, a_args.keywords, key, ty, param_map)
+        end
+        if method_type.rest_keywords
+          return false unless rest_keyword_args_typecheck?(genv, changes, a_args.keywords, method_type, param_map)
+        end
+      end
+
       return true
     end
 
     def resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, force)
       param_map0 = param_map.dup
       if method_type.type_params
-        method_type.type_params.zip(yield(method_type)) do |var, vtx|
-          param_map0[var] = vtx
+        method_type.type_params.zip(yield(method_type)) do |(var, _default_ty), vtx|
+          param_map0[var] = vtx # TODO: default_ty?
         end
       end
 
@@ -213,6 +390,7 @@ module TypeProf::Core
         end
         return false
       end
+
       if rbs_blk && a_args.block
         # rbs_blk_func.optional_keywords, ...
         blk_a_args = rbs_blk.req_positionals.map do |blk_a_arg|
@@ -230,6 +408,8 @@ module TypeProf::Core
                 end
               end
             end
+          when Type::Symbol
+            resolve_symbol_proc(changes, genv, ty.sym, blk_a_args, rbs_blk, param_map0)
           end
         end
       end
@@ -244,6 +424,13 @@ module TypeProf::Core
       end
     end
 
+    def resolve_symbol_proc(changes, genv, sym, blk_a_args, rbs_blk, param_map)
+      box = add_symbol_proc_call_box(changes, genv, sym, blk_a_args)
+      return unless box
+
+      rbs_blk.return_type.typecheck(genv, changes, box.ret, param_map)
+    end
+
     def resolve_overloads(changes, genv, node, param_map, a_args, ret, &blk)
       if @method_types.size == 1
         method_type = @method_types.first
@@ -251,11 +438,67 @@ module TypeProf::Core
         return
       end
 
+      # If any positional argument has no type information, we cannot
+      # determine which overload to select. Return silently (untyped)
+      # rather than attempting to match. This prevents oscillation in
+      # cyclic cases and avoids false "failed to resolve overloads"
+      # diagnostics for untyped arguments.
+      #
+      # 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?)
+      end
+      if has_uninformative_args
+        a_args.positionals.each do |vtx|
+          changes.add_edge(genv, vtx, changes.target)
+        end
+        # Note: keywords already have a permanent edge to the box
+        # (established in MethodCallBox#initialize), so no extra edge needed.
+        return
+      end
+
+      # A splatted call can match only a rest-positional overload; otherwise prefer
+      # the fixed-arity ones, as a rest-positional one is usually a catch-all
+      overload_groups =
+        a_args.splat_flags.any? ? [@method_types] : @method_types.partition_by_rest_positionals
+
       match_any_overload = false
-      @method_types.each do |method_type|
-        if resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, false, &blk)
-          match_any_overload = true
+      overload_groups.each do |method_types|
+        method_types.each do |method_type|
+          if resolve_overload(changes, genv, method_type, node, param_map, a_args, ret, false, &blk)
+            match_any_overload = true
+          end
         end
+        break if match_any_overload
       end
       unless match_any_overload
         meth = node.mid_code_range ? :mid_code_range : :code_range
@@ -263,6 +506,76 @@ module TypeProf::Core
       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
+      vtx.each_type do |ty|
+        base = ty.base_type(genv)
+        next unless base.is_a?(Type::Instance) && !base.args.empty?
+        base.args.each do |arg_vtx|
+          return true if arg_vtx && vertex_uninformative?(genv, arg_vtx, depth + 1)
+        end
+      end
+      false
+    end
+
+    # Typecheck a single keyword argument value against the expected type
+    # by directly inspecting the pre-existing value vertices in the
+    # keywords vertex's types (Record, Hash, Instance).
+    def keyword_arg_typecheck?(genv, changes, keywords_vtx, key, expected_ty, param_map)
+      keywords_vtx.each_type do |kw_ty|
+        val_vtx = case kw_ty
+        when Type::Hash then kw_ty.get_value(key)
+        when Type::Record then kw_ty.get_value(key)
+        when Type::Instance then kw_ty.mod == genv.mod_hash ? kw_ty.args[1] : nil
+        else nil
+        end
+        return false if val_vtx && !expected_ty.typecheck(genv, changes, val_vtx, param_map)
+      end
+      true
+    end
+
+    # Typecheck rest keyword argument values (those not consumed by named
+    # keywords) against the method type's rest_keywords type.
+    def rest_keyword_args_typecheck?(genv, changes, keywords_vtx, method_type, param_map)
+      named_keys = method_type.req_keyword_keys + method_type.opt_keyword_keys
+      rest_ty = method_type.rest_keywords
+      keywords_vtx.each_type do |kw_ty|
+        case kw_ty
+        when Type::Record
+          kw_ty.fields.each do |key, val_vtx|
+            next if named_keys.include?(key)
+            return false unless rest_ty.typecheck(genv, changes, val_vtx, param_map)
+          end
+        when Type::Hash
+          val_vtx = kw_ty.base_type(genv).args[1]
+          return false if val_vtx && !rest_ty.typecheck(genv, changes, val_vtx, param_map)
+        when Type::Instance
+          if kw_ty.mod == genv.mod_hash && kw_ty.args[1]
+            return false unless rest_ty.typecheck(genv, changes, kw_ty.args[1], param_map)
+          end
+        end
+      end
+      true
+    end
+
     def show
       @method_types.map do |method_type|
         args = []
@@ -279,10 +592,10 @@ module TypeProf::Core
           args << arg.show
         end
 
-        method_type.req_keywords.each do |key, arg|
+        method_type.req_keyword_keys.zip(method_type.req_keyword_values) do |key, arg|
           args << "#{ key }: #{arg.show}"
         end
-        method_type.opt_keywords.each do |key, arg|
+        method_type.opt_keyword_keys.zip(method_type.opt_keyword_values) do |key, arg|
           args << "?#{ key }: #{arg.show}"
         end
         if method_type.rest_keywords
@@ -311,7 +624,6 @@ module TypeProf::Core
 
     def wrong_return_type(f_ret_show, changes)
       actual_ty = @a_ret.show
-      return if actual_ty == "untyped" # XXX: too ad-hoc?
       msg = "expected: #{ f_ret_show }; actual: #{ actual_ty }"
       case @node
       when AST::ReturnNode
@@ -331,11 +643,13 @@ module TypeProf::Core
   end
 
   class SplatBox < Box
-    def initialize(node, genv, ary, idx)
+    def initialize(node, genv, ary, idx, unresolved_recv = nil)
       super(node)
       @ary = ary
       @idx = idx
+      @unresolved_recv = unresolved_recv
       @ary.add_edge(genv, self)
+      @unresolved_recv.add_edge(genv, self) if @unresolved_recv
       @ret = Vertex.new(node)
     end
 
@@ -360,6 +674,39 @@ module TypeProf::Core
           "???"
         end
       end
+      # For types where to_a is not defined, [*x] wraps x as [x]
+      if @unresolved_recv
+        @unresolved_recv.each_type do |ty|
+          changes.add_edge(genv, Source.new(ty), @ret)
+        end
+      end
+    end
+  end
+
+  # Merges the keywords being forwarded into the `**rest` hash while keeping the
+  # rest's own fields, so that the callee can still tell the two apart.
+  class KeywordMergeBox < Box
+    def initialize(node, genv, rest, literal_pairs, fallback)
+      super(node)
+      @rest = rest
+      @literal_pairs = literal_pairs
+      @fallback = fallback
+      @rest.add_edge(genv, self)
+      @ret = Vertex.new(node)
+    end
+
+    attr_reader :ret
+
+    def run0(genv, changes)
+      merged = false
+      @rest.each_type do |ty|
+        if ty.is_a?(Type::Record)
+          fields = ty.fields.merge(@literal_pairs)
+          changes.add_edge(genv, Source.new(Type::Record.new(genv, fields, ty.base_type(genv))), @ret)
+          merged = true
+        end
+      end
+      changes.add_edge(genv, @fallback, @ret) unless merged
     end
   end
 
@@ -418,7 +765,7 @@ module TypeProf::Core
 
     attr_accessor :node
 
-    attr_reader :cpath, :singleton, :mid, :f_args, :ret
+    attr_reader :cpath, :singleton, :mid, :f_args, :ret, :record_block
 
     def destroy(genv)
       me = genv.resolve_method(@cpath, @singleton, @mid)
@@ -443,17 +790,17 @@ module TypeProf::Core
         ty = Type::Singleton.new(genv, mod)
         param_map0 = Type.default_param_map(genv, ty)
       else
-        type_params = mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+        type_params = mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
         ty = Type::Instance.new(genv, mod, type_params)
         param_map0 = Type.default_param_map(genv, ty)
         if ty.is_a?(Type::Instance)
-          ty.mod.type_params.zip(ty.args) do |param, arg|
-            param_map0[param] = arg
+          ty.mod.type_params.zip(ty.args) do |(name, _default_ty), arg|
+            param_map0[name] = arg
           end
         end
       end
-      method_type.type_params.each do |param|
-        param_map0[param] = Source.new()
+      method_type.type_params.each do |name, _default_ty|
+        param_map0[name] = Source.new()
       end
 
       positional_args = []
@@ -517,7 +864,7 @@ module TypeProf::Core
           end
         end
         @f_args.opt_positionals.each_with_index do |f_vtx, i|
-          i += @f_args.opt_positionals.size
+          i += @f_args.req_positionals.size
           if i < start_rest
             changes.add_edge(genv, a_args.positionals[i], f_vtx)
           else
@@ -599,16 +946,39 @@ module TypeProf::Core
         end
 
         if @node.rest_keywords
-          # FIXME: Extract the rest keywords excluding req_keywords and opt_keywords.
-          changes.add_edge(genv, a_args.keywords, @f_args.rest_keywords)
+          named_keys = @node.req_keywords + @node.opt_keywords
+          a_args.keywords.each_type do |kw_ty|
+            case kw_ty
+            when Type::Record
+              rest_fields = kw_ty.fields.reject {|key, _| named_keys.include?(key) }
+              base = kw_ty.base_type(genv)
+              rest_record = Type::Record.new(genv, rest_fields, base)
+              changes.add_edge(genv, Source.new(rest_record), @f_args.rest_keywords)
+            when Type::Hash, Type::Instance
+              changes.add_edge(genv, Source.new(kw_ty), @f_args.rest_keywords)
+            end
+          end
         end
       end
 
       return true
     end
 
+    def normalize_keyword_hash_argument_for_def(a_args)
+      return a_args unless a_args.keywords
+      return a_args if @node.no_keywords
+      return a_args if @node.rest_keywords
+      return a_args unless @node.req_keywords.empty? && @node.opt_keywords.empty?
+
+      a_args.with_keywords_as_last_positional_hash
+    end
+
     def call(changes, genv, a_args, ret)
+      a_args = normalize_keyword_hash_argument_for_def(a_args)
       if pass_arguments(changes, genv, a_args)
+        if @node.is_a?(AST::DefNode)
+          @node.body.lenv.forward_args&.accept_actual_arguments(genv, changes, a_args)
+        end
         changes.add_edge(genv, a_args.block, @f_args.block) if @f_args.block && a_args.block
 
         changes.add_edge(genv, @ret, ret)
@@ -635,7 +1005,9 @@ module TypeProf::Core
       @f_args.post_positionals.each do |var|
         args << Type.strip_parens(var.show)
       end
-      if @node.is_a?(AST::DefNode)
+      if @node.respond_to?(:req_keywords) &&
+         @node.req_keywords.size == @f_args.req_keywords.size &&
+         @node.opt_keywords.size == @f_args.opt_keywords.size
         @node.req_keywords.zip(@f_args.req_keywords) do |name, f_vtx|
           args << "#{ name }: #{Type.strip_parens(f_vtx.show)}"
         end
@@ -651,11 +1023,11 @@ module TypeProf::Core
         names = []
         names.concat(@node.req_positionals)
         names.concat(@node.opt_positionals)
-        names.concat(@node.rest_positionals) if @node.rest_positionals
+        names << @node.rest_positionals if @node.rest_positionals
         names.concat(@node.post_positionals)
         names.concat(@node.req_keywords)
         names.concat(@node.opt_keywords)
-        names.concat(@node.rest_keywords) if @node.rest_keywords
+        names << @node.rest_keywords if @node.rest_keywords
         args = args.zip(names).map do |arg, name|
           name ? "#{ arg } #{ name }" : arg
         end
@@ -702,35 +1074,50 @@ module TypeProf::Core
   end
 
   class MethodCallBox < Box
-    def initialize(node, genv, recv, mid, a_args, subclasses)
+    # `unresolved_recv`, when given, collects the receiver types for which no
+    # method entity was found. Without it those types only become "undefined
+    # method" diagnostics; with it the caller can handle them itself, as `[*x]`
+    # does to wrap a receiver that has no `to_a`.
+    def initialize(node, genv, recv, mid, a_args, subclasses, suppress_errors: false, unresolved_recv: nil)
       raise mid.to_s unless mid
       super(node)
       @recv = recv.new_vertex(genv, node)
       @recv.add_edge(genv, self)
       @mid = mid
       @a_args = a_args.new_vertexes(genv, node)
-      @a_args.keywords.add_edge(genv, self) if @a_args.keywords
-      @a_args.block.add_edge(genv, self) if @a_args.block
+      @a_args.add_box_edges(genv, self)
       @ret = Vertex.new(node)
       @subclasses = subclasses
+      @suppress_errors = suppress_errors
+      @unresolved_recv = unresolved_recv
       @generics = {}
     end
 
     attr_reader :recv, :mid, :ret
 
     def run0(genv, changes)
-      edges = Set[]
-      called_mdefs = Set[]
+      a_args = @a_args.normalize_for_method_call(genv)
+      return unless a_args
+
+      edges = Set.empty
+      called_mdefs = Set.empty
       error_count = 0
       resolve(genv, changes) do |me, ty, mid, orig_ty|
-        if !me
-          # TODO: undefined method error
-          if error_count < 3
-            meth = @node.mid_code_range ? :mid_code_range : :code_range
-            changes.add_diagnostic(meth, "undefined method: #{ orig_ty.show }##{ mid }")
+        if @node.is_a?(AST::YieldNode) && mid == :call && orig_ty.is_a?(Type::Symbol)
+          box = add_symbol_proc_call_box(changes, genv, orig_ty.sym, a_args.positionals, a_args.keywords)
+          changes.add_edge(genv, box.ret, @ret) if box
+        elsif !me
+          if @unresolved_recv
+            changes.add_edge(genv, Source.new(orig_ty), @unresolved_recv)
+          end
+          unless @suppress_errors
+            if error_count < 3
+              meth = @node.mid_code_range ? :mid_code_range : :code_range
+              changes.add_diagnostic(meth, "undefined method: #{ orig_ty.show }##{ mid }")
+            end
           end
           error_count += 1
-        elsif me.builtin && me.builtin[changes, @node, orig_ty, @a_args, @ret]
+        elsif me.builtin && me.builtin[changes, @node, orig_ty, a_args, @ret]
           # do nothing
         elsif !me.decls.empty?
           # TODO: support "| ..."
@@ -739,19 +1126,19 @@ module TypeProf::Core
             # TODO: add_depended_method_entity for types used to resolve overloads
             ty_env = Type.default_param_map(genv, orig_ty)
             if ty.is_a?(Type::Instance)
-              ty.mod.type_params.zip(ty.args) do |param, arg|
-                ty_env[param] = arg
+              ty.mod.type_params.zip(ty.args) do |(param, default_ty), arg|
+                ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(genv, changes, ty_env) : Source.new)
               end
             end
-            mdecl.resolve_overloads(changes, genv, @node, ty_env, @a_args, @ret) do |method_type|
-              @generics[method_type] ||= method_type.type_params.map {|var| Vertex.new(@node) }
+            mdecl.resolve_overloads(changes, genv, @node, ty_env, a_args, @ret) do |method_type|
+              @generics[method_type] ||= method_type.type_params.map { Vertex.new(@node) }
             end
           end
         elsif !me.defs.empty?
           me.defs.each do |mdef|
             next if called_mdefs.include?(mdef)
             called_mdefs << mdef
-            mdef.call(changes, genv, @a_args, @ret)
+            mdef.call(changes, genv, a_args, @ret)
           end
         else
           pp me
@@ -764,7 +1151,7 @@ module TypeProf::Core
             me.defs.each do |mdef|
               next if called_mdefs.include?(mdef)
               called_mdefs << mdef
-              mdef.call(changes, genv, @a_args, @ret)
+              mdef.call(changes, genv, a_args, @ret)
             end
           end
         end
@@ -772,7 +1159,7 @@ module TypeProf::Core
       edges.each do |src, dst|
         changes.add_edge(genv, src, dst)
       end
-      if error_count > 3
+      if error_count > 3 && !@suppress_errors
         meth = @node.mid_code_range ? :mid_code_range : :code_range
         changes.add_diagnostic(meth, "... and other #{ error_count - 3 } errors")
       end
@@ -780,7 +1167,7 @@ module TypeProf::Core
 
     def resolve(genv, changes, &blk)
       @recv.each_type do |orig_ty|
-        next if orig_ty == Type::Bot.new(genv)
+        next if orig_ty == genv.bot_type
         if @mid == :"*super"
           mid = @node.lenv.cref.mid
           skip = true
@@ -822,7 +1209,10 @@ module TypeProf::Core
           skip = false
 
           if ty.is_a?(Type::Singleton)
-            # TODO: extended modules
+            # Check extended modules (their instance methods are singleton methods here)
+            break if resolve_extended_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
+              yield me, ty, mid, orig_ty
+            end
           else
             # Finally check included modules
             break if resolve_included_modules(genv, changes, base_ty_env, ty, mid) do |me, ty, mid|
@@ -846,7 +1236,7 @@ module TypeProf::Core
         if prep_decl.is_a?(AST::SigPrependNode) && prep_mod.type_params
           prep_ty = genv.get_instance_type(prep_mod, prep_decl.args, changes, base_ty_env, ty)
         else
-          type_params = prep_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          type_params = prep_mod.type_params.map { Source.new() } # TODO: better support
           prep_ty = Type::Instance.new(genv, prep_mod, type_params)
         end
 
@@ -901,7 +1291,7 @@ module TypeProf::Core
         if inc_decl.is_a?(AST::SigIncludeNode) && inc_mod.type_params
           inc_ty = genv.get_instance_type(inc_mod, inc_decl.args, changes, base_ty_env, ty)
         else
-          type_params = inc_mod.type_params.map {|ty_param| Source.new() } # TODO: better support
+          type_params = inc_mod.type_params.map { Source.new() } # TODO: better support
           inc_ty = Type::Instance.new(genv, inc_mod, type_params)
         end
 
@@ -922,10 +1312,42 @@ module TypeProf::Core
       found
     end
 
+    def resolve_extended_modules(genv, changes, base_ty_env, ty, mid, &blk)
+      found = false
+
+      alias_limit = 0
+      # An extended module's instance methods are resolved as the receiver's
+      # singleton methods, so look them up with singleton = false.
+      ty.mod.extended_modules.each do |ext_decl, ext_mod|
+        if ext_decl.is_a?(AST::SigExtendNode) && ext_mod.type_params
+          ext_ty = genv.get_instance_type(ext_mod, ext_decl.args, changes, base_ty_env, ty)
+        else
+          type_params = ext_mod.type_params.map { Source.new() } # TODO: better support
+          ext_ty = Type::Instance.new(genv, ext_mod, type_params)
+        end
+
+        me = ext_ty.mod.get_method(false, mid)
+        changes.add_depended_method_entity(me) if changes
+        if !me.aliases.empty?
+          mid = me.aliases.values.first
+          alias_limit += 1
+          redo if alias_limit < 5
+        end
+        if me.exist?
+          found = true
+          yield me, ext_ty, mid
+        else
+          # The extended module may itself include other modules.
+          found ||= resolve_included_modules(genv, changes, base_ty_env, ext_ty, mid, &blk)
+        end
+      end
+      found
+    end
+
     def resolve_subclasses(genv, changes)
       # TODO: This does not follow new subclasses
       @recv.each_type do |ty|
-        next if ty == Type::Bot.new(genv)
+        next if ty == genv.bot_type
         base_ty = ty.base_type(genv)
         singleton = base_ty.is_a?(Type::Singleton)
         mod = base_ty.mod
@@ -980,23 +1402,44 @@ module TypeProf::Core
       singleton = @singleton
       cur_ive = mod.get_ivar(singleton, @name)
       target_vtx = nil
+      target_decls = nil
       genv.each_direct_superclass(mod, singleton) do |mod, singleton|
         ive = mod.get_ivar(singleton, @name)
+        # Subscribe to every visited ive so that, if one later acquires an
+        # RBS declaration, this box is re-run and switches to the declared
+        # type instead of the inferred one.
+        changes.add_depended_value_entity(ive)
         if ive.exist?
           target_vtx = ive.vtx
+          target_decls = ive.decls unless ive.decls.empty?
+          break if target_decls
         end
       end
-      edges = []
-      if target_vtx
+
+      if target_decls
+        # When declarations exist, return declared types instead of assigned types
+        target_decls.each do |decl|
+          subst = {}
+          if decl.cpath
+            decl_mod = genv.resolve_cpath(decl.cpath)
+            if decl_mod.type_params && !decl_mod.type_params.empty?
+              subst = decl_mod.type_params.to_h do |param, _default_ty|
+                [param, Vertex.new(@node)]
+              end
+            end
+          end
+          vtx = decl.type.covariant_vertex(genv, changes, subst)
+          changes.add_edge(genv, vtx, @ret)
+        end
+      elsif target_vtx
+        edges = []
         if target_vtx != cur_ive.vtx
           edges << [cur_ive.vtx, @proxy] << [@proxy, target_vtx]
         end
         edges << [target_vtx, @ret]
-      else
-        # TODO: error?
-      end
-      edges.each do |src, dst|
-        changes.add_edge(genv, src, dst)
+        edges.each do |src, dst|
+          changes.add_edge(genv, src, dst)
+        end
       end
     end
   end
@@ -1064,25 +1507,27 @@ module TypeProf::Core
     def ret = @rhs
 
     def run0(genv, changes)
-      edges = []
       @value.each_type do |ty|
         # TODO: call to_ary?
         case ty
         when Type::Array
-          edges.concat(ty.splat_assign(genv, @lefts, @rest_elem, @rights))
-        else
-          if @lefts.size >= 1
-            edges << [Source.new(ty), @lefts[0]]
-          elsif @rights && @rights.size >= 1
-            edges << [Source.new(ty), @rights[0]]
+          ty.splat_assign(genv, @lefts, @rest_elem, @rights).each do |src, dst|
+            changes.add_edge(genv, src, dst)
+          end
+        when Type::Instance
+          if ty.mod == genv.mod_ary && (elem_vtx = ty.args[0])
+            @lefts.each {|lhs| changes.add_edge(genv, elem_vtx, lhs) }
+            changes.add_edge(genv, elem_vtx, @rest_elem) if @rest_elem
+            @rights&.each {|rhs| changes.add_edge(genv, elem_vtx, rhs) }
           else
-            edges << [Source.new(ty), @rest_elem]
+            lhs = @lefts[0] || (@rights && @rights[0]) || @rest_elem
+            changes.add_edge(genv, Source.new(ty), lhs) if lhs
           end
+        else
+          lhs = @lefts[0] || (@rights && @rights[0]) || @rest_elem
+          changes.add_edge(genv, Source.new(ty), lhs) if lhs
         end
       end
-      edges.each do |src, dst|
-        changes.add_edge(genv, src, dst)
-      end
     end
   end