typeprof 0.33.1 → 0.33.2

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

@@ -16,6 +16,8 @@ module TypeProf::Core
 
       attr_reader :stmts
 
+      def ret_code_range = @stmts.last.code_range
+
       def subnodes = { stmts: }
 
       def install0(genv)
@@ -23,8 +25,13 @@ module TypeProf::Core
 
         post_stmts = []
 
+        # BEGIN runs before the surrounding statements, END after them
+        @stmts.each do |stmt|
+          stmt.install(genv) if stmt.is_a?(PreExecutionNode)
+        end
+
         @stmts.each do |stmt|
-          next if stmt.nil?
+          next if stmt.is_a?(PreExecutionNode)
 
           if stmt.is_a?(PostExecutionNode)
             post_stmts << stmt
@@ -126,7 +133,7 @@ module TypeProf::Core
         if @rights
           @rights.each {|lhs| lhs.install(genv) }
           @rights.each {|lhs| lhs.rhs.ret || raise(lhs.rhs.inspect) }
-          rights = @rights.map {|rhs| rhs.ret }
+          rights = @rights.map {|lhs| lhs.rhs.ret }
         end
 
         box = @changes.add_masgn_box(genv, value, lefts, rest_elem, rights)

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

@@ -144,7 +144,8 @@ module TypeProf::Core
         raise if raw_node.statements.type != :statements_node
         raise if raw_node.statements.body.size != 1
         @body = AST.create_pattern_node(raw_node.statements.body[0], lenv)
-        raise if raw_node.subsequent
+        raise if raw_node.type == :if_node && raw_node.subsequent
+        raise if raw_node.type == :unless_node && raw_node.else_clause
       end
 
       attr_reader :cond, :body
@@ -152,8 +153,9 @@ module TypeProf::Core
       def subnodes = { cond:, body: }
 
       def install_pattern0(genv, subject)
-        @cond.install(genv)
+        # The guard is evaluated after the pattern binds its variables
         @body.install_pattern(genv, subject)
+        @cond.install(genv)
         subject
       end
     end

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

@@ -39,7 +39,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, {}, a_ty)
         else
-          type_params = prep_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+          type_params = prep_mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
           prep_ty = Type::Instance.new(genv, prep_mod, type_params)
         end
         if prep_ty.mod == f_mod
@@ -64,7 +64,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, {}, a_ty)
         else
-          type_params = inc_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+          type_params = inc_mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
           inc_ty = Type::Instance.new(genv, inc_mod, type_params)
         end
         if inc_ty.mod == f_mod
@@ -89,7 +89,7 @@ module TypeProf::Core
         if ext_decl.is_a?(AST::SigExtendNode) && ext_mod.type_params
           ext_ty = genv.get_instance_type(ext_mod, ext_decl.args, changes, {}, a_ty)
         else
-          type_params = ext_mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+          type_params = ext_mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
           ext_ty = Type::Instance.new(genv, ext_mod, type_params)
         end
         if ext_ty.mod == f_mod
@@ -705,6 +705,10 @@ module TypeProf::Core
         return unless cpath
         mod = genv.resolve_cpath(cpath)
         args = @args.map {|arg| arg.covariant_vertex(genv, changes, subst) }
+        # Omitted type arguments (e.g., `Foo` for `Foo[T]`) default to untyped
+        mod.type_params.drop(args.size).each do |_, default_ty|
+          args << (default_ty ? default_ty.covariant_vertex(genv, changes, subst) : genv.untyped_arg)
+        end
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
 
@@ -716,7 +720,7 @@ module TypeProf::Core
         # TODO: report error for wrong type arguments
         # TODO: support default type args
         args = mod.type_params.zip(@args).map do |_, arg|
-          arg ? arg.contravariant_vertex(genv, changes, subst) : Source.new
+          arg ? arg.contravariant_vertex(genv, changes, subst) : genv.untyped_arg
         end
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
@@ -1095,6 +1099,10 @@ module TypeProf::Core
         return unless cpath
         mod = genv.resolve_cpath(cpath)
         args = @args.map {|arg| arg.covariant_vertex(genv, changes, subst) }
+        # Omitted type arguments (e.g., `Foo` for `Foo[T]`) default to untyped
+        mod.type_params.drop(args.size).each do |_, default_ty|
+          args << (default_ty ? default_ty.covariant_vertex(genv, changes, subst) : genv.untyped_arg)
+        end
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
 
@@ -1104,6 +1112,7 @@ module TypeProf::Core
         return unless cpath
         mod = genv.resolve_cpath(cpath)
         args = @args.map {|arg| arg.contravariant_vertex(genv, changes, subst) }
+        mod.type_params.drop(args.size).each { args << genv.untyped_arg }
         changes.add_edge(genv, Source.new(Type::Instance.new(genv, mod, args)), vtx)
       end
 

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

@@ -326,10 +326,59 @@ module TypeProf::Core
       end
     end
 
-    class LambdaNode < Node
-      def install0(genv)
-        Source.new(genv.proc_type)
+    # Prism::LambdaNode has the same locals/parameters/body as Prism::BlockNode.
+    # A lambda literal is a block without a call: `->` never dispatches to a
+    # user-defined `lambda` method.
+    class LambdaNode < BlockNode
+      def lambda? = true
+
+      # A diagnostic on the `===` call below, such as wrong arity, points at the
+      # whole lambda.
+      def mid_code_range = nil
+
+      # `in ->(x) { ... }` matches by calling the lambda with the subject.
+      def install_pattern0(genv, subject)
+        recv = install0(genv)
+        a_args = ActualArguments.new([subject], [false], nil, nil)
+        @changes.add_method_call_box(genv, recv, :===, a_args, false)
+        recv
       end
+
+      # A lambda is entered like a method, so every parameter kind binds, not just
+      # the positionals a block is handed.
+      def build_formals(genv, blenv, f_args)
+        # f_args is the block-shaped list, required then optional; numbered and `it`
+        # parameters put names there that @params does not carry.
+        req_count = f_args.size - @opt_positional_defaults.size
+        rest = new_formal(blenv, @params[:rest_positionals])
+        post = @params[:post_positionals].map {|v| blenv.new_var(v, self) }
+        req_keywords = self.req_keywords.map {|v| blenv.new_var(v, self) }
+        opt_keywords = self.opt_keywords.map {|v| blenv.new_var(v, self) }
+        rest_keywords = new_formal(blenv, self.rest_keywords)
+        block = new_formal(blenv, @params[:block])
+
+        if rest
+          @changes.add_edge(genv, Source.new(genv.gen_ary_type(Vertex.new(self))), rest)
+        end
+        # Only the anonymous `**` needs seeding, as it does for a method: a named
+        # one takes its type from what the call passes.
+        if self.rest_keywords == :"**anonymous_keyword"
+          @changes.add_edge(genv, Source.new(genv.gen_hash_type(Vertex.new(self), Vertex.new(self))), rest_keywords)
+        end
+        install_multi_targets(genv, @params[:post_multi_targets], post, blenv)
+        opt_keyword_defaults.zip(opt_keywords) do |expr, vtx|
+          @changes.add_edge(genv, expr.install(genv), vtx)
+        end
+
+        FormalArguments.new(
+          f_args[0, req_count], f_args[req_count..], rest, post,
+          req_keywords, opt_keywords, rest_keywords, block,
+        )
+      end
+
+      private
+
+      def new_formal(blenv, name) = name ? blenv.new_var(name, self) : nil
     end
   end
 end

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

@@ -257,7 +257,7 @@ module TypeProf::Core
       end
     end
 
-    class PostExecutionNode < Node
+    class ExecutionBaseNode < Node
       def initialize(raw_node, lenv)
         super(raw_node, lenv)
         @body = raw_node.statements ? AST.create_node(raw_node.statements, lenv) : DummyNilNode.new(TypeProf::CodeRange.new(code_range.last, code_range.last), lenv)
@@ -273,6 +273,12 @@ module TypeProf::Core
       end
     end
 
+    class PreExecutionNode < ExecutionBaseNode
+    end
+
+    class PostExecutionNode < ExecutionBaseNode
+    end
+
     class ClassVariableWriteNode < Node
       def initialize(raw_node, rhs, lenv)
         super(raw_node, lenv)

data/lib/typeprof/core/ast.rb

@@ -278,6 +278,7 @@ module TypeProf::Core
       when :splat_node then SplatNode.new(raw_node, lenv)
       when :for_node then ForNode.new(raw_node, lenv)
       when :alias_global_variable_node then AliasGlobalVariableNode.new(raw_node, lenv)
+      when :pre_execution_node then PreExecutionNode.new(raw_node, lenv)
       when :post_execution_node then PostExecutionNode.new(raw_node, lenv)
       when :flip_flop_node then FlipFlopNode.new(raw_node, lenv)
       when :shareable_constant_node then create_node(raw_node.write, lenv)
@@ -362,7 +363,7 @@ module TypeProf::Core
 
       when :capture_pattern_node then CapturePatternNode.new(raw_node, lenv)
 
-      when :if_node then IfPatternNode.new(raw_node, lenv)
+      when :if_node, :unless_node then IfPatternNode.new(raw_node, lenv)
 
       when :pinned_variable_node then PinnedPatternNode.new(raw_node, lenv)
       when :pinned_expression_node then PinnedPatternNode.new(raw_node, lenv)
@@ -396,6 +397,7 @@ module TypeProf::Core
 
       when :array_node then ArrayNode.new(raw_node, lenv) # for %w[foo bar]
       when :range_node then RangeNode.new(raw_node, lenv) # TODO: support range pattern correctly
+      when :lambda_node then LambdaNode.new(raw_node, lenv)
 
       else
         raise "unknown pattern node type: #{ raw_node.type }"

data/lib/typeprof/core/builtin.rb

@@ -25,7 +25,7 @@ module TypeProf::Core
     def proc_call(changes, node, ty, a_args, ret)
       case ty
       when Type::Proc
-        ty.block.accept_args(@genv, changes, a_args.positionals)
+        ty.block.pass_arguments(@genv, changes, a_args)
         ty.block.add_ret(@genv, changes, ret)
         true
       else

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

@@ -21,6 +21,136 @@ module TypeProf::Core
     attr_reader :opt_keywords
     attr_reader :rest_keywords
     attr_reader :block
+
+    # Binds a call's actual arguments to these formals. `node` supplies the
+    # keyword names, which live on the AST node rather than in the vertices.
+    def pass_arguments(changes, genv, a_args, node)
+      if a_args.splat_flags.any?
+        # there is at least one splat actual argument
+
+        lower = @req_positionals.size + @post_positionals.size
+        upper = @rest_positionals ? nil : lower + @opt_positionals.size
+        if upper && upper < a_args.positionals.size
+          meth = changes.node.mid_code_range ? :mid_code_range : :code_range
+          err = "#{ a_args.positionals.size } for #{ lower }#{ upper ? lower < upper ? "...#{ upper }" : "" : "+" }"
+          changes.add_diagnostic(meth, "wrong number of arguments (#{ err })")
+          return false
+        end
+
+        start_rest = [a_args.splat_flags.index(true), @req_positionals.size + @opt_positionals.size].min
+        end_rest = [a_args.splat_flags.rindex(true) + 1, a_args.positionals.size - @post_positionals.size].max
+        rest_vtxs = a_args.get_rest_args(genv, changes, start_rest, end_rest)
+
+        @req_positionals.each_with_index do |f_vtx, i|
+          if i < start_rest
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+        @opt_positionals.each_with_index do |f_vtx, i|
+          i += @req_positionals.size
+          if i < start_rest
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+        @post_positionals.each_with_index do |f_vtx, i|
+          i += a_args.positionals.size - @post_positionals.size
+          if end_rest <= i
+            changes.add_edge(genv, a_args.positionals[i], f_vtx)
+          else
+            rest_vtxs.each do |vtx|
+              changes.add_edge(genv, vtx, f_vtx)
+            end
+          end
+        end
+
+        if @rest_positionals
+          rest_vtxs.each do |vtx|
+            @rest_positionals.each_type do |ty|
+              if ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0]
+                changes.add_edge(genv, vtx, ty.args[0])
+              end
+            end
+          end
+        end
+      else
+        # there is no splat actual argument
+
+        lower = @req_positionals.size + @post_positionals.size
+        upper = @rest_positionals ? nil : lower + @opt_positionals.size
+        if a_args.positionals.size < lower || (upper && upper < a_args.positionals.size)
+          meth = changes.node.mid_code_range ? :mid_code_range : :code_range
+          err = "#{ a_args.positionals.size } for #{ lower }#{ upper ? lower < upper ? "...#{ upper }" : "" : "+" }"
+          changes.add_diagnostic(meth, "wrong number of arguments (#{ err })")
+          return false
+        end
+
+        @req_positionals.each_with_index do |f_vtx, i|
+          changes.add_edge(genv, a_args.positionals[i], f_vtx)
+        end
+        @post_positionals.each_with_index do |f_vtx, i|
+          i -= @post_positionals.size
+          changes.add_edge(genv, a_args.positionals[i], f_vtx)
+        end
+        start_rest = @req_positionals.size
+        end_rest = a_args.positionals.size - @post_positionals.size
+        i = 0
+        while i < @opt_positionals.size && start_rest < end_rest
+          f_arg = @opt_positionals[i]
+          changes.add_edge(genv, a_args.positionals[start_rest], f_arg)
+          i += 1
+          start_rest += 1
+        end
+
+        if start_rest < end_rest
+          if @rest_positionals
+            (start_rest..end_rest-1).each do |i|
+              @rest_positionals.each_type do |ty|
+                if ty.is_a?(Type::Instance) && ty.mod == genv.mod_ary && ty.args[0]
+                  changes.add_edge(genv, a_args.positionals[i], ty.args[0])
+                end
+              end
+            end
+          end
+        end
+      end
+
+      if a_args.keywords
+        # TODO: support diagnostics
+        node.req_keywords.zip(@req_keywords) do |name, f_vtx|
+          changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
+        end
+
+        node.opt_keywords.zip(@opt_keywords).each do |name, f_vtx|
+          changes.add_edge(genv, a_args.get_keyword_arg(genv, changes, name), f_vtx)
+        end
+
+        if node.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), @rest_keywords)
+            when Type::Hash, Type::Instance
+              changes.add_edge(genv, Source.new(kw_ty), @rest_keywords)
+            end
+          end
+        end
+      end
+
+      return true
+    end
+
   end
 
   class ActualArguments
@@ -52,6 +182,15 @@ module TypeProf::Core
       )
     end
 
+    # Keywords passed to formals that take none are the last positional hash.
+    def with_keywords_normalized_for(node)
+      return self unless keywords
+      return self if node.no_keywords || node.rest_keywords
+      return self unless node.req_keywords.empty? && node.opt_keywords.empty?
+
+      with_keywords_as_last_positional_hash
+    end
+
     def prepend_positionals(positionals, splat_flags)
       return self if positionals.empty?
 
@@ -245,7 +384,7 @@ module TypeProf::Core
   end
 
   class ForwardingArguments
-    def initialize(req_positionals, opt_positionals, rest_positionals, post_positionals, req_keyword_pairs, opt_keyword_pairs, rest_keywords, block, activation)
+    def initialize(req_positionals, opt_positionals, rest_positionals, post_positionals, req_keyword_pairs, opt_keyword_pairs, rest_keywords, block, activation, param_names)
       @req_positionals = req_positionals
       @opt_positionals = opt_positionals
       @rest_positionals = rest_positionals
@@ -255,33 +394,68 @@ module TypeProf::Core
       @rest_keywords = rest_keywords
       @block = block
       @activation = activation
+      @param_names = param_names
     end
 
-    def to_actual_arguments(genv, changes, node, include_leading_positionals: true, activation_required: false)
-      positionals = include_leading_positionals ? @req_positionals.dup : []
-      splat_flags = ::Array.new(positionals.size, false)
-      positionals_omittable = ::Array.new(positionals.size, false)
+    # The arguments that `...` forwards: only the ones the caller passed to it.
+    # The parameters before `...` (`def foo(a, b = 1, ...)`) are not forwarded,
+    # and none can follow it.
+    def to_actual_arguments(genv, changes, node)
+      positionals = []
+      splat_flags = []
+      positionals_omittable = []
 
-      @opt_positionals.each do |elem_vtx|
-        positionals << Source.new(genv.gen_ary_type(elem_vtx))
+      if @rest_positionals
+        positionals << Source.new(genv.gen_ary_type(@rest_positionals))
         splat_flags << true
         positionals_omittable << true
       end
 
-      if @rest_positionals
+      # `...` cannot follow keyword parameters, so only the rest keywords remain
+      ForwardingActualArguments.new(positionals, splat_flags, @rest_keywords, @block, positionals_omittable, !!@rest_keywords, true, @activation, true)
+    end
+
+    # A bare `super` passes the current values of the parameters, which
+    # include the defaults of omitted ones and any reassignment.
+    def to_implicit_super_arguments(genv, changes, node, lenv)
+      positionals = []
+      splat_flags = []
+      positionals_omittable = []
+
+      # A destructured parameter has no name, so it is passed as it was given
+      @param_names[:req_positionals].zip(@req_positionals) do |name, vtx|
+        positionals << (name ? lenv.get_method_var(name) : vtx)
+        splat_flags << false
+        positionals_omittable << false
+      end
+
+      @param_names[:opt_positionals].each do |name|
+        positionals << lenv.get_method_var(name)
+        splat_flags << false
+        positionals_omittable << false
+      end
+
+      if @param_names[:rest_positionals]
+        positionals << lenv.get_method_var(@param_names[:rest_positionals])
+        splat_flags << true
+        positionals_omittable << true
+      elsif @rest_positionals
         positionals << Source.new(genv.gen_ary_type(@rest_positionals))
         splat_flags << true
         positionals_omittable << true
       end
 
-      @post_positionals.each do |arg|
-        positionals << arg
+      @param_names[:post_positionals].zip(@post_positionals) do |name, vtx|
+        positionals << (name ? lenv.get_method_var(name) : vtx)
         splat_flags << false
         positionals_omittable << false
       end
 
-      keywords, keywords_omittable = build_keyword_args(genv, changes, node)
-      ForwardingActualArguments.new(positionals, splat_flags, keywords, @block, positionals_omittable, keywords_omittable, true, @activation, activation_required)
+      req_keyword_pairs = @param_names[:req_keywords].map {|name| [name, lenv.get_method_var(name)] }
+      opt_keyword_pairs = @param_names[:opt_keywords].map {|name| [name, lenv.get_method_var(name)] }
+      rest_keywords = @param_names[:rest_keywords] ? lenv.get_method_var(@param_names[:rest_keywords]) : @rest_keywords
+      keywords, keywords_omittable = build_keyword_args(genv, changes, node, req_keyword_pairs, opt_keyword_pairs, rest_keywords)
+      ForwardingActualArguments.new(positionals, splat_flags, keywords, @block, positionals_omittable, keywords_omittable, true, @activation, false)
     end
 
     def accept_actual_arguments(genv, changes, a_args)
@@ -386,18 +560,16 @@ module TypeProf::Core
 
     private
 
-    def build_keyword_args(genv, changes, node)
-      opt_keyword_pairs = @opt_keyword_pairs
-
-      if @req_keyword_pairs.empty? && opt_keyword_pairs.empty?
-        return @rest_keywords, !!@rest_keywords
+    def build_keyword_args(genv, changes, node, req_keyword_pairs, opt_keyword_pairs, rest_keywords)
+      if req_keyword_pairs.empty? && opt_keyword_pairs.empty?
+        return rest_keywords, !!rest_keywords
       end
 
       unified_key = Vertex.new(node)
       unified_val = Vertex.new(node)
       literal_pairs = {}
 
-      @req_keyword_pairs.each do |name, vtx|
+      req_keyword_pairs.each do |name, vtx|
         changes.add_edge(genv, Source.new(Type::Symbol.new(genv, name)), unified_key)
         changes.add_edge(genv, vtx, unified_val)
         literal_pairs[name] = vtx
@@ -410,13 +582,13 @@ module TypeProf::Core
       end
 
       base_hash_type = genv.gen_hash_type(unified_key, unified_val)
-      changes.add_hash_splat_box(genv, @rest_keywords, unified_key, unified_val) if @rest_keywords
+      changes.add_hash_splat_box(genv, rest_keywords, unified_key, unified_val) if rest_keywords
 
       if literal_pairs.empty?
         [Source.new(base_hash_type), false]
-      elsif @rest_keywords
+      elsif rest_keywords
         fallback = Source.new(Type::Record.new(genv, literal_pairs, base_hash_type))
-        [changes.add_keyword_merge_box(genv, @rest_keywords, literal_pairs, fallback).ret, false]
+        [changes.add_keyword_merge_box(genv, rest_keywords, literal_pairs, fallback).ret, false]
       else
         [Source.new(Type::Record.new(genv, literal_pairs, base_hash_type)), false]
       end
@@ -424,18 +596,34 @@ module TypeProf::Core
   end
 
   class Block
-    #: (AST::CallBaseNode, Vertex, Array[Vertex], Array[EscapeBox]) -> void
-    def initialize(node, f_ary_arg, f_args, next_boxes)
+    #: (AST::BlockNode, Vertex, Array[Vertex], Array[EscapeBox], FormalArguments?) -> void
+    def initialize(node, f_ary_arg, f_args, next_boxes, formals = nil)
       @node = node
       @f_ary_arg = f_ary_arg
       @f_args = f_args
       @next_boxes = next_boxes
+      # Set when the body is entered like a method rather than yielded to, which
+      # is to say for a lambda: the full formals then bind the call's arguments.
+      @formals = formals
     end
 
     attr_reader :node, :f_args, :next_boxes
 
+    # The arguments of a call that enters this body directly, as Proc#call does.
+    def pass_arguments(genv, changes, a_args)
+      if @formals
+        a_args = a_args.with_keywords_normalized_for(@node)
+        @formals.pass_arguments(changes, genv, a_args, @node)
+        changes.add_edge(genv, a_args.block, @formals.block) if @formals.block && a_args.block
+      else
+        accept_args(genv, changes, a_args.positionals)
+      end
+    end
+
     def accept_args(genv, changes, caller_positionals)
-      if caller_positionals.size == 1 && @f_args.size >= 2
+      if caller_positionals.size == 1 && @f_args.size >= 2 && !@formals
+        # A block deconstructs a sole array argument over its parameters; a
+        # lambda takes it as the one argument it is.
         changes.add_edge(genv, caller_positionals[0], @f_ary_arg)
       else
         caller_positionals.zip(@f_args) do |a_arg, f_arg|
@@ -452,6 +640,10 @@ module TypeProf::Core
   end
 
   class RecordBlock
+    def pass_arguments(genv, changes, a_args)
+      accept_args(genv, changes, a_args.positionals)
+    end
+
     def initialize(node)
       @node = node
       @used = false

data/lib/typeprof/core/env.rb

@@ -42,6 +42,11 @@ module TypeProf::Core
 
       @bot_type = Type::Bot.new(self)
 
+      # The vertex for a type argument that is not given. This must be shared:
+      # a fresh vertex makes a different Instance type and a different edge on
+      # every run, so a box that uses it is re-run forever.
+      @untyped_arg = Source.new
+
       @run_count = 0
     end
 
@@ -52,7 +57,7 @@ module TypeProf::Core
     attr_reader :obj_type, :nil_type, :true_type, :false_type, :str_type
     attr_reader :int_type, :float_type, :rational_type, :complex_type
     attr_reader :proc_type, :symbol_type, :method_type, :set_type, :regexp_type
-    attr_reader :bot_type
+    attr_reader :bot_type, :untyped_arg
 
     def gen_ary_type(elem_vtx)
       Type::Instance.new(self, @mod_ary, [elem_vtx])
@@ -130,18 +135,18 @@ module TypeProf::Core
       ty_env = base_ty_env.dup
       if base_ty.is_a?(Type::Instance)
         base_ty.mod.type_params.zip(base_ty.args) do |(param, default_ty), arg|
-          ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : Source.new)
+          ty_env[param] = arg || (default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : @untyped_arg)
         end
       elsif base_ty.is_a?(Type::Singleton)
         base_ty.mod.type_params&.each do |(param, default_ty)|
-          ty_env[param] = default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : Source.new
+          ty_env[param] = default_ty ? default_ty.covariant_vertex(self, changes, ty_env) : @untyped_arg
         end
       end
       args = mod.type_params.zip(type_args).map do |(param, default_ty), arg|
         if changes
-          (arg || default_ty)&.covariant_vertex(self, changes, ty_env) || Source.new
+          (arg || default_ty)&.covariant_vertex(self, changes, ty_env) || @untyped_arg
         else
-          Source.new
+          @untyped_arg
         end
       end
       Type::Instance.new(self, mod, args)
@@ -374,12 +379,13 @@ module TypeProf::Core
       @ivar_narrowings = {}
       @strict_const_scope = false
       @forward_args = forward_args
+      @shadowed_vars = {}
       # [cpath, names] of the type parameters of the enclosing RBS declaration
       @sig_type_params = sig_type_params
     end
 
     attr_reader :file_context, :cref, :locals, :return_boxes, :break_vtx, :next_boxes, :strict_const_scope, :sig_type_params
-    attr_accessor :module_function, :forward_args
+    attr_accessor :module_function, :forward_args, :shadowed_vars
 
     def path = @file_context&.path
     def code_range_from_node(node)
@@ -398,6 +404,12 @@ module TypeProf::Core
       @locals[name] || raise("#{ name }")
     end
 
+    # A bare `super` passes the variables of the method, not the block
+    # parameters that shadow them
+    def get_method_var(name)
+      @shadowed_vars[name] || get_var(name)
+    end
+
     def exist_var?(name)
       !!@locals[name]
     end
@@ -443,20 +455,23 @@ module TypeProf::Core
   end
 
   class CRef
-    def initialize(cpath, scope_level, mid, outer)
+    # in_method: whether this is inside a method body, which a define_method
+    # block is even though its method name (mid) is not known
+    def initialize(cpath, scope_level, mid, outer, in_method: !mid.nil?)
       @cpath = cpath
       @scope_level = scope_level
       @mid = mid
       @outer = outer
+      @in_method = in_method
     end
 
-    attr_reader :cpath, :scope_level, :mid, :outer
+    attr_reader :cpath, :scope_level, :mid, :outer, :in_method
 
     def get_self(genv)
       case @scope_level
       when :instance
         mod = genv.resolve_cpath(@cpath || [])
-        type_params = mod.type_params.map {|(_name, _default_ty)| Source.new() } # TODO: better support
+        type_params = mod.type_params.map {|(_name, _default_ty)| genv.untyped_arg } # TODO: better support
         ty = Type::Instance.new(genv, mod, type_params)
         Source.new(ty)
       when :class