Support anonymous rest and keyword argument forwarding

- Fix NoMethodError when using anonymous rest (*) and keyword (**) forwarding
- Extract Hash value types for RBS keyword parameters (Hash[K, V] → V)
- Add proper type inference for anonymous argument scenarios

This enables method calls like foo(*) and foo(**) to work correctly
and ensures RBS output shows the actual value types for keyword parameters
rather than the full Hash type.

Author: sinsoku

lib/typeprof/core/ast/call.rb

@@ -35,7 +35,7 @@ def initialize(raw_node, recv, mid, mid_code_range, raw_args, last_arg, raw_bloc
               @splat_flags << false
             end
           end
-          @positional_args = args.map {|arg| AST.create_node(arg, lenv) }
+          @positional_args = args.map {|arg| arg ? AST.create_node(arg, lenv) : DummyNilNode.new(code_range, lenv) }
 
           if @positional_args.last.is_a?(TypeProf::Core::AST::HashNode) && @positional_args.last.keywords
             @keyword_args = @positional_args.pop
@@ -93,7 +93,11 @@ def install0(genv)
         end
 
         positional_args = @positional_args.map do |arg|
-          arg.install(genv)
+          if arg.is_a?(DummyNilNode)
+            @lenv.get_var(:"*anonymous_rest")
+          else
+            arg.install(genv)
+          end
         end
 
         keyword_args = @keyword_args ? @keyword_args.install(genv) : nil

lib/typeprof/core/ast/method.rb

@@ -64,7 +64,7 @@ def self.parse_params(tbl, raw_args, lenv)
 
       post_positionals = raw_args.posts.map {|n| (n.is_a?(Prism::MultiTargetNode) ? nil : n.name) }
 
-      rest_positionals = raw_args.rest&.name
+      rest_positionals = raw_args.rest ? (raw_args.rest.name || :"*anonymous_rest") : nil
 
       req_keywords = []
       opt_keywords = []
@@ -82,7 +82,7 @@ def self.parse_params(tbl, raw_args, lenv)
 
       case raw_args.keyword_rest
       when Prism::KeywordRestParameterNode
-        rest_keywords = raw_args.keyword_rest.name if raw_args.keyword_rest
+        rest_keywords = raw_args.keyword_rest.name || :"**anonymous_keyword"
       when Prism::ForwardingParameterNode
         # TODO: The variable names might be subject to change when supporting the propagation of parameter values to the graph during method calls.
         rest_positionals = :"..."
@@ -228,6 +228,12 @@ def install0(genv)
           @changes.add_edge(genv, Source.new(genv.gen_ary_type(Vertex.new(self))), rest_positionals)
         end
 
+        if rest_keywords
+          if @rest_keywords == :"**anonymous_keyword"
+            @changes.add_edge(genv, Source.new(genv.gen_hash_type(Vertex.new(self), Vertex.new(self))), rest_keywords)
+          end
+        end
+
         @opt_positional_defaults.zip(opt_positionals) do |expr, vtx|
           @changes.add_edge(genv, expr.install(genv), vtx)
         end

lib/typeprof/core/ast/value.rb

@@ -272,7 +272,11 @@ def initialize(raw_node, lenv, keywords)
             @vals << AST.create_node(raw_elem.value, lenv)
           when :assoc_splat_node
             @keys << nil
-            @vals << AST.create_node(raw_elem.value, lenv)
+            if raw_elem.value
+              @vals << AST.create_node(raw_elem.value, lenv)
+            else
+              @vals << DummyNilNode.new(code_range, lenv)
+            end
             @splat = true
           else
             raise "unknown hash elem: #{ raw_elem.type }"
@@ -297,7 +301,11 @@ def install0(genv)
             @changes.add_edge(genv, v, unified_val)
             literal_pairs[key.lit] = v if key.is_a?(SymbolNode)
           else
-            h = val.install(genv)
+            if val.is_a?(DummyNilNode)
+              h = @lenv.get_var(:"**anonymous_keyword")
+            else
+              h = val.install(genv)
+            end
             # TODO: do we want to call to_hash on h?
             @changes.add_hash_splat_box(genv, h, unified_key, unified_val)
           end

lib/typeprof/core/graph/box.rb

@@ -640,7 +640,7 @@ def show(output_parameter_names)
         end
       end
       if @f_args.rest_keywords
-        args << "**#{ Type.strip_parens(@f_args.rest_keywords.show) }"
+        args << "**#{ Type.extract_hash_value_type(Type.strip_parens(@f_args.rest_keywords.show)) }"
       end
 
       if output_parameter_names && @node.is_a?(AST::DefNode)

lib/typeprof/core/type.rb

@@ -15,6 +15,20 @@ def self.strip_array(s)
       s.start_with?("Array[") && s.end_with?("]") ? s[6..-2] || raise : s
     end
 
+    def self.extract_hash_value_type(s)
+      if s.start_with?("Hash[") && s.end_with?("]")
+        type = RBS::Parser.parse_type(s)
+
+        if type.is_a?(RBS::Types::Union)
+          type.types.map {|t| t.args[1].to_s }.join(" | ")
+        else
+          type.args[1].to_s
+        end
+      else
+        s
+      end
+    end
+
     def self.default_param_map(genv, ty)
       ty = ty.base_type(genv)
       instance_ty = ty.is_a?(Type::Instance) ? ty : Type::Instance.new(genv, ty.mod, []) # TODO: type params

scenario/args/anonymous_keyword.rb

@@ -0,0 +1,16 @@
+## update
+def foo(**)
+  bar(**)
+end
+
+def bar(**)
+  nil
+end
+
+bar(x: 1, y: "foo")
+
+## assert
+class Object
+  def foo: (**untyped) -> nil
+  def bar: (**Integer | String | untyped) -> nil
+end

scenario/args/anonymous_rest.rb

@@ -0,0 +1,16 @@
+## update
+def foo(*)
+  bar(*)
+end
+
+def bar(*)
+  nil
+end
+
+bar(1, "foo")
+
+## assert
+class Object
+  def foo: (*untyped) -> nil
+  def bar: (*Integer | String) -> nil
+end

scenario/method/keywords.rb

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