Add rest keywords (**) support for overload resolution and fix FIXME

This allows overload resolution for `(**Integer) -> A | (**String) -> B`.

Author: mame

lib/typeprof/core/graph/box.rb

@@ -190,6 +190,9 @@ def match_arguments?(genv, changes, param_map, a_args, method_type)
         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
@@ -336,6 +339,30 @@ def keyword_arg_typecheck?(genv, changes, keywords_vtx, key, expected_ty, param_
       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
+
     # Check if two method types have structurally identical positional
     # parameter types (req, opt, rest).
     def positionals_match?(mt1, mt2)
@@ -726,8 +753,18 @@ def pass_arguments(changes, genv, a_args)
         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
 

scenario/method/keywords.rb

@@ -71,5 +71,5 @@ def foo(a:, b: 1, **c)
 
 ## assert
 class Object
-  def foo: (a: String, ?b: Integer, **String | Integer | true) -> { a: String, b: Integer, c: true }
+  def foo: (a: String, ?b: Integer, **true) -> { c: true }
 end

scenario/rbs/mixed-keyword-overload.rb

@@ -0,0 +1,21 @@
+## update: test.rbs
+class C
+  def foo: (mode: :read, **Integer) -> Array[Integer]
+         | (mode: :write, **String) -> Array[String]
+end
+
+## update: test.rb
+class C
+  def bar
+    foo(mode: :read, x: 1)
+  end
+  def baz
+    foo(mode: :write, x: "a")
+  end
+end
+
+## assert: test.rb
+class C
+  def bar: -> Array[Integer]
+  def baz: -> Array[String]
+end

scenario/rbs/rest-keyword-overload.rb

@@ -0,0 +1,20 @@
+## update: test.rbs
+class C
+  def foo: (**Integer) -> Integer | (**String) -> String
+end
+
+## update: test.rb
+class C
+  def bar
+    foo(x: 1, y: 2)
+  end
+  def baz
+    foo(x: "a", y: "b")
+  end
+end
+
+## assert: test.rb
+class C
+  def bar: -> Integer
+  def baz: -> String
+end