typeprof 0.33.1 → 0.33.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5fa5ffcf2f4e98328b77be29d4e14574083acd097b9af8bac36c2f8e1113626
-  data.tar.gz: e4a075b8befec5fbf855d4c83cb17c66db0e0441d1e964249b82072a21b40f93
+  metadata.gz: 88b4b5188230ac4fb6ab7b45bf924f94271d93d1664219f35414873283a9ef5b
+  data.tar.gz: f20527a6973ccd740f1c7b8b045216f1ad3d5e757a1262fc00ddd86dd8d2d1cd
 SHA512:
-  metadata.gz: 15d81769ed88b1f1ae097a913a8bc2f4912a36fb792900f86ef4071fe8e04edf1268fb84540e0a56bbc0c30ddeed12b7965aceb1e14fe5917557909146a936f5
-  data.tar.gz: a1ceade33cf5282b8d117dba231a0a59121a2d32865a8bdea17b5b44adb25f4eee53534a4c14b67a3442a1538557430408662b1802aa6769085a37a39a4c7db5
+  metadata.gz: e977f6ef1c6927bb6f85f366af885d6e8b2768d6f26226bf7065ad8a5fbb55ba6537463109d722e112d3be0c77f2523f195a2515118c8cc943a19d71f2f6976f
+  data.tar.gz: 3a757a2cf9d5fe5ea21c0080e10ccc0c93b37e4c54a3508e1b7e4ce808d40b7d713355aa1bb8ca943ffe33b8dd3eb47c7b9169d725d3f699d531d9b711aa7136

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

@@ -218,6 +218,20 @@ module TypeProf::Core
         end
       end
 
+      # Where a diagnostic about the value this node yields is placed: a node
+      # with a body points at the body's last statement, the rest at itself.
+      def ret_code_range = code_range
+
+      def install_multi_targets(genv, multi_targets, positionals, lenv)
+        multi_targets.each do |idx, raw_multi_target|
+          param_vtx = positionals[idx]
+          lefts = raw_multi_target.lefts.map do |n|
+            lenv.new_var(n.is_a?(Prism::MultiTargetNode) ? nil : n.name, self)
+          end
+          @changes.add_masgn_box(genv, param_vtx, lefts, nil, nil)
+        end
+      end
+
       def pretty_print_instance_variables
         super() - [:@raw_node, :@lenv, :@prev_node, :@static_ret, :@changes]
       end

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

@@ -1,6 +1,155 @@
 module TypeProf::Core
   class AST
+    # @lenv is the scope the block closes over; the body has its own LocalEnv.
+    class BlockNode < Node
+      def initialize(raw_node, lenv, method_body: false)
+        super(raw_node, lenv)
+
+        @tbl = raw_node.locals
+        # A `super` in a block calls the super of the enclosing method, but a
+        # block given to define_method is the body of another method, whose name
+        # is not known here
+        ncref = CRef.new(lenv.cref.cpath, :instance, method_body ? nil : lenv.cref.mid, lenv.cref, in_method: method_body || lenv.cref.in_method)
+        # A `return` in a block exits the enclosing method, so the body writes into
+        # its return boxes. A lambda's `return` exits the lambda, so it gets its own.
+        nlenv = LocalEnv.new(lenv.file_context, ncref, {}, lambda? ? [] : lenv.return_boxes)
+
+        # parse_params with no parameters returns the canonical empty set, so the
+        # readers below never have to ask whether there were any.
+        @params = AST.parse_params(@tbl, nil, nlenv)
+        @f_args = []
+        @multi_targets = {}
+        @opt_positional_defaults = []
+        case raw_node.parameters
+        when Prism::BlockParametersNode
+          # `{ || ... }` (empty pipes) and `{ |; x| ... }` (block-local-only)
+          # yield BlockParametersNode whose inner `parameters` is nil.
+          @params = AST.parse_params(@tbl, raw_node.parameters.parameters, nlenv)
+          @f_args = @params[:req_positionals] + @params[:opt_positionals]
+          @multi_targets = @params[:req_multi_targets]
+          @opt_positional_defaults = @params[:opt_positional_defaults]
+        when Prism::NumberedParametersNode
+          @f_args = 1.upto(raw_node.parameters.maximum).map {|n| :"_#{n}" }
+        when Prism::ItParametersNode
+          @f_args = [:it]
+        when nil
+        else
+          raise "not supported yet: #{ raw_node.parameters.class }"
+        end
+        @body = raw_node.body ? AST.create_node(raw_node.body, nlenv) : DummyNilNode.new(code_range, nlenv)
+      end
+
+      attr_reader :tbl, :f_args, :opt_positional_defaults, :body
+
+      # FormalArguments carries vertices; the keyword names stay on the node, which
+      # is where FormalArguments#pass_arguments looks them up.
+      def req_keywords = @params[:req_keywords]
+      def opt_keywords = @params[:opt_keywords]
+      def rest_keywords = @params[:rest_keywords]
+      def opt_keyword_defaults = @params[:opt_keyword_defaults]
+      def no_keywords = @params[:no_keywords]
+
+      def subnodes = { opt_positional_defaults:, body:, opt_keyword_defaults: }
+      # f_args covers only the parameters a block binds, so the rest have to be
+      # compared too or an edit that only touches them looks like no edit at all.
+      def attrs = { tbl:, f_args:, formal_names: }
+
+      def formal_names
+        @params.values_at(
+          :req_positionals, :opt_positionals, :rest_positionals, :post_positionals,
+          :req_keywords, :opt_keywords, :rest_keywords, :block,
+        )
+      end
+
+      def install0(genv)
+        blenv = @body.lenv
+        # `...` in a define_method block still forwards the enclosing method's
+        # arguments; a bare `super` there is rejected in CallBaseNode#install0
+        blenv.forward_args = @lenv.forward_args
+        # An outer block may have shadowed the same name already; its entry is
+        # the method's variable, so it must win over the outer block's own one
+        blenv.shadowed_vars = @lenv.locals.slice(*@tbl).merge(@lenv.shadowed_vars)
+        @lenv.locals.each {|var, vtx| blenv.locals[var] = vtx }
+        @tbl.each {|var| blenv.locals[var] = Source.new(genv.nil_type) }
+        blenv.locals[:"*self"] = blenv.cref.get_self(genv)
+
+        f_args = @f_args.map {|arg| blenv.new_var(arg, self) }
+
+        req_count = f_args.size - @opt_positional_defaults.size
+        @opt_positional_defaults.each_with_index do |expr, i|
+          @changes.add_edge(genv, expr.install(genv), f_args[req_count + i])
+        end
+
+        install_multi_targets(genv, @multi_targets, f_args, blenv)
+        formals = build_formals(genv, blenv, f_args)
+
+        @lenv.locals.each do |var, vtx|
+          blenv.set_var(var, vtx)
+        end
+        vars = []
+        @body.modified_vars(@lenv.locals.keys - @tbl, vars)
+        vars.uniq!
+        vars.each do |var|
+          vtx = @lenv.get_var(var)
+          nvtx = vtx.new_vertex(genv, self)
+          @lenv.set_var(var, nvtx)
+          blenv.set_var(var, nvtx)
+        end
+
+        blenv.locals[:"*expected_block_ret"] = Vertex.new(self)
+        # Present already when the lambda sits in a method; a top-level one still
+        # needs it, or ReturnNode drops the returned value on the floor.
+        blenv.locals[:"*expected_method_ret"] ||= Vertex.new(self) if lambda?
+        @body.install(genv)
+        blenv.add_next_box(@changes.add_escape_box(genv, @body.ret))
+
+        if lambda?
+          # `return` and `break` leave the lambda itself, so they reach the caller
+          # of #call the same way the body's own value does.
+          blenv.return_boxes.each {|box| blenv.add_next_box(box) }
+          blenv.add_next_box(@changes.add_escape_box(genv, blenv.break_vtx)) if blenv.break_vtx
+        end
+
+        vars.each do |var|
+          @changes.add_edge(genv, blenv.get_var(var), @lenv.get_var(var))
+        end
+
+        f_ary_arg = Vertex.new(self)
+        # TODO: support splat "do |a, *b, c|"
+        f_args.each_with_index do |f_arg, i|
+          elem_vtx = @changes.add_splat_box(genv, f_ary_arg, i).ret
+          @changes.add_edge(genv, elem_vtx, f_arg)
+        end
+        block = Block.new(self, f_ary_arg, f_args, blenv.next_boxes, formals)
+        Source.new(Type::Proc.new(genv, block))
+      end
+
+      # A block is yielded to, and what a yielding method passes is the positional
+      # list alone; there are no formals to bind beyond it. Keyword defaults are
+      # still code in the block, so they are analyzed without being bound.
+      def build_formals(genv, blenv, f_args)
+        opt_keyword_defaults.each {|expr| expr.install(genv) }
+        nil
+      end
+
+      # Block-local variables shadow the outer ones, so writes to them are not
+      # modifications of the enclosing scope.
+      def modified_vars(tbl, vars)
+        super(tbl - @tbl, vars)
+      end
+
+      # A block's `break` leaves the method that yielded, so the call it belongs to
+      # takes the value; a lambda's `break` leaves the lambda and is wired above.
+      def lambda? = false
+
+      def break_vtx = lambda? ? nil : @body.lenv.break_vtx
+
+      def ret_code_range = @body.ret_code_range
+    end
+
     class CallBaseNode < Node
+      DEFINE_METHOD_MIDS = [:define_method, :define_singleton_method].freeze
+
       def initialize(raw_node, recv, mid, mid_code_range_loc, raw_args, last_arg, raw_block, lenv, forwarding_arguments: false)
         super(raw_node, lenv)
 
@@ -14,10 +163,7 @@ module TypeProf::Core
         @keyword_args = nil
 
         @block_pass = nil
-        @block_tbl = nil
-        @block_f_args = nil
-        @block_opt_positional_defaults = nil
-        @block_body = nil
+        @block = nil
         @safe_navigation = raw_node.respond_to?(:safe_navigation?) && raw_node.safe_navigation?
         @anonymous_block_forwarding = false
         @forwarding_arguments = forwarding_arguments
@@ -55,47 +201,7 @@ module TypeProf::Core
               @anonymous_block_forwarding = true
             end
           else
-            @block_pass = nil
-            @block_tbl = raw_block.locals
-            @block_multi_targets = {}
-            @block_f_args = case raw_block.parameters
-                            when Prism::BlockParametersNode
-                              # `{ || ... }` (empty pipes) and `{ |; x| ... }`
-                              # (block-local-only) yield BlockParametersNode
-                              # whose inner `parameters` is nil.
-                              params = raw_block.parameters.parameters
-                              if params
-                                req = params.requireds.each_with_index.map do |n, i|
-                                  if n.is_a?(Prism::MultiTargetNode)
-                                    @block_multi_targets[i] = n
-                                    nil
-                                  else
-                                    n.name
-                                  end
-                                end
-                                opt = params.optionals.map {|n| n.name }
-                                req + opt
-                              else
-                                []
-                              end
-                            when Prism::NumberedParametersNode
-                              1.upto(raw_block.parameters.maximum).map { |n| :"_#{n}" }
-                            when Prism::ItParametersNode
-                              [:it]
-                            when nil
-                              []
-                            else
-                              raise "not supported yet: #{ raw_block.parameters.class }"
-                            end
-            ncref = CRef.new(lenv.cref.cpath, :instance, @mid, lenv.cref)
-            nlenv = LocalEnv.new(@lenv.file_context, ncref, {}, @lenv.return_boxes)
-            @block_opt_positional_defaults = []
-            if raw_block.parameters.is_a?(Prism::BlockParametersNode) && raw_block.parameters.parameters
-              raw_block.parameters.parameters.optionals.each do |n|
-                @block_opt_positional_defaults << AST.create_node(n.value, nlenv)
-              end
-            end
-            @block_body = raw_block.body ? AST.create_node(raw_block.body, nlenv) : DummyNilNode.new(code_range, lenv)
+            @block = BlockNode.new(raw_block, lenv, method_body: DEFINE_METHOD_MIDS.include?(@mid))
           end
         end
 
@@ -108,12 +214,11 @@ module TypeProf::Core
         @mid_code_range ||= @lenv.code_range_from_node(@mid_code_range_loc) if @mid_code_range_loc
       end
       attr_reader :positional_args, :splat_flags, :keyword_args
-      attr_reader :block_tbl, :block_f_args, :block_opt_positional_defaults, :block_body, :block_pass, :anonymous_block_forwarding
-      attr_reader :block_multi_targets
+      attr_reader :block, :block_pass, :anonymous_block_forwarding
       attr_reader :safe_navigation, :forwarding_arguments
 
-      def subnodes = { recv:, positional_args:, keyword_args:, block_opt_positional_defaults:, block_body:, block_pass: }
-      def attrs = { mid:, splat_flags:, block_tbl:, block_f_args:, yield:, safe_navigation:, anonymous_block_forwarding:, forwarding_arguments: }
+      def subnodes = { recv:, positional_args:, keyword_args:, block:, block_pass: }
+      def attrs = { mid:, splat_flags:, yield:, safe_navigation:, anonymous_block_forwarding:, forwarding_arguments: }
 
       def install0(genv)
         recv = @recv ? @recv.install(genv) : @yield ? @lenv.get_var(:"*given_block") : @lenv.get_var(:"*self")
@@ -123,14 +228,27 @@ module TypeProf::Core
           recv = NilFilter.new(genv, self, recv, false).next_vtx
         end
 
-        if @forwarding_arguments
-          forward_a_args = (@lenv.forward_args || raise).to_actual_arguments(
-            genv,
-            @changes,
-            self,
-            include_leading_positionals: @forwarding_arguments != :rest,
-            activation_required: @forwarding_arguments == :rest,
-          )
+        if @mid == :"*super"
+          if !@lenv.cref.in_method
+            @changes.add_diagnostic(:code_range, "super called outside of method")
+          elsif @forwarding_arguments && !@lenv.cref.mid
+            # A define_method block: the arguments of the enclosing method, if any,
+            # are not the ones a bare `super` would pass
+            @changes.add_diagnostic(:code_range, "implicit argument passing of super from method defined by define_method() is not supported")
+          end
+        end
+
+        if @forwarding_arguments && (@mid != :"*super" || @lenv.cref.mid)
+          forward_args = @lenv.forward_args
+        end
+
+        if forward_args
+          forward_a_args =
+            if @forwarding_arguments == :all
+              forward_args.to_implicit_super_arguments(genv, @changes, self, @lenv)
+            else
+              forward_args.to_actual_arguments(genv, @changes, self)
+            end
           # An anonymous rest cannot appear here: `bar(*, ...)` is a syntax error
           leading_args = @positional_args.map {|arg| arg.install(genv) }
           a_args = forward_a_args.prepend_positionals(leading_args, @splat_flags)
@@ -146,87 +264,27 @@ module TypeProf::Core
           a_args = ActualArguments.new(positional_args, @splat_flags, @keyword_args ? @keyword_args.install(genv) : nil, nil)
         end
 
-        if @block_body
-          block_body = @block_body # kinda type annotationty
-          block_tbl = @block_tbl || raise
-          block_body.lenv.forward_args = @lenv.forward_args
-          @lenv.locals.each {|var, vtx| block_body.lenv.locals[var] = vtx }
-          block_tbl.each {|var| block_body.lenv.locals[var] = Source.new(genv.nil_type) }
-          block_body.lenv.locals[:"*self"] = block_body.lenv.cref.get_self(genv)
-
-          blk_f_args = []
-          if @block_f_args
-            @block_f_args.each do |arg|
-              blk_f_args << block_body.lenv.new_var(arg, self)
-            end
-          end
-
-          if @block_opt_positional_defaults && !@block_opt_positional_defaults.empty?
-            req_count = blk_f_args.size - @block_opt_positional_defaults.size
-            @block_opt_positional_defaults.each_with_index do |expr, i|
-              @changes.add_edge(genv, expr.install(genv), blk_f_args[req_count + i])
-            end
-          end
-
-          if @block_multi_targets
-            @block_multi_targets.each do |idx, raw_multi_target|
-              param_vtx = blk_f_args[idx]
-              lefts = raw_multi_target.lefts.map do |n|
-                block_body.lenv.new_var(n.is_a?(Prism::MultiTargetNode) ? nil : n.name, self)
-              end
-              @changes.add_masgn_box(genv, param_vtx, lefts, nil, nil)
-            end
-          end
-
-          @lenv.locals.each do |var, vtx|
-            block_body.lenv.set_var(var, vtx)
-          end
-          vars = []
-          block_body.modified_vars(@lenv.locals.keys - block_tbl, vars)
-          vars.uniq!
-          vars.each do |var|
-            vtx = @lenv.get_var(var)
-            nvtx = vtx.new_vertex(genv, self)
-            @lenv.set_var(var, nvtx)
-            block_body.lenv.set_var(var, nvtx)
-          end
-
-          block_body.lenv.locals[:"*expected_block_ret"] = Vertex.new(self)
-          block_body.install(genv)
-          block_body.lenv.add_next_box(@changes.add_escape_box(genv, block_body.ret))
-
-          vars.each do |var|
-            @changes.add_edge(genv, block_body.lenv.get_var(var), @lenv.get_var(var))
-          end
-
-          blk_f_ary_arg = Vertex.new(self)
-          # TODO: support splat "do |a, *b, c|"
-          blk_f_args.each_with_index do |f_arg, i|
-            elem_vtx = @changes.add_splat_box(genv, blk_f_ary_arg, i).ret
-            @changes.add_edge(genv, elem_vtx, f_arg)
-          end
-          block = Block.new(self, blk_f_ary_arg, blk_f_args, block_body.lenv.next_boxes)
-          blk_ty = Source.new(Type::Proc.new(genv, block))
+        if @block
+          blk_ty = @block.install(genv)
         elsif @block_pass
           blk_ty = @block_pass.install(genv)
         elsif @anonymous_block_forwarding
           blk_ty = @lenv.get_var(:"*anonymous_block")
-        elsif @forwarding_arguments
+        elsif forward_args
           blk_ty = forward_a_args.block
         end
 
-        if @forwarding_arguments
-          a_args = a_args.with_block(blk_ty, omittable: !@block_body && !@block_pass && !@anonymous_block_forwarding)
+        if forward_args
+          a_args = a_args.with_block(blk_ty, omittable: !@block && !@block_pass && !@anonymous_block_forwarding)
         else
           a_args = a_args.with_block(blk_ty)
         end
         box = @changes.add_method_call_box(genv, recv, @mid, a_args, !@recv)
 
-        block_body = @block_body
-        if block_body && block_body.lenv.break_vtx
+        if @block && @block.break_vtx
           ret = Vertex.new(self)
           @changes.add_edge(genv, box.ret, ret)
-          @changes.add_edge(genv, block_body.lenv.break_vtx, ret)
+          @changes.add_edge(genv, @block.break_vtx, ret)
         else
           ret = box.ret
         end
@@ -238,18 +296,6 @@ module TypeProf::Core
         ret
       end
 
-      def block_last_stmt_code_range
-        if @block_body
-          if @block_body.is_a?(AST::StatementsNode)
-            @block_body.stmts.last.code_range
-          else
-            @block_body.code_range
-          end
-        else
-          nil
-        end
-      end
-
       def retrieve_at(pos, &blk)
         yield self if mid_code_range&.include?(pos)
         each_subnode do |subnode|
@@ -258,20 +304,6 @@ module TypeProf::Core
         end
       end
 
-      def modified_vars(tbl, vars)
-        subnodes.each do |key, subnode|
-          next unless subnode
-          if subnode.is_a?(AST::Node)
-            if key == :block_body
-              subnode.modified_vars(tbl - self.block_tbl, vars)
-            else
-              subnode.modified_vars(tbl, vars)
-            end
-          else
-            subnode.each {|n| n&.modified_vars(tbl, vars) }
-          end
-        end
-      end
     end
 
     class CallNode < CallBaseNode

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

@@ -620,8 +620,13 @@ module TypeProf::Core
       def install0(genv)
         ret = Vertex.new(self)
 
+        retrying_clauses = @rescue_clauses.select {|clause| has_retry?(clause) }
+
         vars = []
         @body.modified_vars(@lenv.locals.keys, vars) if @body
+        unless retrying_clauses.empty?
+          retrying_clauses.each {|clause| clause.modified_vars(@lenv.locals.keys, vars) }
+        end
         vars.uniq!
 
         old_vtxs = {}
@@ -630,6 +635,17 @@ module TypeProf::Core
           old_vtxs[var] = vtx
         end
 
+        retry_vtxs = {}
+        unless retrying_clauses.empty?
+          # A retry starts the begin body again with the locals from the rescue clause.
+          vars.each do |var|
+            vtx = Vertex.new(self)
+            @changes.add_edge(genv, old_vtxs[var], vtx)
+            retry_vtxs[var] = vtx
+            @lenv.set_var(var, vtx)
+          end
+        end
+
         @changes.add_edge(genv, @body.install(genv), ret)
 
         body_vtxs = {}
@@ -639,12 +655,14 @@ module TypeProf::Core
 
         clause_vtxs_list = []
         @rescue_clauses.each do |clause|
+          rescue_input_vtxs = {}
           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]
 
+            rescue_input_vtxs[var] = nvtx
             @lenv.set_var(var, nvtx)
           end
 
@@ -654,6 +672,14 @@ module TypeProf::Core
           vars.each do |var|
             clause_vtxs_list.last[var] = @lenv.get_var(var)
           end
+
+          if retrying_clauses.include?(clause)
+            vars.each do |var|
+              # Avoid a redundant cycle when neither the body nor rescue changes this local.
+              next if clause_vtxs_list.last[var] == rescue_input_vtxs[var] && body_vtxs[var] == retry_vtxs[var]
+              @changes.add_edge(genv, clause_vtxs_list.last[var], retry_vtxs[var])
+            end
+          end
         end
 
         if @else_clause
@@ -703,6 +729,25 @@ module TypeProf::Core
 
         ret
       end
+
+      private
+
+      def has_retry?(root)
+        nodes = [root]
+        until nodes.empty?
+          node = nodes.pop
+          next if node != root && (node.is_a?(DefNode) || node.is_a?(LambdaNode))
+          if node != root && node.is_a?(BeginNode)
+            # Its body and else remain in this retry scope; its rescue clauses form a new one.
+            nodes << node.body
+            nodes << node.else_clause if node.else_clause
+            next
+          end
+          return true if node.is_a?(RetryNode)
+          node.each_subnode {|subnode| nodes << subnode }
+        end
+        false
+      end
     end
 
     class RetryNode < Node

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

@@ -305,8 +305,9 @@ module TypeProf::Core
       def attrs = { static_cpath:, members:, kind: }
 
       # Interface expected by MethodDefBox
-      def req_positionals = @kind == :struct ? @members : []
-      def opt_positionals = []
+      def req_positionals = []
+      # Struct.new(:x).new is valid, so every member is optional
+      def opt_positionals = @kind == :struct ? @members : []
       def rest_positionals = nil
       def post_positionals = []
       def req_keywords = @kind == :data ? @members : []
@@ -323,6 +324,15 @@ module TypeProf::Core
           ive = genv.resolve_ivar(struct_base_cpath, false, member)
           ive.add_def(self)
         end
+        if @kind == :struct
+          # Struct.[] calls the receiver's initialize, like Class#new
+          me = genv.resolve_method(struct_base_cpath, true, :[])
+          unless me.builtin
+            me.builtin = Builtin.new(genv).method(:class_new)
+            # Unlike a method definition, a builtin does not notify the calls itself
+            me.add_run_all_method_call_boxes(genv)
+          end
+        end
         @block_body.define(genv) if @block_body
         cdef
       end
@@ -345,11 +355,18 @@ module TypeProf::Core
       def undefine0(genv)
         mod = genv.resolve_cpath(@static_cpath)
         mod.remove_module_def(genv, self)
-        genv.resolve_cpath(struct_base_cpath).remove_module_def(genv, self)
+        base = genv.resolve_cpath(struct_base_cpath)
+        base.remove_module_def(genv, self)
         @members.each do |member|
           ive = genv.resolve_ivar(struct_base_cpath, false, member)
           ive.remove_def(self)
         end
+        # On an update, the new node has already set the builtin
+        if base.module_defs.to_a.none? { _1.kind == :struct }
+          me = genv.resolve_method(struct_base_cpath, true, :[])
+          me.builtin = nil
+          me.add_run_all_method_call_boxes(genv)
+        end
         @block_body.undefine(genv) if @block_body
       end
 
@@ -388,20 +405,13 @@ module TypeProf::Core
         end
         init_ret = @changes.add_escape_box(genv, Source.new(genv.nil_type))
         if @kind == :struct
-          init_f_args = FormalArguments.new(init_vtxs, [], nil, [], [], [], nil, nil)
+          init_f_args = FormalArguments.new([], init_vtxs, nil, [], [], [], nil, nil)
         else
           # Data.define uses keyword arguments
           init_f_args = FormalArguments.new([], [], nil, [], init_vtxs, [], nil, nil)
         end
         @changes.add_method_def_box(genv, cpath, false, :initialize, init_f_args, [init_ret])
 
-        # Struct.[] is an alias for Struct.new
-        if @kind == :struct
-          # Struct.[] builds the struct class itself, not the base class
-          self_ret = @changes.add_escape_box(genv, Source.new(Type::Instance.new(genv, genv.resolve_cpath(@static_cpath), [])))
-          @changes.add_method_def_box(genv, cpath, true, :[], init_f_args, [self_ret])
-        end
-
         # Install block body (additional method definitions)
         if @block_body
           @block_body.lenv.locals[:"*self"] = @block_body.lenv.cref.get_self(genv)

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

@@ -77,7 +77,17 @@ module TypeProf::Core
         end
       end
 
-      rest_positionals = raw_args.rest ? (raw_args.rest.name || :"*anonymous_rest") : nil
+      rest_positionals =
+        case raw_args.rest
+        when nil
+          nil
+        when Prism::ImplicitRestNode
+          # `{ |a,| }`. The trailing comma says there is a rest without naming
+          # it, so the node carries no name to ask for.
+          :"*anonymous_rest"
+        else
+          raw_args.rest.name || :"*anonymous_rest"
+        end
 
       req_keywords = []
       opt_keywords = []
@@ -244,8 +254,8 @@ module TypeProf::Core
         opt_positionals = @opt_positionals.map {|var| @body.lenv.new_var(var, self) }
         rest_positionals = @rest_positionals ? @body.lenv.new_var(@rest_positionals, self) : nil
         post_positionals = @post_positionals.map {|var| @body.lenv.new_var(var, self) }
-        install_multi_targets(genv, @req_multi_targets, req_positionals)
-        install_multi_targets(genv, @post_multi_targets, post_positionals)
+        install_multi_targets(genv, @req_multi_targets, req_positionals, @body.lenv)
+        install_multi_targets(genv, @post_multi_targets, post_positionals, @body.lenv)
         req_keywords = @req_keywords.map {|var| @body.lenv.new_var(var, self) }
         opt_keywords = @opt_keywords.map {|var| @body.lenv.new_var(var, self) }
         rest_keywords = @rest_keywords ? @body.lenv.new_var(@rest_keywords, self) : nil
@@ -290,6 +300,17 @@ module TypeProf::Core
           forward_rest_keywords,
           forward_block,
           forward_activation,
+          {
+            req_positionals: @req_positionals,
+            opt_positionals: @opt_positionals,
+            # The variables of `...` and anonymous parameters hold only a
+            # placeholder, so what the caller passed is forwarded instead
+            rest_positionals: [:"...", :"*anonymous_rest"].include?(@rest_positionals) ? nil : @rest_positionals,
+            post_positionals: @post_positionals,
+            req_keywords: @req_keywords,
+            opt_keywords: @opt_keywords,
+            rest_keywords: [:"...", :"**anonymous_keyword"].include?(@rest_keywords) ? nil : @rest_keywords,
+          },
         )
 
         if @body
@@ -317,27 +338,7 @@ module TypeProf::Core
         Source.new(Type::Symbol.new(genv, @mid))
       end
 
-      def install_multi_targets(genv, multi_targets, positionals)
-        multi_targets.each do |idx, raw_multi_target|
-          param_vtx = positionals[idx]
-          lefts = raw_multi_target.lefts.map do |n|
-            @body.lenv.new_var(n.is_a?(Prism::MultiTargetNode) ? nil : n.name, self)
-          end
-          @changes.add_masgn_box(genv, param_vtx, lefts, nil, nil)
-        end
-      end
-
-      def last_stmt_code_range
-        if @body
-          if @body.is_a?(AST::StatementsNode)
-            @body.stmts.last.code_range
-          else
-            @body.code_range
-          end
-        else
-          nil
-        end
-      end
+      def ret_code_range = @body.ret_code_range
 
       def retrieve_at(pos, &blk)
         if @rbs_method_type