typeprof 0.31.1 → 0.32.0

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

@@ -87,7 +87,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 +99,141 @@ 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
+
+    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)
@@ -179,14 +314,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 +364,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|
@@ -251,6 +403,54 @@ 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
+
       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)
@@ -263,6 +463,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 +549,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 +581,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 +600,13 @@ module TypeProf::Core
   end
 
   class SplatBox < Box
-    def initialize(node, genv, ary, idx)
+    def initialize(node, genv, ary, idx, orig = nil)
       super(node)
       @ary = ary
       @idx = idx
+      @orig = orig
       @ary.add_edge(genv, self)
+      @orig.add_edge(genv, self) if @orig
       @ret = Vertex.new(node)
     end
 
@@ -360,6 +631,12 @@ module TypeProf::Core
           "???"
         end
       end
+      # For types where to_a is not defined, [*x] wraps x as [x]
+      if @orig && @ary.types.empty?
+        @orig.each_type do |ty|
+          changes.add_edge(genv, Source.new(ty), @ret)
+        end
+      end
     end
   end
 
@@ -418,7 +695,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 +720,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 +794,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 +876,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 +935,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 +953,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,7 +1004,7 @@ module TypeProf::Core
   end
 
   class MethodCallBox < Box
-    def initialize(node, genv, recv, mid, a_args, subclasses)
+    def initialize(node, genv, recv, mid, a_args, subclasses, suppress_errors: false)
       raise mid.to_s unless mid
       super(node)
       @recv = recv.new_vertex(genv, node)
@@ -713,21 +1015,23 @@ module TypeProf::Core
       @a_args.block.add_edge(genv, self) if @a_args.block
       @ret = Vertex.new(node)
       @subclasses = subclasses
+      @suppress_errors = suppress_errors
       @generics = {}
     end
 
     attr_reader :recv, :mid, :ret
 
     def run0(genv, changes)
-      edges = Set[]
-      called_mdefs = Set[]
+      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 }")
+          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]
@@ -739,12 +1043,12 @@ 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) }
+              @generics[method_type] ||= method_type.type_params.map { Vertex.new(@node) }
             end
           end
         elsif !me.defs.empty?
@@ -772,7 +1076,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 +1084,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
@@ -846,7 +1150,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 +1205,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
 
@@ -925,7 +1229,7 @@ module TypeProf::Core
     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 +1284,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 +1389,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