typeprof 0.30.0 → 0.31.0

data/lib/typeprof/core/ast/control.rb

@@ -13,6 +13,42 @@ module TypeProf::Core
       return nil
     end
 
+    # Apply multiple narrowings from the new narrowing system
+    def self.with_narrowing(genv, node, lenv, narrowing)
+      return yield if narrowing.map.empty?
+
+      # Store original vertices (only for local variables)
+      original_vtxs = {}
+      narrowing.map.each do |var, narrowing|
+        original_vtxs[var] = var.start_with?("@") ? nil : lenv.get_var(var)
+      end
+
+      # Apply all narrowings
+      narrowing.map.each do |var, narrowing|
+        if var.start_with?("@")
+          lenv.push_ivar_narrowing(var, narrowing)
+        else
+          original_vtx = original_vtxs[var]
+          narrowed_vtx = original_vtx.new_vertex(genv, node)
+          narrowed_vtx = narrowing.narrow(genv, node, narrowed_vtx)
+          lenv.set_var(var, narrowed_vtx)
+        end
+      end
+
+      result = yield
+
+      # Restore original vertices and remove instance variable filters
+      original_vtxs.each do |var, original_vtx|
+        if var.start_with?("@")
+          lenv.pop_ivar_narrowing(var)
+        else
+          lenv.set_var(var, original_vtx)
+        end
+      end
+
+      result
+    end
+
     class BranchNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
@@ -37,11 +73,11 @@ module TypeProf::Core
         @cond.install(genv)
 
         vars = []
-        vars << @cond.var if @cond.is_a?(LocalVariableReadNode)
-        var, filter_class = AST.is_a_class(@cond)
-        vars << var if var
         @then.modified_vars(@lenv.locals.keys, vars) if @then
         @else.modified_vars(@lenv.locals.keys, vars) if @else
+        then_narrowing, else_narrowing = @cond.narrowings
+        vars.concat(then_narrowing.map.keys.reject {|var| var.start_with?("@") })
+        vars.concat(else_narrowing.map.keys.reject {|var| var.start_with?("@") })
         modified_vtxs = {}
         vars.uniq.each do |var|
           vtx = @lenv.get_var(var)
@@ -49,48 +85,30 @@ module TypeProf::Core
           nvtx_else = vtx.new_vertex(genv, self)
           modified_vtxs[var] = [nvtx_then, nvtx_else]
         end
-        if @cond.is_a?(LocalVariableReadNode)
-          nvtx_then, nvtx_else = modified_vtxs[@cond.var]
-          nvtx_then = NilFilter.new(genv, self, nvtx_then, !self.is_a?(IfNode)).next_vtx
-          nvtx_else = NilFilter.new(genv, self, nvtx_else, self.is_a?(IfNode)).next_vtx
-          modified_vtxs[@cond.var] = [nvtx_then, nvtx_else]
-        end
-        if filter_class
-          nvtx_then, nvtx_else = modified_vtxs[var]
-          nvtx_then = IsAFilter.new(genv, self, nvtx_then, !self.is_a?(IfNode), filter_class).next_vtx
-          nvtx_else = IsAFilter.new(genv, self, nvtx_else, self.is_a?(IfNode), filter_class).next_vtx
-          modified_vtxs[var] = [nvtx_then, nvtx_else]
-        end
 
-        if @then
-          modified_vtxs.each do |var, (nvtx_then, _)|
-            @lenv.set_var(var, nvtx_then)
-          end
-          if @cond.is_a?(InstanceVariableReadNode)
-            @lenv.push_read_filter(@cond.var, :non_nil)
-          end
-          then_val = @then.install(genv)
-          if @cond.is_a?(InstanceVariableReadNode)
-            @lenv.pop_read_filter(@cond.var)
-          end
+        narrowing = self.is_a?(IfNode) ? then_narrowing : else_narrowing
+        modified_vtxs.each do |var, (nvtx_then, _)|
+          @lenv.set_var(var, nvtx_then)
+        end
+        then_val = AST.with_narrowing(genv, self, @lenv, narrowing) do
+          val = @then ? @then.install(genv) : Source.new(genv.nil_type)
           modified_vtxs.each do |var, ary|
             ary[0] = @lenv.get_var(var)
           end
-        else
-          then_val = Source.new(genv.nil_type)
+          val
         end
         @changes.add_edge(genv, then_val, ret)
 
-        if @else
-          modified_vtxs.each do |var, (_, nvtx_else)|
-            @lenv.set_var(var, nvtx_else)
-          end
-          else_val = @else.install(genv)
+        narrowing = self.is_a?(IfNode) ? else_narrowing : then_narrowing
+        modified_vtxs.each do |var, (_, nvtx_else)|
+          @lenv.set_var(var, nvtx_else)
+        end
+        else_val = AST.with_narrowing(genv, self, @lenv, narrowing) do
+          val = @else ? @else.install(genv) : Source.new(genv.nil_type)
           modified_vtxs.each do |var, ary|
             ary[1] = @lenv.get_var(var)
           end
-        else
-          else_val = Source.new(genv.nil_type)
+          val
         end
         @changes.add_edge(genv, else_val, ret)
 
@@ -176,7 +194,7 @@ module TypeProf::Core
     class BreakNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
-        @arg = raw_node.arguments ? AST.create_node(raw_node.arguments.arguments.first, lenv) : nil
+        @arg = AST.parse_return_arguments(raw_node, lenv, code_range)
       end
 
       attr_reader :arg
@@ -184,8 +202,9 @@ module TypeProf::Core
       def subnodes = { arg: }
 
       def install0(genv)
-        _arg = @arg ? @arg.install(genv) : Source.new(genv.nil_type)
-        # TODO: implement!
+        arg = @arg.install(genv)
+        @changes.add_edge(genv, arg, @lenv.get_break_vtx)
+        Source.new()
       end
     end
 
@@ -215,7 +234,7 @@ module TypeProf::Core
       def install0(genv)
         @arg.install(genv)
         if @lenv.exist_var?(:"*expected_block_ret")
-          @lenv.add_next_box(@changes.add_escape_box(genv, @arg.ret, @lenv.get_var(:"*expected_block_ret")))
+          @lenv.add_next_box(@changes.add_escape_box(genv, @arg.ret))
         end
         Source.new(Type::Bot.new(genv))
       end
@@ -232,31 +251,115 @@ module TypeProf::Core
       end
     end
 
+    class WhenNode < Node
+      def initialize(raw_when_node, lenv, pivot_var = nil)
+        super(raw_when_node, lenv)
+        @conditions = raw_when_node.conditions.map {|cond| AST.create_node(cond, lenv) }
+        @body = raw_when_node.statements ? AST.create_node(raw_when_node.statements, lenv) : DummyNilNode.new(code_range, lenv)
+        @pivot_var = pivot_var
+      end
+
+      attr_reader :conditions, :body, :pivot_var
+
+      def subnodes = { conditions:, body: }
+
+      def install0(genv)
+        @conditions.each {|condition| condition.install(genv) }
+
+        # 型絞り込みが必要な場合（pivot_varが設定されている場合）
+        if @pivot_var && @lenv.locals.key?(:"*pivot")
+          original_vtx = @lenv.locals[:"*pivot"]
+
+          # 複数条件のOR（union）処理
+          filtered_vtxs = []
+
+          @conditions.each do |condition|
+            if condition.is_a?(ConstantReadNode) && condition.static_ret
+              # 各条件に対して独立して型絞り込みを適用
+              condition_vtx = original_vtx.new_vertex(genv, self)
+              condition_vtx = IsAFilter.new(genv, self, condition_vtx, false, condition.static_ret).next_vtx
+              filtered_vtxs << condition_vtx
+            end
+          end
+
+          # 複数の絞り込み結果をマージして使用
+          if !filtered_vtxs.empty?
+            merged_vtx = Vertex.new(self)
+            filtered_vtxs.each do |vtx|
+              @changes.add_edge(genv, vtx, merged_vtx)
+            end
+            @lenv.set_var(@pivot_var, merged_vtx)
+          end
+        end
+
+        @body.install(genv)
+      end
+
+      # else節での型除外に使用する条件を取得
+      def get_exclusion_conditions
+        @conditions.select {|condition| condition.is_a?(ConstantReadNode) && condition.static_ret }
+                   .map {|condition| condition.static_ret }
+      end
+    end
+
     class CaseNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
         @pivot = raw_node.predicate ? AST.create_node(raw_node.predicate, lenv) : nil
-        @whens = []
-        @clauses = []
-        raw_node.conditions.each do |raw_cond|
-          @whens << AST.create_node(raw_cond.conditions.first, lenv) # XXX: multiple conditions
-          @clauses << (raw_cond.statements ? AST.create_node(raw_cond.statements, lenv) : DummyNilNode.new(code_range, lenv)) # TODO: code_range for NilNode
-        end
+
+        # pivot変数名を決定
+        pivot_var = @pivot.is_a?(LocalVariableReadNode) ? @pivot.var : nil
+
+        @when_nodes = raw_node.conditions.map {|raw_cond| WhenNode.new(raw_cond, lenv, pivot_var) }
         @else_clause = raw_node.else_clause && raw_node.else_clause.statements ? AST.create_node(raw_node.else_clause.statements, lenv) : DummyNilNode.new(code_range, lenv) # TODO: code_range for NilNode
       end
 
-      attr_reader :pivot, :whens, :clauses, :else_clause
+      attr_reader :pivot, :when_nodes, :else_clause
 
-      def subnodes = { pivot:, whens:, clauses:, else_clause: }
+      def subnodes = { pivot:, when_nodes:, else_clause: }
 
       def install0(genv)
         ret = Vertex.new(self)
         @pivot&.install(genv)
-        @whens.zip(@clauses) do |vals, clause|
-          vals.install(genv)
-          @changes.add_edge(genv, clause.install(genv), ret)
+
+        # case文での型絞り込みを実装
+        if @pivot && @pivot.is_a?(LocalVariableReadNode)
+          var = @pivot.var
+          original_vtx = @lenv.get_var(var)
+
+          # ダミー変数に元の型情報を設定
+          @lenv.set_var(:"*pivot", original_vtx)
+
+          # 各when節を実行
+          @when_nodes.each do |when_node|
+            clause_result = when_node.install(genv)
+            @changes.add_edge(genv, clause_result, ret)
+            # 元の型に戻す
+            @lenv.set_var(var, original_vtx)
+          end
+
+          # else節（他のwhen節で除外された後の型）
+          filtered_else_vtx = original_vtx.new_vertex(genv, self)
+          @when_nodes.each do |when_node|
+            when_node.get_exclusion_conditions.each do |static_ret|
+              # 各when節の型を除外（negation）
+              filtered_else_vtx = IsAFilter.new(genv, self, filtered_else_vtx, true, static_ret).next_vtx
+            end
+          end
+          @lenv.set_var(var, filtered_else_vtx)
+          @changes.add_edge(genv, @else_clause.install(genv), ret)
+          @lenv.set_var(var, original_vtx)
+
+          # ダミー変数をクリア
+          @lenv.locals.delete(:"*pivot")
+        else
+          # pivotが変数でない場合は従来通り
+          @when_nodes.each do |when_node|
+            @changes.add_edge(genv, when_node.install(genv), ret)
+          end
+          @changes.add_edge(genv, @else_clause.install(genv), ret)
         end
-        @changes.add_edge(genv, @else_clause.install(genv), ret)
+
         ret
       end
     end
@@ -292,8 +395,9 @@ module TypeProf::Core
     end
 
     class AndNode < Node
-      def initialize(raw_node, e1 = nil, raw_e2 = nil, lenv)
+      def initialize(raw_node, e1 = nil, raw_e2 = raw_node.right, lenv)
         super(raw_node, lenv)
+
         @e1 = e1 || AST.create_node(raw_node.left, lenv)
         @e2 = AST.create_node(raw_e2 || raw_node.right, lenv)
       end
@@ -304,15 +408,39 @@ module TypeProf::Core
 
       def install0(genv)
         ret = Vertex.new(self)
-        @changes.add_edge(genv, @e1.install(genv), ret)
-        @changes.add_edge(genv, @e2.install(genv), ret)
+
+        v1 = @e1.install(genv)
+
+        # For AND: if left side is truthy, apply its narrowing to right side
+        # Use legacy detect_narrowing for now to maintain compatibility
+        then_narrowing, _else_narrowing = @e1.narrowings
+        if then_narrowing
+          v2 = AST.with_narrowing(genv, self, @lenv, then_narrowing) do
+            @e2.install(genv)
+          end
+        else
+          v2 = @e2.install(genv)
+        end
+
+        @changes.add_edge(genv, v1, ret)
+        @changes.add_edge(genv, v2, ret)
+
         ret
       end
+
+      def narrowings
+        @narrowings ||= begin
+          e1_then_narrowing, e1_else_narrowing = @e1.narrowings
+          e2_then_narrowing, e2_else_narrowing = @e2.narrowings
+          [e1_then_narrowing.and(e2_then_narrowing), e1_else_narrowing.or(e2_else_narrowing)]
+        end
+      end
     end
 
     class OrNode < Node
-      def initialize(raw_node, e1 = nil, raw_e2 = nil, lenv)
+      def initialize(raw_node, e1 = nil, raw_e2 = raw_node.right, lenv)
         super(raw_node, lenv)
+
         @e1 = e1 || AST.create_node(raw_node.left, lenv)
         @e2 = AST.create_node(raw_e2 || raw_node.right, lenv)
       end
@@ -323,12 +451,35 @@ module TypeProf::Core
 
       def install0(genv)
         ret = Vertex.new(self)
+
         v1 = @e1.install(genv)
         v1 = NilFilter.new(genv, self, v1, false).next_vtx
+
+        # For OR: if left side is falsy, apply negated narrowing to right side
+        # Use legacy detect_narrowing for now to maintain compatibility
+        _then_narrowing, else_narrowing = @e1.narrowings
+        if else_narrowing
+          # For OR: negated narrowing (negate: true)
+          v2 = AST.with_narrowing(genv, self, @lenv, else_narrowing) do
+            @e2.install(genv)
+          end
+        else
+          v2 = @e2.install(genv)
+        end
+
         @changes.add_edge(genv, v1, ret)
-        @changes.add_edge(genv, @e2.install(genv), ret)
+        @changes.add_edge(genv, v2, ret)
+
         ret
       end
+
+      def narrowings
+        @narrowings ||= begin
+          e1_then_narrowing, e1_else_narrowing = @e1.narrowings
+          e2_then_narrowing, e2_else_narrowing = @e2.narrowings
+          [e1_then_narrowing.or(e2_then_narrowing), e1_else_narrowing.and(e2_else_narrowing)]
+        end
+      end
     end
 
     class ReturnNode < Node
@@ -344,38 +495,86 @@ module TypeProf::Core
       def install0(genv)
         @arg.install(genv)
         e_ret = @lenv.locals[:"*expected_method_ret"]
-        @lenv.add_return_box(@changes.add_escape_box(genv, @arg.ret, e_ret)) if e_ret
+        @lenv.add_return_box(@changes.add_escape_box(genv, @arg.ret)) if e_ret
         Source.new(Type::Bot.new(genv))
       end
     end
 
+    class RescueNode < Node
+      def initialize(raw_node, lenv)
+        super(raw_node, lenv)
+
+        @exceptions = raw_node.exceptions.map {|raw_cond| AST.create_node(raw_cond, lenv) }
+        @statements = AST.create_node(raw_node.statements, lenv) if raw_node.statements
+        if raw_node.reference && @statements
+          @reference = AST.create_target_node(raw_node.reference, @statements.lenv)
+        end
+      end
+
+      attr_reader :exceptions, :reference, :statements
+
+      def subnodes = { exceptions:, reference:, statements: }
+
+      def define0(genv)
+        @exceptions.each {|exc| exc.define(genv) }
+        @reference.define(genv) if @reference
+        @statements.define(genv) if @statements
+      end
+
+      def undefine0(genv)
+        @exceptions.each {|exc| exc.undefine(genv) }
+        @reference.undefine(genv) if @reference
+        @statements.undefine(genv) if @statements
+      end
+
+      def install0(genv)
+        cond_vtxs = @exceptions.map do |exc|
+          case exc
+          when AST::SplatNode
+            ary_vtx = exc.expr.install(genv)
+            @changes.add_splat_box(genv, ary_vtx).ret
+          else
+            exc.install(genv)
+          end
+        end
+
+        if @reference
+          @reference.install(genv)
+          cond_vtxs.each do |cond_vtx|
+            instance_ty_box = @changes.add_instance_type_box(genv, cond_vtx)
+            @changes.add_edge(genv, instance_ty_box.ret, @reference.rhs.ret)
+          end
+        end
+
+        if @statements
+          @statements.install(genv)
+        else
+          Source.new(genv.nil_type)
+        end
+      end
+    end
+
     class BeginNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
         @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(code_range, lenv)
-        @rescue_conds = []
+
         @rescue_clauses = []
         raw_res = raw_node.rescue_clause
         while raw_res
-          raw_res.exceptions.each do |raw_cond|
-            @rescue_conds << AST.create_node(raw_cond, lenv)
-          end
-          if raw_res.statements
-            @rescue_clauses << AST.create_node(raw_res.statements, lenv)
-          end
+          @rescue_clauses << AST.create_node(raw_res, lenv)
           raw_res = raw_res.subsequent
         end
-        @else_clause = raw_node.else_clause ? AST.create_node(raw_node.else_clause.statements, lenv) : DummyNilNode.new(code_range, lenv)
-        @ensure_clause = raw_node.ensure_clause ? AST.create_node(raw_node.ensure_clause.statements, lenv) : DummyNilNode.new(code_range, lenv)
+        @else_clause = AST.create_node(raw_node.else_clause.statements, lenv) if raw_node.else_clause&.statements
+        @ensure_clause = AST.create_node(raw_node.ensure_clause.statements, lenv) if raw_node.ensure_clause&.statements
       end
 
-      attr_reader :body, :rescue_conds, :rescue_clauses, :else_clause, :ensure_clause
+      attr_reader :body, :rescue_clauses, :else_clause, :ensure_clause
 
-      def subnodes = { body:, rescue_conds:, rescue_clauses:, else_clause:, ensure_clause: }
+      def subnodes = { body:, rescue_clauses:, else_clause:, ensure_clause: }
 
       def define0(genv)
         @body.define(genv)
-        @rescue_conds.each {|cond| cond.define(genv) }
         @rescue_clauses.each {|clause| clause.define(genv) }
         @else_clause.define(genv) if @else_clause
         @ensure_clause.define(genv) if @ensure_clause
@@ -383,7 +582,6 @@ module TypeProf::Core
 
       def undefine0(genv)
         @body.undefine(genv)
-        @rescue_conds.each {|cond| cond.undefine(genv) }
         @rescue_clauses.each {|clause| clause.undefine(genv) }
         @else_clause.undefine(genv) if @else_clause
         @ensure_clause.undefine(genv) if @ensure_clause
@@ -391,11 +589,88 @@ module TypeProf::Core
 
       def install0(genv)
         ret = Vertex.new(self)
+
+        vars = []
+        @body.modified_vars(@lenv.locals.keys, vars) if @body
+        vars.uniq!
+
+        old_vtxs = {}
+        vars.each do |var|
+          vtx = @lenv.get_var(var)
+          old_vtxs[var] = vtx
+        end
+
         @changes.add_edge(genv, @body.install(genv), ret)
-        @rescue_conds.each {|cond| cond.install(genv) }
-        @rescue_clauses.each {|clause| @changes.add_edge(genv, clause.install(genv), ret) }
-        @changes.add_edge(genv, @else_clause.install(genv), ret) if @else_clause
-        @ensure_clause.install(genv) if @ensure_clause
+
+        body_vtxs = {}
+        vars.each do |var|
+          body_vtxs[var] = @lenv.get_var(var)
+        end
+
+        clause_vtxs_list = []
+        @rescue_clauses.each do |clause|
+          vars.each do |var|
+            old_vtx = old_vtxs[var]
+            nvtx = old_vtx.new_vertex(genv, self)
+
+            @changes.add_edge(genv, body_vtxs[var], nvtx) unless body_vtxs[var] == old_vtxs[var]
+
+            @lenv.set_var(var, nvtx)
+          end
+
+          @changes.add_edge(genv, clause.install(genv), ret)
+
+          clause_vtxs_list << {}
+          vars.each do |var|
+            clause_vtxs_list.last[var] = @lenv.get_var(var)
+          end
+        end
+
+        if @else_clause
+          vars.each do |var|
+            @lenv.set_var(var, body_vtxs[var])
+          end
+          @changes.add_edge(genv, @else_clause.install(genv), ret)
+          clause_vtxs_list << {}
+          vars.each do |var|
+            clause_vtxs_list.last[var] = @lenv.get_var(var)
+          end
+        end
+
+        if @ensure_clause
+          vars.each do |var|
+            union_vtx = old_vtxs[var].new_vertex(genv, self)
+            @changes.add_edge(genv, body_vtxs[var], union_vtx)
+            clause_vtxs_list.each do |clause_vtx|
+              @changes.add_edge(genv, clause_vtx[var], union_vtx)
+            end
+            @lenv.set_var(var, union_vtx)
+          end
+
+          @ensure_clause.install(genv)
+
+          clause_vtxs_list << {}
+          vars.each do |var|
+            clause_vtxs_list.last[var] = @lenv.get_var(var)
+          end
+        end
+
+        result_vtxs = {}
+        vars.each do |var|
+          result_vtx = old_vtxs[var].new_vertex(genv, self)
+          result_vtxs[var] = result_vtx
+
+          @changes.add_edge(genv, body_vtxs[var], result_vtx) unless body_vtxs[var] == old_vtxs[var]
+
+          clause_vtxs_list.each do |clause_vtx|
+            @changes.add_edge(genv, clause_vtx[var], result_vtx)
+          end
+        end
+
+        vars.each do |var|
+          @lenv.set_var(var, result_vtxs[var])
+        end
+
         ret
       end
     end

data/lib/typeprof/core/ast/meta.rb

@@ -6,7 +6,9 @@ module TypeProf::Core
         # TODO: error for splat
         @args = raw_node.arguments.arguments.map do |raw_arg|
           next if raw_arg.is_a?(Prism::SplatNode)
-          AST.create_node(raw_arg, lenv)
+          lenv.use_strict_const_scope do
+            AST.create_node(raw_arg, lenv)
+          end
         end.compact
         # TODO: error for non-LIT
         # TODO: fine-grained hover
@@ -77,8 +79,7 @@ module TypeProf::Core
         @args.each do |arg|
           ivar_name = :"@#{ arg }"
           ivar_box = @changes.add_ivar_read_box(genv, @lenv.cref.cpath, false, ivar_name)
-          e_ret = Vertex.new(self)
-          ret_box = @changes.add_escape_box(genv, ivar_box.ret, e_ret)
+          ret_box = @changes.add_escape_box(genv, ivar_box.ret)
           @changes.add_method_def_box(genv, @lenv.cref.cpath, false, arg, FormalArguments::Empty, [ret_box])
         end
         Source.new
@@ -134,8 +135,7 @@ module TypeProf::Core
       def install0(genv)
         @args.zip(@static_ret) do |arg, ive|
           ivar_box = @changes.add_ivar_read_box(genv, @lenv.cref.cpath, false, :"@#{ arg }")
-          e_ret = Vertex.new(self)
-          ret_box = @changes.add_escape_box(genv, ivar_box.ret, e_ret)
+          ret_box = @changes.add_escape_box(genv, ivar_box.ret)
           @changes.add_method_def_box(genv, @lenv.cref.cpath, false, arg, FormalArguments::Empty, [ret_box])
 
           vtx = Vertex.new(self)

data/lib/typeprof/core/ast/method.rb

@@ -64,7 +64,7 @@ module TypeProf::Core
 
       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,11 @@ module TypeProf::Core
 
       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 = :"..."
+        rest_keywords = :"..."
       when Prism::NoKeywordsParameterNode
         # what to do?
       when nil
@@ -91,7 +95,7 @@ module TypeProf::Core
         raise "unexpected keyword rest: #{ raw_args.keyword_rest.class }"
       end
 
-      block = raw_args.block.name if raw_args.block
+      block = raw_args.block.name || :"*anonymous_block" if raw_args.block
 
       {
         req_positionals:,
@@ -220,6 +224,16 @@ module TypeProf::Core
         rest_keywords = @rest_keywords ? @body.lenv.new_var(@rest_keywords, self) : nil
         block = @block ? @body.lenv.new_var(@block, self) : nil
 
+        if rest_positionals
+          @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
@@ -234,9 +248,9 @@ module TypeProf::Core
         end
 
         if @body
-          e_ret = @body.lenv.locals[:"*expected_method_ret"] = Vertex.new(self)
+          @body.lenv.locals[:"*expected_method_ret"] = Vertex.new(self)
           @body.install(genv)
-          @body.lenv.add_return_box(@changes.add_escape_box(genv, @body.ret, e_ret))
+          @body.lenv.add_return_box(@changes.add_escape_box(genv, @body.ret))
         end
 
         f_args = FormalArguments.new(